diff --git a/agent/go.mod b/agent/go.mod index 7609b70d924..40c35a82564 100644 --- a/agent/go.mod +++ b/agent/go.mod @@ -13,7 +13,7 @@ require ( github.com/aws/aws-sdk-go-v2/credentials v1.17.67 github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.30 github.com/aws/aws-sdk-go-v2/feature/s3/manager v1.17.72 - github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs v1.47.3 + github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs v1.65.0 github.com/aws/aws-sdk-go-v2/service/ecr v1.45.1 github.com/aws/aws-sdk-go-v2/service/ecs v1.47.3 github.com/aws/aws-sdk-go-v2/service/fsx v1.53.1 diff --git a/agent/go.sum b/agent/go.sum index 63acd9a6563..cd1121f2d5a 100644 --- a/agent/go.sum +++ b/agent/go.sum @@ -24,8 +24,8 @@ github.com/aws/aws-sdk-go-v2/internal/ini v1.8.3 h1:bIqFDwgGXXN1Kpp99pDOdKMTTb5d github.com/aws/aws-sdk-go-v2/internal/ini v1.8.3/go.mod h1:H5O/EsxDWyU+LP/V8i5sm8cxoZgc2fdNR9bxlOFrQTo= github.com/aws/aws-sdk-go-v2/internal/v4a v1.4.22 h1:rWyie/PxDRIdhNf4DzRk0lvjVOqFJuNnO8WwaIRVxzQ= github.com/aws/aws-sdk-go-v2/internal/v4a v1.4.22/go.mod h1:zd/JsJ4P7oGfUhXn1VyLqaRZwPmZwg44Jf2dS84Dm3Y= -github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs v1.47.3 h1:3y0jkGtsaZLCg+n73BoSXOAkLFtgmD/+4prXW1pzovc= -github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs v1.47.3/go.mod h1:uo14VBn5cNk/BPGTPz3kyLBxgpgOObgO8lmz+H7Z4Ck= +github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs v1.65.0 h1:3yaFbUbuLfN8n1q01wZtQtHRzUDc/jm0VvniMY0IPE8= +github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs v1.65.0/go.mod h1:PobeppEnIjw4pcgjFryNDZCTH7AiqZw0yb5r98Gvf9c= github.com/aws/aws-sdk-go-v2/service/ec2 v1.195.0 h1:F3pFi50sK30DZ4IkkNpHwTLGeal5c3nlKuvTgv7xec4= github.com/aws/aws-sdk-go-v2/service/ec2 v1.195.0/go.mod h1:00zqVNJFK6UASrTnuvjJHJuaqUdkVz5tW8Ip+VhzuNg= github.com/aws/aws-sdk-go-v2/service/ecr v1.45.1 h1:Bwzh202Aq7/MYnAjXA9VawCf6u+hjwMdoYmZ4HYsdf8= diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/CHANGELOG.md b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/CHANGELOG.md index b099f4214e1..777e2f79176 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/CHANGELOG.md +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/CHANGELOG.md @@ -1,3 +1,202 @@ +# v1.65.0 (2026-03-26) + +* **Feature**: This release adds parameter support to saved queries in CloudWatch Logs Insights. Define reusable query templates with named placeholders, invoke them using start query. Available in Console, CLI and SDK +* **Bug Fix**: Fix a bug where a recorded clock skew could persist on the client even if the client and server clock ended up realigning. +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.64.2 (2026-03-23) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.64.1 (2026-03-13) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.64.0 (2026-03-03) + +* **Feature**: CloudWatch Logs updates- Added support for the PutBearerTokenAuthentication API to enable or disable bearer token authentication on a log group. For more information, see CloudWatch Logs API documentation. +* **Dependency Update**: Bump minimum Go version to 1.24 +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.63.2 (2026-02-23) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.63.1 (2026-01-09) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.63.0 (2025-12-15) + +* **Feature**: This release allows you to import your historical CloudTrail Lake data into CloudWatch with a few steps, enabling you to easily consolidate operational, security, and compliance data in one place. + +# v1.62.2 (2025-12-09) + +* No change notes available for this release. + +# v1.62.1 (2025-12-08) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.62.0 (2025-12-02) + +* **Feature**: CloudWatch Logs adds managed S3 Tables integration to access logs using other analytical tools, as well as facets and field indexing to simplify log analytics in CloudWatch Logs Insights. +* **Dependency Update**: Updated to the latest SDK module versions +* **Dependency Update**: Upgrade to smithy-go v1.24.0. Notably this version of the library reduces the allocation footprint of the middleware system. We observe a ~10% reduction in allocations per SDK call with this change. + +# v1.61.1 (2025-11-25) + +* **Bug Fix**: Add error check for endpoint param binding during auth scheme resolution to fix panic reported in #3234 + +# v1.61.0 (2025-11-24) + +* **Feature**: New CloudWatch Logs feature - LogGroup Deletion Protection, a capability that allows customers to safeguard their critical CloudWatch log groups from accidental or unintended deletion. + +# v1.60.1 (2025-11-19.2) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.60.0 (2025-11-19) + +* **Feature**: Adding support for ocsf version 1.5, add optional parameter MappingVersion + +# v1.59.0 (2025-11-18) + +* **Feature**: CloudWatch Logs updates: Added capability to setup a recurring schedule for log insights queries. Logs introduced Scheduled Queries (managed through Create/Update/Get/Delete/List/History Scheduled Query APIs). For more information, see CloudWatch Logs API documentation. + +# v1.58.9 (2025-11-12) + +* **Bug Fix**: Further reduce allocation overhead when the metrics system isn't in-use. +* **Bug Fix**: Reduce allocation overhead when the client doesn't have any HTTP interceptors configured. +* **Bug Fix**: Remove blank trace spans towards the beginning of the request that added no additional information. This conveys a slight reduction in overall allocations. + +# v1.58.8 (2025-11-11) + +* **Bug Fix**: Return validation error if input region is not a valid host label. + +# v1.58.7 (2025-11-04) + +* **Dependency Update**: Updated to the latest SDK module versions +* **Dependency Update**: Upgrade to smithy-go v1.23.2 which should convey some passive reduction of overall allocations, especially when not using the metrics system. + +# v1.58.6 (2025-10-30) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.58.5 (2025-10-23) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.58.4 (2025-10-22) + +* No change notes available for this release. + +# v1.58.3 (2025-10-16) + +* **Dependency Update**: Bump minimum Go version to 1.23. +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.58.2 (2025-09-26) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.58.1 (2025-09-23) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.58.0 (2025-09-16) + +* **Feature**: Cloudwatch Logs added support for 2 new API parameters in metric and subscription filter APIs to filter log events based on system field values and emit system field values as dimensions and send them to customer destination as additional metadata. + +# v1.57.4 (2025-09-10) + +* No change notes available for this release. + +# v1.57.3 (2025-09-08) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.57.2 (2025-08-29) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.57.1 (2025-08-27) + +* **Dependency Update**: Update to smithy-go v1.23.0. +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.57.0 (2025-08-25) + +* **Feature**: Remove incorrect endpoint tests + +# v1.56.2 (2025-08-21) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.56.1 (2025-08-20) + +* **Bug Fix**: Remove unused deserialization code. + +# v1.56.0 (2025-08-11) + +* **Feature**: Add support for configuring per-service Options via callback on global config. +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.55.0 (2025-08-04) + +* **Feature**: Support configurable auth scheme preferences in service clients via AWS_AUTH_SCHEME_PREFERENCE in the environment, auth_scheme_preference in the config file, and through in-code settings on LoadDefaultConfig and client constructor methods. +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.54.1 (2025-07-30) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.54.0 (2025-07-28) + +* **Feature**: Add support for HTTP interceptors. +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.53.1 (2025-07-19) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.53.0 (2025-07-18) + +* **Feature**: CloudWatchLogs launches GetLogObject API with streaming support for efficient log data retrieval. Logs added support for new AccountPolicy type METRIC_EXTRACTION_POLICY. For more information, see CloudWatch Logs API documentation + +# v1.52.0 (2025-07-16.2) + +* **Feature**: CloudWatch Logs updates: Added X-Ray tracing for Amazon Bedrock Agent resources. Logs introduced Log Group level resource policies (managed through Put/Delete/Describe Resource Policy APIs). For more information, see CloudWatch Logs API documentation. + +# v1.51.0 (2025-06-18) + +* **Feature**: Added CloudWatch Logs Transformer support for converting CloudTrail, VPC Flow, EKS Audit, AWS WAF and Route53 Resolver logs to OCSF v1.1 format. + +# v1.50.3 (2025-06-17) + +* **Dependency Update**: Update to smithy-go v1.22.4. +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.50.2 (2025-06-10) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.50.1 (2025-06-06) + +* No change notes available for this release. + +# v1.50.0 (2025-05-14) + +* **Feature**: This release adds a new API "ListLogGroups" and an improvement in API "DescribeLogGroups" + +# v1.49.0 (2025-05-09) + +* **Feature**: We are pleased to announce limit increases to our grok processor logs transformation feature. Now you can define 20 Grok patterns in their configurations, with an expanded total pattern matching limit of 512 characters. + +# v1.48.0 (2025-04-30) + +* **Feature**: CloudWatch Logs supports "DELIVERY" log class. This log class is used only for delivering AWS Lambda logs to Amazon S3 or Amazon Data Firehose. + # v1.47.3 (2025-04-10) * No change notes available for this release. diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_client.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_client.go index f26a1ad099c..7d8f4938813 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_client.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_client.go @@ -16,9 +16,7 @@ import ( internalauth "github.com/aws/aws-sdk-go-v2/internal/auth" internalauthsmithy "github.com/aws/aws-sdk-go-v2/internal/auth/smithy" internalConfig "github.com/aws/aws-sdk-go-v2/internal/configsources" - internalmiddleware "github.com/aws/aws-sdk-go-v2/internal/middleware" smithy "github.com/aws/smithy-go" - smithyauth "github.com/aws/smithy-go/auth" smithydocument "github.com/aws/smithy-go/document" "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/metrics" @@ -67,7 +65,12 @@ func timeOperationMetric[T any]( ctx context.Context, metric string, fn func() (T, error), opts ...metrics.RecordMetricOption, ) (T, error) { - instr := getOperationMetrics(ctx).histogramFor(metric) + mm := getOperationMetrics(ctx) + if mm == nil { // not using the metrics system + return fn() + } + + instr := mm.histogramFor(metric) opts = append([]metrics.RecordMetricOption{withOperationMetadata(ctx)}, opts...) start := time.Now() @@ -80,7 +83,12 @@ func timeOperationMetric[T any]( } func startMetricTimer(ctx context.Context, metric string, opts ...metrics.RecordMetricOption) func() { - instr := getOperationMetrics(ctx).histogramFor(metric) + mm := getOperationMetrics(ctx) + if mm == nil { // not using the metrics system + return func() {} + } + + instr := mm.histogramFor(metric) opts = append([]metrics.RecordMetricOption{withOperationMetadata(ctx)}, opts...) var ended bool @@ -108,6 +116,12 @@ func withOperationMetadata(ctx context.Context) metrics.RecordMetricOption { type operationMetricsKey struct{} func withOperationMetrics(parent context.Context, mp metrics.MeterProvider) (context.Context, error) { + if _, ok := mp.(metrics.NopMeterProvider); ok { + // not using the metrics system - setting up the metrics context is a memory-intensive operation + // so we should skip it in this case + return parent, nil + } + meter := mp.Meter("github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs") om := &operationMetrics{} @@ -155,7 +169,10 @@ func operationMetricTimer(m metrics.Meter, name, desc string) (metrics.Float64Hi } func getOperationMetrics(ctx context.Context) *operationMetrics { - return ctx.Value(operationMetricsKey{}).(*operationMetrics) + if v := ctx.Value(operationMetricsKey{}); v != nil { + return v.(*operationMetrics) + } + return nil } func operationTracer(p tracing.TracerProvider) tracing.Tracer { @@ -426,24 +443,33 @@ func setResolvedDefaultsMode(o *Options) { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - DefaultsMode: cfg.DefaultsMode, - RuntimeEnvironment: cfg.RuntimeEnvironment, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, - AppID: cfg.AppID, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, + AppID: cfg.AppID, + AuthSchemePreference: cfg.AuthSchemePreference, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSRetryMaxAttempts(cfg, &opts) resolveAWSRetryMode(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) + resolveInterceptors(cfg, &opts) resolveUseDualStackEndpoint(cfg, &opts) resolveUseFIPSEndpoint(cfg, &opts) resolveBaseEndpoint(cfg, &opts) - return New(opts, optFns...) + return New(opts, func(o *Options) { + for _, opt := range cfg.ServiceOptions { + opt(ServiceID, o) + } + for _, opt := range optFns { + opt(o) + } + }) } func resolveHTTPClient(o *Options) { @@ -557,6 +583,10 @@ func resolveAWSEndpointResolver(cfg aws.Config, o *Options) { o.EndpointResolver = withEndpointResolver(cfg.EndpointResolver, cfg.EndpointResolverWithOptions) } +func resolveInterceptors(cfg aws.Config, o *Options) { + o.Interceptors = cfg.Interceptors.Copy() +} + func addClientUserAgent(stack *middleware.Stack, options Options) error { ua, err := getOrAddRequestUserAgent(stack) if err != nil { @@ -693,10 +723,11 @@ func resolveIdempotencyTokenProvider(o *Options) { o.IdempotencyTokenProvider = smithyrand.NewUUIDIdempotencyToken(cryptorand.Reader) } -func addRetry(stack *middleware.Stack, o Options) error { +func addRetry(stack *middleware.Stack, o Options, c *Client) error { attempt := retry.NewAttemptMiddleware(o.Retryer, smithyhttp.RequestCloner, func(m *retry.Attempt) { m.LogAttempts = o.ClientLogMode.IsRetries() m.OperationMeter = o.MeterProvider.Meter("github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs") + m.ClientSkew = c.timeOffset }) if err := stack.Finalize.Insert(attempt, "ResolveAuthScheme", middleware.Before); err != nil { return err @@ -737,25 +768,6 @@ func resolveUseFIPSEndpoint(cfg aws.Config, o *Options) error { return nil } -func resolveAccountID(identity smithyauth.Identity, mode aws.AccountIDEndpointMode) *string { - if mode == aws.AccountIDEndpointModeDisabled { - return nil - } - - if ca, ok := identity.(*internalauthsmithy.CredentialsAdapter); ok && ca.Credentials.AccountID != "" { - return aws.String(ca.Credentials.AccountID) - } - - return nil -} - -func addTimeOffsetBuild(stack *middleware.Stack, c *Client) error { - mw := internalmiddleware.AddTimeOffsetMiddleware{Offset: c.timeOffset} - if err := stack.Build.Add(&mw, middleware.After); err != nil { - return err - } - return stack.Deserialize.Insert(&mw, "RecordResponseTiming", middleware.Before) -} func initializeTimeOffsetResolver(c *Client) { c.timeOffset = new(atomic.Int64) } @@ -875,88 +887,62 @@ func addDisableHTTPSMiddleware(stack *middleware.Stack, o Options) error { }, "ResolveEndpointV2", middleware.After) } -type spanInitializeStart struct { -} - -func (*spanInitializeStart) ID() string { - return "spanInitializeStart" -} - -func (m *spanInitializeStart) HandleInitialize( - ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler, -) ( - middleware.InitializeOutput, middleware.Metadata, error, -) { - ctx, _ = tracing.StartSpan(ctx, "Initialize") - - return next.HandleInitialize(ctx, in) -} - -type spanInitializeEnd struct { -} - -func (*spanInitializeEnd) ID() string { - return "spanInitializeEnd" -} - -func (m *spanInitializeEnd) HandleInitialize( - ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler, -) ( - middleware.InitializeOutput, middleware.Metadata, error, -) { - ctx, span := tracing.PopSpan(ctx) - span.End() - - return next.HandleInitialize(ctx, in) -} - -type spanBuildRequestStart struct { -} - -func (*spanBuildRequestStart) ID() string { - return "spanBuildRequestStart" -} - -func (m *spanBuildRequestStart) HandleSerialize( - ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler, -) ( - middleware.SerializeOutput, middleware.Metadata, error, -) { - ctx, _ = tracing.StartSpan(ctx, "BuildRequest") - - return next.HandleSerialize(ctx, in) -} - -type spanBuildRequestEnd struct { -} - -func (*spanBuildRequestEnd) ID() string { - return "spanBuildRequestEnd" -} - -func (m *spanBuildRequestEnd) HandleBuild( - ctx context.Context, in middleware.BuildInput, next middleware.BuildHandler, -) ( - middleware.BuildOutput, middleware.Metadata, error, -) { - ctx, span := tracing.PopSpan(ctx) - span.End() - - return next.HandleBuild(ctx, in) -} - -func addSpanInitializeStart(stack *middleware.Stack) error { - return stack.Initialize.Add(&spanInitializeStart{}, middleware.Before) -} - -func addSpanInitializeEnd(stack *middleware.Stack) error { - return stack.Initialize.Add(&spanInitializeEnd{}, middleware.After) -} - -func addSpanBuildRequestStart(stack *middleware.Stack) error { - return stack.Serialize.Add(&spanBuildRequestStart{}, middleware.Before) -} +func addInterceptBeforeRetryLoop(stack *middleware.Stack, opts Options) error { + return stack.Finalize.Insert(&smithyhttp.InterceptBeforeRetryLoop{ + Interceptors: opts.Interceptors.BeforeRetryLoop, + }, "Retry", middleware.Before) +} + +func addInterceptAttempt(stack *middleware.Stack, opts Options) error { + return stack.Finalize.Insert(&smithyhttp.InterceptAttempt{ + BeforeAttempt: opts.Interceptors.BeforeAttempt, + AfterAttempt: opts.Interceptors.AfterAttempt, + }, "Retry", middleware.After) +} + +func addInterceptors(stack *middleware.Stack, opts Options) error { + // middlewares are expensive, don't add all of these interceptor ones unless the caller + // actually has at least one interceptor configured + // + // at the moment it's all-or-nothing because some of the middlewares here are responsible for + // setting fields in the interceptor context for future ones + if len(opts.Interceptors.BeforeExecution) == 0 && + len(opts.Interceptors.BeforeSerialization) == 0 && len(opts.Interceptors.AfterSerialization) == 0 && + len(opts.Interceptors.BeforeRetryLoop) == 0 && + len(opts.Interceptors.BeforeAttempt) == 0 && + len(opts.Interceptors.BeforeSigning) == 0 && len(opts.Interceptors.AfterSigning) == 0 && + len(opts.Interceptors.BeforeTransmit) == 0 && len(opts.Interceptors.AfterTransmit) == 0 && + len(opts.Interceptors.BeforeDeserialization) == 0 && len(opts.Interceptors.AfterDeserialization) == 0 && + len(opts.Interceptors.AfterAttempt) == 0 && len(opts.Interceptors.AfterExecution) == 0 { + return nil + } -func addSpanBuildRequestEnd(stack *middleware.Stack) error { - return stack.Build.Add(&spanBuildRequestEnd{}, middleware.After) + return errors.Join( + stack.Initialize.Add(&smithyhttp.InterceptExecution{ + BeforeExecution: opts.Interceptors.BeforeExecution, + AfterExecution: opts.Interceptors.AfterExecution, + }, middleware.Before), + stack.Serialize.Insert(&smithyhttp.InterceptBeforeSerialization{ + Interceptors: opts.Interceptors.BeforeSerialization, + }, "OperationSerializer", middleware.Before), + stack.Serialize.Insert(&smithyhttp.InterceptAfterSerialization{ + Interceptors: opts.Interceptors.AfterSerialization, + }, "OperationSerializer", middleware.After), + stack.Finalize.Insert(&smithyhttp.InterceptBeforeSigning{ + Interceptors: opts.Interceptors.BeforeSigning, + }, "Signing", middleware.Before), + stack.Finalize.Insert(&smithyhttp.InterceptAfterSigning{ + Interceptors: opts.Interceptors.AfterSigning, + }, "Signing", middleware.After), + stack.Deserialize.Add(&smithyhttp.InterceptTransmit{ + BeforeTransmit: opts.Interceptors.BeforeTransmit, + AfterTransmit: opts.Interceptors.AfterTransmit, + }, middleware.After), + stack.Deserialize.Insert(&smithyhttp.InterceptBeforeDeserialization{ + Interceptors: opts.Interceptors.BeforeDeserialization, + }, "OperationDeserializer", middleware.After), // (deserialize stack is called in reverse) + stack.Deserialize.Insert(&smithyhttp.InterceptAfterDeserialization{ + Interceptors: opts.Interceptors.AfterDeserialization, + }, "OperationDeserializer", middleware.Before), + ) } diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_AssociateKmsKey.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_AssociateKmsKey.go index 674d6e18fa9..daf25716dca 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_AssociateKmsKey.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_AssociateKmsKey.go @@ -52,7 +52,7 @@ import ( // results, then all the associated stored log events or query results that were // encrypted with that key will be unencryptable and unusable. // -// CloudWatch Logs supports only symmetric KMS keys. Do not use an associate an +// CloudWatch Logs supports only symmetric KMS keys. Do not associate an // asymmetric KMS key with your log group or query results. For more information, // see [Using Symmetric and Asymmetric Keys]. // @@ -165,7 +165,7 @@ func (c *Client) addOperationAssociateKmsKeyMiddlewares(stack *middleware.Stack, if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -189,9 +189,6 @@ func (c *Client) addOperationAssociateKmsKeyMiddlewares(stack *middleware.Stack, if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -219,16 +216,13 @@ func (c *Client) addOperationAssociateKmsKeyMiddlewares(stack *middleware.Stack, if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_AssociateSourceToS3TableIntegration.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_AssociateSourceToS3TableIntegration.go new file mode 100644 index 00000000000..1952324b31d --- /dev/null +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_AssociateSourceToS3TableIntegration.go @@ -0,0 +1,164 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package cloudwatchlogs + +import ( + "context" + "fmt" + awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/types" + "github.com/aws/smithy-go/middleware" + smithyhttp "github.com/aws/smithy-go/transport/http" +) + +// Associates a data source with an S3 Table Integration for query access in the +// 'logs' namespace. This enables querying log data using analytics engines that +// support Iceberg such as Amazon Athena, Amazon Redshift, and Apache Spark. +func (c *Client) AssociateSourceToS3TableIntegration(ctx context.Context, params *AssociateSourceToS3TableIntegrationInput, optFns ...func(*Options)) (*AssociateSourceToS3TableIntegrationOutput, error) { + if params == nil { + params = &AssociateSourceToS3TableIntegrationInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "AssociateSourceToS3TableIntegration", params, optFns, c.addOperationAssociateSourceToS3TableIntegrationMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*AssociateSourceToS3TableIntegrationOutput) + out.ResultMetadata = metadata + return out, nil +} + +type AssociateSourceToS3TableIntegrationInput struct { + + // The data source to associate with the S3 Table Integration. Contains the name + // and type of the data source. + // + // This member is required. + DataSource *types.DataSource + + // The Amazon Resource Name (ARN) of the S3 Table Integration to associate the + // data source with. + // + // This member is required. + IntegrationArn *string + + noSmithyDocumentSerde +} + +type AssociateSourceToS3TableIntegrationOutput struct { + + // The unique identifier for the association between the data source and S3 Table + // Integration. + Identifier *string + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationAssociateSourceToS3TableIntegrationMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&setOperationInputMiddleware{}, middleware.After); err != nil { + return err + } + err = stack.Serialize.Add(&awsAwsjson11_serializeOpAssociateSourceToS3TableIntegration{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpAssociateSourceToS3TableIntegration{}, middleware.After) + if err != nil { + return err + } + if err := addProtocolFinalizerMiddlewares(stack, options, "AssociateSourceToS3TableIntegration"); err != nil { + return fmt.Errorf("add protocol finalizers: %v", err) + } + + if err = addlegacyEndpointContextSetter(stack, options); err != nil { + return err + } + if err = addSetLoggerMiddleware(stack, options); err != nil { + return err + } + if err = addClientRequestID(stack); err != nil { + return err + } + if err = addComputeContentLength(stack); err != nil { + return err + } + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRetry(stack, options, c); err != nil { + return err + } + if err = addRawResponseToMetadata(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack); err != nil { + return err + } + if err = addSpanRetryLoop(stack, options); err != nil { + return err + } + if err = addClientUserAgent(stack, options); err != nil { + return err + } + if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { + return err + } + if err = addUserAgentRetryMode(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = addOpAssociateSourceToS3TableIntegrationValidationMiddleware(stack); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opAssociateSourceToS3TableIntegration(options.Region), middleware.Before); err != nil { + return err + } + if err = addRecursionDetection(stack); err != nil { + return err + } + if err = addRequestIDRetrieverMiddleware(stack); err != nil { + return err + } + if err = addResponseErrorMiddleware(stack); err != nil { + return err + } + if err = addRequestResponseLogging(stack, options); err != nil { + return err + } + if err = addDisableHTTPSMiddleware(stack, options); err != nil { + return err + } + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { + return err + } + if err = addInterceptAttempt(stack, options); err != nil { + return err + } + if err = addInterceptors(stack, options); err != nil { + return err + } + return nil +} + +func newServiceMetadataMiddleware_opAssociateSourceToS3TableIntegration(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + OperationName: "AssociateSourceToS3TableIntegration", + } +} diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_CancelExportTask.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_CancelExportTask.go index 74329ccb46f..fa0a28f32dc 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_CancelExportTask.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_CancelExportTask.go @@ -79,7 +79,7 @@ func (c *Client) addOperationCancelExportTaskMiddlewares(stack *middleware.Stack if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -103,9 +103,6 @@ func (c *Client) addOperationCancelExportTaskMiddlewares(stack *middleware.Stack if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -133,16 +130,13 @@ func (c *Client) addOperationCancelExportTaskMiddlewares(stack *middleware.Stack if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_CancelImportTask.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_CancelImportTask.go new file mode 100644 index 00000000000..b05b4cb5b6f --- /dev/null +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_CancelImportTask.go @@ -0,0 +1,169 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package cloudwatchlogs + +import ( + "context" + "fmt" + awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/types" + "github.com/aws/smithy-go/middleware" + smithyhttp "github.com/aws/smithy-go/transport/http" +) + +// Cancels an active import task and stops importing data from the CloudTrail Lake +// Event Data Store. +func (c *Client) CancelImportTask(ctx context.Context, params *CancelImportTaskInput, optFns ...func(*Options)) (*CancelImportTaskOutput, error) { + if params == nil { + params = &CancelImportTaskInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "CancelImportTask", params, optFns, c.addOperationCancelImportTaskMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*CancelImportTaskOutput) + out.ResultMetadata = metadata + return out, nil +} + +type CancelImportTaskInput struct { + + // The ID of the import task to cancel. + // + // This member is required. + ImportId *string + + noSmithyDocumentSerde +} + +type CancelImportTaskOutput struct { + + // The timestamp when the import task was created, expressed as the number of + // milliseconds after Jan 1, 1970 00:00:00 UTC. + CreationTime *int64 + + // The ID of the cancelled import task. + ImportId *string + + // Statistics about the import progress at the time of cancellation. + ImportStatistics *types.ImportStatistics + + // The final status of the import task. This will be set to CANCELLED. + ImportStatus types.ImportStatus + + // The timestamp when the import task was cancelled, expressed as the number of + // milliseconds after Jan 1, 1970 00:00:00 UTC. + LastUpdatedTime *int64 + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationCancelImportTaskMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&setOperationInputMiddleware{}, middleware.After); err != nil { + return err + } + err = stack.Serialize.Add(&awsAwsjson11_serializeOpCancelImportTask{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCancelImportTask{}, middleware.After) + if err != nil { + return err + } + if err := addProtocolFinalizerMiddlewares(stack, options, "CancelImportTask"); err != nil { + return fmt.Errorf("add protocol finalizers: %v", err) + } + + if err = addlegacyEndpointContextSetter(stack, options); err != nil { + return err + } + if err = addSetLoggerMiddleware(stack, options); err != nil { + return err + } + if err = addClientRequestID(stack); err != nil { + return err + } + if err = addComputeContentLength(stack); err != nil { + return err + } + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRetry(stack, options, c); err != nil { + return err + } + if err = addRawResponseToMetadata(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack); err != nil { + return err + } + if err = addSpanRetryLoop(stack, options); err != nil { + return err + } + if err = addClientUserAgent(stack, options); err != nil { + return err + } + if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { + return err + } + if err = addUserAgentRetryMode(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = addOpCancelImportTaskValidationMiddleware(stack); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCancelImportTask(options.Region), middleware.Before); err != nil { + return err + } + if err = addRecursionDetection(stack); err != nil { + return err + } + if err = addRequestIDRetrieverMiddleware(stack); err != nil { + return err + } + if err = addResponseErrorMiddleware(stack); err != nil { + return err + } + if err = addRequestResponseLogging(stack, options); err != nil { + return err + } + if err = addDisableHTTPSMiddleware(stack, options); err != nil { + return err + } + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { + return err + } + if err = addInterceptAttempt(stack, options); err != nil { + return err + } + if err = addInterceptors(stack, options); err != nil { + return err + } + return nil +} + +func newServiceMetadataMiddleware_opCancelImportTask(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + OperationName: "CancelImportTask", + } +} diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_CreateDelivery.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_CreateDelivery.go index 7dfe935040a..a8d9448a19e 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_CreateDelivery.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_CreateDelivery.go @@ -19,7 +19,7 @@ import ( // Permissions] in the table at [Enabling logging from Amazon Web Services services.] // // A delivery destination can represent a log group in CloudWatch Logs, an Amazon -// S3 bucket, or a delivery stream in Firehose. +// S3 bucket, a delivery stream in Firehose, or X-Ray. // // To configure logs delivery between a supported Amazon Web Services service and // a destination, you must do the following: @@ -143,7 +143,7 @@ func (c *Client) addOperationCreateDeliveryMiddlewares(stack *middleware.Stack, if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -167,9 +167,6 @@ func (c *Client) addOperationCreateDeliveryMiddlewares(stack *middleware.Stack, if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -197,16 +194,13 @@ func (c *Client) addOperationCreateDeliveryMiddlewares(stack *middleware.Stack, if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_CreateExportTask.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_CreateExportTask.go index cd51da31110..eb5c0dc3727 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_CreateExportTask.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_CreateExportTask.go @@ -32,7 +32,7 @@ import ( // be used as the Amazon S3 key prefix for all exported objects. // // We recommend that you don't regularly export to Amazon S3 as a way to -// continuously archive your logs. For that use case, we instaed recommend that you +// continuously archive your logs. For that use case, we instead recommend that you // use subscriptions. For more information about subscriptions, see [Real-time processing of log data with subscriptions]. // // Time-based sorting on chunks of log data inside an exported file is not @@ -149,7 +149,7 @@ func (c *Client) addOperationCreateExportTaskMiddlewares(stack *middleware.Stack if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -173,9 +173,6 @@ func (c *Client) addOperationCreateExportTaskMiddlewares(stack *middleware.Stack if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -203,16 +200,13 @@ func (c *Client) addOperationCreateExportTaskMiddlewares(stack *middleware.Stack if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_CreateImportTask.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_CreateImportTask.go new file mode 100644 index 00000000000..56533ae82f9 --- /dev/null +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_CreateImportTask.go @@ -0,0 +1,230 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package cloudwatchlogs + +import ( + "context" + "fmt" + awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/types" + "github.com/aws/smithy-go/middleware" + smithyhttp "github.com/aws/smithy-go/transport/http" +) + +// Starts an import from a data source to CloudWatch Log and creates a managed log +// group as the destination for the imported data. Currently, [CloudTrail Event Data Store]is the only +// supported data source. +// +// The import task must satisfy the following constraints: +// +// - The specified source must be in an ACTIVE state. +// +// - The API caller must have permissions to access the data in the provided +// source and to perform iam:PassRole on the provided import role which has the +// same permissions, as described below. +// +// - The provided IAM role must trust the "cloudtrail.amazonaws.com" principal +// and have the following permissions: +// +// - cloudtrail:GetEventDataStoreData +// +// - logs:CreateLogGroup +// +// - logs:CreateLogStream +// +// - logs:PutResourcePolicy +// +// - (If source has an associated Amazon Web Services KMS Key) kms:Decrypt +// +// - (If source has an associated Amazon Web Services KMS Key) +// kms:GenerateDataKey +// +// Example IAM policy for provided import role: +// +// [ { "Effect": "Allow", "Action": "iam:PassRole", "Resource": +// +// "arn:aws:iam::123456789012:role/apiCallerCredentials", "Condition": { +// "StringLike": { "iam:AssociatedResourceARN": +// "arn:aws:logs:us-east-1:123456789012:log-group:aws/cloudtrail/f1d45bff-d0e3-4868-b5d9-2eb678aa32fb:*" +// } } }, { "Effect": "Allow", "Action": [ "cloudtrail:GetEventDataStoreData" ], +// "Resource": [ +// "arn:aws:cloudtrail:us-east-1:123456789012:eventdatastore/f1d45bff-d0e3-4868-b5d9-2eb678aa32fb" +// ] }, { "Effect": "Allow", "Action": [ "logs:CreateImportTask", +// "logs:CreateLogGroup", "logs:CreateLogStream", "logs:PutResourcePolicy" ], +// "Resource": [ "arn:aws:logs:us-east-1:123456789012:log-group:/aws/cloudtrail/*" +// ] }, { "Effect": "Allow", "Action": [ "kms:Decrypt", "kms:GenerateDataKey" ], +// "Resource": [ +// "arn:aws:kms:us-east-1:123456789012:key/12345678-1234-1234-1234-123456789012" ] +// } ] +// +// - If the import source has a customer managed key, the +// "cloudtrail.amazonaws.com" principal needs permissions to perform kms:Decrypt +// and kms:GenerateDataKey. +// +// - There can be no more than 3 active imports per account at a given time. +// +// - The startEventTime must be less than or equal to endEventTime. +// +// - The data being imported must be within the specified source's retention +// period. +// +// [CloudTrail Event Data Store]: https://docs.aws.amazon.com/awscloudtrail/latest/userguide/query-event-data-store.html +func (c *Client) CreateImportTask(ctx context.Context, params *CreateImportTaskInput, optFns ...func(*Options)) (*CreateImportTaskOutput, error) { + if params == nil { + params = &CreateImportTaskInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "CreateImportTask", params, optFns, c.addOperationCreateImportTaskMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*CreateImportTaskOutput) + out.ResultMetadata = metadata + return out, nil +} + +type CreateImportTaskInput struct { + + // The ARN of the IAM role that grants CloudWatch Logs permission to import from + // the CloudTrail Lake Event Data Store. + // + // This member is required. + ImportRoleArn *string + + // The ARN of the source to import from. + // + // This member is required. + ImportSourceArn *string + + // Optional filters to constrain the import by CloudTrail event time. Times are + // specified in Unix timestamp milliseconds. The range of data being imported must + // be within the specified source's retention period. + ImportFilter *types.ImportFilter + + noSmithyDocumentSerde +} + +type CreateImportTaskOutput struct { + + // The timestamp when the import task was created, expressed as the number of + // milliseconds after Jan 1, 1970 00:00:00 UTC. + CreationTime *int64 + + // The ARN of the CloudWatch Logs log group created as the destination for the + // imported events. + ImportDestinationArn *string + + // A unique identifier for the import task. + ImportId *string + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationCreateImportTaskMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&setOperationInputMiddleware{}, middleware.After); err != nil { + return err + } + err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateImportTask{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateImportTask{}, middleware.After) + if err != nil { + return err + } + if err := addProtocolFinalizerMiddlewares(stack, options, "CreateImportTask"); err != nil { + return fmt.Errorf("add protocol finalizers: %v", err) + } + + if err = addlegacyEndpointContextSetter(stack, options); err != nil { + return err + } + if err = addSetLoggerMiddleware(stack, options); err != nil { + return err + } + if err = addClientRequestID(stack); err != nil { + return err + } + if err = addComputeContentLength(stack); err != nil { + return err + } + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRetry(stack, options, c); err != nil { + return err + } + if err = addRawResponseToMetadata(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack); err != nil { + return err + } + if err = addSpanRetryLoop(stack, options); err != nil { + return err + } + if err = addClientUserAgent(stack, options); err != nil { + return err + } + if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { + return err + } + if err = addUserAgentRetryMode(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = addOpCreateImportTaskValidationMiddleware(stack); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateImportTask(options.Region), middleware.Before); err != nil { + return err + } + if err = addRecursionDetection(stack); err != nil { + return err + } + if err = addRequestIDRetrieverMiddleware(stack); err != nil { + return err + } + if err = addResponseErrorMiddleware(stack); err != nil { + return err + } + if err = addRequestResponseLogging(stack, options); err != nil { + return err + } + if err = addDisableHTTPSMiddleware(stack, options); err != nil { + return err + } + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { + return err + } + if err = addInterceptAttempt(stack, options); err != nil { + return err + } + if err = addInterceptors(stack, options); err != nil { + return err + } + return nil +} + +func newServiceMetadataMiddleware_opCreateImportTask(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + OperationName: "CreateImportTask", + } +} diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_CreateLogAnomalyDetector.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_CreateLogAnomalyDetector.go index f7c6ece4f81..2aa1c0de44f 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_CreateLogAnomalyDetector.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_CreateLogAnomalyDetector.go @@ -16,11 +16,10 @@ import ( // // An anomaly detector can help surface issues by automatically discovering // anomalies in your log event traffic. An anomaly detector uses machine learning -// algorithms to scan log events and find patterns. -// -// A pattern is a shared text structure that recurs among your log fields. -// Patterns provide a useful tool for analyzing large sets of logs because a large -// number of log events can often be compressed into a few patterns. +// algorithms to scan log events and find patterns. A pattern is a shared text +// structure that recurs among your log fields. Patterns provide a useful tool for +// analyzing large sets of logs because a large number of log events can often be +// compressed into a few patterns. // // The anomaly detector uses pattern recognition to find anomalies , which are // unusual log events. It uses the evaluationFrequency to compare current log @@ -28,13 +27,11 @@ import ( // // Fields within a pattern are called tokens. Fields that vary within a pattern, // such as a request ID or timestamp, are referred to as dynamic tokens and -// represented by <> . +// represented by <*> . // // The following is an example of a pattern: // -// [INFO] Request time: < -// -// > ms +// [INFO] Request time: <*> ms // // This pattern represents log events like [INFO] Request time: 327 ms and other // similar log events that differ only by the number, in this csse 327. When the @@ -157,7 +154,7 @@ func (c *Client) addOperationCreateLogAnomalyDetectorMiddlewares(stack *middlewa if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -181,9 +178,6 @@ func (c *Client) addOperationCreateLogAnomalyDetectorMiddlewares(stack *middlewa if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -211,16 +205,13 @@ func (c *Client) addOperationCreateLogAnomalyDetectorMiddlewares(stack *middlewa if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_CreateLogGroup.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_CreateLogGroup.go index 322243b9e14..1cba65ea619 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_CreateLogGroup.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_CreateLogGroup.go @@ -67,6 +67,12 @@ type CreateLogGroupInput struct { // This member is required. LogGroupName *string + // Use this parameter to enable deletion protection for the new log group. When + // enabled on a log group, deletion protection blocks all deletion operations until + // it is explicitly disabled. By default log groups are created without deletion + // protection enabled. + DeletionProtectionEnabled *bool + // The Amazon Resource Name (ARN) of the KMS key to use when encrypting log data. // For more information, see [Amazon Resource Names]. // @@ -74,13 +80,18 @@ type CreateLogGroupInput struct { KmsKeyId *string // Use this parameter to specify the log group class for this log group. There are - // two classes: + // three classes: // // - The Standard log class supports all CloudWatch Logs features. // // - The Infrequent Access log class supports a subset of CloudWatch Logs // features and incurs lower costs. // + // - Use the Delivery log class only for delivering Lambda logs to store in + // Amazon S3 or Amazon Data Firehose. Log events in log groups in the Delivery + // class are kept in CloudWatch Logs for only one day. This log class doesn't offer + // rich CloudWatch Logs capabilities such as CloudWatch Logs Insights queries. + // // If you omit this parameter, the default of STANDARD is used. // // The value of logGroupClass can't be changed after a log group is created. @@ -147,7 +158,7 @@ func (c *Client) addOperationCreateLogGroupMiddlewares(stack *middleware.Stack, if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -171,9 +182,6 @@ func (c *Client) addOperationCreateLogGroupMiddlewares(stack *middleware.Stack, if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -201,16 +209,13 @@ func (c *Client) addOperationCreateLogGroupMiddlewares(stack *middleware.Stack, if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_CreateLogStream.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_CreateLogStream.go index 4f369b1579d..b63f4c600e7 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_CreateLogStream.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_CreateLogStream.go @@ -96,7 +96,7 @@ func (c *Client) addOperationCreateLogStreamMiddlewares(stack *middleware.Stack, if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -120,9 +120,6 @@ func (c *Client) addOperationCreateLogStreamMiddlewares(stack *middleware.Stack, if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -150,16 +147,13 @@ func (c *Client) addOperationCreateLogStreamMiddlewares(stack *middleware.Stack, if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_CreateScheduledQuery.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_CreateScheduledQuery.go new file mode 100644 index 00000000000..e3a0e3fe459 --- /dev/null +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_CreateScheduledQuery.go @@ -0,0 +1,224 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package cloudwatchlogs + +import ( + "context" + "fmt" + awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/types" + "github.com/aws/smithy-go/middleware" + smithyhttp "github.com/aws/smithy-go/transport/http" +) + +// Creates a scheduled query that runs CloudWatch Logs Insights queries at regular +// intervals. Scheduled queries enable proactive monitoring by automatically +// executing queries to detect patterns and anomalies in your log data. Query +// results can be delivered to Amazon S3 for analysis or further processing. +func (c *Client) CreateScheduledQuery(ctx context.Context, params *CreateScheduledQueryInput, optFns ...func(*Options)) (*CreateScheduledQueryOutput, error) { + if params == nil { + params = &CreateScheduledQueryInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "CreateScheduledQuery", params, optFns, c.addOperationCreateScheduledQueryMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*CreateScheduledQueryOutput) + out.ResultMetadata = metadata + return out, nil +} + +type CreateScheduledQueryInput struct { + + // The ARN of the IAM role that grants permissions to execute the query and + // deliver results to the specified destination. The role must have permissions to + // read from the specified log groups and write to the destination. + // + // This member is required. + ExecutionRoleArn *string + + // The name of the scheduled query. The name must be unique within your account + // and region. Valid characters are alphanumeric characters, hyphens, underscores, + // and periods. Length must be between 1 and 255 characters. + // + // This member is required. + Name *string + + // The query language to use for the scheduled query. Valid values are CWLI , PPL , + // and SQL . + // + // This member is required. + QueryLanguage types.QueryLanguage + + // The query string to execute. This is the same query syntax used in CloudWatch + // Logs Insights. Maximum length is 10,000 characters. + // + // This member is required. + QueryString *string + + // A cron expression that defines when the scheduled query runs. The expression + // uses standard cron syntax and supports minute-level precision. Maximum length is + // 256 characters. + // + // This member is required. + ScheduleExpression *string + + // An optional description for the scheduled query to help identify its purpose + // and functionality. + Description *string + + // Configuration for where to deliver query results. Currently supports Amazon S3 + // destinations for storing query output. + DestinationConfiguration *types.DestinationConfiguration + + // An array of log group names or ARNs to query. You can specify between 1 and 50 + // log groups. Log groups can be identified by name or full ARN. + LogGroupIdentifiers []string + + // The end time for the scheduled query in Unix epoch format. The query will stop + // executing after this time. + ScheduleEndTime *int64 + + // The start time for the scheduled query in Unix epoch format. The query will not + // execute before this time. + ScheduleStartTime *int64 + + // The time offset in seconds that defines the lookback period for the query. This + // determines how far back in time the query searches from the execution time. + StartTimeOffset *int64 + + // The initial state of the scheduled query. Valid values are ENABLED and DISABLED + // . Default is ENABLED . + State types.ScheduledQueryState + + // Key-value pairs to associate with the scheduled query for resource management + // and cost allocation. + Tags map[string]string + + // The timezone for evaluating the schedule expression. This determines when the + // scheduled query executes relative to the specified timezone. + Timezone *string + + noSmithyDocumentSerde +} + +type CreateScheduledQueryOutput struct { + + // The ARN of the created scheduled query. + ScheduledQueryArn *string + + // The current state of the scheduled query. + State types.ScheduledQueryState + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationCreateScheduledQueryMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&setOperationInputMiddleware{}, middleware.After); err != nil { + return err + } + err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateScheduledQuery{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateScheduledQuery{}, middleware.After) + if err != nil { + return err + } + if err := addProtocolFinalizerMiddlewares(stack, options, "CreateScheduledQuery"); err != nil { + return fmt.Errorf("add protocol finalizers: %v", err) + } + + if err = addlegacyEndpointContextSetter(stack, options); err != nil { + return err + } + if err = addSetLoggerMiddleware(stack, options); err != nil { + return err + } + if err = addClientRequestID(stack); err != nil { + return err + } + if err = addComputeContentLength(stack); err != nil { + return err + } + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRetry(stack, options, c); err != nil { + return err + } + if err = addRawResponseToMetadata(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack); err != nil { + return err + } + if err = addSpanRetryLoop(stack, options); err != nil { + return err + } + if err = addClientUserAgent(stack, options); err != nil { + return err + } + if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { + return err + } + if err = addUserAgentRetryMode(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = addOpCreateScheduledQueryValidationMiddleware(stack); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateScheduledQuery(options.Region), middleware.Before); err != nil { + return err + } + if err = addRecursionDetection(stack); err != nil { + return err + } + if err = addRequestIDRetrieverMiddleware(stack); err != nil { + return err + } + if err = addResponseErrorMiddleware(stack); err != nil { + return err + } + if err = addRequestResponseLogging(stack, options); err != nil { + return err + } + if err = addDisableHTTPSMiddleware(stack, options); err != nil { + return err + } + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { + return err + } + if err = addInterceptAttempt(stack, options); err != nil { + return err + } + if err = addInterceptors(stack, options); err != nil { + return err + } + return nil +} + +func newServiceMetadataMiddleware_opCreateScheduledQuery(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + OperationName: "CreateScheduledQuery", + } +} diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteAccountPolicy.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteAccountPolicy.go index 62507285a00..5425e4ded78 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteAccountPolicy.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteAccountPolicy.go @@ -12,9 +12,11 @@ import ( ) // Deletes a CloudWatch Logs account policy. This stops the account-wide policy -// from applying to log groups in the account. If you delete a data protection -// policy or subscription filter policy, any log-group level policies of those -// types remain in effect. +// from applying to log groups or data sources in the account. If you delete a data +// protection policy or subscription filter policy, any log-group level policies of +// those types remain in effect. This operation supports deletion of data +// source-based field index policies, including facet configurations, in addition +// to log group-based policies. // // To use this operation, you must be signed on with the correct permissions // depending on the type of policy that you are deleting. @@ -31,6 +33,11 @@ import ( // - To delete a field index policy, you must have the logs:DeleteIndexPolicy and // logs:DeleteAccountPolicy permissions. // +// If you delete a field index policy that included facet configurations, those +// +// facets will no longer be available for interactive exploration in the CloudWatch +// Logs Insights console. However, facet data is retained for up to 30 days. +// // If you delete a field index policy, the indexing of the log events that // happened before you deleted the policy will still be used for up to 30 days to // improve CloudWatch Logs Insights queries. @@ -105,7 +112,7 @@ func (c *Client) addOperationDeleteAccountPolicyMiddlewares(stack *middleware.St if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -129,9 +136,6 @@ func (c *Client) addOperationDeleteAccountPolicyMiddlewares(stack *middleware.St if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -159,16 +163,13 @@ func (c *Client) addOperationDeleteAccountPolicyMiddlewares(stack *middleware.St if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteDataProtectionPolicy.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteDataProtectionPolicy.go index 4588e8cb558..0eea5896f5f 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteDataProtectionPolicy.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteDataProtectionPolicy.go @@ -82,7 +82,7 @@ func (c *Client) addOperationDeleteDataProtectionPolicyMiddlewares(stack *middle if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -106,9 +106,6 @@ func (c *Client) addOperationDeleteDataProtectionPolicyMiddlewares(stack *middle if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -136,16 +133,13 @@ func (c *Client) addOperationDeleteDataProtectionPolicyMiddlewares(stack *middle if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteDelivery.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteDelivery.go index bea0a1918f0..ff4b862e322 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteDelivery.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteDelivery.go @@ -83,7 +83,7 @@ func (c *Client) addOperationDeleteDeliveryMiddlewares(stack *middleware.Stack, if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -107,9 +107,6 @@ func (c *Client) addOperationDeleteDeliveryMiddlewares(stack *middleware.Stack, if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -137,16 +134,13 @@ func (c *Client) addOperationDeleteDeliveryMiddlewares(stack *middleware.Stack, if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteDeliveryDestination.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteDeliveryDestination.go index baa964c1965..c8ae1685680 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteDeliveryDestination.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteDeliveryDestination.go @@ -37,7 +37,7 @@ func (c *Client) DeleteDeliveryDestination(ctx context.Context, params *DeleteDe type DeleteDeliveryDestinationInput struct { // The name of the delivery destination that you want to delete. You can find a - // list of delivery destionation names by using the [DescribeDeliveryDestinations]operation. + // list of delivery destination names by using the [DescribeDeliveryDestinations]operation. // // [DescribeDeliveryDestinations]: https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_DescribeDeliveryDestinations.html // @@ -88,7 +88,7 @@ func (c *Client) addOperationDeleteDeliveryDestinationMiddlewares(stack *middlew if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -112,9 +112,6 @@ func (c *Client) addOperationDeleteDeliveryDestinationMiddlewares(stack *middlew if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -142,16 +139,13 @@ func (c *Client) addOperationDeleteDeliveryDestinationMiddlewares(stack *middlew if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteDeliveryDestinationPolicy.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteDeliveryDestinationPolicy.go index 2876294ec43..a2f883811e5 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteDeliveryDestinationPolicy.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteDeliveryDestinationPolicy.go @@ -80,7 +80,7 @@ func (c *Client) addOperationDeleteDeliveryDestinationPolicyMiddlewares(stack *m if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -104,9 +104,6 @@ func (c *Client) addOperationDeleteDeliveryDestinationPolicyMiddlewares(stack *m if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -134,16 +131,13 @@ func (c *Client) addOperationDeleteDeliveryDestinationPolicyMiddlewares(stack *m if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteDeliverySource.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteDeliverySource.go index 96c4110a225..acb19633c86 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteDeliverySource.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteDeliverySource.go @@ -84,7 +84,7 @@ func (c *Client) addOperationDeleteDeliverySourceMiddlewares(stack *middleware.S if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -108,9 +108,6 @@ func (c *Client) addOperationDeleteDeliverySourceMiddlewares(stack *middleware.S if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -138,16 +135,13 @@ func (c *Client) addOperationDeleteDeliverySourceMiddlewares(stack *middleware.S if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteDestination.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteDestination.go index fe187946eeb..72e24e1e27d 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteDestination.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteDestination.go @@ -79,7 +79,7 @@ func (c *Client) addOperationDeleteDestinationMiddlewares(stack *middleware.Stac if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -103,9 +103,6 @@ func (c *Client) addOperationDeleteDestinationMiddlewares(stack *middleware.Stac if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -133,16 +130,13 @@ func (c *Client) addOperationDeleteDestinationMiddlewares(stack *middleware.Stac if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteIndexPolicy.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteIndexPolicy.go index 5f2e521f845..f94feb32447 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteIndexPolicy.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteIndexPolicy.go @@ -15,14 +15,21 @@ import ( // will still be used for as many as 30 days to improve CloudWatch Logs Insights // queries. // +// If the deleted policy included facet configurations, those facets will no +// longer be available for interactive exploration in the CloudWatch Logs Insights +// console for this log group. However, facet data is retained for up to 30 days. +// // You can't use this operation to delete an account-level index policy. Instead, -// use [DeletAccountPolicy]. +// use [DeleteAccountPolicy]. // // If you delete a log-group level field index policy and there is an // account-level field index policy, in a few minutes the log group begins using -// that account-wide policy to index new incoming log events. +// that account-wide policy to index new incoming log events. This operation only +// affects log group-level policies, including any facet configurations, and +// preserves any data source-based account policies that may apply to the log +// group. // -// [DeletAccountPolicy]: https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_DeleteAccountPolicy.html +// [DeleteAccountPolicy]: https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_DeleteAccountPolicy.html func (c *Client) DeleteIndexPolicy(ctx context.Context, params *DeleteIndexPolicyInput, optFns ...func(*Options)) (*DeleteIndexPolicyOutput, error) { if params == nil { params = &DeleteIndexPolicyInput{} @@ -90,7 +97,7 @@ func (c *Client) addOperationDeleteIndexPolicyMiddlewares(stack *middleware.Stac if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -114,9 +121,6 @@ func (c *Client) addOperationDeleteIndexPolicyMiddlewares(stack *middleware.Stac if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -144,16 +148,13 @@ func (c *Client) addOperationDeleteIndexPolicyMiddlewares(stack *middleware.Stac if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteIntegration.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteIntegration.go index fef00d14b9e..8568de07721 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteIntegration.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteIntegration.go @@ -91,7 +91,7 @@ func (c *Client) addOperationDeleteIntegrationMiddlewares(stack *middleware.Stac if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -115,9 +115,6 @@ func (c *Client) addOperationDeleteIntegrationMiddlewares(stack *middleware.Stac if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -145,16 +142,13 @@ func (c *Client) addOperationDeleteIntegrationMiddlewares(stack *middleware.Stac if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteLogAnomalyDetector.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteLogAnomalyDetector.go index be86038ec70..8d1013617da 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteLogAnomalyDetector.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteLogAnomalyDetector.go @@ -80,7 +80,7 @@ func (c *Client) addOperationDeleteLogAnomalyDetectorMiddlewares(stack *middlewa if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -104,9 +104,6 @@ func (c *Client) addOperationDeleteLogAnomalyDetectorMiddlewares(stack *middlewa if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -134,16 +131,13 @@ func (c *Client) addOperationDeleteLogAnomalyDetectorMiddlewares(stack *middlewa if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteLogGroup.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteLogGroup.go index 9a2209e3b83..b9201e6d253 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteLogGroup.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteLogGroup.go @@ -78,7 +78,7 @@ func (c *Client) addOperationDeleteLogGroupMiddlewares(stack *middleware.Stack, if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -102,9 +102,6 @@ func (c *Client) addOperationDeleteLogGroupMiddlewares(stack *middleware.Stack, if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -132,16 +129,13 @@ func (c *Client) addOperationDeleteLogGroupMiddlewares(stack *middleware.Stack, if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteLogStream.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteLogStream.go index 4cf8c3d3653..365eee814a0 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteLogStream.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteLogStream.go @@ -83,7 +83,7 @@ func (c *Client) addOperationDeleteLogStreamMiddlewares(stack *middleware.Stack, if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -107,9 +107,6 @@ func (c *Client) addOperationDeleteLogStreamMiddlewares(stack *middleware.Stack, if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -137,16 +134,13 @@ func (c *Client) addOperationDeleteLogStreamMiddlewares(stack *middleware.Stack, if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteMetricFilter.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteMetricFilter.go index b57e62bc1a7..6fd1a90367e 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteMetricFilter.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteMetricFilter.go @@ -82,7 +82,7 @@ func (c *Client) addOperationDeleteMetricFilterMiddlewares(stack *middleware.Sta if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -106,9 +106,6 @@ func (c *Client) addOperationDeleteMetricFilterMiddlewares(stack *middleware.Sta if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -136,16 +133,13 @@ func (c *Client) addOperationDeleteMetricFilterMiddlewares(stack *middleware.Sta if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteQueryDefinition.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteQueryDefinition.go index 8c3457e1615..6876c4608f8 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteQueryDefinition.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteQueryDefinition.go @@ -91,7 +91,7 @@ func (c *Client) addOperationDeleteQueryDefinitionMiddlewares(stack *middleware. if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -115,9 +115,6 @@ func (c *Client) addOperationDeleteQueryDefinitionMiddlewares(stack *middleware. if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -145,16 +142,13 @@ func (c *Client) addOperationDeleteQueryDefinitionMiddlewares(stack *middleware. if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteResourcePolicy.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteResourcePolicy.go index 9af6955c6c7..b99e52a2d94 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteResourcePolicy.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteResourcePolicy.go @@ -29,9 +29,17 @@ func (c *Client) DeleteResourcePolicy(ctx context.Context, params *DeleteResourc type DeleteResourcePolicyInput struct { + // The expected revision ID of the resource policy. Required when deleting a + // resource-scoped policy to prevent concurrent modifications. + ExpectedRevisionId *string + // The name of the policy to be revoked. This parameter is required. PolicyName *string + // The ARN of the CloudWatch Logs resource for which the resource policy needs to + // be deleted + ResourceArn *string + noSmithyDocumentSerde } @@ -76,7 +84,7 @@ func (c *Client) addOperationDeleteResourcePolicyMiddlewares(stack *middleware.S if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -100,9 +108,6 @@ func (c *Client) addOperationDeleteResourcePolicyMiddlewares(stack *middleware.S if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -127,16 +132,13 @@ func (c *Client) addOperationDeleteResourcePolicyMiddlewares(stack *middleware.S if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteRetentionPolicy.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteRetentionPolicy.go index dcc53d7870a..d241bda74d5 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteRetentionPolicy.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteRetentionPolicy.go @@ -80,7 +80,7 @@ func (c *Client) addOperationDeleteRetentionPolicyMiddlewares(stack *middleware. if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -104,9 +104,6 @@ func (c *Client) addOperationDeleteRetentionPolicyMiddlewares(stack *middleware. if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -134,16 +131,13 @@ func (c *Client) addOperationDeleteRetentionPolicyMiddlewares(stack *middleware. if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteScheduledQuery.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteScheduledQuery.go new file mode 100644 index 00000000000..29ca4673a10 --- /dev/null +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteScheduledQuery.go @@ -0,0 +1,150 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package cloudwatchlogs + +import ( + "context" + "fmt" + awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/smithy-go/middleware" + smithyhttp "github.com/aws/smithy-go/transport/http" +) + +// Deletes a scheduled query and stops all future executions. This operation also +// removes any configured actions and associated resources. +func (c *Client) DeleteScheduledQuery(ctx context.Context, params *DeleteScheduledQueryInput, optFns ...func(*Options)) (*DeleteScheduledQueryOutput, error) { + if params == nil { + params = &DeleteScheduledQueryInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "DeleteScheduledQuery", params, optFns, c.addOperationDeleteScheduledQueryMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*DeleteScheduledQueryOutput) + out.ResultMetadata = metadata + return out, nil +} + +type DeleteScheduledQueryInput struct { + + // The ARN or name of the scheduled query to delete. + // + // This member is required. + Identifier *string + + noSmithyDocumentSerde +} + +type DeleteScheduledQueryOutput struct { + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationDeleteScheduledQueryMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&setOperationInputMiddleware{}, middleware.After); err != nil { + return err + } + err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteScheduledQuery{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteScheduledQuery{}, middleware.After) + if err != nil { + return err + } + if err := addProtocolFinalizerMiddlewares(stack, options, "DeleteScheduledQuery"); err != nil { + return fmt.Errorf("add protocol finalizers: %v", err) + } + + if err = addlegacyEndpointContextSetter(stack, options); err != nil { + return err + } + if err = addSetLoggerMiddleware(stack, options); err != nil { + return err + } + if err = addClientRequestID(stack); err != nil { + return err + } + if err = addComputeContentLength(stack); err != nil { + return err + } + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRetry(stack, options, c); err != nil { + return err + } + if err = addRawResponseToMetadata(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack); err != nil { + return err + } + if err = addSpanRetryLoop(stack, options); err != nil { + return err + } + if err = addClientUserAgent(stack, options); err != nil { + return err + } + if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { + return err + } + if err = addUserAgentRetryMode(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = addOpDeleteScheduledQueryValidationMiddleware(stack); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteScheduledQuery(options.Region), middleware.Before); err != nil { + return err + } + if err = addRecursionDetection(stack); err != nil { + return err + } + if err = addRequestIDRetrieverMiddleware(stack); err != nil { + return err + } + if err = addResponseErrorMiddleware(stack); err != nil { + return err + } + if err = addRequestResponseLogging(stack, options); err != nil { + return err + } + if err = addDisableHTTPSMiddleware(stack, options); err != nil { + return err + } + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { + return err + } + if err = addInterceptAttempt(stack, options); err != nil { + return err + } + if err = addInterceptors(stack, options); err != nil { + return err + } + return nil +} + +func newServiceMetadataMiddleware_opDeleteScheduledQuery(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + OperationName: "DeleteScheduledQuery", + } +} diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteSubscriptionFilter.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteSubscriptionFilter.go index 0bd5935a000..f9b6bb28d47 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteSubscriptionFilter.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteSubscriptionFilter.go @@ -82,7 +82,7 @@ func (c *Client) addOperationDeleteSubscriptionFilterMiddlewares(stack *middlewa if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -106,9 +106,6 @@ func (c *Client) addOperationDeleteSubscriptionFilterMiddlewares(stack *middlewa if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -136,16 +133,13 @@ func (c *Client) addOperationDeleteSubscriptionFilterMiddlewares(stack *middlewa if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteTransformer.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteTransformer.go index b8a79450005..cf1912b8430 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteTransformer.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DeleteTransformer.go @@ -86,7 +86,7 @@ func (c *Client) addOperationDeleteTransformerMiddlewares(stack *middleware.Stac if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -110,9 +110,6 @@ func (c *Client) addOperationDeleteTransformerMiddlewares(stack *middleware.Stac if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -140,16 +137,13 @@ func (c *Client) addOperationDeleteTransformerMiddlewares(stack *middleware.Stac if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DescribeAccountPolicies.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DescribeAccountPolicies.go index 7a17e0c31d0..db184fd7433 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DescribeAccountPolicies.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DescribeAccountPolicies.go @@ -20,7 +20,7 @@ import ( // logs:GetDataProtectionPolicy and logs:DescribeAccountPolicies permissions. // // - To see subscription filter policies, you must have the -// logs:DescrubeSubscriptionFilters and logs:DescribeAccountPolicies permissions. +// logs:DescribeSubscriptionFilters and logs:DescribeAccountPolicies permissions. // // - To see transformer policies, you must have the logs:GetTransformer and // logs:DescribeAccountPolicies permissions. @@ -120,7 +120,7 @@ func (c *Client) addOperationDescribeAccountPoliciesMiddlewares(stack *middlewar if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -144,9 +144,6 @@ func (c *Client) addOperationDescribeAccountPoliciesMiddlewares(stack *middlewar if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -174,16 +171,13 @@ func (c *Client) addOperationDescribeAccountPoliciesMiddlewares(stack *middlewar if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DescribeConfigurationTemplates.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DescribeConfigurationTemplates.go index ce7264639c8..015965ca8e7 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DescribeConfigurationTemplates.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DescribeConfigurationTemplates.go @@ -108,7 +108,7 @@ func (c *Client) addOperationDescribeConfigurationTemplatesMiddlewares(stack *mi if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -132,9 +132,6 @@ func (c *Client) addOperationDescribeConfigurationTemplatesMiddlewares(stack *mi if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -159,16 +156,13 @@ func (c *Client) addOperationDescribeConfigurationTemplatesMiddlewares(stack *mi if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DescribeDeliveries.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DescribeDeliveries.go index cee46589289..8111c6830a1 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DescribeDeliveries.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DescribeDeliveries.go @@ -17,8 +17,8 @@ import ( // // A delivery source represents an Amazon Web Services resource that sends logs to // an logs delivery destination. The destination can be CloudWatch Logs, Amazon S3, -// or Firehose. Only some Amazon Web Services services support being configured as -// a delivery source. These services are listed in [Enable logging from Amazon Web Services services.] +// Firehose or X-Ray. Only some Amazon Web Services services support being +// configured as a delivery source. These services are listed in [Enable logging from Amazon Web Services services.] // // [delivery destination]: https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_PutDeliveryDestination.html // [delivery source]: https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_PutDeliverySource.html @@ -98,7 +98,7 @@ func (c *Client) addOperationDescribeDeliveriesMiddlewares(stack *middleware.Sta if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -122,9 +122,6 @@ func (c *Client) addOperationDescribeDeliveriesMiddlewares(stack *middleware.Sta if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -149,16 +146,13 @@ func (c *Client) addOperationDescribeDeliveriesMiddlewares(stack *middleware.Sta if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DescribeDeliveryDestinations.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DescribeDeliveryDestinations.go index b7af948538d..bd78f42a8fb 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DescribeDeliveryDestinations.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DescribeDeliveryDestinations.go @@ -89,7 +89,7 @@ func (c *Client) addOperationDescribeDeliveryDestinationsMiddlewares(stack *midd if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -113,9 +113,6 @@ func (c *Client) addOperationDescribeDeliveryDestinationsMiddlewares(stack *midd if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -140,16 +137,13 @@ func (c *Client) addOperationDescribeDeliveryDestinationsMiddlewares(stack *midd if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DescribeDeliverySources.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DescribeDeliverySources.go index 9b139fe6972..6ae69794029 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DescribeDeliverySources.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DescribeDeliverySources.go @@ -88,7 +88,7 @@ func (c *Client) addOperationDescribeDeliverySourcesMiddlewares(stack *middlewar if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -112,9 +112,6 @@ func (c *Client) addOperationDescribeDeliverySourcesMiddlewares(stack *middlewar if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -139,16 +136,13 @@ func (c *Client) addOperationDescribeDeliverySourcesMiddlewares(stack *middlewar if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DescribeDestinations.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DescribeDestinations.go index 768fe80b3b5..c22de80a2cc 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DescribeDestinations.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DescribeDestinations.go @@ -91,7 +91,7 @@ func (c *Client) addOperationDescribeDestinationsMiddlewares(stack *middleware.S if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -115,9 +115,6 @@ func (c *Client) addOperationDescribeDestinationsMiddlewares(stack *middleware.S if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -142,16 +139,13 @@ func (c *Client) addOperationDescribeDestinationsMiddlewares(stack *middleware.S if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DescribeExportTasks.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DescribeExportTasks.go index 12a0a5d0513..66a1cfb9df2 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DescribeExportTasks.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DescribeExportTasks.go @@ -97,7 +97,7 @@ func (c *Client) addOperationDescribeExportTasksMiddlewares(stack *middleware.St if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -121,9 +121,6 @@ func (c *Client) addOperationDescribeExportTasksMiddlewares(stack *middleware.St if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -148,16 +145,13 @@ func (c *Client) addOperationDescribeExportTasksMiddlewares(stack *middleware.St if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DescribeFieldIndexes.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DescribeFieldIndexes.go index 18556d8af4b..2ed1f8c2da7 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DescribeFieldIndexes.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DescribeFieldIndexes.go @@ -11,8 +11,8 @@ import ( smithyhttp "github.com/aws/smithy-go/transport/http" ) -// Returns a list of field indexes listed in the field index policies of one or -// more log groups. For more information about field index policies, see [PutIndexPolicy]. +// Returns a list of custom and default field indexes which are discovered in log +// data. For more information about field index policies, see [PutIndexPolicy]. // // [PutIndexPolicy]: https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_PutIndexPolicy.html func (c *Client) DescribeFieldIndexes(ctx context.Context, params *DescribeFieldIndexesInput, optFns ...func(*Options)) (*DescribeFieldIndexesOutput, error) { @@ -92,7 +92,7 @@ func (c *Client) addOperationDescribeFieldIndexesMiddlewares(stack *middleware.S if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -116,9 +116,6 @@ func (c *Client) addOperationDescribeFieldIndexesMiddlewares(stack *middleware.S if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -146,16 +143,13 @@ func (c *Client) addOperationDescribeFieldIndexesMiddlewares(stack *middleware.S if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DescribeImportTaskBatches.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DescribeImportTaskBatches.go new file mode 100644 index 00000000000..9dba40fedd9 --- /dev/null +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DescribeImportTaskBatches.go @@ -0,0 +1,176 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package cloudwatchlogs + +import ( + "context" + "fmt" + awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/types" + "github.com/aws/smithy-go/middleware" + smithyhttp "github.com/aws/smithy-go/transport/http" +) + +// Gets detailed information about the individual batches within an import task, +// including their status and any error messages. For CloudTrail Event Data Store +// sources, a batch refers to a subset of stored events grouped by their eventTime. +func (c *Client) DescribeImportTaskBatches(ctx context.Context, params *DescribeImportTaskBatchesInput, optFns ...func(*Options)) (*DescribeImportTaskBatchesOutput, error) { + if params == nil { + params = &DescribeImportTaskBatchesInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "DescribeImportTaskBatches", params, optFns, c.addOperationDescribeImportTaskBatchesMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*DescribeImportTaskBatchesOutput) + out.ResultMetadata = metadata + return out, nil +} + +type DescribeImportTaskBatchesInput struct { + + // The ID of the import task to get batch information for. + // + // This member is required. + ImportId *string + + // Optional filter to list import batches by their status. Accepts multiple status + // values: IN_PROGRESS, CANCELLED, COMPLETED and FAILED. + BatchImportStatus []types.ImportStatus + + // The maximum number of import batches to return in the response. Default: 10 + Limit *int32 + + // The pagination token for the next set of results. + NextToken *string + + noSmithyDocumentSerde +} + +type DescribeImportTaskBatchesOutput struct { + + // The list of import batches that match the request filters. + ImportBatches []types.ImportBatch + + // The ID of the import task. + ImportId *string + + // The ARN of the source being imported from. + ImportSourceArn *string + + // The token to use when requesting the next set of results. Not present if there + // are no additional results to retrieve. + NextToken *string + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationDescribeImportTaskBatchesMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&setOperationInputMiddleware{}, middleware.After); err != nil { + return err + } + err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeImportTaskBatches{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeImportTaskBatches{}, middleware.After) + if err != nil { + return err + } + if err := addProtocolFinalizerMiddlewares(stack, options, "DescribeImportTaskBatches"); err != nil { + return fmt.Errorf("add protocol finalizers: %v", err) + } + + if err = addlegacyEndpointContextSetter(stack, options); err != nil { + return err + } + if err = addSetLoggerMiddleware(stack, options); err != nil { + return err + } + if err = addClientRequestID(stack); err != nil { + return err + } + if err = addComputeContentLength(stack); err != nil { + return err + } + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRetry(stack, options, c); err != nil { + return err + } + if err = addRawResponseToMetadata(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack); err != nil { + return err + } + if err = addSpanRetryLoop(stack, options); err != nil { + return err + } + if err = addClientUserAgent(stack, options); err != nil { + return err + } + if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { + return err + } + if err = addUserAgentRetryMode(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = addOpDescribeImportTaskBatchesValidationMiddleware(stack); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeImportTaskBatches(options.Region), middleware.Before); err != nil { + return err + } + if err = addRecursionDetection(stack); err != nil { + return err + } + if err = addRequestIDRetrieverMiddleware(stack); err != nil { + return err + } + if err = addResponseErrorMiddleware(stack); err != nil { + return err + } + if err = addRequestResponseLogging(stack, options); err != nil { + return err + } + if err = addDisableHTTPSMiddleware(stack, options); err != nil { + return err + } + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { + return err + } + if err = addInterceptAttempt(stack, options); err != nil { + return err + } + if err = addInterceptors(stack, options); err != nil { + return err + } + return nil +} + +func newServiceMetadataMiddleware_opDescribeImportTaskBatches(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + OperationName: "DescribeImportTaskBatches", + } +} diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DescribeImportTasks.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DescribeImportTasks.go new file mode 100644 index 00000000000..7479f5c4e81 --- /dev/null +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DescribeImportTasks.go @@ -0,0 +1,167 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package cloudwatchlogs + +import ( + "context" + "fmt" + awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/types" + "github.com/aws/smithy-go/middleware" + smithyhttp "github.com/aws/smithy-go/transport/http" +) + +// Lists and describes import tasks, with optional filtering by import status and +// source ARN. +func (c *Client) DescribeImportTasks(ctx context.Context, params *DescribeImportTasksInput, optFns ...func(*Options)) (*DescribeImportTasksOutput, error) { + if params == nil { + params = &DescribeImportTasksInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "DescribeImportTasks", params, optFns, c.addOperationDescribeImportTasksMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*DescribeImportTasksOutput) + out.ResultMetadata = metadata + return out, nil +} + +type DescribeImportTasksInput struct { + + // Optional filter to describe a specific import task by its ID. + ImportId *string + + // Optional filter to list imports from a specific source + ImportSourceArn *string + + // Optional filter to list imports by their status. Valid values are IN_PROGRESS, + // CANCELLED, COMPLETED and FAILED. + ImportStatus types.ImportStatus + + // The maximum number of import tasks to return in the response. Default: 50 + Limit *int32 + + // The pagination token for the next set of results. + NextToken *string + + noSmithyDocumentSerde +} + +type DescribeImportTasksOutput struct { + + // The list of import tasks that match the request filters. + Imports []types.Import + + // The token to use when requesting the next set of results. Not present if there + // are no additional results to retrieve. + NextToken *string + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationDescribeImportTasksMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&setOperationInputMiddleware{}, middleware.After); err != nil { + return err + } + err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeImportTasks{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeImportTasks{}, middleware.After) + if err != nil { + return err + } + if err := addProtocolFinalizerMiddlewares(stack, options, "DescribeImportTasks"); err != nil { + return fmt.Errorf("add protocol finalizers: %v", err) + } + + if err = addlegacyEndpointContextSetter(stack, options); err != nil { + return err + } + if err = addSetLoggerMiddleware(stack, options); err != nil { + return err + } + if err = addClientRequestID(stack); err != nil { + return err + } + if err = addComputeContentLength(stack); err != nil { + return err + } + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRetry(stack, options, c); err != nil { + return err + } + if err = addRawResponseToMetadata(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack); err != nil { + return err + } + if err = addSpanRetryLoop(stack, options); err != nil { + return err + } + if err = addClientUserAgent(stack, options); err != nil { + return err + } + if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { + return err + } + if err = addUserAgentRetryMode(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeImportTasks(options.Region), middleware.Before); err != nil { + return err + } + if err = addRecursionDetection(stack); err != nil { + return err + } + if err = addRequestIDRetrieverMiddleware(stack); err != nil { + return err + } + if err = addResponseErrorMiddleware(stack); err != nil { + return err + } + if err = addRequestResponseLogging(stack, options); err != nil { + return err + } + if err = addDisableHTTPSMiddleware(stack, options); err != nil { + return err + } + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { + return err + } + if err = addInterceptAttempt(stack, options); err != nil { + return err + } + if err = addInterceptors(stack, options); err != nil { + return err + } + return nil +} + +func newServiceMetadataMiddleware_opDescribeImportTasks(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + OperationName: "DescribeImportTasks", + } +} diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DescribeIndexPolicies.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DescribeIndexPolicies.go index bf71dd0912c..5eac3b496e6 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DescribeIndexPolicies.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DescribeIndexPolicies.go @@ -11,7 +11,7 @@ import ( smithyhttp "github.com/aws/smithy-go/transport/http" ) -// Returns the field index policies of one or more log groups. For more +// Returns the field index policies of the specified log group. For more // information about field index policies, see [PutIndexPolicy]. // // If a specified log group has a log-group level index policy, that policy is @@ -102,7 +102,7 @@ func (c *Client) addOperationDescribeIndexPoliciesMiddlewares(stack *middleware. if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -126,9 +126,6 @@ func (c *Client) addOperationDescribeIndexPoliciesMiddlewares(stack *middleware. if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -156,16 +153,13 @@ func (c *Client) addOperationDescribeIndexPoliciesMiddlewares(stack *middleware. if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DescribeLogGroups.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DescribeLogGroups.go index 4140505ea5e..b81dc3ca179 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DescribeLogGroups.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DescribeLogGroups.go @@ -11,8 +11,9 @@ import ( smithyhttp "github.com/aws/smithy-go/transport/http" ) -// Lists the specified log groups. You can list all your log groups or filter the -// results by prefix. The results are ASCII-sorted by log group name. +// Returns information about log groups, including data sources that ingest into +// each log group. You can return all your log groups or filter the results by +// prefix. The results are ASCII-sorted by log group name. // // CloudWatch Logs doesn't support IAM policies that control access to the // DescribeLogGroups action by using the aws:ResourceTag/key-name condition key. @@ -43,41 +44,62 @@ func (c *Client) DescribeLogGroups(ctx context.Context, params *DescribeLogGroup type DescribeLogGroupsInput struct { - // When includeLinkedAccounts is set to True , use this parameter to specify the + // When includeLinkedAccounts is set to true , use this parameter to specify the // list of accounts to search. You can specify as many as 20 account IDs in the // array. AccountIdentifiers []string - // If you are using a monitoring account, set this to True to have the operation + // If you are using a monitoring account, set this to true to have the operation // return log groups in the accounts listed in accountIdentifiers . // - // If this parameter is set to true and accountIdentifiers + // If this parameter is set to true and accountIdentifiers contains a null value, + // the operation returns all log groups in the monitoring account and all log + // groups in all source accounts that are linked to the monitoring account. // - // contains a null value, the operation returns all log groups in the monitoring - // account and all log groups in all source accounts that are linked to the - // monitoring account. + // The default for this parameter is false . IncludeLinkedAccounts *bool // The maximum number of items returned. If you don't specify a value, the default // is up to 50 items. Limit *int32 - // Specifies the log group class for this log group. There are two classes: + // Use this parameter to limit the results to only those log groups in the + // specified log group class. If you omit this parameter, log groups of all classes + // can be returned. + // + // Specifies the log group class for this log group. There are three classes: // // - The Standard log class supports all CloudWatch Logs features. // // - The Infrequent Access log class supports a subset of CloudWatch Logs // features and incurs lower costs. // + // - Use the Delivery log class only for delivering Lambda logs to store in + // Amazon S3 or Amazon Data Firehose. Log events in log groups in the Delivery + // class are kept in CloudWatch Logs for only one day. This log class doesn't offer + // rich CloudWatch Logs capabilities such as CloudWatch Logs Insights queries. + // // For details about the features supported by each class, see [Log classes] // // [Log classes]: https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CloudWatch_Logs_Log_Classes.html LogGroupClass types.LogGroupClass + // Use this array to filter the list of log groups returned. If you specify this + // parameter, the only other filter that you can choose to specify is + // includeLinkedAccounts . + // + // If you are using this operation in a monitoring account, you can specify the + // ARNs of log groups in source accounts and in the monitoring account itself. If + // you are using this operation in an account that is not a cross-account + // monitoring account, you can specify only log group names in the same account as + // the operation. + LogGroupIdentifiers []string + // If you specify a string for this parameter, the operation returns only log // groups that have names that match the string based on a case-sensitive substring - // search. For example, if you specify Foo , log groups named FooBar , aws/Foo , - // and GroupFoo would match, but foo , F/o/o and Froo would not match. + // search. For example, if you specify DataLogs , log groups named DataLogs , + // aws/DataLogs , and GroupDataLogs would match, but datalogs , Data/log/s and + // Groupdata would not match. // // If you specify logGroupNamePattern in your request, then only arn , creationTime // , and logGroupName are included in the response. @@ -101,10 +123,8 @@ type DescribeLogGroupsInput struct { type DescribeLogGroupsOutput struct { - // The log groups. - // - // If the retentionInDays value is not included for a log group, then that log - // group's events do not expire. + // An array of structures, where each structure contains the information about one + // log group. LogGroups []types.LogGroup // The token for the next set of items to return. The token expires after 24 hours. @@ -150,7 +170,7 @@ func (c *Client) addOperationDescribeLogGroupsMiddlewares(stack *middleware.Stac if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -174,9 +194,6 @@ func (c *Client) addOperationDescribeLogGroupsMiddlewares(stack *middleware.Stac if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -201,16 +218,13 @@ func (c *Client) addOperationDescribeLogGroupsMiddlewares(stack *middleware.Stac if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DescribeLogStreams.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DescribeLogStreams.go index 87904a2fc5a..89198ba59c6 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DescribeLogStreams.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DescribeLogStreams.go @@ -138,7 +138,7 @@ func (c *Client) addOperationDescribeLogStreamsMiddlewares(stack *middleware.Sta if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -162,9 +162,6 @@ func (c *Client) addOperationDescribeLogStreamsMiddlewares(stack *middleware.Sta if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -189,16 +186,13 @@ func (c *Client) addOperationDescribeLogStreamsMiddlewares(stack *middleware.Sta if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DescribeMetricFilters.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DescribeMetricFilters.go index 4bcbeffb8e5..c6a074b4e56 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DescribeMetricFilters.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DescribeMetricFilters.go @@ -107,7 +107,7 @@ func (c *Client) addOperationDescribeMetricFiltersMiddlewares(stack *middleware. if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -131,9 +131,6 @@ func (c *Client) addOperationDescribeMetricFiltersMiddlewares(stack *middleware. if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -158,16 +155,13 @@ func (c *Client) addOperationDescribeMetricFiltersMiddlewares(stack *middleware. if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DescribeQueries.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DescribeQueries.go index 3ebfba84209..c221ad745f0 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DescribeQueries.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DescribeQueries.go @@ -14,6 +14,11 @@ import ( // Returns a list of CloudWatch Logs Insights queries that are scheduled, running, // or have been run recently in this account. You can request all queries or limit // it to queries of a specific log group or queries with a certain status. +// +// This operation includes both interactive queries started directly by users and +// automated queries executed by scheduled query configurations. Scheduled query +// executions appear in the results alongside manually initiated queries, providing +// visibility into all query activity in your account. func (c *Client) DescribeQueries(ctx context.Context, params *DescribeQueriesInput, optFns ...func(*Options)) (*DescribeQueriesOutput, error) { if params == nil { params = &DescribeQueriesInput{} @@ -99,7 +104,7 @@ func (c *Client) addOperationDescribeQueriesMiddlewares(stack *middleware.Stack, if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -123,9 +128,6 @@ func (c *Client) addOperationDescribeQueriesMiddlewares(stack *middleware.Stack, if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -150,16 +152,13 @@ func (c *Client) addOperationDescribeQueriesMiddlewares(stack *middleware.Stack, if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DescribeQueryDefinitions.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DescribeQueryDefinitions.go index 582883bb31b..5039e68604f 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DescribeQueryDefinitions.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DescribeQueryDefinitions.go @@ -101,7 +101,7 @@ func (c *Client) addOperationDescribeQueryDefinitionsMiddlewares(stack *middlewa if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -125,9 +125,6 @@ func (c *Client) addOperationDescribeQueryDefinitionsMiddlewares(stack *middlewa if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -152,16 +149,13 @@ func (c *Client) addOperationDescribeQueryDefinitionsMiddlewares(stack *middlewa if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DescribeResourcePolicies.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DescribeResourcePolicies.go index 86526e4ef47..0113a06eb01 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DescribeResourcePolicies.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DescribeResourcePolicies.go @@ -36,6 +36,13 @@ type DescribeResourcePoliciesInput struct { // The token for the next set of items to return. The token expires after 24 hours. NextToken *string + // Specifies the scope of the resource policy. Valid values are ACCOUNT or RESOURCE + // . When not specified, defaults to ACCOUNT . + PolicyScope types.PolicyScope + + // The ARN of the CloudWatch Logs resource for which to query the resource policy. + ResourceArn *string + noSmithyDocumentSerde } @@ -87,7 +94,7 @@ func (c *Client) addOperationDescribeResourcePoliciesMiddlewares(stack *middlewa if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -111,9 +118,6 @@ func (c *Client) addOperationDescribeResourcePoliciesMiddlewares(stack *middlewa if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -138,16 +142,13 @@ func (c *Client) addOperationDescribeResourcePoliciesMiddlewares(stack *middlewa if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DescribeSubscriptionFilters.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DescribeSubscriptionFilters.go index 901cd9ede78..8da7e0deefb 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DescribeSubscriptionFilters.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DescribeSubscriptionFilters.go @@ -98,7 +98,7 @@ func (c *Client) addOperationDescribeSubscriptionFiltersMiddlewares(stack *middl if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -122,9 +122,6 @@ func (c *Client) addOperationDescribeSubscriptionFiltersMiddlewares(stack *middl if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -152,16 +149,13 @@ func (c *Client) addOperationDescribeSubscriptionFiltersMiddlewares(stack *middl if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DisassociateKmsKey.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DisassociateKmsKey.go index 5b739b2c13b..436bca8e85d 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DisassociateKmsKey.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DisassociateKmsKey.go @@ -125,7 +125,7 @@ func (c *Client) addOperationDisassociateKmsKeyMiddlewares(stack *middleware.Sta if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -149,9 +149,6 @@ func (c *Client) addOperationDisassociateKmsKeyMiddlewares(stack *middleware.Sta if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -176,16 +173,13 @@ func (c *Client) addOperationDisassociateKmsKeyMiddlewares(stack *middleware.Sta if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DisassociateSourceFromS3TableIntegration.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DisassociateSourceFromS3TableIntegration.go new file mode 100644 index 00000000000..a3d555cb909 --- /dev/null +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_DisassociateSourceFromS3TableIntegration.go @@ -0,0 +1,155 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package cloudwatchlogs + +import ( + "context" + "fmt" + awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/smithy-go/middleware" + smithyhttp "github.com/aws/smithy-go/transport/http" +) + +// Disassociates a data source from an S3 Table Integration, removing query access +// and deleting all associated data from the integration. +func (c *Client) DisassociateSourceFromS3TableIntegration(ctx context.Context, params *DisassociateSourceFromS3TableIntegrationInput, optFns ...func(*Options)) (*DisassociateSourceFromS3TableIntegrationOutput, error) { + if params == nil { + params = &DisassociateSourceFromS3TableIntegrationInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "DisassociateSourceFromS3TableIntegration", params, optFns, c.addOperationDisassociateSourceFromS3TableIntegrationMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*DisassociateSourceFromS3TableIntegrationOutput) + out.ResultMetadata = metadata + return out, nil +} + +type DisassociateSourceFromS3TableIntegrationInput struct { + + // The unique identifier of the association to remove between the data source and + // S3 Table Integration. + // + // This member is required. + Identifier *string + + noSmithyDocumentSerde +} + +type DisassociateSourceFromS3TableIntegrationOutput struct { + + // The unique identifier of the association that was removed. + Identifier *string + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationDisassociateSourceFromS3TableIntegrationMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&setOperationInputMiddleware{}, middleware.After); err != nil { + return err + } + err = stack.Serialize.Add(&awsAwsjson11_serializeOpDisassociateSourceFromS3TableIntegration{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDisassociateSourceFromS3TableIntegration{}, middleware.After) + if err != nil { + return err + } + if err := addProtocolFinalizerMiddlewares(stack, options, "DisassociateSourceFromS3TableIntegration"); err != nil { + return fmt.Errorf("add protocol finalizers: %v", err) + } + + if err = addlegacyEndpointContextSetter(stack, options); err != nil { + return err + } + if err = addSetLoggerMiddleware(stack, options); err != nil { + return err + } + if err = addClientRequestID(stack); err != nil { + return err + } + if err = addComputeContentLength(stack); err != nil { + return err + } + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRetry(stack, options, c); err != nil { + return err + } + if err = addRawResponseToMetadata(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack); err != nil { + return err + } + if err = addSpanRetryLoop(stack, options); err != nil { + return err + } + if err = addClientUserAgent(stack, options); err != nil { + return err + } + if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { + return err + } + if err = addUserAgentRetryMode(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = addOpDisassociateSourceFromS3TableIntegrationValidationMiddleware(stack); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDisassociateSourceFromS3TableIntegration(options.Region), middleware.Before); err != nil { + return err + } + if err = addRecursionDetection(stack); err != nil { + return err + } + if err = addRequestIDRetrieverMiddleware(stack); err != nil { + return err + } + if err = addResponseErrorMiddleware(stack); err != nil { + return err + } + if err = addRequestResponseLogging(stack, options); err != nil { + return err + } + if err = addDisableHTTPSMiddleware(stack, options); err != nil { + return err + } + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { + return err + } + if err = addInterceptAttempt(stack, options); err != nil { + return err + } + if err = addInterceptors(stack, options); err != nil { + return err + } + return nil +} + +func newServiceMetadataMiddleware_opDisassociateSourceFromS3TableIntegration(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + OperationName: "DisassociateSourceFromS3TableIntegration", + } +} diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_FilterLogEvents.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_FilterLogEvents.go index 1160471bf98..981a0d70a54 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_FilterLogEvents.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_FilterLogEvents.go @@ -18,7 +18,7 @@ import ( // // - A time range // -// - The log stream name, or a log stream name prefix that matches mutltiple log +// - The log stream name, or a log stream name prefix that matches multiple log // streams // // You must have the logs:FilterLogEvents permission to perform this operation. @@ -39,11 +39,9 @@ import ( // in a subsequent FilterLogEvents operation. If the results don't include a // nextToken , then pagination is finished. // -// If you set startFromHead to true and you don’t include endTime in your request, -// you can end up in a situation where the pagination doesn't terminate. This can -// happen when the new log events are being added to the target log streams faster -// than they are being read. This situation is a good use case for the CloudWatch -// Logs [Live Tail]feature. +// Specifying the limit parameter only guarantees that a single page doesn't +// return more log events than the specified limit, but it might return fewer +// events than the limit. This is the expected API behavior. // // The returned log events are sorted by event timestamp, the timestamp when the // event was ingested by CloudWatch Logs, and the ID of the PutLogEvents request. @@ -59,7 +57,6 @@ import ( // [log transformation]: https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CloudWatch-Logs-Transformation.html // [CloudWatch cross-account observability]: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch-Unified-Cross-Account.html // [CloudWatch Logs query.]: https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/AnalyzingLogData.html -// [Live Tail]: https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CloudWatchLogs_LiveTail.html func (c *Client) FilterLogEvents(ctx context.Context, params *FilterLogEventsInput, optFns ...func(*Options)) (*FilterLogEventsOutput, error) { if params == nil { params = &FilterLogEventsInput{} @@ -207,7 +204,7 @@ func (c *Client) addOperationFilterLogEventsMiddlewares(stack *middleware.Stack, if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -231,9 +228,6 @@ func (c *Client) addOperationFilterLogEventsMiddlewares(stack *middleware.Stack, if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -258,16 +252,13 @@ func (c *Client) addOperationFilterLogEventsMiddlewares(stack *middleware.Stack, if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_GetDataProtectionPolicy.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_GetDataProtectionPolicy.go index f46b263bd72..f36aec539de 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_GetDataProtectionPolicy.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_GetDataProtectionPolicy.go @@ -88,7 +88,7 @@ func (c *Client) addOperationGetDataProtectionPolicyMiddlewares(stack *middlewar if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -112,9 +112,6 @@ func (c *Client) addOperationGetDataProtectionPolicyMiddlewares(stack *middlewar if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -142,16 +139,13 @@ func (c *Client) addOperationGetDataProtectionPolicyMiddlewares(stack *middlewar if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_GetDelivery.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_GetDelivery.go index e6852f6e8b4..8b17c7141e6 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_GetDelivery.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_GetDelivery.go @@ -96,7 +96,7 @@ func (c *Client) addOperationGetDeliveryMiddlewares(stack *middleware.Stack, opt if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -120,9 +120,6 @@ func (c *Client) addOperationGetDeliveryMiddlewares(stack *middleware.Stack, opt if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -150,16 +147,13 @@ func (c *Client) addOperationGetDeliveryMiddlewares(stack *middleware.Stack, opt if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_GetDeliveryDestination.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_GetDeliveryDestination.go index a01dc31d90f..31047dfe012 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_GetDeliveryDestination.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_GetDeliveryDestination.go @@ -82,7 +82,7 @@ func (c *Client) addOperationGetDeliveryDestinationMiddlewares(stack *middleware if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -106,9 +106,6 @@ func (c *Client) addOperationGetDeliveryDestinationMiddlewares(stack *middleware if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -136,16 +133,13 @@ func (c *Client) addOperationGetDeliveryDestinationMiddlewares(stack *middleware if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_GetDeliveryDestinationPolicy.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_GetDeliveryDestinationPolicy.go index 5d08aa538dc..83f389bfa37 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_GetDeliveryDestinationPolicy.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_GetDeliveryDestinationPolicy.go @@ -86,7 +86,7 @@ func (c *Client) addOperationGetDeliveryDestinationPolicyMiddlewares(stack *midd if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -110,9 +110,6 @@ func (c *Client) addOperationGetDeliveryDestinationPolicyMiddlewares(stack *midd if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -140,16 +137,13 @@ func (c *Client) addOperationGetDeliveryDestinationPolicyMiddlewares(stack *midd if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_GetDeliverySource.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_GetDeliverySource.go index e6638a75108..e12bc718d41 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_GetDeliverySource.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_GetDeliverySource.go @@ -82,7 +82,7 @@ func (c *Client) addOperationGetDeliverySourceMiddlewares(stack *middleware.Stac if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -106,9 +106,6 @@ func (c *Client) addOperationGetDeliverySourceMiddlewares(stack *middleware.Stac if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -136,16 +133,13 @@ func (c *Client) addOperationGetDeliverySourceMiddlewares(stack *middleware.Stac if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_GetIntegration.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_GetIntegration.go index 483236a1a8b..fd1212b61a6 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_GetIntegration.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_GetIntegration.go @@ -99,7 +99,7 @@ func (c *Client) addOperationGetIntegrationMiddlewares(stack *middleware.Stack, if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -123,9 +123,6 @@ func (c *Client) addOperationGetIntegrationMiddlewares(stack *middleware.Stack, if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -153,16 +150,13 @@ func (c *Client) addOperationGetIntegrationMiddlewares(stack *middleware.Stack, if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_GetLogAnomalyDetector.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_GetLogAnomalyDetector.go index 06dca98a50e..c0c356ab82f 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_GetLogAnomalyDetector.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_GetLogAnomalyDetector.go @@ -122,7 +122,7 @@ func (c *Client) addOperationGetLogAnomalyDetectorMiddlewares(stack *middleware. if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -146,9 +146,6 @@ func (c *Client) addOperationGetLogAnomalyDetectorMiddlewares(stack *middleware. if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -176,16 +173,13 @@ func (c *Client) addOperationGetLogAnomalyDetectorMiddlewares(stack *middleware. if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_GetLogEvents.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_GetLogEvents.go index 484503f0e55..411c488b954 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_GetLogEvents.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_GetLogEvents.go @@ -174,7 +174,7 @@ func (c *Client) addOperationGetLogEventsMiddlewares(stack *middleware.Stack, op if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -198,9 +198,6 @@ func (c *Client) addOperationGetLogEventsMiddlewares(stack *middleware.Stack, op if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -228,16 +225,13 @@ func (c *Client) addOperationGetLogEventsMiddlewares(stack *middleware.Stack, op if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_GetLogFields.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_GetLogFields.go new file mode 100644 index 00000000000..61b5e4dc12f --- /dev/null +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_GetLogFields.go @@ -0,0 +1,162 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package cloudwatchlogs + +import ( + "context" + "fmt" + awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/types" + "github.com/aws/smithy-go/middleware" + smithyhttp "github.com/aws/smithy-go/transport/http" +) + +// Discovers available fields for a specific data source and type. The response +// includes any field modifications introduced through pipelines, such as new +// fields or changed field types. +func (c *Client) GetLogFields(ctx context.Context, params *GetLogFieldsInput, optFns ...func(*Options)) (*GetLogFieldsOutput, error) { + if params == nil { + params = &GetLogFieldsInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "GetLogFields", params, optFns, c.addOperationGetLogFieldsMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*GetLogFieldsOutput) + out.ResultMetadata = metadata + return out, nil +} + +type GetLogFieldsInput struct { + + // The name of the data source to retrieve log fields for. + // + // This member is required. + DataSourceName *string + + // The type of the data source to retrieve log fields for. + // + // This member is required. + DataSourceType *string + + noSmithyDocumentSerde +} + +type GetLogFieldsOutput struct { + + // The list of log fields for the specified data source, including field names and + // their data types. + LogFields []types.LogFieldsListItem + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationGetLogFieldsMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&setOperationInputMiddleware{}, middleware.After); err != nil { + return err + } + err = stack.Serialize.Add(&awsAwsjson11_serializeOpGetLogFields{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpGetLogFields{}, middleware.After) + if err != nil { + return err + } + if err := addProtocolFinalizerMiddlewares(stack, options, "GetLogFields"); err != nil { + return fmt.Errorf("add protocol finalizers: %v", err) + } + + if err = addlegacyEndpointContextSetter(stack, options); err != nil { + return err + } + if err = addSetLoggerMiddleware(stack, options); err != nil { + return err + } + if err = addClientRequestID(stack); err != nil { + return err + } + if err = addComputeContentLength(stack); err != nil { + return err + } + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRetry(stack, options, c); err != nil { + return err + } + if err = addRawResponseToMetadata(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack); err != nil { + return err + } + if err = addSpanRetryLoop(stack, options); err != nil { + return err + } + if err = addClientUserAgent(stack, options); err != nil { + return err + } + if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { + return err + } + if err = addUserAgentRetryMode(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = addOpGetLogFieldsValidationMiddleware(stack); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetLogFields(options.Region), middleware.Before); err != nil { + return err + } + if err = addRecursionDetection(stack); err != nil { + return err + } + if err = addRequestIDRetrieverMiddleware(stack); err != nil { + return err + } + if err = addResponseErrorMiddleware(stack); err != nil { + return err + } + if err = addRequestResponseLogging(stack, options); err != nil { + return err + } + if err = addDisableHTTPSMiddleware(stack, options); err != nil { + return err + } + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { + return err + } + if err = addInterceptAttempt(stack, options); err != nil { + return err + } + if err = addInterceptors(stack, options); err != nil { + return err + } + return nil +} + +func newServiceMetadataMiddleware_opGetLogFields(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + OperationName: "GetLogFields", + } +} diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_GetLogGroupFields.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_GetLogGroupFields.go index 23815830daf..b5d83453549 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_GetLogGroupFields.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_GetLogGroupFields.go @@ -15,6 +15,9 @@ import ( // log group. Includes the percentage of log events that contain each field. The // search is limited to a time period that you specify. // +// This operation is used for discovering fields within log group events. For +// discovering fields across data sources, use the GetLogFields operation. +// // You can specify the log group to search by using either logGroupIdentifier or // logGroupName . You must specify one of these parameters, but you can't specify // both. @@ -119,7 +122,7 @@ func (c *Client) addOperationGetLogGroupFieldsMiddlewares(stack *middleware.Stac if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -143,9 +146,6 @@ func (c *Client) addOperationGetLogGroupFieldsMiddlewares(stack *middleware.Stac if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -170,16 +170,13 @@ func (c *Client) addOperationGetLogGroupFieldsMiddlewares(stack *middleware.Stac if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_GetLogObject.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_GetLogObject.go new file mode 100644 index 00000000000..7de48b59095 --- /dev/null +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_GetLogObject.go @@ -0,0 +1,315 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package cloudwatchlogs + +import ( + "context" + "fmt" + awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/types" + "github.com/aws/smithy-go/middleware" + smithysync "github.com/aws/smithy-go/sync" + smithyhttp "github.com/aws/smithy-go/transport/http" + "sync" +) + +// Retrieves a large logging object (LLO) and streams it back. This API is used to +// fetch the content of large portions of log events that have been ingested +// through the PutOpenTelemetryLogs API. When log events contain fields that would +// cause the total event size to exceed 1MB, CloudWatch Logs automatically +// processes up to 10 fields, starting with the largest fields. Each field is +// truncated as needed to keep the total event size as close to 1MB as possible. +// The excess portions are stored as Large Log Objects (LLOs) and these fields are +// processed separately and LLO reference system fields (in the format +// @ptr.$[path.to.field] ) are added. The path in the reference field reflects the +// original JSON structure where the large field was located. For example, this +// could be @ptr.$['input']['message'] , @ptr.$['AAA']['BBB']['CCC']['DDD'] , +// @ptr.$['AAA'] , or any other path matching your log structure. +// +// The GetLogObject API routes requests using SDK host prefix injection. SDK +// versions released before April 1, 2026 route to +// streaming-logs.Region.amazonaws.com , which does not support VPC endpoints. SDK +// versions released on or after April 1, 2026 route to +// stream-logs.Region.amazonaws.com , which supports VPC endpoints. To set up a VPC +// endpoint for this API, see [Creating a VPC endpoint for CloudWatch Logs]. +// +// [Creating a VPC endpoint for CloudWatch Logs]: https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/cloudwatch-logs-and-interface-VPC.html#create-VPC-endpoint-for-CloudWatchLogs +func (c *Client) GetLogObject(ctx context.Context, params *GetLogObjectInput, optFns ...func(*Options)) (*GetLogObjectOutput, error) { + if params == nil { + params = &GetLogObjectInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "GetLogObject", params, optFns, c.addOperationGetLogObjectMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*GetLogObjectOutput) + out.ResultMetadata = metadata + return out, nil +} + +// The parameters for the GetLogObject operation. +type GetLogObjectInput struct { + + // A pointer to the specific log object to retrieve. This is a required parameter + // that uniquely identifies the log object within CloudWatch Logs. The pointer is + // typically obtained from a previous query or filter operation. + // + // This member is required. + LogObjectPointer *string + + // A boolean flag that indicates whether to unmask sensitive log data. When set to + // true, any masked or redacted data in the log object will be displayed in its + // original form. Default is false. + Unmask bool + + noSmithyDocumentSerde +} + +// The response from the GetLogObject operation. +type GetLogObjectOutput struct { + eventStream *GetLogObjectEventStream + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +// GetStream returns the type to interact with the event stream. +func (o *GetLogObjectOutput) GetStream() *GetLogObjectEventStream { + return o.eventStream +} + +func (c *Client) addOperationGetLogObjectMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&setOperationInputMiddleware{}, middleware.After); err != nil { + return err + } + err = stack.Serialize.Add(&awsAwsjson11_serializeOpGetLogObject{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpGetLogObject{}, middleware.After) + if err != nil { + return err + } + if err := addProtocolFinalizerMiddlewares(stack, options, "GetLogObject"); err != nil { + return fmt.Errorf("add protocol finalizers: %v", err) + } + + if err = addlegacyEndpointContextSetter(stack, options); err != nil { + return err + } + if err = addEventStreamGetLogObjectMiddleware(stack, options); err != nil { + return err + } + if err = addSetLoggerMiddleware(stack, options); err != nil { + return err + } + if err = addClientRequestID(stack); err != nil { + return err + } + if err = addComputeContentLength(stack); err != nil { + return err + } + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRetry(stack, options, c); err != nil { + return err + } + if err = addRawResponseToMetadata(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack); err != nil { + return err + } + if err = addSpanRetryLoop(stack, options); err != nil { + return err + } + if err = addClientUserAgent(stack, options); err != nil { + return err + } + if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { + return err + } + if err = addUserAgentRetryMode(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = addEndpointPrefix_opGetLogObjectMiddleware(stack); err != nil { + return err + } + if err = addOpGetLogObjectValidationMiddleware(stack); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetLogObject(options.Region), middleware.Before); err != nil { + return err + } + if err = addRecursionDetection(stack); err != nil { + return err + } + if err = addRequestIDRetrieverMiddleware(stack); err != nil { + return err + } + if err = addResponseErrorMiddleware(stack); err != nil { + return err + } + if err = addRequestResponseLogging(stack, options); err != nil { + return err + } + if err = addDisableHTTPSMiddleware(stack, options); err != nil { + return err + } + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { + return err + } + if err = addInterceptAttempt(stack, options); err != nil { + return err + } + if err = addInterceptors(stack, options); err != nil { + return err + } + return nil +} + +type endpointPrefix_opGetLogObjectMiddleware struct { +} + +func (*endpointPrefix_opGetLogObjectMiddleware) ID() string { + return "EndpointHostPrefix" +} + +func (m *endpointPrefix_opGetLogObjectMiddleware) HandleFinalize(ctx context.Context, in middleware.FinalizeInput, next middleware.FinalizeHandler) ( + out middleware.FinalizeOutput, metadata middleware.Metadata, err error, +) { + if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) { + return next.HandleFinalize(ctx, in) + } + + req, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, fmt.Errorf("unknown transport type %T", in.Request) + } + + req.URL.Host = "streaming-" + req.URL.Host + + return next.HandleFinalize(ctx, in) +} +func addEndpointPrefix_opGetLogObjectMiddleware(stack *middleware.Stack) error { + return stack.Finalize.Insert(&endpointPrefix_opGetLogObjectMiddleware{}, "ResolveEndpointV2", middleware.After) +} + +func newServiceMetadataMiddleware_opGetLogObject(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + OperationName: "GetLogObject", + } +} + +// GetLogObjectEventStream provides the event stream handling for the GetLogObject operation. +// +// For testing and mocking the event stream this type should be initialized via +// the NewGetLogObjectEventStream constructor function. Using the functional options +// to pass in nested mock behavior. +type GetLogObjectEventStream struct { + // GetLogObjectResponseStreamReader is the EventStream reader for the + // GetLogObjectResponseStream 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 GetLogObjectResponseStreamReader + + done chan struct{} + closeOnce sync.Once + err *smithysync.OnceErr +} + +// NewGetLogObjectEventStream initializes an GetLogObjectEventStream. +// This function should only be used for testing and mocking the GetLogObjectEventStream +// stream within your application. +// +// The Reader member must be set before reading events from the stream. +func NewGetLogObjectEventStream(optFns ...func(*GetLogObjectEventStream)) *GetLogObjectEventStream { + es := &GetLogObjectEventStream{ + done: make(chan struct{}), + err: smithysync.NewOnceErr(), + } + for _, fn := range optFns { + fn(es) + } + return es +} + +// Events returns a channel to read events from. +func (es *GetLogObjectEventStream) Events() <-chan types.GetLogObjectResponseStream { + return es.Reader.Events() +} + +// 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. +// +// Will close the underlying EventStream writer and reader, and no more events can be +// sent or received. +func (es *GetLogObjectEventStream) Close() error { + es.closeOnce.Do(es.safeClose) + return es.Err() +} + +func (es *GetLogObjectEventStream) safeClose() { + close(es.done) + + es.Reader.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 *GetLogObjectEventStream) Err() error { + if err := es.err.Err(); err != nil { + return err + } + + if err := es.Reader.Err(); err != nil { + return err + } + + return nil +} + +func (es *GetLogObjectEventStream) waitStreamClose() { + type errorSet interface { + ErrorSet() <-chan struct{} + } + + var outputErrCh <-chan struct{} + if v, ok := es.Reader.(errorSet); 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() + + } +} diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_GetLogRecord.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_GetLogRecord.go index 3b8c798fbc3..1a22e788e2c 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_GetLogRecord.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_GetLogRecord.go @@ -96,7 +96,7 @@ func (c *Client) addOperationGetLogRecordMiddlewares(stack *middleware.Stack, op if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -120,9 +120,6 @@ func (c *Client) addOperationGetLogRecordMiddlewares(stack *middleware.Stack, op if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -150,16 +147,13 @@ func (c *Client) addOperationGetLogRecordMiddlewares(stack *middleware.Stack, op if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_GetQueryResults.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_GetQueryResults.go index 4e99cf45b43..2e61addbbe7 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_GetQueryResults.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_GetQueryResults.go @@ -24,6 +24,11 @@ import ( // returns only partial results. If you see a value of Scheduled or Running for // the status, you can retry the operation later to see the final results. // +// This operation is used both for retrieving results from interactive queries and +// from automated scheduled query executions. Scheduled queries use GetQueryResults +// internally to retrieve query results for processing and delivery to configured +// destinations. +// // If you are using CloudWatch cross-account observability, you can use this // operation in a monitoring account to start queries in linked source accounts. // For more information, see [CloudWatch cross-account observability]. @@ -133,7 +138,7 @@ func (c *Client) addOperationGetQueryResultsMiddlewares(stack *middleware.Stack, if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -157,9 +162,6 @@ func (c *Client) addOperationGetQueryResultsMiddlewares(stack *middleware.Stack, if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -187,16 +189,13 @@ func (c *Client) addOperationGetQueryResultsMiddlewares(stack *middleware.Stack, if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_GetScheduledQuery.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_GetScheduledQuery.go new file mode 100644 index 00000000000..4e5d7371aab --- /dev/null +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_GetScheduledQuery.go @@ -0,0 +1,206 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package cloudwatchlogs + +import ( + "context" + "fmt" + awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/types" + "github.com/aws/smithy-go/middleware" + smithyhttp "github.com/aws/smithy-go/transport/http" +) + +// Retrieves details about a specific scheduled query, including its +// configuration, execution status, and metadata. +func (c *Client) GetScheduledQuery(ctx context.Context, params *GetScheduledQueryInput, optFns ...func(*Options)) (*GetScheduledQueryOutput, error) { + if params == nil { + params = &GetScheduledQueryInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "GetScheduledQuery", params, optFns, c.addOperationGetScheduledQueryMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*GetScheduledQueryOutput) + out.ResultMetadata = metadata + return out, nil +} + +type GetScheduledQueryInput struct { + + // The ARN or name of the scheduled query to retrieve. + // + // This member is required. + Identifier *string + + noSmithyDocumentSerde +} + +type GetScheduledQueryOutput struct { + + // The timestamp when the scheduled query was created. + CreationTime *int64 + + // The description of the scheduled query. + Description *string + + // Configuration for where query results are delivered. + DestinationConfiguration *types.DestinationConfiguration + + // The ARN of the IAM role used to execute the query and deliver results. + ExecutionRoleArn *string + + // The status of the most recent execution of the scheduled query. + LastExecutionStatus types.ExecutionStatus + + // The timestamp when the scheduled query was last executed. + LastTriggeredTime *int64 + + // The timestamp when the scheduled query was last updated. + LastUpdatedTime *int64 + + // The log groups queried by the scheduled query. + LogGroupIdentifiers []string + + // The name of the scheduled query. + Name *string + + // The query language used by the scheduled query. + QueryLanguage types.QueryLanguage + + // The query string executed by the scheduled query. + QueryString *string + + // The end time for the scheduled query in Unix epoch format. + ScheduleEndTime *int64 + + // The cron expression that defines when the scheduled query runs. + ScheduleExpression *string + + // The start time for the scheduled query in Unix epoch format. + ScheduleStartTime *int64 + + // The ARN of the scheduled query. + ScheduledQueryArn *string + + // The time offset in seconds that defines the lookback period for the query. + StartTimeOffset *int64 + + // The current state of the scheduled query. + State types.ScheduledQueryState + + // The timezone used for evaluating the schedule expression. + Timezone *string + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationGetScheduledQueryMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&setOperationInputMiddleware{}, middleware.After); err != nil { + return err + } + err = stack.Serialize.Add(&awsAwsjson11_serializeOpGetScheduledQuery{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpGetScheduledQuery{}, middleware.After) + if err != nil { + return err + } + if err := addProtocolFinalizerMiddlewares(stack, options, "GetScheduledQuery"); err != nil { + return fmt.Errorf("add protocol finalizers: %v", err) + } + + if err = addlegacyEndpointContextSetter(stack, options); err != nil { + return err + } + if err = addSetLoggerMiddleware(stack, options); err != nil { + return err + } + if err = addClientRequestID(stack); err != nil { + return err + } + if err = addComputeContentLength(stack); err != nil { + return err + } + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRetry(stack, options, c); err != nil { + return err + } + if err = addRawResponseToMetadata(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack); err != nil { + return err + } + if err = addSpanRetryLoop(stack, options); err != nil { + return err + } + if err = addClientUserAgent(stack, options); err != nil { + return err + } + if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { + return err + } + if err = addUserAgentRetryMode(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = addOpGetScheduledQueryValidationMiddleware(stack); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetScheduledQuery(options.Region), middleware.Before); err != nil { + return err + } + if err = addRecursionDetection(stack); err != nil { + return err + } + if err = addRequestIDRetrieverMiddleware(stack); err != nil { + return err + } + if err = addResponseErrorMiddleware(stack); err != nil { + return err + } + if err = addRequestResponseLogging(stack, options); err != nil { + return err + } + if err = addDisableHTTPSMiddleware(stack, options); err != nil { + return err + } + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { + return err + } + if err = addInterceptAttempt(stack, options); err != nil { + return err + } + if err = addInterceptors(stack, options); err != nil { + return err + } + return nil +} + +func newServiceMetadataMiddleware_opGetScheduledQuery(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + OperationName: "GetScheduledQuery", + } +} diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_GetScheduledQueryHistory.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_GetScheduledQueryHistory.go new file mode 100644 index 00000000000..902a5e4f836 --- /dev/null +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_GetScheduledQueryHistory.go @@ -0,0 +1,279 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package cloudwatchlogs + +import ( + "context" + "fmt" + awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/types" + "github.com/aws/smithy-go/middleware" + smithyhttp "github.com/aws/smithy-go/transport/http" +) + +// Retrieves the execution history of a scheduled query within a specified time +// range, including query results and destination processing status. +func (c *Client) GetScheduledQueryHistory(ctx context.Context, params *GetScheduledQueryHistoryInput, optFns ...func(*Options)) (*GetScheduledQueryHistoryOutput, error) { + if params == nil { + params = &GetScheduledQueryHistoryInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "GetScheduledQueryHistory", params, optFns, c.addOperationGetScheduledQueryHistoryMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*GetScheduledQueryHistoryOutput) + out.ResultMetadata = metadata + return out, nil +} + +type GetScheduledQueryHistoryInput struct { + + // The end time for the history query in Unix epoch format. + // + // This member is required. + EndTime *int64 + + // The ARN or name of the scheduled query to retrieve history for. + // + // This member is required. + Identifier *string + + // The start time for the history query in Unix epoch format. + // + // This member is required. + StartTime *int64 + + // An array of execution statuses to filter the history results. Only executions + // with the specified statuses are returned. + ExecutionStatuses []types.ExecutionStatus + + // The maximum number of history records to return. Valid range is 1 to 1000. + MaxResults *int32 + + // The token for the next set of items to return. The token expires after 24 hours. + NextToken *string + + noSmithyDocumentSerde +} + +type GetScheduledQueryHistoryOutput struct { + + // The name of the scheduled query. + Name *string + + // The token for the next set of items to return. The token expires after 24 hours. + NextToken *string + + // The ARN of the scheduled query. + ScheduledQueryArn *string + + // An array of execution history records for the scheduled query. + TriggerHistory []types.TriggerHistoryRecord + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationGetScheduledQueryHistoryMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&setOperationInputMiddleware{}, middleware.After); err != nil { + return err + } + err = stack.Serialize.Add(&awsAwsjson11_serializeOpGetScheduledQueryHistory{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpGetScheduledQueryHistory{}, middleware.After) + if err != nil { + return err + } + if err := addProtocolFinalizerMiddlewares(stack, options, "GetScheduledQueryHistory"); err != nil { + return fmt.Errorf("add protocol finalizers: %v", err) + } + + if err = addlegacyEndpointContextSetter(stack, options); err != nil { + return err + } + if err = addSetLoggerMiddleware(stack, options); err != nil { + return err + } + if err = addClientRequestID(stack); err != nil { + return err + } + if err = addComputeContentLength(stack); err != nil { + return err + } + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRetry(stack, options, c); err != nil { + return err + } + if err = addRawResponseToMetadata(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack); err != nil { + return err + } + if err = addSpanRetryLoop(stack, options); err != nil { + return err + } + if err = addClientUserAgent(stack, options); err != nil { + return err + } + if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { + return err + } + if err = addUserAgentRetryMode(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = addOpGetScheduledQueryHistoryValidationMiddleware(stack); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetScheduledQueryHistory(options.Region), middleware.Before); err != nil { + return err + } + if err = addRecursionDetection(stack); err != nil { + return err + } + if err = addRequestIDRetrieverMiddleware(stack); err != nil { + return err + } + if err = addResponseErrorMiddleware(stack); err != nil { + return err + } + if err = addRequestResponseLogging(stack, options); err != nil { + return err + } + if err = addDisableHTTPSMiddleware(stack, options); err != nil { + return err + } + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { + return err + } + if err = addInterceptAttempt(stack, options); err != nil { + return err + } + if err = addInterceptors(stack, options); err != nil { + return err + } + return nil +} + +// GetScheduledQueryHistoryPaginatorOptions is the paginator options for +// GetScheduledQueryHistory +type GetScheduledQueryHistoryPaginatorOptions struct { + // The maximum number of history records to return. Valid range is 1 to 1000. + Limit int32 + + // Set to true if pagination should stop if the service returns a pagination token + // that matches the most recent token provided to the service. + StopOnDuplicateToken bool +} + +// GetScheduledQueryHistoryPaginator is a paginator for GetScheduledQueryHistory +type GetScheduledQueryHistoryPaginator struct { + options GetScheduledQueryHistoryPaginatorOptions + client GetScheduledQueryHistoryAPIClient + params *GetScheduledQueryHistoryInput + nextToken *string + firstPage bool +} + +// NewGetScheduledQueryHistoryPaginator returns a new +// GetScheduledQueryHistoryPaginator +func NewGetScheduledQueryHistoryPaginator(client GetScheduledQueryHistoryAPIClient, params *GetScheduledQueryHistoryInput, optFns ...func(*GetScheduledQueryHistoryPaginatorOptions)) *GetScheduledQueryHistoryPaginator { + if params == nil { + params = &GetScheduledQueryHistoryInput{} + } + + options := GetScheduledQueryHistoryPaginatorOptions{} + if params.MaxResults != nil { + options.Limit = *params.MaxResults + } + + for _, fn := range optFns { + fn(&options) + } + + return &GetScheduledQueryHistoryPaginator{ + options: options, + client: client, + params: params, + firstPage: true, + nextToken: params.NextToken, + } +} + +// HasMorePages returns a boolean indicating whether more pages are available +func (p *GetScheduledQueryHistoryPaginator) HasMorePages() bool { + return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0) +} + +// NextPage retrieves the next GetScheduledQueryHistory page. +func (p *GetScheduledQueryHistoryPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*GetScheduledQueryHistoryOutput, error) { + if !p.HasMorePages() { + return nil, fmt.Errorf("no more pages available") + } + + params := *p.params + params.NextToken = p.nextToken + + var limit *int32 + if p.options.Limit > 0 { + limit = &p.options.Limit + } + params.MaxResults = limit + + optFns = append([]func(*Options){ + addIsPaginatorUserAgent, + }, optFns...) + result, err := p.client.GetScheduledQueryHistory(ctx, ¶ms, optFns...) + if err != nil { + return nil, err + } + p.firstPage = false + + prevToken := p.nextToken + p.nextToken = result.NextToken + + if p.options.StopOnDuplicateToken && + prevToken != nil && + p.nextToken != nil && + *prevToken == *p.nextToken { + p.nextToken = nil + } + + return result, nil +} + +// GetScheduledQueryHistoryAPIClient is a client that implements the +// GetScheduledQueryHistory operation. +type GetScheduledQueryHistoryAPIClient interface { + GetScheduledQueryHistory(context.Context, *GetScheduledQueryHistoryInput, ...func(*Options)) (*GetScheduledQueryHistoryOutput, error) +} + +var _ GetScheduledQueryHistoryAPIClient = (*Client)(nil) + +func newServiceMetadataMiddleware_opGetScheduledQueryHistory(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + OperationName: "GetScheduledQueryHistory", + } +} diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_GetTransformer.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_GetTransformer.go index 40923c0c4db..d20cb9557b0 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_GetTransformer.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_GetTransformer.go @@ -101,7 +101,7 @@ func (c *Client) addOperationGetTransformerMiddlewares(stack *middleware.Stack, if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -125,9 +125,6 @@ func (c *Client) addOperationGetTransformerMiddlewares(stack *middleware.Stack, if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -155,16 +152,13 @@ func (c *Client) addOperationGetTransformerMiddlewares(stack *middleware.Stack, if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_ListAggregateLogGroupSummaries.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_ListAggregateLogGroupSummaries.go new file mode 100644 index 00000000000..976809e3871 --- /dev/null +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_ListAggregateLogGroupSummaries.go @@ -0,0 +1,316 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package cloudwatchlogs + +import ( + "context" + "fmt" + awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/types" + "github.com/aws/smithy-go/middleware" + smithyhttp "github.com/aws/smithy-go/transport/http" +) + +// Returns an aggregate summary of all log groups in the Region grouped by +// specified data source characteristics. Supports optional filtering by log group +// class, name patterns, and data sources. If you perform this action in a +// monitoring account, you can also return aggregated summaries of log groups from +// source accounts that are linked to the monitoring account. For more information +// about using cross-account observability to set up monitoring accounts and source +// accounts, see [CloudWatch cross-account observability]. +// +// The operation aggregates log groups by data source name and type and optionally +// format, providing counts of log groups that share these characteristics. The +// operation paginates results. By default, it returns up to 50 results and +// includes a token to retrieve more results. +// +// [CloudWatch cross-account observability]: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch-Unified-Cross-Account.html +func (c *Client) ListAggregateLogGroupSummaries(ctx context.Context, params *ListAggregateLogGroupSummariesInput, optFns ...func(*Options)) (*ListAggregateLogGroupSummariesOutput, error) { + if params == nil { + params = &ListAggregateLogGroupSummariesInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "ListAggregateLogGroupSummaries", params, optFns, c.addOperationListAggregateLogGroupSummariesMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*ListAggregateLogGroupSummariesOutput) + out.ResultMetadata = metadata + return out, nil +} + +type ListAggregateLogGroupSummariesInput struct { + + // Specifies how to group the log groups in the summary. + // + // This member is required. + GroupBy types.ListAggregateLogGroupSummariesGroupBy + + // When includeLinkedAccounts is set to true , use this parameter to specify the + // list of accounts to search. You can specify as many as 20 account IDs in the + // array. + AccountIdentifiers []string + + // Filters the results by data source characteristics to include only log groups + // associated with the specified data sources. + DataSources []types.DataSourceFilter + + // If you are using a monitoring account, set this to true to have the operation + // return log groups in the accounts listed in accountIdentifiers . + // + // If this parameter is set to true and accountIdentifiers contains a null value, + // the operation returns all log groups in the monitoring account and all log + // groups in all source accounts that are linked to the monitoring account. + // + // The default for this parameter is false . + IncludeLinkedAccounts *bool + + // The maximum number of aggregated summaries to return. If you omit this + // parameter, the default is up to 50 aggregated summaries. + Limit *int32 + + // Filters the results by log group class to include only log groups of the + // specified class. + LogGroupClass types.LogGroupClass + + // Use this parameter to limit the returned log groups to only those with names + // that match the pattern that you specify. This parameter is a regular expression + // that can match prefixes and substrings, and supports wildcard matching and + // matching multiple patterns, as in the following examples. + // + // - Use ^ to match log group names by prefix. + // + // - For a substring match, specify the string to match. All matches are case + // sensitive + // + // - To match multiple patterns, separate them with a | as in the example + // ^/aws/lambda|discovery + // + // You can specify as many as five different regular expression patterns in this + // field, each of which must be between 3 and 24 characters. You can include the ^ + // symbol as many as five times, and include the | symbol as many as four times. + LogGroupNamePattern *string + + // The token for the next set of items to return. The token expires after 24 hours. + NextToken *string + + noSmithyDocumentSerde +} + +type ListAggregateLogGroupSummariesOutput struct { + + // The list of aggregate log group summaries grouped by the specified data source + // characteristics. + AggregateLogGroupSummaries []types.AggregateLogGroupSummary + + // The token for the next set of items to return. The token expires after 24 hours. + NextToken *string + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationListAggregateLogGroupSummariesMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&setOperationInputMiddleware{}, middleware.After); err != nil { + return err + } + err = stack.Serialize.Add(&awsAwsjson11_serializeOpListAggregateLogGroupSummaries{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpListAggregateLogGroupSummaries{}, middleware.After) + if err != nil { + return err + } + if err := addProtocolFinalizerMiddlewares(stack, options, "ListAggregateLogGroupSummaries"); err != nil { + return fmt.Errorf("add protocol finalizers: %v", err) + } + + if err = addlegacyEndpointContextSetter(stack, options); err != nil { + return err + } + if err = addSetLoggerMiddleware(stack, options); err != nil { + return err + } + if err = addClientRequestID(stack); err != nil { + return err + } + if err = addComputeContentLength(stack); err != nil { + return err + } + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRetry(stack, options, c); err != nil { + return err + } + if err = addRawResponseToMetadata(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack); err != nil { + return err + } + if err = addSpanRetryLoop(stack, options); err != nil { + return err + } + if err = addClientUserAgent(stack, options); err != nil { + return err + } + if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { + return err + } + if err = addUserAgentRetryMode(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = addOpListAggregateLogGroupSummariesValidationMiddleware(stack); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListAggregateLogGroupSummaries(options.Region), middleware.Before); err != nil { + return err + } + if err = addRecursionDetection(stack); err != nil { + return err + } + if err = addRequestIDRetrieverMiddleware(stack); err != nil { + return err + } + if err = addResponseErrorMiddleware(stack); err != nil { + return err + } + if err = addRequestResponseLogging(stack, options); err != nil { + return err + } + if err = addDisableHTTPSMiddleware(stack, options); err != nil { + return err + } + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { + return err + } + if err = addInterceptAttempt(stack, options); err != nil { + return err + } + if err = addInterceptors(stack, options); err != nil { + return err + } + return nil +} + +// ListAggregateLogGroupSummariesPaginatorOptions is the paginator options for +// ListAggregateLogGroupSummaries +type ListAggregateLogGroupSummariesPaginatorOptions struct { + // The maximum number of aggregated summaries to return. If you omit this + // parameter, the default is up to 50 aggregated summaries. + Limit int32 + + // Set to true if pagination should stop if the service returns a pagination token + // that matches the most recent token provided to the service. + StopOnDuplicateToken bool +} + +// ListAggregateLogGroupSummariesPaginator is a paginator for +// ListAggregateLogGroupSummaries +type ListAggregateLogGroupSummariesPaginator struct { + options ListAggregateLogGroupSummariesPaginatorOptions + client ListAggregateLogGroupSummariesAPIClient + params *ListAggregateLogGroupSummariesInput + nextToken *string + firstPage bool +} + +// NewListAggregateLogGroupSummariesPaginator returns a new +// ListAggregateLogGroupSummariesPaginator +func NewListAggregateLogGroupSummariesPaginator(client ListAggregateLogGroupSummariesAPIClient, params *ListAggregateLogGroupSummariesInput, optFns ...func(*ListAggregateLogGroupSummariesPaginatorOptions)) *ListAggregateLogGroupSummariesPaginator { + if params == nil { + params = &ListAggregateLogGroupSummariesInput{} + } + + options := ListAggregateLogGroupSummariesPaginatorOptions{} + if params.Limit != nil { + options.Limit = *params.Limit + } + + for _, fn := range optFns { + fn(&options) + } + + return &ListAggregateLogGroupSummariesPaginator{ + options: options, + client: client, + params: params, + firstPage: true, + nextToken: params.NextToken, + } +} + +// HasMorePages returns a boolean indicating whether more pages are available +func (p *ListAggregateLogGroupSummariesPaginator) HasMorePages() bool { + return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0) +} + +// NextPage retrieves the next ListAggregateLogGroupSummaries page. +func (p *ListAggregateLogGroupSummariesPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListAggregateLogGroupSummariesOutput, error) { + if !p.HasMorePages() { + return nil, fmt.Errorf("no more pages available") + } + + params := *p.params + params.NextToken = p.nextToken + + var limit *int32 + if p.options.Limit > 0 { + limit = &p.options.Limit + } + params.Limit = limit + + optFns = append([]func(*Options){ + addIsPaginatorUserAgent, + }, optFns...) + result, err := p.client.ListAggregateLogGroupSummaries(ctx, ¶ms, optFns...) + if err != nil { + return nil, err + } + p.firstPage = false + + prevToken := p.nextToken + p.nextToken = result.NextToken + + if p.options.StopOnDuplicateToken && + prevToken != nil && + p.nextToken != nil && + *prevToken == *p.nextToken { + p.nextToken = nil + } + + return result, nil +} + +// ListAggregateLogGroupSummariesAPIClient is a client that implements the +// ListAggregateLogGroupSummaries operation. +type ListAggregateLogGroupSummariesAPIClient interface { + ListAggregateLogGroupSummaries(context.Context, *ListAggregateLogGroupSummariesInput, ...func(*Options)) (*ListAggregateLogGroupSummariesOutput, error) +} + +var _ ListAggregateLogGroupSummariesAPIClient = (*Client)(nil) + +func newServiceMetadataMiddleware_opListAggregateLogGroupSummaries(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + OperationName: "ListAggregateLogGroupSummaries", + } +} diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_ListAnomalies.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_ListAnomalies.go index 5dfd2389861..f14ae641557 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_ListAnomalies.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_ListAnomalies.go @@ -98,7 +98,7 @@ func (c *Client) addOperationListAnomaliesMiddlewares(stack *middleware.Stack, o if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -122,9 +122,6 @@ func (c *Client) addOperationListAnomaliesMiddlewares(stack *middleware.Stack, o if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -149,16 +146,13 @@ func (c *Client) addOperationListAnomaliesMiddlewares(stack *middleware.Stack, o if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_ListIntegrations.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_ListIntegrations.go index f6850e03c86..ffa2fc80fda 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_ListIntegrations.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_ListIntegrations.go @@ -91,7 +91,7 @@ func (c *Client) addOperationListIntegrationsMiddlewares(stack *middleware.Stack if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -115,9 +115,6 @@ func (c *Client) addOperationListIntegrationsMiddlewares(stack *middleware.Stack if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -142,16 +139,13 @@ func (c *Client) addOperationListIntegrationsMiddlewares(stack *middleware.Stack if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_ListLogAnomalyDetectors.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_ListLogAnomalyDetectors.go index 1dc599a3f5d..99abaefd981 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_ListLogAnomalyDetectors.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_ListLogAnomalyDetectors.go @@ -92,7 +92,7 @@ func (c *Client) addOperationListLogAnomalyDetectorsMiddlewares(stack *middlewar if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -116,9 +116,6 @@ func (c *Client) addOperationListLogAnomalyDetectorsMiddlewares(stack *middlewar if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -143,16 +140,13 @@ func (c *Client) addOperationListLogAnomalyDetectorsMiddlewares(stack *middlewar if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_ListLogGroups.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_ListLogGroups.go new file mode 100644 index 00000000000..7adc191d61b --- /dev/null +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_ListLogGroups.go @@ -0,0 +1,226 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package cloudwatchlogs + +import ( + "context" + "fmt" + awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/types" + "github.com/aws/smithy-go/middleware" + smithyhttp "github.com/aws/smithy-go/transport/http" +) + +// Returns a list of log groups in the Region in your account. If you are +// performing this action in a monitoring account, you can choose to also return +// log groups from source accounts that are linked to the monitoring account. For +// more information about using cross-account observability to set up monitoring +// accounts and source accounts, see [CloudWatch cross-account observability]. +// +// You can optionally filter the list by log group class, by using regular +// expressions in your request to match strings in the log group names, by using +// the fieldIndexes parameter to filter log groups based on which field indexes are +// configured, by using the dataSources parameter to filter log groups by data +// source types, and by using the fieldIndexNames parameter to filter by specific +// field index names. +// +// This operation is paginated. By default, your first use of this operation +// returns 50 results, and includes a token to use in a subsequent operation to +// return more results. +// +// [CloudWatch cross-account observability]: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch-Unified-Cross-Account.html +func (c *Client) ListLogGroups(ctx context.Context, params *ListLogGroupsInput, optFns ...func(*Options)) (*ListLogGroupsOutput, error) { + if params == nil { + params = &ListLogGroupsInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "ListLogGroups", params, optFns, c.addOperationListLogGroupsMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*ListLogGroupsOutput) + out.ResultMetadata = metadata + return out, nil +} + +type ListLogGroupsInput struct { + + // When includeLinkedAccounts is set to true , use this parameter to specify the + // list of accounts to search. You can specify as many as 20 account IDs in the + // array. + AccountIdentifiers []string + + // An array of data source filters to filter log groups by their associated data + // sources. You can filter by data source name, type, or both. Multiple filters + // within the same dimension are combined with OR logic, while filters across + // different dimensions are combined with AND logic. + DataSources []types.DataSourceFilter + + // An array of field index names to filter log groups that have specific field + // indexes. Only log groups containing all specified field indexes are returned. + // You can specify 1 to 20 field index names, each with 1 to 512 characters. + FieldIndexNames []string + + // If you are using a monitoring account, set this to true to have the operation + // return log groups in the accounts listed in accountIdentifiers . + // + // If this parameter is set to true and accountIdentifiers contains a null value, + // the operation returns all log groups in the monitoring account and all log + // groups in all source accounts that are linked to the monitoring account. + // + // The default for this parameter is false . + IncludeLinkedAccounts *bool + + // The maximum number of log groups to return. If you omit this parameter, the + // default is up to 50 log groups. + Limit *int32 + + // Use this parameter to limit the results to only those log groups in the + // specified log group class. If you omit this parameter, log groups of all classes + // can be returned. + LogGroupClass types.LogGroupClass + + // Use this parameter to limit the returned log groups to only those with names + // that match the pattern that you specify. This parameter is a regular expression + // that can match prefixes and substrings, and supports wildcard matching and + // matching multiple patterns, as in the following examples. + // + // - Use ^ to match log group names by prefix. + // + // - For a substring match, specify the string to match. All matches are case + // sensitive + // + // - To match multiple patterns, separate them with a | as in the example + // ^/aws/lambda|discovery + // + // You can specify as many as five different regular expression patterns in this + // field, each of which must be between 3 and 24 characters. You can include the ^ + // symbol as many as five times, and include the | symbol as many as four times. + LogGroupNamePattern *string + + // The token for the next set of items to return. The token expires after 24 hours. + NextToken *string + + noSmithyDocumentSerde +} + +type ListLogGroupsOutput struct { + + // An array of structures, where each structure contains the information about one + // log group. + LogGroups []types.LogGroupSummary + + // The token for the next set of items to return. The token expires after 24 hours. + NextToken *string + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationListLogGroupsMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&setOperationInputMiddleware{}, middleware.After); err != nil { + return err + } + err = stack.Serialize.Add(&awsAwsjson11_serializeOpListLogGroups{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpListLogGroups{}, middleware.After) + if err != nil { + return err + } + if err := addProtocolFinalizerMiddlewares(stack, options, "ListLogGroups"); err != nil { + return fmt.Errorf("add protocol finalizers: %v", err) + } + + if err = addlegacyEndpointContextSetter(stack, options); err != nil { + return err + } + if err = addSetLoggerMiddleware(stack, options); err != nil { + return err + } + if err = addClientRequestID(stack); err != nil { + return err + } + if err = addComputeContentLength(stack); err != nil { + return err + } + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRetry(stack, options, c); err != nil { + return err + } + if err = addRawResponseToMetadata(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack); err != nil { + return err + } + if err = addSpanRetryLoop(stack, options); err != nil { + return err + } + if err = addClientUserAgent(stack, options); err != nil { + return err + } + if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { + return err + } + if err = addUserAgentRetryMode(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = addOpListLogGroupsValidationMiddleware(stack); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListLogGroups(options.Region), middleware.Before); err != nil { + return err + } + if err = addRecursionDetection(stack); err != nil { + return err + } + if err = addRequestIDRetrieverMiddleware(stack); err != nil { + return err + } + if err = addResponseErrorMiddleware(stack); err != nil { + return err + } + if err = addRequestResponseLogging(stack, options); err != nil { + return err + } + if err = addDisableHTTPSMiddleware(stack, options); err != nil { + return err + } + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { + return err + } + if err = addInterceptAttempt(stack, options); err != nil { + return err + } + if err = addInterceptors(stack, options); err != nil { + return err + } + return nil +} + +func newServiceMetadataMiddleware_opListLogGroups(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + OperationName: "ListLogGroups", + } +} diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_ListLogGroupsForQuery.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_ListLogGroupsForQuery.go index dc42f50a76a..e8edc981898 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_ListLogGroupsForQuery.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_ListLogGroupsForQuery.go @@ -101,7 +101,7 @@ func (c *Client) addOperationListLogGroupsForQueryMiddlewares(stack *middleware. if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -125,9 +125,6 @@ func (c *Client) addOperationListLogGroupsForQueryMiddlewares(stack *middleware. if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -155,16 +152,13 @@ func (c *Client) addOperationListLogGroupsForQueryMiddlewares(stack *middleware. if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_ListScheduledQueries.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_ListScheduledQueries.go new file mode 100644 index 00000000000..daf9b76233f --- /dev/null +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_ListScheduledQueries.go @@ -0,0 +1,254 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package cloudwatchlogs + +import ( + "context" + "fmt" + awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/types" + "github.com/aws/smithy-go/middleware" + smithyhttp "github.com/aws/smithy-go/transport/http" +) + +// Lists all scheduled queries in your account and region. You can filter results +// by state to show only enabled or disabled queries. +func (c *Client) ListScheduledQueries(ctx context.Context, params *ListScheduledQueriesInput, optFns ...func(*Options)) (*ListScheduledQueriesOutput, error) { + if params == nil { + params = &ListScheduledQueriesInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "ListScheduledQueries", params, optFns, c.addOperationListScheduledQueriesMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*ListScheduledQueriesOutput) + out.ResultMetadata = metadata + return out, nil +} + +type ListScheduledQueriesInput struct { + + // The maximum number of scheduled queries to return. Valid range is 1 to 1000. + MaxResults *int32 + + // The token for the next set of items to return. The token expires after 24 hours. + NextToken *string + + // Filter scheduled queries by state. Valid values are ENABLED and DISABLED . If + // not specified, all scheduled queries are returned. + State types.ScheduledQueryState + + noSmithyDocumentSerde +} + +type ListScheduledQueriesOutput struct { + + // The token for the next set of items to return. The token expires after 24 hours. + NextToken *string + + // An array of scheduled query summary information. + ScheduledQueries []types.ScheduledQuerySummary + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationListScheduledQueriesMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&setOperationInputMiddleware{}, middleware.After); err != nil { + return err + } + err = stack.Serialize.Add(&awsAwsjson11_serializeOpListScheduledQueries{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpListScheduledQueries{}, middleware.After) + if err != nil { + return err + } + if err := addProtocolFinalizerMiddlewares(stack, options, "ListScheduledQueries"); err != nil { + return fmt.Errorf("add protocol finalizers: %v", err) + } + + if err = addlegacyEndpointContextSetter(stack, options); err != nil { + return err + } + if err = addSetLoggerMiddleware(stack, options); err != nil { + return err + } + if err = addClientRequestID(stack); err != nil { + return err + } + if err = addComputeContentLength(stack); err != nil { + return err + } + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRetry(stack, options, c); err != nil { + return err + } + if err = addRawResponseToMetadata(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack); err != nil { + return err + } + if err = addSpanRetryLoop(stack, options); err != nil { + return err + } + if err = addClientUserAgent(stack, options); err != nil { + return err + } + if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { + return err + } + if err = addUserAgentRetryMode(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListScheduledQueries(options.Region), middleware.Before); err != nil { + return err + } + if err = addRecursionDetection(stack); err != nil { + return err + } + if err = addRequestIDRetrieverMiddleware(stack); err != nil { + return err + } + if err = addResponseErrorMiddleware(stack); err != nil { + return err + } + if err = addRequestResponseLogging(stack, options); err != nil { + return err + } + if err = addDisableHTTPSMiddleware(stack, options); err != nil { + return err + } + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { + return err + } + if err = addInterceptAttempt(stack, options); err != nil { + return err + } + if err = addInterceptors(stack, options); err != nil { + return err + } + return nil +} + +// ListScheduledQueriesPaginatorOptions is the paginator options for +// ListScheduledQueries +type ListScheduledQueriesPaginatorOptions struct { + // The maximum number of scheduled queries to return. Valid range is 1 to 1000. + Limit int32 + + // Set to true if pagination should stop if the service returns a pagination token + // that matches the most recent token provided to the service. + StopOnDuplicateToken bool +} + +// ListScheduledQueriesPaginator is a paginator for ListScheduledQueries +type ListScheduledQueriesPaginator struct { + options ListScheduledQueriesPaginatorOptions + client ListScheduledQueriesAPIClient + params *ListScheduledQueriesInput + nextToken *string + firstPage bool +} + +// NewListScheduledQueriesPaginator returns a new ListScheduledQueriesPaginator +func NewListScheduledQueriesPaginator(client ListScheduledQueriesAPIClient, params *ListScheduledQueriesInput, optFns ...func(*ListScheduledQueriesPaginatorOptions)) *ListScheduledQueriesPaginator { + if params == nil { + params = &ListScheduledQueriesInput{} + } + + options := ListScheduledQueriesPaginatorOptions{} + if params.MaxResults != nil { + options.Limit = *params.MaxResults + } + + for _, fn := range optFns { + fn(&options) + } + + return &ListScheduledQueriesPaginator{ + options: options, + client: client, + params: params, + firstPage: true, + nextToken: params.NextToken, + } +} + +// HasMorePages returns a boolean indicating whether more pages are available +func (p *ListScheduledQueriesPaginator) HasMorePages() bool { + return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0) +} + +// NextPage retrieves the next ListScheduledQueries page. +func (p *ListScheduledQueriesPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListScheduledQueriesOutput, error) { + if !p.HasMorePages() { + return nil, fmt.Errorf("no more pages available") + } + + params := *p.params + params.NextToken = p.nextToken + + var limit *int32 + if p.options.Limit > 0 { + limit = &p.options.Limit + } + params.MaxResults = limit + + optFns = append([]func(*Options){ + addIsPaginatorUserAgent, + }, optFns...) + result, err := p.client.ListScheduledQueries(ctx, ¶ms, optFns...) + if err != nil { + return nil, err + } + p.firstPage = false + + prevToken := p.nextToken + p.nextToken = result.NextToken + + if p.options.StopOnDuplicateToken && + prevToken != nil && + p.nextToken != nil && + *prevToken == *p.nextToken { + p.nextToken = nil + } + + return result, nil +} + +// ListScheduledQueriesAPIClient is a client that implements the +// ListScheduledQueries operation. +type ListScheduledQueriesAPIClient interface { + ListScheduledQueries(context.Context, *ListScheduledQueriesInput, ...func(*Options)) (*ListScheduledQueriesOutput, error) +} + +var _ ListScheduledQueriesAPIClient = (*Client)(nil) + +func newServiceMetadataMiddleware_opListScheduledQueries(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + OperationName: "ListScheduledQueries", + } +} diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_ListSourcesForS3TableIntegration.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_ListSourcesForS3TableIntegration.go new file mode 100644 index 00000000000..7c13bdf09d8 --- /dev/null +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_ListSourcesForS3TableIntegration.go @@ -0,0 +1,264 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package cloudwatchlogs + +import ( + "context" + "fmt" + awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/types" + "github.com/aws/smithy-go/middleware" + smithyhttp "github.com/aws/smithy-go/transport/http" +) + +// Returns a list of data source associations for a specified S3 Table +// Integration, showing which data sources are currently associated for query +// access. +func (c *Client) ListSourcesForS3TableIntegration(ctx context.Context, params *ListSourcesForS3TableIntegrationInput, optFns ...func(*Options)) (*ListSourcesForS3TableIntegrationOutput, error) { + if params == nil { + params = &ListSourcesForS3TableIntegrationInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "ListSourcesForS3TableIntegration", params, optFns, c.addOperationListSourcesForS3TableIntegrationMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*ListSourcesForS3TableIntegrationOutput) + out.ResultMetadata = metadata + return out, nil +} + +type ListSourcesForS3TableIntegrationInput struct { + + // The Amazon Resource Name (ARN) of the S3 Table Integration to list associations + // for. + // + // This member is required. + IntegrationArn *string + + // The maximum number of associations to return in a single call. Valid range is 1 + // to 100. + MaxResults *int32 + + // The token for the next set of items to return. The token expires after 24 hours. + NextToken *string + + noSmithyDocumentSerde +} + +type ListSourcesForS3TableIntegrationOutput struct { + + // The token for the next set of items to return. The token expires after 24 hours. + NextToken *string + + // The list of data source associations for the specified S3 Table Integration. + Sources []types.S3TableIntegrationSource + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationListSourcesForS3TableIntegrationMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&setOperationInputMiddleware{}, middleware.After); err != nil { + return err + } + err = stack.Serialize.Add(&awsAwsjson11_serializeOpListSourcesForS3TableIntegration{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpListSourcesForS3TableIntegration{}, middleware.After) + if err != nil { + return err + } + if err := addProtocolFinalizerMiddlewares(stack, options, "ListSourcesForS3TableIntegration"); err != nil { + return fmt.Errorf("add protocol finalizers: %v", err) + } + + if err = addlegacyEndpointContextSetter(stack, options); err != nil { + return err + } + if err = addSetLoggerMiddleware(stack, options); err != nil { + return err + } + if err = addClientRequestID(stack); err != nil { + return err + } + if err = addComputeContentLength(stack); err != nil { + return err + } + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRetry(stack, options, c); err != nil { + return err + } + if err = addRawResponseToMetadata(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack); err != nil { + return err + } + if err = addSpanRetryLoop(stack, options); err != nil { + return err + } + if err = addClientUserAgent(stack, options); err != nil { + return err + } + if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { + return err + } + if err = addUserAgentRetryMode(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = addOpListSourcesForS3TableIntegrationValidationMiddleware(stack); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListSourcesForS3TableIntegration(options.Region), middleware.Before); err != nil { + return err + } + if err = addRecursionDetection(stack); err != nil { + return err + } + if err = addRequestIDRetrieverMiddleware(stack); err != nil { + return err + } + if err = addResponseErrorMiddleware(stack); err != nil { + return err + } + if err = addRequestResponseLogging(stack, options); err != nil { + return err + } + if err = addDisableHTTPSMiddleware(stack, options); err != nil { + return err + } + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { + return err + } + if err = addInterceptAttempt(stack, options); err != nil { + return err + } + if err = addInterceptors(stack, options); err != nil { + return err + } + return nil +} + +// ListSourcesForS3TableIntegrationPaginatorOptions is the paginator options for +// ListSourcesForS3TableIntegration +type ListSourcesForS3TableIntegrationPaginatorOptions struct { + // The maximum number of associations to return in a single call. Valid range is 1 + // to 100. + Limit int32 + + // Set to true if pagination should stop if the service returns a pagination token + // that matches the most recent token provided to the service. + StopOnDuplicateToken bool +} + +// ListSourcesForS3TableIntegrationPaginator is a paginator for +// ListSourcesForS3TableIntegration +type ListSourcesForS3TableIntegrationPaginator struct { + options ListSourcesForS3TableIntegrationPaginatorOptions + client ListSourcesForS3TableIntegrationAPIClient + params *ListSourcesForS3TableIntegrationInput + nextToken *string + firstPage bool +} + +// NewListSourcesForS3TableIntegrationPaginator returns a new +// ListSourcesForS3TableIntegrationPaginator +func NewListSourcesForS3TableIntegrationPaginator(client ListSourcesForS3TableIntegrationAPIClient, params *ListSourcesForS3TableIntegrationInput, optFns ...func(*ListSourcesForS3TableIntegrationPaginatorOptions)) *ListSourcesForS3TableIntegrationPaginator { + if params == nil { + params = &ListSourcesForS3TableIntegrationInput{} + } + + options := ListSourcesForS3TableIntegrationPaginatorOptions{} + if params.MaxResults != nil { + options.Limit = *params.MaxResults + } + + for _, fn := range optFns { + fn(&options) + } + + return &ListSourcesForS3TableIntegrationPaginator{ + options: options, + client: client, + params: params, + firstPage: true, + nextToken: params.NextToken, + } +} + +// HasMorePages returns a boolean indicating whether more pages are available +func (p *ListSourcesForS3TableIntegrationPaginator) HasMorePages() bool { + return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0) +} + +// NextPage retrieves the next ListSourcesForS3TableIntegration page. +func (p *ListSourcesForS3TableIntegrationPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListSourcesForS3TableIntegrationOutput, error) { + if !p.HasMorePages() { + return nil, fmt.Errorf("no more pages available") + } + + params := *p.params + params.NextToken = p.nextToken + + var limit *int32 + if p.options.Limit > 0 { + limit = &p.options.Limit + } + params.MaxResults = limit + + optFns = append([]func(*Options){ + addIsPaginatorUserAgent, + }, optFns...) + result, err := p.client.ListSourcesForS3TableIntegration(ctx, ¶ms, optFns...) + if err != nil { + return nil, err + } + p.firstPage = false + + prevToken := p.nextToken + p.nextToken = result.NextToken + + if p.options.StopOnDuplicateToken && + prevToken != nil && + p.nextToken != nil && + *prevToken == *p.nextToken { + p.nextToken = nil + } + + return result, nil +} + +// ListSourcesForS3TableIntegrationAPIClient is a client that implements the +// ListSourcesForS3TableIntegration operation. +type ListSourcesForS3TableIntegrationAPIClient interface { + ListSourcesForS3TableIntegration(context.Context, *ListSourcesForS3TableIntegrationInput, ...func(*Options)) (*ListSourcesForS3TableIntegrationOutput, error) +} + +var _ ListSourcesForS3TableIntegrationAPIClient = (*Client)(nil) + +func newServiceMetadataMiddleware_opListSourcesForS3TableIntegration(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + OperationName: "ListSourcesForS3TableIntegration", + } +} diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_ListTagsForResource.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_ListTagsForResource.go index c3e9f6ba500..e35a314a541 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_ListTagsForResource.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_ListTagsForResource.go @@ -92,7 +92,7 @@ func (c *Client) addOperationListTagsForResourceMiddlewares(stack *middleware.St if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -116,9 +116,6 @@ func (c *Client) addOperationListTagsForResourceMiddlewares(stack *middleware.St if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -146,16 +143,13 @@ func (c *Client) addOperationListTagsForResourceMiddlewares(stack *middleware.St if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_ListTagsLogGroup.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_ListTagsLogGroup.go index 20c0878e5e1..1f005e5b76a 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_ListTagsLogGroup.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_ListTagsLogGroup.go @@ -88,7 +88,7 @@ func (c *Client) addOperationListTagsLogGroupMiddlewares(stack *middleware.Stack if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -112,9 +112,6 @@ func (c *Client) addOperationListTagsLogGroupMiddlewares(stack *middleware.Stack if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -142,16 +139,13 @@ func (c *Client) addOperationListTagsLogGroupMiddlewares(stack *middleware.Stack if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_PutAccountPolicy.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_PutAccountPolicy.go index b31d5080fca..ac71c68fe94 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_PutAccountPolicy.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_PutAccountPolicy.go @@ -11,9 +11,15 @@ import ( smithyhttp "github.com/aws/smithy-go/transport/http" ) -// Creates an account-level data protection policy, subscription filter policy, or -// field index policy that applies to all log groups or a subset of log groups in -// the account. +// Creates an account-level data protection policy, subscription filter policy, +// field index policy, transformer policy, or metric extraction policy that applies +// to all log groups, a subset of log groups, or a data source name and type +// combination in the account. +// +// For field index policies, you can configure indexed fields as facets to enable +// interactive exploration of your logs. Facets provide value distributions and +// counts for indexed fields in the CloudWatch Logs Insights console without +// requiring query execution. For more information, see [Use facets to group and explore logs]. // // To use this operation, you must be signed on with the correct permissions // depending on the type of policy that you are creating. @@ -22,7 +28,7 @@ import ( // logs:PutDataProtectionPolicy and logs:PutAccountPolicy permissions. // // - To create a subscription filter policy, you must have the -// logs:PutSubscriptionFilter and logs:PutccountPolicy permissions. +// logs:PutSubscriptionFilter and logs:PutAccountPolicy permissions. // // - To create a transformer policy, you must have the logs:PutTransformer and // logs:PutAccountPolicy permissions. @@ -30,6 +36,12 @@ import ( // - To create a field index policy, you must have the logs:PutIndexPolicy and // logs:PutAccountPolicy permissions. // +// - To configure facets for field index policies, you must have the +// logs:PutIndexPolicy and logs:PutAccountPolicy permissions. +// +// - To create a metric extraction policy, you must have the +// logs:PutMetricExtractionPolicy and logs:PutAccountPolicy permissions. +// // # Data protection policy // // A data protection policy can help safeguard sensitive data that's ingested by @@ -131,7 +143,7 @@ import ( // selectionCriteria parameter. If you have multiple account-level transformer // policies with selection criteria, no two of them can use the same or overlapping // log group name prefixes. For example, if you have one policy filtered to log -// groups that start with my-log , you can't have another field index policy +// groups that start with my-log , you can't have another transformer policy // filtered to my-logpprod or my-logging . // // You can also set up a transformer at the log-group level. For more information, @@ -143,15 +155,16 @@ import ( // # Field index policy // // You can use field index policies to create indexes on fields found in log -// events in the log group. Creating field indexes can help lower the scan volume -// for CloudWatch Logs Insights queries that reference those fields, because these -// queries attempt to skip the processing of log events that are known to not match -// the indexed field. Good fields to index are fields that you often need to query -// for and fields or values that match only a small fraction of the total log -// events. Common examples of indexes include request ID, session ID, user IDs, or -// instance IDs. For more information, see [Create field indexes to improve query performance and reduce costs] +// events for a log group or data source name and type combination. Creating field +// indexes can help lower the scan volume for CloudWatch Logs Insights queries that +// reference those fields, because these queries attempt to skip the processing of +// log events that are known to not match the indexed field. Good fields to index +// are fields that you often need to query for and fields or values that match only +// a small fraction of the total log events. Common examples of indexes include +// request ID, session ID, user IDs, or instance IDs. For more information, see [Create field indexes to improve query performance and reduce costs] // -// To find the fields that are in your log group events, use the [GetLogGroupFields] operation. +// To find the fields that are in your log group events, use the [GetLogGroupFields] operation. To +// find the fields for a data source use the [GetLogFields]operation. // // For example, suppose you have created a field index for requestId . Then, any // CloudWatch Logs Insights query on that log group that includes requestId = @@ -164,33 +177,176 @@ import ( // // You can have one account-level field index policy that applies to all log // groups in the account. Or you can create as many as 20 account-level field index -// policies that are each scoped to a subset of log groups with the +// policies that are each scoped to a subset of log groups using LogGroupNamePrefix +// with the selectionCriteria parameter. You can have another 20 account-level +// field index policies using DataSourceName and DataSourceType for the // selectionCriteria parameter. If you have multiple account-level index policies -// with selection criteria, no two of them can use the same or overlapping log -// group name prefixes. For example, if you have one policy filtered to log groups -// that start with my-log , you can't have another field index policy filtered to -// my-logpprod or my-logging . +// with LogGroupNamePrefix selection criteria, no two of them can use the same or +// overlapping log group name prefixes. For example, if you have one policy +// filtered to log groups that start with my-log, you can't have another field +// index policy filtered to my-logpprod or my-logging. Similarly, if you have +// multiple account-level index policies with DataSourceName and DataSourceType +// selection criteria, no two of them can use the same data source name and type +// combination. For example, if you have one policy filtered to the data source +// name amazon_vpc and data source type flow you cannot create another policy with +// this combination. // // If you create an account-level field index policy in a monitoring account in // cross-account observability, the policy is applied only to the monitoring // account and not to any source accounts. // +// CloudWatch Logs provides default field indexes for all log groups in the +// Standard log class. Default field indexes are automatically available for the +// following fields: +// +// - @logStream +// +// - @aws.region +// +// - @aws.account +// +// - @source.log +// +// - @data_source_name +// +// - @data_source_type +// +// - @data_format +// +// - traceId +// +// - severityText +// +// - attributes.session.id +// +// CloudWatch Logs provides default field indexes for certain data source name and +// type combinations as well. Default field indexes are automatically available for +// the following data source name and type combinations as identified in the +// following list: +// +// amazon_vpc.flow +// +// - action +// +// - logStatus +// +// - region +// +// - flowDirection +// +// - type +// +// amazon_route53.resolver_query +// +// - transport +// +// - rcode +// +// aws_waf.access +// +// - action +// +// - httpRequest.country +// +// aws_cloudtrail.data , aws_cloudtrail.management +// +// - eventSource +// +// - eventName +// +// - awsRegion +// +// - userAgent +// +// - errorCode +// +// - eventType +// +// - managementEvent +// +// - readOnly +// +// - eventCategory +// +// - requestId +// +// Default field indexes are in addition to any custom field indexes you define +// within your policy. Default field indexes are not counted towards your [field index quota]. +// // If you want to create a field index policy for a single log group, you can use [PutIndexPolicy] -// instead of PutAccountPolicy . If you do so, that log group will use only that -// log-group level policy, and will ignore the account-level policy that you create -// with [PutAccountPolicy]. +// instead of PutAccountPolicy . If you do so, that log group will use that +// log-group level policy and any account-level policies that match at the data +// source level; any account-level policy that matches at the log group level (for +// example, no selection criteria or log group name prefix selection criteria) will +// be ignored. +// +// # Metric extraction policy +// +// A metric extraction policy controls whether CloudWatch Metrics can be created +// through the Embedded Metrics Format (EMF) for log groups in your account. By +// default, EMF metric creation is enabled for all log groups. You can use metric +// extraction policies to disable EMF metric creation for your entire account or +// specific log groups. +// +// When a policy disables EMF metric creation for a log group, log events in the +// EMF format are still ingested, but no CloudWatch Metrics are created from them. +// +// Creating a policy disables metrics for Amazon Web Services features that use +// EMF to create metrics, such as CloudWatch Container Insights and CloudWatch +// Application Signals. To prevent turning off those features by accident, we +// recommend that you exclude the underlying log-groups through a +// selection-criteria such as LogGroupNamePrefix NOT IN ["/aws/containerinsights", +// "/aws/ecs/containerinsights", "/aws/application-signals/data"] . +// +// Each account can have either one account-level metric extraction policy that +// applies to all log groups, or up to 5 policies that are each scoped to a subset +// of log groups with the selectionCriteria parameter. The selection criteria +// supports filtering by LogGroupName and LogGroupNamePrefix using the operators IN +// and NOT IN . You can specify up to 50 values in each IN or NOT IN list. +// +// The selection criteria can be specified in these formats: +// +// LogGroupName IN ["log-group-1", "log-group-2"] +// +// LogGroupNamePrefix NOT IN ["/aws/prefix1", "/aws/prefix2"] +// +// If you have multiple account-level metric extraction policies with selection +// criteria, no two of them can have overlapping criteria. For example, if you have +// one policy with selection criteria LogGroupNamePrefix IN ["my-log"] , you can't +// have another metric extraction policy with selection criteria +// LogGroupNamePrefix IN ["/my-log-prod"] or LogGroupNamePrefix IN ["/my-logging"] +// , as the set of log groups matching these prefixes would be a subset of the log +// groups matching the first policy's prefix, creating an overlap. +// +// When using NOT IN , only one policy with this operator is allowed per account. +// +// When combining policies with IN and NOT IN operators, the overlap check ensures +// that policies don't have conflicting effects. Two policies with IN and NOT IN +// operators do not overlap if and only if every value in the IN policy is +// completely contained within some value in the NOT IN policy. For example: +// +// - If you have a NOT IN policy for prefix "/aws/lambda" , you can create an IN +// policy for the exact log group name "/aws/lambda/function1" because the set of +// log groups matching "/aws/lambda/function1" is a subset of the log groups +// matching "/aws/lambda" . +// +// - If you have a NOT IN policy for prefix "/aws/lambda" , you cannot create an +// IN policy for prefix "/aws" because the set of log groups matching "/aws" is +// not a subset of the log groups matching "/aws/lambda" . // // [PutDestination]: https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_PutDestination.html // [PutTransformer]: https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_PutTransformer.html -// [PutIndexPolicy]: https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_PutIndexPolicy.html +// [GetLogFields]: https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_GetLogFields.html // [PutDataProtectionPolicy]: https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_PutDataProtectionPolicy.html -// [Protect sensitive log data with masking]: https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/mask-sensitive-log-data.html // [FilterLogEvents]: https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_FilterLogEvents.html -// [GetLogGroupFields]: https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_GetLogGroupFields.html // [Processors that you can use]: https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CloudWatch-Logs-Transformation.html#CloudWatch-Logs-Transformation-Processors -// [PutAccountPolicy]: https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_PutAccountPolicy.html -// [Create field indexes to improve query performance and reduce costs]: https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CloudWatchLogs-Field-Indexing.html // [GetLogEvents]: https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_GetLogEvents.html +// [field index quota]: https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CloudWatchLogs-Field-Indexing-Syntax +// [PutIndexPolicy]: https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_PutIndexPolicy.html +// [Protect sensitive log data with masking]: https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/mask-sensitive-log-data.html +// [GetLogGroupFields]: https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_GetLogGroupFields.html +// [Use facets to group and explore logs]: https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CloudWatchLogs-Facets.html +// [Create field indexes to improve query performance and reduce costs]: https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CloudWatchLogs-Field-Indexing.html func (c *Client) PutAccountPolicy(ctx context.Context, params *PutAccountPolicyInput, optFns ...func(*Options)) (*PutAccountPolicyOutput, error) { if params == nil { params = &PutAccountPolicyInput{} @@ -290,12 +446,20 @@ type PutAccountPolicyInput struct { // // - Fields The array of field indexes to create. // + // - FieldsV2 The object of field indexes to create along with it's type. + // // It must contain at least one field index. // - // The following is an example of an index policy document that creates two - // indexes, RequestId and TransactionId . + // The following is an example of an index policy document that creates indexes + // with different types. + // + // "policyDocument": "{ \"Fields\": [ \"TransactionId\" ], \"FieldsV2\": + // {\"RequestId\": {\"type\": \"FIELD_INDEX\"}, \"APIName\": {\"type\": \"FACET\"}, + // \"StatusCode\": {\"type\": \"FACET\"}}}" // - // "policyDocument": "{ \"Fields\": [ \"RequestId\", \"TransactionId\" ] }" + // You can use FieldsV2 to specify the type for each field. Supported types are + // FIELD_INDEX and FACET . Field names within Fields and FieldsV2 must be mutually + // exclusive. // // [PutDestination]: https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_PutDestination.html // [Processors that you can use]: https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CloudWatch-Logs-Transformation.html#CloudWatch-Logs-Transformation-Processors @@ -304,7 +468,8 @@ type PutAccountPolicyInput struct { // This member is required. PolicyDocument *string - // A name for the policy. This must be unique within the account. + // A name for the policy. This must be unique within the account and cannot start + // with aws/ . // // This member is required. PolicyName *string @@ -320,17 +485,27 @@ type PutAccountPolicyInput struct { Scope types.Scope // Use this parameter to apply the new policy to a subset of log groups in the - // account. + // account or a data source name and type combination. // - // Specifing selectionCriteria is valid only when you specify + // Specifying selectionCriteria is valid only when you specify // SUBSCRIPTION_FILTER_POLICY , FIELD_INDEX_POLICY or TRANSFORMER_POLICY for // policyType . // - // If policyType is SUBSCRIPTION_FILTER_POLICY , the only supported - // selectionCriteria filter is LogGroupName NOT IN [] + // - If policyType is SUBSCRIPTION_FILTER_POLICY , the only supported + // selectionCriteria filter is LogGroupName NOT IN [] + // + // - If policyType is TRANSFORMER_POLICY , the only supported selectionCriteria + // filter is LogGroupNamePrefix // - // If policyType is FIELD_INDEX_POLICY or TRANSFORMER_POLICY , the only supported - // selectionCriteria filter is LogGroupNamePrefix + // - If policyType is FIELD_INDEX_POLICY , the supported selectionCriteria + // filters are: + // + // - LogGroupNamePrefix + // + // - DataSourceName AND DataSourceType + // + // When you specify selectionCriteria for a field index policy you can use either + // LogGroupNamePrefix by itself or DataSourceName and DataSourceType together. // // The selectionCriteria string can be up to 25KB in length. The length is // determined by using its UTF-8 bytes. @@ -389,7 +564,7 @@ func (c *Client) addOperationPutAccountPolicyMiddlewares(stack *middleware.Stack if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -413,9 +588,6 @@ func (c *Client) addOperationPutAccountPolicyMiddlewares(stack *middleware.Stack if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -443,16 +615,13 @@ func (c *Client) addOperationPutAccountPolicyMiddlewares(stack *middleware.Stack if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_PutBearerTokenAuthentication.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_PutBearerTokenAuthentication.go new file mode 100644 index 00000000000..484b34d9bfc --- /dev/null +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_PutBearerTokenAuthentication.go @@ -0,0 +1,172 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package cloudwatchlogs + +import ( + "context" + "fmt" + awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/smithy-go/middleware" + smithyhttp "github.com/aws/smithy-go/transport/http" +) + +// Enables or disables bearer token authentication for the specified log group. +// When enabled on a log group, bearer token authentication is enabled on +// operations until it is explicitly disabled. +// +// For information about the parameters that are common to all actions, see [Common Parameters]. +// +// [Common Parameters]: https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/CommonParameters.html +func (c *Client) PutBearerTokenAuthentication(ctx context.Context, params *PutBearerTokenAuthenticationInput, optFns ...func(*Options)) (*PutBearerTokenAuthenticationOutput, error) { + if params == nil { + params = &PutBearerTokenAuthenticationInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "PutBearerTokenAuthentication", params, optFns, c.addOperationPutBearerTokenAuthenticationMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*PutBearerTokenAuthenticationOutput) + out.ResultMetadata = metadata + return out, nil +} + +type PutBearerTokenAuthenticationInput struct { + + // Whether to enable bearer token authentication. + // + // Type: Boolean + // + // Required: Yes + // + // This member is required. + BearerTokenAuthenticationEnabled *bool + + // The name or ARN of the log group. + // + // Type: String + // + // Length Constraints: Minimum length of 1. Maximum length of 512. + // + // Pattern: [\.\-_/#A-Za-z0-9]+ + // + // Required: Yes + // + // This member is required. + LogGroupIdentifier *string + + noSmithyDocumentSerde +} + +type PutBearerTokenAuthenticationOutput struct { + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationPutBearerTokenAuthenticationMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&setOperationInputMiddleware{}, middleware.After); err != nil { + return err + } + err = stack.Serialize.Add(&awsAwsjson11_serializeOpPutBearerTokenAuthentication{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpPutBearerTokenAuthentication{}, middleware.After) + if err != nil { + return err + } + if err := addProtocolFinalizerMiddlewares(stack, options, "PutBearerTokenAuthentication"); err != nil { + return fmt.Errorf("add protocol finalizers: %v", err) + } + + if err = addlegacyEndpointContextSetter(stack, options); err != nil { + return err + } + if err = addSetLoggerMiddleware(stack, options); err != nil { + return err + } + if err = addClientRequestID(stack); err != nil { + return err + } + if err = addComputeContentLength(stack); err != nil { + return err + } + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRetry(stack, options, c); err != nil { + return err + } + if err = addRawResponseToMetadata(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack); err != nil { + return err + } + if err = addSpanRetryLoop(stack, options); err != nil { + return err + } + if err = addClientUserAgent(stack, options); err != nil { + return err + } + if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { + return err + } + if err = addUserAgentRetryMode(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = addOpPutBearerTokenAuthenticationValidationMiddleware(stack); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opPutBearerTokenAuthentication(options.Region), middleware.Before); err != nil { + return err + } + if err = addRecursionDetection(stack); err != nil { + return err + } + if err = addRequestIDRetrieverMiddleware(stack); err != nil { + return err + } + if err = addResponseErrorMiddleware(stack); err != nil { + return err + } + if err = addRequestResponseLogging(stack, options); err != nil { + return err + } + if err = addDisableHTTPSMiddleware(stack, options); err != nil { + return err + } + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { + return err + } + if err = addInterceptAttempt(stack, options); err != nil { + return err + } + if err = addInterceptors(stack, options); err != nil { + return err + } + return nil +} + +func newServiceMetadataMiddleware_opPutBearerTokenAuthentication(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + OperationName: "PutBearerTokenAuthentication", + } +} diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_PutDataProtectionPolicy.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_PutDataProtectionPolicy.go index 6457b3dee9a..86b284ccfa1 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_PutDataProtectionPolicy.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_PutDataProtectionPolicy.go @@ -154,7 +154,7 @@ func (c *Client) addOperationPutDataProtectionPolicyMiddlewares(stack *middlewar if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -178,9 +178,6 @@ func (c *Client) addOperationPutDataProtectionPolicyMiddlewares(stack *middlewar if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -208,16 +205,13 @@ func (c *Client) addOperationPutDataProtectionPolicyMiddlewares(stack *middlewar if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_PutDeliveryDestination.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_PutDeliveryDestination.go index a763ab3eb7c..8df5ec83f31 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_PutDeliveryDestination.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_PutDeliveryDestination.go @@ -14,7 +14,7 @@ import ( // Creates or updates a logical delivery destination. A delivery destination is an // Amazon Web Services resource that represents an Amazon Web Services service that // logs can be sent to. CloudWatch Logs, Amazon S3, and Firehose are supported as -// logs delivery destinations. +// logs delivery destinations and X-Ray as the trace delivery destination. // // To configure logs delivery between a supported Amazon Web Services service and // a destination, you must do the following: @@ -66,17 +66,36 @@ func (c *Client) PutDeliveryDestination(ctx context.Context, params *PutDelivery type PutDeliveryDestinationInput struct { + // A name for this delivery destination. This name must be unique for all delivery + // destinations in your account. + // + // This member is required. + Name *string + // A structure that contains the ARN of the Amazon Web Services resource that will // receive the logs. // - // This member is required. + // deliveryDestinationConfiguration is required for CloudWatch Logs, Amazon S3, + // Firehose log delivery destinations and not required for X-Ray trace delivery + // destinations. deliveryDestinationType is needed for X-Ray trace delivery + // destinations but not required for other logs delivery destinations. DeliveryDestinationConfiguration *types.DeliveryDestinationConfiguration - // A name for this delivery destination. This name must be unique for all delivery - // destinations in your account. + // The type of delivery destination. This parameter specifies the target service + // where log data will be delivered. Valid values include: // - // This member is required. - Name *string + // - S3 - Amazon S3 for long-term storage and analytics + // + // - CWL - CloudWatch Logs for centralized log management + // + // - FH - Amazon Kinesis Data Firehose for real-time data streaming + // + // - XRAY - Amazon Web Services X-Ray for distributed tracing and application + // monitoring + // + // The delivery destination type determines the format and configuration options + // available for log delivery. + DeliveryDestinationType types.DeliveryDestinationType // The format for the logs that this delivery destination will receive. OutputFormat types.OutputFormat @@ -137,7 +156,7 @@ func (c *Client) addOperationPutDeliveryDestinationMiddlewares(stack *middleware if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -161,9 +180,6 @@ func (c *Client) addOperationPutDeliveryDestinationMiddlewares(stack *middleware if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -191,16 +207,13 @@ func (c *Client) addOperationPutDeliveryDestinationMiddlewares(stack *middleware if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_PutDeliveryDestinationPolicy.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_PutDeliveryDestinationPolicy.go index 7760bfa2bdb..2bde7b72fea 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_PutDeliveryDestinationPolicy.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_PutDeliveryDestinationPolicy.go @@ -115,7 +115,7 @@ func (c *Client) addOperationPutDeliveryDestinationPolicyMiddlewares(stack *midd if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -139,9 +139,6 @@ func (c *Client) addOperationPutDeliveryDestinationPolicyMiddlewares(stack *midd if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -169,16 +166,13 @@ func (c *Client) addOperationPutDeliveryDestinationPolicyMiddlewares(stack *midd if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_PutDeliverySource.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_PutDeliverySource.go index f6e89c47c09..d57c53214dc 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_PutDeliverySource.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_PutDeliverySource.go @@ -13,7 +13,8 @@ import ( // Creates or updates a logical delivery source. A delivery source represents an // Amazon Web Services resource that sends logs to an logs delivery destination. -// The destination can be CloudWatch Logs, Amazon S3, or Firehose. +// The destination can be CloudWatch Logs, Amazon S3, Firehose or X-Ray for sending +// traces. // // To configure logs delivery between a delivery destination and an Amazon Web // Services service that is supported as a delivery source, you must do the @@ -68,7 +69,25 @@ type PutDeliverySourceInput struct { // Defines the type of log that the source is sending. // - // - For Amazon Bedrock, the valid value is APPLICATION_LOGS . + // - For Amazon Bedrock Agents, the valid values are APPLICATION_LOGS and + // EVENT_LOGS . + // + // - For Amazon Bedrock Knowledge Bases, the valid value is APPLICATION_LOGS . + // + // - For Amazon Bedrock AgentCore Runtime, the valid values are APPLICATION_LOGS + // , USAGE_LOGS and TRACES . + // + // - For Amazon Bedrock AgentCore Tools, the valid values are APPLICATION_LOGS , + // USAGE_LOGS and TRACES . + // + // - For Amazon Bedrock AgentCore Identity, the valid values are APPLICATION_LOGS + // and TRACES . + // + // - For Amazon Bedrock AgentCore Memory, the valid values are APPLICATION_LOGS + // and TRACES . + // + // - For Amazon Bedrock AgentCore Gateway, the valid values are APPLICATION_LOGS + // and TRACES . // // - For CloudFront, the valid value is ACCESS_LOGS . // @@ -80,16 +99,36 @@ type PutDeliverySourceInput struct { // - For Elemental MediaTailor, the valid values are AD_DECISION_SERVER_LOGS , // MANIFEST_SERVICE_LOGS , and TRANSCODE_LOGS . // + // - For Amazon EKS Auto Mode, the valid values are AUTO_MODE_BLOCK_STORAGE_LOGS + // , AUTO_MODE_COMPUTE_LOGS , AUTO_MODE_IPAM_LOGS , and + // AUTO_MODE_LOAD_BALANCING_LOGS . + // + // - For Entity Resolution, the valid value is WORKFLOW_LOGS . + // // - For IAM Identity Center, the valid value is ERROR_LOGS . // - // - For Amazon Q, the valid value is EVENT_LOGS . + // - For Network Firewall Proxy, the valid values are ALERT_LOGS , ALLOW_LOGS , + // and DENY_LOGS . + // + // - For Network Load Balancer, the valid value is NLB_ACCESS_LOGS . // - // - For Amazon SES mail manager, the valid value is APPLICATION_LOG . + // - For PCS, the valid values are PCS_SCHEDULER_LOGS and PCS_JOBCOMP_LOGS . + // + // - For Quick, the valid values are CHAT_LOGS and FEEDBACK_LOGS . + // + // - For Amazon Web Services RTB Fabric, the valid values is APPLICATION_LOGS . + // + // - For Amazon Q, the valid values are EVENT_LOGS and SYNC_JOB_LOGS . + // + // - For Amazon SES mail manager, the valid values are APPLICATION_LOGS and + // TRAFFIC_POLICY_DEBUG_LOGS . // // - For Amazon WorkMail, the valid values are ACCESS_CONTROL_LOGS , // AUTHENTICATION_LOGS , WORKMAIL_AVAILABILITY_PROVIDER_LOGS , // WORKMAIL_MAILBOX_ACCESS_LOGS , and WORKMAIL_PERSONAL_ACCESS_TOKEN_LOGS . // + // - For Amazon VPC Route Server, the valid value is EVENT_LOGS . + // // This member is required. LogType *string @@ -162,7 +201,7 @@ func (c *Client) addOperationPutDeliverySourceMiddlewares(stack *middleware.Stac if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -186,9 +225,6 @@ func (c *Client) addOperationPutDeliverySourceMiddlewares(stack *middleware.Stac if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -216,16 +252,13 @@ func (c *Client) addOperationPutDeliverySourceMiddlewares(stack *middleware.Stac if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_PutDestination.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_PutDestination.go index 5eef3392294..0ed2432e8ea 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_PutDestination.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_PutDestination.go @@ -117,7 +117,7 @@ func (c *Client) addOperationPutDestinationMiddlewares(stack *middleware.Stack, if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -141,9 +141,6 @@ func (c *Client) addOperationPutDestinationMiddlewares(stack *middleware.Stack, if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -171,16 +168,13 @@ func (c *Client) addOperationPutDestinationMiddlewares(stack *middleware.Stack, if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_PutDestinationPolicy.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_PutDestinationPolicy.go index 7e88532dc01..7a35329bad0 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_PutDestinationPolicy.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_PutDestinationPolicy.go @@ -100,7 +100,7 @@ func (c *Client) addOperationPutDestinationPolicyMiddlewares(stack *middleware.S if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -124,9 +124,6 @@ func (c *Client) addOperationPutDestinationPolicyMiddlewares(stack *middleware.S if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -154,16 +151,13 @@ func (c *Client) addOperationPutDestinationPolicyMiddlewares(stack *middleware.S if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_PutIndexPolicy.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_PutIndexPolicy.go index b9bdab74fef..784e2c674de 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_PutIndexPolicy.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_PutIndexPolicy.go @@ -24,6 +24,12 @@ import ( // events. Common examples of indexes include request ID, session ID, userID, and // instance IDs. For more information, see [Create field indexes to improve query performance and reduce costs]. // +// You can configure indexed fields as facets to enable interactive exploration +// and filtering of your logs in the CloudWatch Logs Insights console. Facets allow +// you to view value distributions and counts for indexed fields without running +// queries. When you create a field index, you can optionally set it as a facet to +// enable this interactive analysis capability. For more information, see [Use facets to group and explore logs]. +// // To find the fields that are in your log group events, use the [GetLogGroupFields] operation. // // For example, suppose you have created a field index for requestId . Then, any @@ -31,6 +37,24 @@ import ( // value or requestId IN [value, value, ...] will process fewer log events to // reduce costs, and have improved performance. // +// CloudWatch Logs provides default field indexes for all log groups in the +// Standard log class. Default field indexes are automatically available for the +// following fields: +// +// - @logStream +// +// - @aws.region +// +// - @aws.account +// +// - @source.log +// +// - traceId +// +// Default field indexes are in addition to any custom field indexes you define +// within your policy. Default field indexes are not counted towards your field +// index quota. +// // Each index policy has the following quotas and restrictions: // // - As many as 20 fields can be included in the policy. @@ -42,15 +66,17 @@ import ( // . // // Log group-level field index policies created with PutIndexPolicy override -// account-level field index policies created with [PutAccountPolicy]. If you use PutIndexPolicy to -// create a field index policy for a log group, that log group uses only that -// policy. The log group ignores any account-wide field index policy that you might -// have created. +// account-level field index policies created with [PutAccountPolicy]that apply to log groups. If +// you use PutIndexPolicy to create a field index policy for a log group, that log +// group uses only that policy for log group-level indexing, including any facet +// configurations. The log group ignores any account-wide field index policy that +// applies to log groups, but data source-based account policies may still apply. // // [Log classes]: https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CloudWatch_Logs_Log_Classes.html // [GetLogGroupFields]: https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_GetLogGroupFields.html // [PutAccountPolicy]: https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_PutAccountPolicy.html // [Create field indexes to improve query performance and reduce costs]: https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CloudWatchLogs-Field-Indexing.html +// [Use facets to group and explore logs]: https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CloudWatchLogs-Facets.html func (c *Client) PutIndexPolicy(ctx context.Context, params *PutIndexPolicyInput, optFns ...func(*Options)) (*PutIndexPolicyOutput, error) { if params == nil { params = &PutIndexPolicyInput{} @@ -77,9 +103,15 @@ type PutIndexPolicyInput struct { LogGroupIdentifier *string // The index policy document, in JSON format. The following is an example of an - // index policy document that creates two indexes, RequestId and TransactionId . + // index policy document that creates indexes with different types. + // + // "policyDocument": "{"Fields": [ "TransactionId" ], "FieldsV2": {"RequestId": + // {"type": "FIELD_INDEX"}, "APIName": {"type": "FACET"}, "StatusCode": {"type": + // "FACET"}}}" // - // "policyDocument": "{ "Fields": [ "RequestId", "TransactionId" ] }" + // You can use FieldsV2 to specify the type for each field. Supported types are + // FIELD_INDEX and FACET . Field names within Fields and FieldsV2 must be mutually + // exclusive. // // The policy document must include at least one field index. For more information // about the fields that can be included and other restrictions, see [Field index syntax and quotas]. @@ -137,7 +169,7 @@ func (c *Client) addOperationPutIndexPolicyMiddlewares(stack *middleware.Stack, if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -161,9 +193,6 @@ func (c *Client) addOperationPutIndexPolicyMiddlewares(stack *middleware.Stack, if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -191,16 +220,13 @@ func (c *Client) addOperationPutIndexPolicyMiddlewares(stack *middleware.Stack, if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_PutIntegration.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_PutIntegration.go index 404072c52f7..c20a7ddd12a 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_PutIntegration.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_PutIntegration.go @@ -110,7 +110,7 @@ func (c *Client) addOperationPutIntegrationMiddlewares(stack *middleware.Stack, if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -134,9 +134,6 @@ func (c *Client) addOperationPutIntegrationMiddlewares(stack *middleware.Stack, if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -164,16 +161,13 @@ func (c *Client) addOperationPutIntegrationMiddlewares(stack *middleware.Stack, if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_PutLogEvents.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_PutLogEvents.go index d939a973b10..4dfefefd670 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_PutLogEvents.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_PutLogEvents.go @@ -23,11 +23,11 @@ import ( // - The maximum batch size is 1,048,576 bytes. This size is calculated as the // sum of all event messages in UTF-8, plus 26 bytes for each log event. // -// - None of the log events in the batch can be more than 2 hours in the future. +// - Events more than 2 hours in the future are rejected while processing +// remaining valid events. // -// - None of the log events in the batch can be more than 14 days in the past. -// Also, none of the log events can be from earlier than the retention period of -// the log group. +// - Events older than 14 days or preceding the log group's retention period are +// rejected while processing remaining valid events. // // - The log events in the batch must be in chronological order by their // timestamp. The timestamp is the time that the event occurred, expressed as the @@ -36,17 +36,21 @@ import ( // timestamp is specified in .NET format: yyyy-mm-ddThh:mm:ss . For example, // 2017-09-15T13:45:30 .) // -// - A batch of log events in a single request cannot span more than 24 hours. +// - A batch of log events in a single request must be in a chronological order. // Otherwise, the operation fails. // -// - Each log event can be no larger than 256 KB. +// - Each log event can be no larger than 1 MB. // // - The maximum number of log events in a batch is 10,000. // -// - The quota of five requests per second per log stream has been removed. -// Instead, PutLogEvents actions are throttled based on a per-second per-account -// quota. You can request an increase to the per-second throttling quota by using -// the Service Quotas service. +// - For valid events (within 14 days in the past to 2 hours in future), the +// time span in a single batch cannot exceed 24 hours. Otherwise, the operation +// fails. +// +// The quota of five requests per second per log stream has been removed. Instead, +// PutLogEvents actions are throttled based on a per-second per-account quota. You +// can request an increase to the per-second throttling quota by using the Service +// Quotas service. // // If a call to PutLogEvents returns "UnrecognizedClientException" the most likely // cause is a non-valid Amazon Web Services access key ID or secret key. @@ -157,7 +161,7 @@ func (c *Client) addOperationPutLogEventsMiddlewares(stack *middleware.Stack, op if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -181,9 +185,6 @@ func (c *Client) addOperationPutLogEventsMiddlewares(stack *middleware.Stack, op if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -211,16 +212,13 @@ func (c *Client) addOperationPutLogEventsMiddlewares(stack *middleware.Stack, op if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_PutLogGroupDeletionProtection.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_PutLogGroupDeletionProtection.go new file mode 100644 index 00000000000..24d31cfc39d --- /dev/null +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_PutLogGroupDeletionProtection.go @@ -0,0 +1,172 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package cloudwatchlogs + +import ( + "context" + "fmt" + awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/smithy-go/middleware" + smithyhttp "github.com/aws/smithy-go/transport/http" +) + +// Enables or disables deletion protection for the specified log group. When +// enabled on a log group, deletion protection blocks all deletion operations until +// it is explicitly disabled. +// +// For information about the parameters that are common to all actions, see [Common Parameters]. +// +// [Common Parameters]: https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/CommonParameters.html +func (c *Client) PutLogGroupDeletionProtection(ctx context.Context, params *PutLogGroupDeletionProtectionInput, optFns ...func(*Options)) (*PutLogGroupDeletionProtectionOutput, error) { + if params == nil { + params = &PutLogGroupDeletionProtectionInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "PutLogGroupDeletionProtection", params, optFns, c.addOperationPutLogGroupDeletionProtectionMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*PutLogGroupDeletionProtectionOutput) + out.ResultMetadata = metadata + return out, nil +} + +type PutLogGroupDeletionProtectionInput struct { + + // Whether to enable deletion protection. + // + // Type: Boolean + // + // Required: Yes + // + // This member is required. + DeletionProtectionEnabled *bool + + // The name or ARN of the log group. + // + // Type: String + // + // Length Constraints: Minimum length of 1. Maximum length of 512. + // + // Pattern: [\.\-_/#A-Za-z0-9]+ + // + // Required: Yes + // + // This member is required. + LogGroupIdentifier *string + + noSmithyDocumentSerde +} + +type PutLogGroupDeletionProtectionOutput struct { + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationPutLogGroupDeletionProtectionMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&setOperationInputMiddleware{}, middleware.After); err != nil { + return err + } + err = stack.Serialize.Add(&awsAwsjson11_serializeOpPutLogGroupDeletionProtection{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpPutLogGroupDeletionProtection{}, middleware.After) + if err != nil { + return err + } + if err := addProtocolFinalizerMiddlewares(stack, options, "PutLogGroupDeletionProtection"); err != nil { + return fmt.Errorf("add protocol finalizers: %v", err) + } + + if err = addlegacyEndpointContextSetter(stack, options); err != nil { + return err + } + if err = addSetLoggerMiddleware(stack, options); err != nil { + return err + } + if err = addClientRequestID(stack); err != nil { + return err + } + if err = addComputeContentLength(stack); err != nil { + return err + } + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRetry(stack, options, c); err != nil { + return err + } + if err = addRawResponseToMetadata(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack); err != nil { + return err + } + if err = addSpanRetryLoop(stack, options); err != nil { + return err + } + if err = addClientUserAgent(stack, options); err != nil { + return err + } + if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { + return err + } + if err = addUserAgentRetryMode(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = addOpPutLogGroupDeletionProtectionValidationMiddleware(stack); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opPutLogGroupDeletionProtection(options.Region), middleware.Before); err != nil { + return err + } + if err = addRecursionDetection(stack); err != nil { + return err + } + if err = addRequestIDRetrieverMiddleware(stack); err != nil { + return err + } + if err = addResponseErrorMiddleware(stack); err != nil { + return err + } + if err = addRequestResponseLogging(stack, options); err != nil { + return err + } + if err = addDisableHTTPSMiddleware(stack, options); err != nil { + return err + } + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { + return err + } + if err = addInterceptAttempt(stack, options); err != nil { + return err + } + if err = addInterceptors(stack, options); err != nil { + return err + } + return nil +} + +func newServiceMetadataMiddleware_opPutLogGroupDeletionProtection(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + OperationName: "PutLogGroupDeletionProtection", + } +} diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_PutMetricFilter.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_PutMetricFilter.go index 02fd63ee2d6..ec7f6bbb47c 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_PutMetricFilter.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_PutMetricFilter.go @@ -89,6 +89,19 @@ type PutMetricFilterInput struct { // [PutTransformer]: https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_PutTransformer.html ApplyOnTransformedLogs bool + // A list of system fields to emit as additional dimensions in the generated + // metrics. Valid values are @aws.account and @aws.region . These dimensions help + // identify the source of centralized log data and count toward the total dimension + // limit for metric filters. + EmitSystemFieldDimensions []string + + // A filter expression that specifies which log events should be processed by this + // metric filter based on system fields such as source account and source region. + // Uses selection criteria syntax with operators like = , != , AND , OR , IN , NOT + // IN . Example: @aws.region = "us-east-1" or @aws.account IN ["123456789012", + // "987654321098"] . Maximum length: 2000 characters. + FieldSelectionCriteria *string + noSmithyDocumentSerde } @@ -133,7 +146,7 @@ func (c *Client) addOperationPutMetricFilterMiddlewares(stack *middleware.Stack, if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -157,9 +170,6 @@ func (c *Client) addOperationPutMetricFilterMiddlewares(stack *middleware.Stack, if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -187,16 +197,13 @@ func (c *Client) addOperationPutMetricFilterMiddlewares(stack *middleware.Stack, if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_PutQueryDefinition.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_PutQueryDefinition.go index 2524737a70a..80466c5359b 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_PutQueryDefinition.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_PutQueryDefinition.go @@ -61,9 +61,7 @@ type PutQueryDefinitionInput struct { QueryString *string // Used as an idempotency token, to avoid returning an exception if the service - // receives the same request twice because of a network - // - // error. + // receives the same request twice because of a network error. ClientToken *string // Use this parameter to include specific log groups as part of your query @@ -75,6 +73,13 @@ type PutQueryDefinitionInput struct { // will contain no log groups. LogGroupNames []string + // Use this parameter to include specific query parameters as part of your query + // definition. Query parameters are supported only for Logs Insights QL queries. + // Query parameters allow you to use placeholder variables in your query string + // that are substituted with values at execution time. Use the {{parameterName}} + // syntax in your query string to reference a parameter. + Parameters []types.QueryParameter + // If you are updating a query definition, use this parameter to specify the ID of // the query definition that you want to update. You can use [DescribeQueryDefinitions]to retrieve the IDs // of your saved query definitions. @@ -141,7 +146,7 @@ func (c *Client) addOperationPutQueryDefinitionMiddlewares(stack *middleware.Sta if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -165,9 +170,6 @@ func (c *Client) addOperationPutQueryDefinitionMiddlewares(stack *middleware.Sta if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -198,16 +200,13 @@ func (c *Client) addOperationPutQueryDefinitionMiddlewares(stack *middleware.Sta if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_PutResourcePolicy.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_PutResourcePolicy.go index ce1b211989c..c750a38c12f 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_PutResourcePolicy.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_PutResourcePolicy.go @@ -12,8 +12,23 @@ import ( ) // Creates or updates a resource policy allowing other Amazon Web Services -// services to put log events to this account, such as Amazon Route 53. An account -// can have up to 10 resource policies per Amazon Web Services Region. +// services to put log events to this account, such as Amazon Route 53. This API +// has the following restrictions: +// +// - Supported actions - Policy only supports logs:PutLogEvents and +// logs:CreateLogStream actions +// +// - Supported principals - Policy only applies when operations are invoked by +// Amazon Web Services service principals (not IAM users, roles, or cross-account +// principals +// +// - Policy limits - An account can have a maximum of 10 policies without +// resourceARN and one per LogGroup resourceARN +// +// Resource policies with actions invoked by non-Amazon Web Services service +// principals (such as IAM users, roles, or other Amazon Web Services accounts) +// will not be enforced. For access control involving these principals, use the IAM +// policies. func (c *Client) PutResourcePolicy(ctx context.Context, params *PutResourcePolicyInput, optFns ...func(*Options)) (*PutResourcePolicyOutput, error) { if params == nil { params = &PutResourcePolicyInput{} @@ -31,6 +46,11 @@ func (c *Client) PutResourcePolicy(ctx context.Context, params *PutResourcePolic type PutResourcePolicyInput struct { + // The expected revision ID of the resource policy. Required when resourceArn is + // provided to prevent concurrent modifications. Use null when creating a resource + // policy for the first time. + ExpectedRevisionId *string + // Details of the new policy, including the identity of the principal that is // enabled to put logs to this account. This is formatted as a JSON string. This // parameter is required. @@ -59,6 +79,10 @@ type PutResourcePolicyInput struct { // Name of the new policy. This parameter is required. PolicyName *string + // The ARN of the CloudWatch Logs resource to which the resource policy needs to + // be added or attached. Currently only supports LogGroup ARN. + ResourceArn *string + noSmithyDocumentSerde } @@ -67,6 +91,10 @@ type PutResourcePolicyOutput struct { // The new policy. ResourcePolicy *types.ResourcePolicy + // The revision ID of the created or updated resource policy. Only returned for + // resource-scoped policies. + RevisionId *string + // Metadata pertaining to the operation's result. ResultMetadata middleware.Metadata @@ -107,7 +135,7 @@ func (c *Client) addOperationPutResourcePolicyMiddlewares(stack *middleware.Stac if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -131,9 +159,6 @@ func (c *Client) addOperationPutResourcePolicyMiddlewares(stack *middleware.Stac if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -158,16 +183,13 @@ func (c *Client) addOperationPutResourcePolicyMiddlewares(stack *middleware.Stac if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_PutRetentionPolicy.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_PutRetentionPolicy.go index 927e9e226a4..746220b2122 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_PutRetentionPolicy.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_PutRetentionPolicy.go @@ -108,7 +108,7 @@ func (c *Client) addOperationPutRetentionPolicyMiddlewares(stack *middleware.Sta if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -132,9 +132,6 @@ func (c *Client) addOperationPutRetentionPolicyMiddlewares(stack *middleware.Sta if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -162,16 +159,13 @@ func (c *Client) addOperationPutRetentionPolicyMiddlewares(stack *middleware.Sta if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_PutSubscriptionFilter.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_PutSubscriptionFilter.go index e6731e01ebd..3b3f30a9a17 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_PutSubscriptionFilter.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_PutSubscriptionFilter.go @@ -125,6 +125,18 @@ type PutSubscriptionFilterInput struct { // Kinesis data stream. Distribution types.Distribution + // A list of system fields to include in the log events sent to the subscription + // destination. Valid values are @aws.account and @aws.region . These fields + // provide source information for centralized log data in the forwarded payload. + EmitSystemFields []string + + // A filter expression that specifies which log events should be processed by this + // subscription filter based on system fields such as source account and source + // region. Uses selection criteria syntax with operators like = , != , AND , OR , + // IN , NOT IN . Example: @aws.region NOT IN ["cn-north-1"] or @aws.account = + // "123456789012" AND @aws.region = "us-east-1" . Maximum length: 2000 characters. + FieldSelectionCriteria *string + // The ARN of an IAM role that grants CloudWatch Logs permissions to deliver // ingested log events to the destination stream. You don't need to provide the ARN // when you are working with a logical destination for cross-account delivery. @@ -174,7 +186,7 @@ func (c *Client) addOperationPutSubscriptionFilterMiddlewares(stack *middleware. if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -198,9 +210,6 @@ func (c *Client) addOperationPutSubscriptionFilterMiddlewares(stack *middleware. if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -228,16 +237,13 @@ func (c *Client) addOperationPutSubscriptionFilterMiddlewares(stack *middleware. if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_PutTransformer.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_PutTransformer.go index 4aaa6a3aac4..32880eca200 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_PutTransformer.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_PutTransformer.go @@ -122,7 +122,7 @@ func (c *Client) addOperationPutTransformerMiddlewares(stack *middleware.Stack, if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -146,9 +146,6 @@ func (c *Client) addOperationPutTransformerMiddlewares(stack *middleware.Stack, if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -176,16 +173,13 @@ func (c *Client) addOperationPutTransformerMiddlewares(stack *middleware.Stack, if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_StartLiveTail.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_StartLiveTail.go index a3fc7e2f499..72cf9389cb2 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_StartLiveTail.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_StartLiveTail.go @@ -47,6 +47,13 @@ import ( // - A [SessionTimeoutException]object is returned when the session times out, after it has been kept // open for three hours. // +// The StartLiveTail API routes requests using SDK host prefix injection. SDK +// versions released before April 1, 2026 route to +// streaming-logs.Region.amazonaws.com , which does not support VPC endpoints. SDK +// versions released on or after April 1, 2026 route to +// stream-logs.Region.amazonaws.com , which supports VPC endpoints. To set up a VPC +// endpoint for this API, see [Creating a VPC endpoint for CloudWatch Logs]. +// // You can end a session before it times out by closing the session stream or by // closing the client that is receiving the stream. The session also ends if the // established connection between the client and the server breaks. @@ -56,6 +63,7 @@ import ( // [LiveTailSessionStart]: https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_LiveTailSessionStart.html // [LiveTailSessionUpdate]: https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_LiveTailSessionUpdate.html // [Use Live Tail to view logs in near real time]: https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CloudWatchLogs_LiveTail.html +// [Creating a VPC endpoint for CloudWatch Logs]: https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/cloudwatch-logs-and-interface-VPC.html#create-VPC-endpoint-for-CloudWatchLogs // [Start a Live Tail session using an Amazon Web Services SDK]: https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/example_cloudwatch-logs_StartLiveTail_section.html // // [SessionTimeoutException]: https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_StartLiveTailResponseStream.html#CWL-Type-StartLiveTailResponseStream-SessionTimeoutException @@ -175,7 +183,7 @@ func (c *Client) addOperationStartLiveTailMiddlewares(stack *middleware.Stack, o if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -193,9 +201,6 @@ func (c *Client) addOperationStartLiveTailMiddlewares(stack *middleware.Stack, o if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -226,16 +231,13 @@ func (c *Client) addOperationStartLiveTailMiddlewares(stack *middleware.Stack, o if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_StartQuery.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_StartQuery.go index d5e92ab6113..3f73cd00ca9 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_StartQuery.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_StartQuery.go @@ -11,8 +11,9 @@ import ( smithyhttp "github.com/aws/smithy-go/transport/http" ) -// Starts a query of one or more log groups using CloudWatch Logs Insights. You -// specify the log groups and time range to query and the query string to use. +// Starts a query of one or more log groups or data sources using CloudWatch Logs +// Insights. You specify the log groups or data sources and time range to query and +// the query string to use. You can query up to 10 data sources in a single query. // // For more information, see [CloudWatch Logs Insights Query Syntax]. // @@ -20,6 +21,11 @@ import ( // CloudWatch Logs. You can use [GetQueryResults]to retrieve the results of a query, using the // queryId that StartQuery returns. // +// Interactive queries started with StartQuery share concurrency limits with +// automated scheduled query executions. Both types of queries count toward the +// same regional concurrent query quota, so high scheduled query activity may +// affect the availability of concurrent slots for interactive queries. +// // To specify the log groups to query, a StartQuery operation must include one of // the following: // @@ -28,7 +34,8 @@ import ( // // - Or the queryString must include a SOURCE command to select log groups for // the query. The SOURCE command can select log groups based on log group name -// prefix, account ID, and log class. +// prefix, account ID, and log class, or select data sources using dataSource +// syntax in LogsQL, PPL, and SQL. // // For more information about the SOURCE command, see [SOURCE]. // @@ -46,7 +53,7 @@ import ( // For more information, see [CloudWatch cross-account observability]. For a cross-account StartQuery operation, the query // definition must be defined in the monitoring account. // -// You can have up to 30 concurrent CloudWatch Logs insights queries, including +// You can have up to 100 concurrent CloudWatch Logs insights queries, including // queries that have been added to dashboards. // // [CloudWatch Logs Insights Query Syntax]: https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_QuerySyntax.html @@ -185,7 +192,7 @@ func (c *Client) addOperationStartQueryMiddlewares(stack *middleware.Stack, opti if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -209,9 +216,6 @@ func (c *Client) addOperationStartQueryMiddlewares(stack *middleware.Stack, opti if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -239,16 +243,13 @@ func (c *Client) addOperationStartQueryMiddlewares(stack *middleware.Stack, opti if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_StopQuery.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_StopQuery.go index cf174c576f3..19ad02cb36f 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_StopQuery.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_StopQuery.go @@ -13,6 +13,11 @@ import ( // Stops a CloudWatch Logs Insights query that is in progress. If the query has // already ended, the operation returns an error indicating that the specified // query is not running. +// +// This operation can be used to cancel both interactive queries and individual +// scheduled query executions. When used with scheduled queries, StopQuery cancels +// only the specific execution identified by the query ID, not the scheduled query +// configuration itself. func (c *Client) StopQuery(ctx context.Context, params *StopQueryInput, optFns ...func(*Options)) (*StopQueryOutput, error) { if params == nil { params = &StopQueryInput{} @@ -83,7 +88,7 @@ func (c *Client) addOperationStopQueryMiddlewares(stack *middleware.Stack, optio if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -107,9 +112,6 @@ func (c *Client) addOperationStopQueryMiddlewares(stack *middleware.Stack, optio if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -137,16 +139,13 @@ func (c *Client) addOperationStopQueryMiddlewares(stack *middleware.Stack, optio if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_TagLogGroup.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_TagLogGroup.go index d01de90ac39..68e6b236e6b 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_TagLogGroup.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_TagLogGroup.go @@ -101,7 +101,7 @@ func (c *Client) addOperationTagLogGroupMiddlewares(stack *middleware.Stack, opt if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -125,9 +125,6 @@ func (c *Client) addOperationTagLogGroupMiddlewares(stack *middleware.Stack, opt if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -155,16 +152,13 @@ func (c *Client) addOperationTagLogGroupMiddlewares(stack *middleware.Stack, opt if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_TagResource.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_TagResource.go index 1531cc73a64..4e44d98edaf 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_TagResource.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_TagResource.go @@ -109,7 +109,7 @@ func (c *Client) addOperationTagResourceMiddlewares(stack *middleware.Stack, opt if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -133,9 +133,6 @@ func (c *Client) addOperationTagResourceMiddlewares(stack *middleware.Stack, opt if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -163,16 +160,13 @@ func (c *Client) addOperationTagResourceMiddlewares(stack *middleware.Stack, opt if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_TestMetricFilter.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_TestMetricFilter.go index 6b00cc14304..47fe26e7869 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_TestMetricFilter.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_TestMetricFilter.go @@ -92,7 +92,7 @@ func (c *Client) addOperationTestMetricFilterMiddlewares(stack *middleware.Stack if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -116,9 +116,6 @@ func (c *Client) addOperationTestMetricFilterMiddlewares(stack *middleware.Stack if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -146,16 +143,13 @@ func (c *Client) addOperationTestMetricFilterMiddlewares(stack *middleware.Stack if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_TestTransformer.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_TestTransformer.go index 909ff778af2..dcf17f5e2c1 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_TestTransformer.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_TestTransformer.go @@ -92,7 +92,7 @@ func (c *Client) addOperationTestTransformerMiddlewares(stack *middleware.Stack, if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -116,9 +116,6 @@ func (c *Client) addOperationTestTransformerMiddlewares(stack *middleware.Stack, if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -146,16 +143,13 @@ func (c *Client) addOperationTestTransformerMiddlewares(stack *middleware.Stack, if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_UntagLogGroup.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_UntagLogGroup.go index eb69283ac18..cc12250aebc 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_UntagLogGroup.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_UntagLogGroup.go @@ -17,9 +17,9 @@ import ( // // To list the tags for a log group, use [ListTagsForResource]. To add tags, use [TagResource]. // -// CloudWatch Logs doesn't support IAM policies that prevent users from assigning -// specified tags to log groups using the aws:Resource/key-name or aws:TagKeys -// condition keys. +// When using IAM policies to control tag management for CloudWatch Logs log +// groups, the condition keys aws:Resource/key-name and aws:TagKeys cannot be used +// to restrict which tags users can assign. // // Deprecated: Please use the generic tagging API UntagResource // @@ -97,7 +97,7 @@ func (c *Client) addOperationUntagLogGroupMiddlewares(stack *middleware.Stack, o if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -121,9 +121,6 @@ func (c *Client) addOperationUntagLogGroupMiddlewares(stack *middleware.Stack, o if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -151,16 +148,13 @@ func (c *Client) addOperationUntagLogGroupMiddlewares(stack *middleware.Stack, o if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_UntagResource.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_UntagResource.go index 3f9de28455a..0b91cc73470 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_UntagResource.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_UntagResource.go @@ -92,7 +92,7 @@ func (c *Client) addOperationUntagResourceMiddlewares(stack *middleware.Stack, o if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -116,9 +116,6 @@ func (c *Client) addOperationUntagResourceMiddlewares(stack *middleware.Stack, o if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -146,16 +143,13 @@ func (c *Client) addOperationUntagResourceMiddlewares(stack *middleware.Stack, o if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_UpdateAnomaly.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_UpdateAnomaly.go index b7601d53699..19aa8f828af 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_UpdateAnomaly.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_UpdateAnomaly.go @@ -120,7 +120,7 @@ func (c *Client) addOperationUpdateAnomalyMiddlewares(stack *middleware.Stack, o if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -144,9 +144,6 @@ func (c *Client) addOperationUpdateAnomalyMiddlewares(stack *middleware.Stack, o if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -174,16 +171,13 @@ func (c *Client) addOperationUpdateAnomalyMiddlewares(stack *middleware.Stack, o if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_UpdateDeliveryConfiguration.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_UpdateDeliveryConfiguration.go index 44112aa21b2..611ed1137b8 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_UpdateDeliveryConfiguration.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_UpdateDeliveryConfiguration.go @@ -94,7 +94,7 @@ func (c *Client) addOperationUpdateDeliveryConfigurationMiddlewares(stack *middl if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -118,9 +118,6 @@ func (c *Client) addOperationUpdateDeliveryConfigurationMiddlewares(stack *middl if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -148,16 +145,13 @@ func (c *Client) addOperationUpdateDeliveryConfigurationMiddlewares(stack *middl if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_UpdateLogAnomalyDetector.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_UpdateLogAnomalyDetector.go index 95014fc95c8..d1c6c0418fa 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_UpdateLogAnomalyDetector.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_UpdateLogAnomalyDetector.go @@ -102,7 +102,7 @@ func (c *Client) addOperationUpdateLogAnomalyDetectorMiddlewares(stack *middlewa if err = addComputePayloadSHA256(stack); err != nil { return err } - if err = addRetry(stack, options); err != nil { + if err = addRetry(stack, options, c); err != nil { return err } if err = addRawResponseToMetadata(stack); err != nil { @@ -126,9 +126,6 @@ func (c *Client) addOperationUpdateLogAnomalyDetectorMiddlewares(stack *middlewa if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { return err } - if err = addTimeOffsetBuild(stack, c); err != nil { - return err - } if err = addUserAgentRetryMode(stack, options); err != nil { return err } @@ -156,16 +153,13 @@ func (c *Client) addOperationUpdateLogAnomalyDetectorMiddlewares(stack *middlewa if err = addDisableHTTPSMiddleware(stack, options); err != nil { return err } - if err = addSpanInitializeStart(stack); err != nil { - return err - } - if err = addSpanInitializeEnd(stack); err != nil { + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { return err } - if err = addSpanBuildRequestStart(stack); err != nil { + if err = addInterceptAttempt(stack, options); err != nil { return err } - if err = addSpanBuildRequestEnd(stack); err != nil { + if err = addInterceptors(stack, options); err != nil { return err } return nil diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_UpdateScheduledQuery.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_UpdateScheduledQuery.go new file mode 100644 index 00000000000..ac77ea672ea --- /dev/null +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/api_op_UpdateScheduledQuery.go @@ -0,0 +1,253 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package cloudwatchlogs + +import ( + "context" + "fmt" + awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/types" + "github.com/aws/smithy-go/middleware" + smithyhttp "github.com/aws/smithy-go/transport/http" +) + +// Updates an existing scheduled query with new configuration. This operation uses +// PUT semantics, allowing modification of query parameters, schedule, and +// destinations. +func (c *Client) UpdateScheduledQuery(ctx context.Context, params *UpdateScheduledQueryInput, optFns ...func(*Options)) (*UpdateScheduledQueryOutput, error) { + if params == nil { + params = &UpdateScheduledQueryInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "UpdateScheduledQuery", params, optFns, c.addOperationUpdateScheduledQueryMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*UpdateScheduledQueryOutput) + out.ResultMetadata = metadata + return out, nil +} + +type UpdateScheduledQueryInput struct { + + // The updated ARN of the IAM role that grants permissions to execute the query + // and deliver results. + // + // This member is required. + ExecutionRoleArn *string + + // The ARN or name of the scheduled query to update. + // + // This member is required. + Identifier *string + + // The updated query language for the scheduled query. + // + // This member is required. + QueryLanguage types.QueryLanguage + + // The updated query string to execute. + // + // This member is required. + QueryString *string + + // The updated cron expression that defines when the scheduled query runs. + // + // This member is required. + ScheduleExpression *string + + // An updated description for the scheduled query. + Description *string + + // The updated configuration for where to deliver query results. + DestinationConfiguration *types.DestinationConfiguration + + // The updated array of log group names or ARNs to query. + LogGroupIdentifiers []string + + // The updated end time for the scheduled query in Unix epoch format. + ScheduleEndTime *int64 + + // The updated start time for the scheduled query in Unix epoch format. + ScheduleStartTime *int64 + + // The updated time offset in seconds that defines the lookback period for the + // query. + StartTimeOffset *int64 + + // The updated state of the scheduled query. + State types.ScheduledQueryState + + // The updated timezone for evaluating the schedule expression. + Timezone *string + + noSmithyDocumentSerde +} + +type UpdateScheduledQueryOutput struct { + + // The timestamp when the scheduled query was originally created. + CreationTime *int64 + + // The description of the updated scheduled query. + Description *string + + // The destination configuration of the updated scheduled query. + DestinationConfiguration *types.DestinationConfiguration + + // The execution role ARN of the updated scheduled query. + ExecutionRoleArn *string + + // The status of the most recent execution of the updated scheduled query. + LastExecutionStatus types.ExecutionStatus + + // The timestamp when the updated scheduled query was last executed. + LastTriggeredTime *int64 + + // The timestamp when the scheduled query was last updated. + LastUpdatedTime *int64 + + // The log groups queried by the updated scheduled query. + LogGroupIdentifiers []string + + // The name of the updated scheduled query. + Name *string + + // The query language of the updated scheduled query. + QueryLanguage types.QueryLanguage + + // The query string of the updated scheduled query. + QueryString *string + + // The end time of the updated scheduled query. + ScheduleEndTime *int64 + + // The cron expression of the updated scheduled query. + ScheduleExpression *string + + // The start time of the updated scheduled query. + ScheduleStartTime *int64 + + // The ARN of the updated scheduled query. + ScheduledQueryArn *string + + // The time offset of the updated scheduled query. + StartTimeOffset *int64 + + // The state of the updated scheduled query. + State types.ScheduledQueryState + + // The timezone of the updated scheduled query. + Timezone *string + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationUpdateScheduledQueryMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&setOperationInputMiddleware{}, middleware.After); err != nil { + return err + } + err = stack.Serialize.Add(&awsAwsjson11_serializeOpUpdateScheduledQuery{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpUpdateScheduledQuery{}, middleware.After) + if err != nil { + return err + } + if err := addProtocolFinalizerMiddlewares(stack, options, "UpdateScheduledQuery"); err != nil { + return fmt.Errorf("add protocol finalizers: %v", err) + } + + if err = addlegacyEndpointContextSetter(stack, options); err != nil { + return err + } + if err = addSetLoggerMiddleware(stack, options); err != nil { + return err + } + if err = addClientRequestID(stack); err != nil { + return err + } + if err = addComputeContentLength(stack); err != nil { + return err + } + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRetry(stack, options, c); err != nil { + return err + } + if err = addRawResponseToMetadata(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack); err != nil { + return err + } + if err = addSpanRetryLoop(stack, options); err != nil { + return err + } + if err = addClientUserAgent(stack, options); err != nil { + return err + } + if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { + return err + } + if err = addUserAgentRetryMode(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = addOpUpdateScheduledQueryValidationMiddleware(stack); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdateScheduledQuery(options.Region), middleware.Before); err != nil { + return err + } + if err = addRecursionDetection(stack); err != nil { + return err + } + if err = addRequestIDRetrieverMiddleware(stack); err != nil { + return err + } + if err = addResponseErrorMiddleware(stack); err != nil { + return err + } + if err = addRequestResponseLogging(stack, options); err != nil { + return err + } + if err = addDisableHTTPSMiddleware(stack, options); err != nil { + return err + } + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { + return err + } + if err = addInterceptAttempt(stack, options); err != nil { + return err + } + if err = addInterceptors(stack, options); err != nil { + return err + } + return nil +} + +func newServiceMetadataMiddleware_opUpdateScheduledQuery(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + OperationName: "UpdateScheduledQuery", + } +} diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/auth.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/auth.go index 0d47a2ca777..e745d87d3e5 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/auth.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/auth.go @@ -12,10 +12,13 @@ import ( "github.com/aws/smithy-go/middleware" "github.com/aws/smithy-go/tracing" smithyhttp "github.com/aws/smithy-go/transport/http" + "slices" + "strings" ) -func bindAuthParamsRegion(_ interface{}, params *AuthResolverParameters, _ interface{}, options Options) { +func bindAuthParamsRegion(_ interface{}, params *AuthResolverParameters, _ interface{}, options Options) error { params.Region = options.Region + return nil } type setLegacyContextSigningOptionsMiddleware struct { @@ -92,14 +95,16 @@ type AuthResolverParameters struct { Region string } -func bindAuthResolverParams(ctx context.Context, operation string, input interface{}, options Options) *AuthResolverParameters { +func bindAuthResolverParams(ctx context.Context, operation string, input interface{}, options Options) (*AuthResolverParameters, error) { params := &AuthResolverParameters{ Operation: operation, } - bindAuthParamsRegion(ctx, params, input, options) + if err := bindAuthParamsRegion(ctx, params, input, options); err != nil { + return nil, err + } - return params + return params, nil } // AuthSchemeResolver returns a set of possible authentication options for an @@ -150,7 +155,10 @@ func (m *resolveAuthSchemeMiddleware) HandleFinalize(ctx context.Context, in mid _, span := tracing.StartSpan(ctx, "ResolveAuthScheme") defer span.End() - params := bindAuthResolverParams(ctx, m.operation, getOperationInput(ctx), m.options) + params, err := bindAuthResolverParams(ctx, m.operation, getOperationInput(ctx), m.options) + if err != nil { + return out, metadata, fmt.Errorf("bind auth scheme params: %w", err) + } options, err := m.options.AuthSchemeResolver.ResolveAuthSchemes(ctx, params) if err != nil { return out, metadata, fmt.Errorf("resolve auth scheme: %w", err) @@ -169,7 +177,8 @@ func (m *resolveAuthSchemeMiddleware) HandleFinalize(ctx context.Context, in mid } func (m *resolveAuthSchemeMiddleware) selectScheme(options []*smithyauth.Option) (*resolvedAuthScheme, bool) { - for _, option := range options { + sorted := sortAuthOptions(options, m.options.AuthSchemePreference) + for _, option := range sorted { if option.SchemeID == smithyauth.SchemeIDAnonymous { return newResolvedAuthScheme(smithyhttp.NewAnonymousScheme(), option), true } @@ -188,6 +197,29 @@ func (m *resolveAuthSchemeMiddleware) selectScheme(options []*smithyauth.Option) return nil, false } +func sortAuthOptions(options []*smithyauth.Option, preferred []string) []*smithyauth.Option { + byPriority := make([]*smithyauth.Option, 0, len(options)) + for _, prefName := range preferred { + for _, option := range options { + optName := option.SchemeID + if parts := strings.Split(option.SchemeID, "#"); len(parts) == 2 { + optName = parts[1] + } + if prefName == optName { + byPriority = append(byPriority, option) + } + } + } + for _, option := range options { + if !slices.ContainsFunc(byPriority, func(o *smithyauth.Option) bool { + return o.SchemeID == option.SchemeID + }) { + byPriority = append(byPriority, option) + } + } + return byPriority +} + type resolvedAuthSchemeKey struct{} type resolvedAuthScheme struct { diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/deserializers.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/deserializers.go index 39776b15d4e..207b7be2914 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/deserializers.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/deserializers.go @@ -5,6 +5,7 @@ package cloudwatchlogs import ( "bytes" "context" + "encoding/base64" "encoding/json" "fmt" "github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream" @@ -15,24 +16,14 @@ import ( smithyio "github.com/aws/smithy-go/io" "github.com/aws/smithy-go/middleware" "github.com/aws/smithy-go/ptr" - smithytime "github.com/aws/smithy-go/time" "github.com/aws/smithy-go/tracing" smithyhttp "github.com/aws/smithy-go/transport/http" "io" "io/ioutil" "math" "strings" - "time" ) -func deserializeS3Expires(v string) (*time.Time, error) { - t, err := smithytime.ParseHTTPDate(v) - if err != nil { - return nil, nil - } - return &t, nil -} - type awsAwsjson11_deserializeOpAssociateKmsKey struct { } @@ -131,14 +122,14 @@ func awsAwsjson11_deserializeOpErrorAssociateKmsKey(response *smithyhttp.Respons } } -type awsAwsjson11_deserializeOpCancelExportTask struct { +type awsAwsjson11_deserializeOpAssociateSourceToS3TableIntegration struct { } -func (*awsAwsjson11_deserializeOpCancelExportTask) ID() string { +func (*awsAwsjson11_deserializeOpAssociateSourceToS3TableIntegration) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpCancelExportTask) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpAssociateSourceToS3TableIntegration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -156,21 +147,43 @@ func (m *awsAwsjson11_deserializeOpCancelExportTask) HandleDeserialize(ctx conte } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorCancelExportTask(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorAssociateSourceToS3TableIntegration(response, &metadata) } - output := &CancelExportTaskOutput{} + output := &AssociateSourceToS3TableIntegrationOutput{} out.Result = output - if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { - return out, metadata, &smithy.DeserializationError{ - Err: fmt.Errorf("failed to discard response body, %w", err), + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(response.Body, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + var shape interface{} + if err := decoder.Decode(&shape); err != nil && err != io.EOF { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return out, metadata, err + } + + err = awsAwsjson11_deserializeOpDocumentAssociateSourceToS3TableIntegrationOutput(&output, shape) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), } + return out, metadata, err } return out, metadata, err } -func awsAwsjson11_deserializeOpErrorCancelExportTask(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorAssociateSourceToS3TableIntegration(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -207,17 +220,20 @@ func awsAwsjson11_deserializeOpErrorCancelExportTask(response *smithyhttp.Respon errorMessage = bodyInfo.Message } switch { - case strings.EqualFold("InvalidOperationException", errorCode): - return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody) + case strings.EqualFold("AccessDeniedException", errorCode): + return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) - case strings.EqualFold("InvalidParameterException", errorCode): - return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) + case strings.EqualFold("InternalServerException", errorCode): + return awsAwsjson11_deserializeErrorInternalServerException(response, errorBody) case strings.EqualFold("ResourceNotFoundException", errorCode): return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) - case strings.EqualFold("ServiceUnavailableException", errorCode): - return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) + case strings.EqualFold("ThrottlingException", errorCode): + return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) + + case strings.EqualFold("ValidationException", errorCode): + return awsAwsjson11_deserializeErrorValidationException(response, errorBody) default: genericError := &smithy.GenericAPIError{ @@ -229,14 +245,14 @@ func awsAwsjson11_deserializeOpErrorCancelExportTask(response *smithyhttp.Respon } } -type awsAwsjson11_deserializeOpCreateDelivery struct { +type awsAwsjson11_deserializeOpCancelExportTask struct { } -func (*awsAwsjson11_deserializeOpCreateDelivery) ID() string { +func (*awsAwsjson11_deserializeOpCancelExportTask) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpCreateDelivery) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpCancelExportTask) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -254,43 +270,21 @@ func (m *awsAwsjson11_deserializeOpCreateDelivery) HandleDeserialize(ctx context } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorCreateDelivery(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorCancelExportTask(response, &metadata) } - output := &CreateDeliveryOutput{} + output := &CancelExportTaskOutput{} out.Result = output - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - - body := io.TeeReader(response.Body, ringBuffer) - decoder := json.NewDecoder(body) - decoder.UseNumber() - var shape interface{} - if err := decoder.Decode(&shape); err != nil && err != io.EOF { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return out, metadata, err - } - - err = awsAwsjson11_deserializeOpDocumentCreateDeliveryOutput(&output, shape) - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), + if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { + return out, metadata, &smithy.DeserializationError{ + Err: fmt.Errorf("failed to discard response body, %w", err), } - return out, metadata, err } return out, metadata, err } -func awsAwsjson11_deserializeOpErrorCreateDelivery(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorCancelExportTask(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -327,27 +321,18 @@ func awsAwsjson11_deserializeOpErrorCreateDelivery(response *smithyhttp.Response errorMessage = bodyInfo.Message } switch { - case strings.EqualFold("AccessDeniedException", errorCode): - return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) + case strings.EqualFold("InvalidOperationException", errorCode): + return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody) - case strings.EqualFold("ConflictException", errorCode): - return awsAwsjson11_deserializeErrorConflictException(response, errorBody) + case strings.EqualFold("InvalidParameterException", errorCode): + return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) case strings.EqualFold("ResourceNotFoundException", errorCode): return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) - case strings.EqualFold("ServiceQuotaExceededException", errorCode): - return awsAwsjson11_deserializeErrorServiceQuotaExceededException(response, errorBody) - case strings.EqualFold("ServiceUnavailableException", errorCode): return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) - case strings.EqualFold("ThrottlingException", errorCode): - return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) - - case strings.EqualFold("ValidationException", errorCode): - return awsAwsjson11_deserializeErrorValidationException(response, errorBody) - default: genericError := &smithy.GenericAPIError{ Code: errorCode, @@ -358,14 +343,14 @@ func awsAwsjson11_deserializeOpErrorCreateDelivery(response *smithyhttp.Response } } -type awsAwsjson11_deserializeOpCreateExportTask struct { +type awsAwsjson11_deserializeOpCancelImportTask struct { } -func (*awsAwsjson11_deserializeOpCreateExportTask) ID() string { +func (*awsAwsjson11_deserializeOpCancelImportTask) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpCreateExportTask) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpCancelImportTask) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -383,9 +368,9 @@ func (m *awsAwsjson11_deserializeOpCreateExportTask) HandleDeserialize(ctx conte } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorCreateExportTask(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorCancelImportTask(response, &metadata) } - output := &CreateExportTaskOutput{} + output := &CancelImportTaskOutput{} out.Result = output var buff [1024]byte @@ -405,7 +390,7 @@ func (m *awsAwsjson11_deserializeOpCreateExportTask) HandleDeserialize(ctx conte return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentCreateExportTaskOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentCancelImportTaskOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -419,7 +404,7 @@ func (m *awsAwsjson11_deserializeOpCreateExportTask) HandleDeserialize(ctx conte return out, metadata, err } -func awsAwsjson11_deserializeOpErrorCreateExportTask(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorCancelImportTask(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -456,23 +441,20 @@ func awsAwsjson11_deserializeOpErrorCreateExportTask(response *smithyhttp.Respon errorMessage = bodyInfo.Message } switch { - case strings.EqualFold("InvalidParameterException", errorCode): - return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) - - case strings.EqualFold("LimitExceededException", errorCode): - return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) + case strings.EqualFold("AccessDeniedException", errorCode): + return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) - case strings.EqualFold("OperationAbortedException", errorCode): - return awsAwsjson11_deserializeErrorOperationAbortedException(response, errorBody) + case strings.EqualFold("InvalidOperationException", errorCode): + return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody) - case strings.EqualFold("ResourceAlreadyExistsException", errorCode): - return awsAwsjson11_deserializeErrorResourceAlreadyExistsException(response, errorBody) + case strings.EqualFold("InvalidParameterException", errorCode): + return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) case strings.EqualFold("ResourceNotFoundException", errorCode): return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) - case strings.EqualFold("ServiceUnavailableException", errorCode): - return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) + case strings.EqualFold("ThrottlingException", errorCode): + return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) default: genericError := &smithy.GenericAPIError{ @@ -484,14 +466,14 @@ func awsAwsjson11_deserializeOpErrorCreateExportTask(response *smithyhttp.Respon } } -type awsAwsjson11_deserializeOpCreateLogAnomalyDetector struct { +type awsAwsjson11_deserializeOpCreateDelivery struct { } -func (*awsAwsjson11_deserializeOpCreateLogAnomalyDetector) ID() string { +func (*awsAwsjson11_deserializeOpCreateDelivery) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpCreateLogAnomalyDetector) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpCreateDelivery) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -509,9 +491,9 @@ func (m *awsAwsjson11_deserializeOpCreateLogAnomalyDetector) HandleDeserialize(c } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorCreateLogAnomalyDetector(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorCreateDelivery(response, &metadata) } - output := &CreateLogAnomalyDetectorOutput{} + output := &CreateDeliveryOutput{} out.Result = output var buff [1024]byte @@ -531,7 +513,7 @@ func (m *awsAwsjson11_deserializeOpCreateLogAnomalyDetector) HandleDeserialize(c return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentCreateLogAnomalyDetectorOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentCreateDeliveryOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -545,7 +527,7 @@ func (m *awsAwsjson11_deserializeOpCreateLogAnomalyDetector) HandleDeserialize(c return out, metadata, err } -func awsAwsjson11_deserializeOpErrorCreateLogAnomalyDetector(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorCreateDelivery(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -582,21 +564,27 @@ func awsAwsjson11_deserializeOpErrorCreateLogAnomalyDetector(response *smithyhtt errorMessage = bodyInfo.Message } switch { - case strings.EqualFold("InvalidParameterException", errorCode): - return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) - - case strings.EqualFold("LimitExceededException", errorCode): - return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) + case strings.EqualFold("AccessDeniedException", errorCode): + return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) - case strings.EqualFold("OperationAbortedException", errorCode): - return awsAwsjson11_deserializeErrorOperationAbortedException(response, errorBody) + case strings.EqualFold("ConflictException", errorCode): + return awsAwsjson11_deserializeErrorConflictException(response, errorBody) case strings.EqualFold("ResourceNotFoundException", errorCode): return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) + case strings.EqualFold("ServiceQuotaExceededException", errorCode): + return awsAwsjson11_deserializeErrorServiceQuotaExceededException(response, errorBody) + case strings.EqualFold("ServiceUnavailableException", errorCode): return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) + case strings.EqualFold("ThrottlingException", errorCode): + return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) + + case strings.EqualFold("ValidationException", errorCode): + return awsAwsjson11_deserializeErrorValidationException(response, errorBody) + default: genericError := &smithy.GenericAPIError{ Code: errorCode, @@ -607,14 +595,14 @@ func awsAwsjson11_deserializeOpErrorCreateLogAnomalyDetector(response *smithyhtt } } -type awsAwsjson11_deserializeOpCreateLogGroup struct { +type awsAwsjson11_deserializeOpCreateExportTask struct { } -func (*awsAwsjson11_deserializeOpCreateLogGroup) ID() string { +func (*awsAwsjson11_deserializeOpCreateExportTask) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpCreateLogGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpCreateExportTask) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -632,21 +620,43 @@ func (m *awsAwsjson11_deserializeOpCreateLogGroup) HandleDeserialize(ctx context } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorCreateLogGroup(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorCreateExportTask(response, &metadata) } - output := &CreateLogGroupOutput{} + output := &CreateExportTaskOutput{} out.Result = output - if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { - return out, metadata, &smithy.DeserializationError{ - Err: fmt.Errorf("failed to discard response body, %w", err), + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(response.Body, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + var shape interface{} + if err := decoder.Decode(&shape); err != nil && err != io.EOF { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return out, metadata, err + } + + err = awsAwsjson11_deserializeOpDocumentCreateExportTaskOutput(&output, shape) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), } + return out, metadata, err } return out, metadata, err } -func awsAwsjson11_deserializeOpErrorCreateLogGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorCreateExportTask(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -695,6 +705,9 @@ func awsAwsjson11_deserializeOpErrorCreateLogGroup(response *smithyhttp.Response case strings.EqualFold("ResourceAlreadyExistsException", errorCode): return awsAwsjson11_deserializeErrorResourceAlreadyExistsException(response, errorBody) + case strings.EqualFold("ResourceNotFoundException", errorCode): + return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) + case strings.EqualFold("ServiceUnavailableException", errorCode): return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) @@ -708,14 +721,14 @@ func awsAwsjson11_deserializeOpErrorCreateLogGroup(response *smithyhttp.Response } } -type awsAwsjson11_deserializeOpCreateLogStream struct { +type awsAwsjson11_deserializeOpCreateImportTask struct { } -func (*awsAwsjson11_deserializeOpCreateLogStream) ID() string { +func (*awsAwsjson11_deserializeOpCreateImportTask) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpCreateLogStream) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpCreateImportTask) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -733,21 +746,43 @@ func (m *awsAwsjson11_deserializeOpCreateLogStream) HandleDeserialize(ctx contex } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorCreateLogStream(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorCreateImportTask(response, &metadata) } - output := &CreateLogStreamOutput{} + output := &CreateImportTaskOutput{} out.Result = output - if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { - return out, metadata, &smithy.DeserializationError{ - Err: fmt.Errorf("failed to discard response body, %w", err), + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(response.Body, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + var shape interface{} + if err := decoder.Decode(&shape); err != nil && err != io.EOF { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return out, metadata, err + } + + err = awsAwsjson11_deserializeOpDocumentCreateImportTaskOutput(&output, shape) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), } + return out, metadata, err } return out, metadata, err } -func awsAwsjson11_deserializeOpErrorCreateLogStream(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorCreateImportTask(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -784,17 +819,26 @@ func awsAwsjson11_deserializeOpErrorCreateLogStream(response *smithyhttp.Respons errorMessage = bodyInfo.Message } switch { + case strings.EqualFold("AccessDeniedException", errorCode): + return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) + + case strings.EqualFold("ConflictException", errorCode): + return awsAwsjson11_deserializeErrorConflictException(response, errorBody) + + case strings.EqualFold("InvalidOperationException", errorCode): + return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody) + case strings.EqualFold("InvalidParameterException", errorCode): return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) - case strings.EqualFold("ResourceAlreadyExistsException", errorCode): - return awsAwsjson11_deserializeErrorResourceAlreadyExistsException(response, errorBody) - case strings.EqualFold("ResourceNotFoundException", errorCode): return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) - case strings.EqualFold("ServiceUnavailableException", errorCode): - return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) + case strings.EqualFold("ThrottlingException", errorCode): + return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) + + case strings.EqualFold("ValidationException", errorCode): + return awsAwsjson11_deserializeErrorValidationException(response, errorBody) default: genericError := &smithy.GenericAPIError{ @@ -806,14 +850,14 @@ func awsAwsjson11_deserializeOpErrorCreateLogStream(response *smithyhttp.Respons } } -type awsAwsjson11_deserializeOpDeleteAccountPolicy struct { +type awsAwsjson11_deserializeOpCreateLogAnomalyDetector struct { } -func (*awsAwsjson11_deserializeOpDeleteAccountPolicy) ID() string { +func (*awsAwsjson11_deserializeOpCreateLogAnomalyDetector) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpDeleteAccountPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpCreateLogAnomalyDetector) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -831,21 +875,43 @@ func (m *awsAwsjson11_deserializeOpDeleteAccountPolicy) HandleDeserialize(ctx co } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorDeleteAccountPolicy(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorCreateLogAnomalyDetector(response, &metadata) } - output := &DeleteAccountPolicyOutput{} + output := &CreateLogAnomalyDetectorOutput{} out.Result = output - if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { - return out, metadata, &smithy.DeserializationError{ - Err: fmt.Errorf("failed to discard response body, %w", err), + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(response.Body, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + var shape interface{} + if err := decoder.Decode(&shape); err != nil && err != io.EOF { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), } + return out, metadata, err + } + + err = awsAwsjson11_deserializeOpDocumentCreateLogAnomalyDetectorOutput(&output, shape) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return out, metadata, err } return out, metadata, err } -func awsAwsjson11_deserializeOpErrorDeleteAccountPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorCreateLogAnomalyDetector(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -885,6 +951,9 @@ func awsAwsjson11_deserializeOpErrorDeleteAccountPolicy(response *smithyhttp.Res case strings.EqualFold("InvalidParameterException", errorCode): return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) + case strings.EqualFold("LimitExceededException", errorCode): + return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) + case strings.EqualFold("OperationAbortedException", errorCode): return awsAwsjson11_deserializeErrorOperationAbortedException(response, errorBody) @@ -904,14 +973,14 @@ func awsAwsjson11_deserializeOpErrorDeleteAccountPolicy(response *smithyhttp.Res } } -type awsAwsjson11_deserializeOpDeleteDataProtectionPolicy struct { +type awsAwsjson11_deserializeOpCreateLogGroup struct { } -func (*awsAwsjson11_deserializeOpDeleteDataProtectionPolicy) ID() string { +func (*awsAwsjson11_deserializeOpCreateLogGroup) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpDeleteDataProtectionPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpCreateLogGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -929,9 +998,9 @@ func (m *awsAwsjson11_deserializeOpDeleteDataProtectionPolicy) HandleDeserialize } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorDeleteDataProtectionPolicy(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorCreateLogGroup(response, &metadata) } - output := &DeleteDataProtectionPolicyOutput{} + output := &CreateLogGroupOutput{} out.Result = output if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { @@ -943,7 +1012,7 @@ func (m *awsAwsjson11_deserializeOpDeleteDataProtectionPolicy) HandleDeserialize return out, metadata, err } -func awsAwsjson11_deserializeOpErrorDeleteDataProtectionPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorCreateLogGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -983,11 +1052,14 @@ func awsAwsjson11_deserializeOpErrorDeleteDataProtectionPolicy(response *smithyh case strings.EqualFold("InvalidParameterException", errorCode): return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) + case strings.EqualFold("LimitExceededException", errorCode): + return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) + case strings.EqualFold("OperationAbortedException", errorCode): return awsAwsjson11_deserializeErrorOperationAbortedException(response, errorBody) - case strings.EqualFold("ResourceNotFoundException", errorCode): - return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) + case strings.EqualFold("ResourceAlreadyExistsException", errorCode): + return awsAwsjson11_deserializeErrorResourceAlreadyExistsException(response, errorBody) case strings.EqualFold("ServiceUnavailableException", errorCode): return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) @@ -1002,14 +1074,14 @@ func awsAwsjson11_deserializeOpErrorDeleteDataProtectionPolicy(response *smithyh } } -type awsAwsjson11_deserializeOpDeleteDelivery struct { +type awsAwsjson11_deserializeOpCreateLogStream struct { } -func (*awsAwsjson11_deserializeOpDeleteDelivery) ID() string { +func (*awsAwsjson11_deserializeOpCreateLogStream) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpDeleteDelivery) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpCreateLogStream) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -1027,9 +1099,9 @@ func (m *awsAwsjson11_deserializeOpDeleteDelivery) HandleDeserialize(ctx context } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorDeleteDelivery(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorCreateLogStream(response, &metadata) } - output := &DeleteDeliveryOutput{} + output := &CreateLogStreamOutput{} out.Result = output if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { @@ -1041,7 +1113,7 @@ func (m *awsAwsjson11_deserializeOpDeleteDelivery) HandleDeserialize(ctx context return out, metadata, err } -func awsAwsjson11_deserializeOpErrorDeleteDelivery(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorCreateLogStream(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -1078,24 +1150,18 @@ func awsAwsjson11_deserializeOpErrorDeleteDelivery(response *smithyhttp.Response errorMessage = bodyInfo.Message } switch { - case strings.EqualFold("ConflictException", errorCode): - return awsAwsjson11_deserializeErrorConflictException(response, errorBody) + case strings.EqualFold("InvalidParameterException", errorCode): + return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) + + case strings.EqualFold("ResourceAlreadyExistsException", errorCode): + return awsAwsjson11_deserializeErrorResourceAlreadyExistsException(response, errorBody) case strings.EqualFold("ResourceNotFoundException", errorCode): return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) - case strings.EqualFold("ServiceQuotaExceededException", errorCode): - return awsAwsjson11_deserializeErrorServiceQuotaExceededException(response, errorBody) - case strings.EqualFold("ServiceUnavailableException", errorCode): return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) - case strings.EqualFold("ThrottlingException", errorCode): - return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) - - case strings.EqualFold("ValidationException", errorCode): - return awsAwsjson11_deserializeErrorValidationException(response, errorBody) - default: genericError := &smithy.GenericAPIError{ Code: errorCode, @@ -1106,14 +1172,14 @@ func awsAwsjson11_deserializeOpErrorDeleteDelivery(response *smithyhttp.Response } } -type awsAwsjson11_deserializeOpDeleteDeliveryDestination struct { +type awsAwsjson11_deserializeOpCreateScheduledQuery struct { } -func (*awsAwsjson11_deserializeOpDeleteDeliveryDestination) ID() string { +func (*awsAwsjson11_deserializeOpCreateScheduledQuery) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpDeleteDeliveryDestination) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpCreateScheduledQuery) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -1131,21 +1197,43 @@ func (m *awsAwsjson11_deserializeOpDeleteDeliveryDestination) HandleDeserialize( } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorDeleteDeliveryDestination(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorCreateScheduledQuery(response, &metadata) } - output := &DeleteDeliveryDestinationOutput{} + output := &CreateScheduledQueryOutput{} out.Result = output - if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { - return out, metadata, &smithy.DeserializationError{ - Err: fmt.Errorf("failed to discard response body, %w", err), + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(response.Body, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + var shape interface{} + if err := decoder.Decode(&shape); err != nil && err != io.EOF { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return out, metadata, err + } + + err = awsAwsjson11_deserializeOpDocumentCreateScheduledQueryOutput(&output, shape) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), } + return out, metadata, err } return out, metadata, err } -func awsAwsjson11_deserializeOpErrorDeleteDeliveryDestination(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorCreateScheduledQuery(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -1182,18 +1270,21 @@ func awsAwsjson11_deserializeOpErrorDeleteDeliveryDestination(response *smithyht errorMessage = bodyInfo.Message } switch { + case strings.EqualFold("AccessDeniedException", errorCode): + return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) + case strings.EqualFold("ConflictException", errorCode): return awsAwsjson11_deserializeErrorConflictException(response, errorBody) + case strings.EqualFold("InternalServerException", errorCode): + return awsAwsjson11_deserializeErrorInternalServerException(response, errorBody) + case strings.EqualFold("ResourceNotFoundException", errorCode): return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) case strings.EqualFold("ServiceQuotaExceededException", errorCode): return awsAwsjson11_deserializeErrorServiceQuotaExceededException(response, errorBody) - case strings.EqualFold("ServiceUnavailableException", errorCode): - return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) - case strings.EqualFold("ThrottlingException", errorCode): return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) @@ -1210,14 +1301,14 @@ func awsAwsjson11_deserializeOpErrorDeleteDeliveryDestination(response *smithyht } } -type awsAwsjson11_deserializeOpDeleteDeliveryDestinationPolicy struct { +type awsAwsjson11_deserializeOpDeleteAccountPolicy struct { } -func (*awsAwsjson11_deserializeOpDeleteDeliveryDestinationPolicy) ID() string { +func (*awsAwsjson11_deserializeOpDeleteAccountPolicy) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpDeleteDeliveryDestinationPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpDeleteAccountPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -1235,9 +1326,9 @@ func (m *awsAwsjson11_deserializeOpDeleteDeliveryDestinationPolicy) HandleDeseri } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorDeleteDeliveryDestinationPolicy(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorDeleteAccountPolicy(response, &metadata) } - output := &DeleteDeliveryDestinationPolicyOutput{} + output := &DeleteAccountPolicyOutput{} out.Result = output if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { @@ -1249,7 +1340,7 @@ func (m *awsAwsjson11_deserializeOpDeleteDeliveryDestinationPolicy) HandleDeseri return out, metadata, err } -func awsAwsjson11_deserializeOpErrorDeleteDeliveryDestinationPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorDeleteAccountPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -1286,8 +1377,11 @@ func awsAwsjson11_deserializeOpErrorDeleteDeliveryDestinationPolicy(response *sm errorMessage = bodyInfo.Message } switch { - case strings.EqualFold("ConflictException", errorCode): - return awsAwsjson11_deserializeErrorConflictException(response, errorBody) + case strings.EqualFold("InvalidParameterException", errorCode): + return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) + + case strings.EqualFold("OperationAbortedException", errorCode): + return awsAwsjson11_deserializeErrorOperationAbortedException(response, errorBody) case strings.EqualFold("ResourceNotFoundException", errorCode): return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) @@ -1295,9 +1389,6 @@ func awsAwsjson11_deserializeOpErrorDeleteDeliveryDestinationPolicy(response *sm case strings.EqualFold("ServiceUnavailableException", errorCode): return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) - case strings.EqualFold("ValidationException", errorCode): - return awsAwsjson11_deserializeErrorValidationException(response, errorBody) - default: genericError := &smithy.GenericAPIError{ Code: errorCode, @@ -1308,14 +1399,14 @@ func awsAwsjson11_deserializeOpErrorDeleteDeliveryDestinationPolicy(response *sm } } -type awsAwsjson11_deserializeOpDeleteDeliverySource struct { +type awsAwsjson11_deserializeOpDeleteDataProtectionPolicy struct { } -func (*awsAwsjson11_deserializeOpDeleteDeliverySource) ID() string { +func (*awsAwsjson11_deserializeOpDeleteDataProtectionPolicy) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpDeleteDeliverySource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpDeleteDataProtectionPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -1333,9 +1424,9 @@ func (m *awsAwsjson11_deserializeOpDeleteDeliverySource) HandleDeserialize(ctx c } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorDeleteDeliverySource(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorDeleteDataProtectionPolicy(response, &metadata) } - output := &DeleteDeliverySourceOutput{} + output := &DeleteDataProtectionPolicyOutput{} out.Result = output if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { @@ -1347,7 +1438,7 @@ func (m *awsAwsjson11_deserializeOpDeleteDeliverySource) HandleDeserialize(ctx c return out, metadata, err } -func awsAwsjson11_deserializeOpErrorDeleteDeliverySource(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorDeleteDataProtectionPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -1384,24 +1475,18 @@ func awsAwsjson11_deserializeOpErrorDeleteDeliverySource(response *smithyhttp.Re errorMessage = bodyInfo.Message } switch { - case strings.EqualFold("ConflictException", errorCode): - return awsAwsjson11_deserializeErrorConflictException(response, errorBody) + case strings.EqualFold("InvalidParameterException", errorCode): + return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) + + case strings.EqualFold("OperationAbortedException", errorCode): + return awsAwsjson11_deserializeErrorOperationAbortedException(response, errorBody) case strings.EqualFold("ResourceNotFoundException", errorCode): return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) - case strings.EqualFold("ServiceQuotaExceededException", errorCode): - return awsAwsjson11_deserializeErrorServiceQuotaExceededException(response, errorBody) - case strings.EqualFold("ServiceUnavailableException", errorCode): return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) - case strings.EqualFold("ThrottlingException", errorCode): - return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) - - case strings.EqualFold("ValidationException", errorCode): - return awsAwsjson11_deserializeErrorValidationException(response, errorBody) - default: genericError := &smithy.GenericAPIError{ Code: errorCode, @@ -1412,14 +1497,14 @@ func awsAwsjson11_deserializeOpErrorDeleteDeliverySource(response *smithyhttp.Re } } -type awsAwsjson11_deserializeOpDeleteDestination struct { +type awsAwsjson11_deserializeOpDeleteDelivery struct { } -func (*awsAwsjson11_deserializeOpDeleteDestination) ID() string { +func (*awsAwsjson11_deserializeOpDeleteDelivery) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpDeleteDestination) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpDeleteDelivery) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -1437,9 +1522,9 @@ func (m *awsAwsjson11_deserializeOpDeleteDestination) HandleDeserialize(ctx cont } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorDeleteDestination(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorDeleteDelivery(response, &metadata) } - output := &DeleteDestinationOutput{} + output := &DeleteDeliveryOutput{} out.Result = output if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { @@ -1451,7 +1536,7 @@ func (m *awsAwsjson11_deserializeOpDeleteDestination) HandleDeserialize(ctx cont return out, metadata, err } -func awsAwsjson11_deserializeOpErrorDeleteDestination(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorDeleteDelivery(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -1488,18 +1573,24 @@ func awsAwsjson11_deserializeOpErrorDeleteDestination(response *smithyhttp.Respo errorMessage = bodyInfo.Message } switch { - case strings.EqualFold("InvalidParameterException", errorCode): - return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) - - case strings.EqualFold("OperationAbortedException", errorCode): - return awsAwsjson11_deserializeErrorOperationAbortedException(response, errorBody) + case strings.EqualFold("ConflictException", errorCode): + return awsAwsjson11_deserializeErrorConflictException(response, errorBody) case strings.EqualFold("ResourceNotFoundException", errorCode): return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) + case strings.EqualFold("ServiceQuotaExceededException", errorCode): + return awsAwsjson11_deserializeErrorServiceQuotaExceededException(response, errorBody) + case strings.EqualFold("ServiceUnavailableException", errorCode): return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) + case strings.EqualFold("ThrottlingException", errorCode): + return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) + + case strings.EqualFold("ValidationException", errorCode): + return awsAwsjson11_deserializeErrorValidationException(response, errorBody) + default: genericError := &smithy.GenericAPIError{ Code: errorCode, @@ -1510,14 +1601,14 @@ func awsAwsjson11_deserializeOpErrorDeleteDestination(response *smithyhttp.Respo } } -type awsAwsjson11_deserializeOpDeleteIndexPolicy struct { +type awsAwsjson11_deserializeOpDeleteDeliveryDestination struct { } -func (*awsAwsjson11_deserializeOpDeleteIndexPolicy) ID() string { +func (*awsAwsjson11_deserializeOpDeleteDeliveryDestination) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpDeleteIndexPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpDeleteDeliveryDestination) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -1535,43 +1626,21 @@ func (m *awsAwsjson11_deserializeOpDeleteIndexPolicy) HandleDeserialize(ctx cont } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorDeleteIndexPolicy(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorDeleteDeliveryDestination(response, &metadata) } - output := &DeleteIndexPolicyOutput{} + output := &DeleteDeliveryDestinationOutput{} out.Result = output - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - - body := io.TeeReader(response.Body, ringBuffer) - decoder := json.NewDecoder(body) - decoder.UseNumber() - var shape interface{} - if err := decoder.Decode(&shape); err != nil && err != io.EOF { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return out, metadata, err - } - - err = awsAwsjson11_deserializeOpDocumentDeleteIndexPolicyOutput(&output, shape) - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), + if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { + return out, metadata, &smithy.DeserializationError{ + Err: fmt.Errorf("failed to discard response body, %w", err), } - return out, metadata, err } return out, metadata, err } -func awsAwsjson11_deserializeOpErrorDeleteIndexPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorDeleteDeliveryDestination(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -1608,21 +1677,24 @@ func awsAwsjson11_deserializeOpErrorDeleteIndexPolicy(response *smithyhttp.Respo errorMessage = bodyInfo.Message } switch { - case strings.EqualFold("InvalidParameterException", errorCode): - return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) - - case strings.EqualFold("LimitExceededException", errorCode): - return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) - - case strings.EqualFold("OperationAbortedException", errorCode): - return awsAwsjson11_deserializeErrorOperationAbortedException(response, errorBody) + case strings.EqualFold("ConflictException", errorCode): + return awsAwsjson11_deserializeErrorConflictException(response, errorBody) case strings.EqualFold("ResourceNotFoundException", errorCode): return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) + case strings.EqualFold("ServiceQuotaExceededException", errorCode): + return awsAwsjson11_deserializeErrorServiceQuotaExceededException(response, errorBody) + case strings.EqualFold("ServiceUnavailableException", errorCode): return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) + case strings.EqualFold("ThrottlingException", errorCode): + return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) + + case strings.EqualFold("ValidationException", errorCode): + return awsAwsjson11_deserializeErrorValidationException(response, errorBody) + default: genericError := &smithy.GenericAPIError{ Code: errorCode, @@ -1633,14 +1705,14 @@ func awsAwsjson11_deserializeOpErrorDeleteIndexPolicy(response *smithyhttp.Respo } } -type awsAwsjson11_deserializeOpDeleteIntegration struct { +type awsAwsjson11_deserializeOpDeleteDeliveryDestinationPolicy struct { } -func (*awsAwsjson11_deserializeOpDeleteIntegration) ID() string { +func (*awsAwsjson11_deserializeOpDeleteDeliveryDestinationPolicy) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpDeleteIntegration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpDeleteDeliveryDestinationPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -1658,43 +1730,21 @@ func (m *awsAwsjson11_deserializeOpDeleteIntegration) HandleDeserialize(ctx cont } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorDeleteIntegration(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorDeleteDeliveryDestinationPolicy(response, &metadata) } - output := &DeleteIntegrationOutput{} + output := &DeleteDeliveryDestinationPolicyOutput{} out.Result = output - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - - body := io.TeeReader(response.Body, ringBuffer) - decoder := json.NewDecoder(body) - decoder.UseNumber() - var shape interface{} - if err := decoder.Decode(&shape); err != nil && err != io.EOF { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return out, metadata, err - } - - err = awsAwsjson11_deserializeOpDocumentDeleteIntegrationOutput(&output, shape) - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), + if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { + return out, metadata, &smithy.DeserializationError{ + Err: fmt.Errorf("failed to discard response body, %w", err), } - return out, metadata, err } return out, metadata, err } -func awsAwsjson11_deserializeOpErrorDeleteIntegration(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorDeleteDeliveryDestinationPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -1731,8 +1781,8 @@ func awsAwsjson11_deserializeOpErrorDeleteIntegration(response *smithyhttp.Respo errorMessage = bodyInfo.Message } switch { - case strings.EqualFold("InvalidParameterException", errorCode): - return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) + case strings.EqualFold("ConflictException", errorCode): + return awsAwsjson11_deserializeErrorConflictException(response, errorBody) case strings.EqualFold("ResourceNotFoundException", errorCode): return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) @@ -1753,14 +1803,14 @@ func awsAwsjson11_deserializeOpErrorDeleteIntegration(response *smithyhttp.Respo } } -type awsAwsjson11_deserializeOpDeleteLogAnomalyDetector struct { +type awsAwsjson11_deserializeOpDeleteDeliverySource struct { } -func (*awsAwsjson11_deserializeOpDeleteLogAnomalyDetector) ID() string { +func (*awsAwsjson11_deserializeOpDeleteDeliverySource) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpDeleteLogAnomalyDetector) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpDeleteDeliverySource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -1778,9 +1828,9 @@ func (m *awsAwsjson11_deserializeOpDeleteLogAnomalyDetector) HandleDeserialize(c } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorDeleteLogAnomalyDetector(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorDeleteDeliverySource(response, &metadata) } - output := &DeleteLogAnomalyDetectorOutput{} + output := &DeleteDeliverySourceOutput{} out.Result = output if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { @@ -1792,7 +1842,7 @@ func (m *awsAwsjson11_deserializeOpDeleteLogAnomalyDetector) HandleDeserialize(c return out, metadata, err } -func awsAwsjson11_deserializeOpErrorDeleteLogAnomalyDetector(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorDeleteDeliverySource(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -1829,18 +1879,24 @@ func awsAwsjson11_deserializeOpErrorDeleteLogAnomalyDetector(response *smithyhtt errorMessage = bodyInfo.Message } switch { - case strings.EqualFold("InvalidParameterException", errorCode): - return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) - - case strings.EqualFold("OperationAbortedException", errorCode): - return awsAwsjson11_deserializeErrorOperationAbortedException(response, errorBody) + case strings.EqualFold("ConflictException", errorCode): + return awsAwsjson11_deserializeErrorConflictException(response, errorBody) case strings.EqualFold("ResourceNotFoundException", errorCode): return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) + case strings.EqualFold("ServiceQuotaExceededException", errorCode): + return awsAwsjson11_deserializeErrorServiceQuotaExceededException(response, errorBody) + case strings.EqualFold("ServiceUnavailableException", errorCode): return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) + case strings.EqualFold("ThrottlingException", errorCode): + return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) + + case strings.EqualFold("ValidationException", errorCode): + return awsAwsjson11_deserializeErrorValidationException(response, errorBody) + default: genericError := &smithy.GenericAPIError{ Code: errorCode, @@ -1851,14 +1907,14 @@ func awsAwsjson11_deserializeOpErrorDeleteLogAnomalyDetector(response *smithyhtt } } -type awsAwsjson11_deserializeOpDeleteLogGroup struct { +type awsAwsjson11_deserializeOpDeleteDestination struct { } -func (*awsAwsjson11_deserializeOpDeleteLogGroup) ID() string { +func (*awsAwsjson11_deserializeOpDeleteDestination) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpDeleteLogGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpDeleteDestination) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -1876,9 +1932,9 @@ func (m *awsAwsjson11_deserializeOpDeleteLogGroup) HandleDeserialize(ctx context } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorDeleteLogGroup(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorDeleteDestination(response, &metadata) } - output := &DeleteLogGroupOutput{} + output := &DeleteDestinationOutput{} out.Result = output if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { @@ -1890,7 +1946,7 @@ func (m *awsAwsjson11_deserializeOpDeleteLogGroup) HandleDeserialize(ctx context return out, metadata, err } -func awsAwsjson11_deserializeOpErrorDeleteLogGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorDeleteDestination(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -1949,14 +2005,14 @@ func awsAwsjson11_deserializeOpErrorDeleteLogGroup(response *smithyhttp.Response } } -type awsAwsjson11_deserializeOpDeleteLogStream struct { +type awsAwsjson11_deserializeOpDeleteIndexPolicy struct { } -func (*awsAwsjson11_deserializeOpDeleteLogStream) ID() string { +func (*awsAwsjson11_deserializeOpDeleteIndexPolicy) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpDeleteLogStream) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpDeleteIndexPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -1974,21 +2030,43 @@ func (m *awsAwsjson11_deserializeOpDeleteLogStream) HandleDeserialize(ctx contex } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorDeleteLogStream(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorDeleteIndexPolicy(response, &metadata) } - output := &DeleteLogStreamOutput{} + output := &DeleteIndexPolicyOutput{} out.Result = output - if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { - return out, metadata, &smithy.DeserializationError{ - Err: fmt.Errorf("failed to discard response body, %w", err), + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(response.Body, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + var shape interface{} + if err := decoder.Decode(&shape); err != nil && err != io.EOF { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return out, metadata, err + } + + err = awsAwsjson11_deserializeOpDocumentDeleteIndexPolicyOutput(&output, shape) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), } + return out, metadata, err } return out, metadata, err } -func awsAwsjson11_deserializeOpErrorDeleteLogStream(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorDeleteIndexPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -2028,6 +2106,9 @@ func awsAwsjson11_deserializeOpErrorDeleteLogStream(response *smithyhttp.Respons case strings.EqualFold("InvalidParameterException", errorCode): return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) + case strings.EqualFold("LimitExceededException", errorCode): + return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) + case strings.EqualFold("OperationAbortedException", errorCode): return awsAwsjson11_deserializeErrorOperationAbortedException(response, errorBody) @@ -2047,14 +2128,14 @@ func awsAwsjson11_deserializeOpErrorDeleteLogStream(response *smithyhttp.Respons } } -type awsAwsjson11_deserializeOpDeleteMetricFilter struct { +type awsAwsjson11_deserializeOpDeleteIntegration struct { } -func (*awsAwsjson11_deserializeOpDeleteMetricFilter) ID() string { +func (*awsAwsjson11_deserializeOpDeleteIntegration) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpDeleteMetricFilter) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpDeleteIntegration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -2072,21 +2153,43 @@ func (m *awsAwsjson11_deserializeOpDeleteMetricFilter) HandleDeserialize(ctx con } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorDeleteMetricFilter(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorDeleteIntegration(response, &metadata) } - output := &DeleteMetricFilterOutput{} + output := &DeleteIntegrationOutput{} out.Result = output - if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { - return out, metadata, &smithy.DeserializationError{ - Err: fmt.Errorf("failed to discard response body, %w", err), + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(response.Body, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + var shape interface{} + if err := decoder.Decode(&shape); err != nil && err != io.EOF { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return out, metadata, err + } + + err = awsAwsjson11_deserializeOpDocumentDeleteIntegrationOutput(&output, shape) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), } + return out, metadata, err } return out, metadata, err } -func awsAwsjson11_deserializeOpErrorDeleteMetricFilter(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorDeleteIntegration(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -2126,15 +2229,15 @@ func awsAwsjson11_deserializeOpErrorDeleteMetricFilter(response *smithyhttp.Resp case strings.EqualFold("InvalidParameterException", errorCode): return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) - case strings.EqualFold("OperationAbortedException", errorCode): - return awsAwsjson11_deserializeErrorOperationAbortedException(response, errorBody) - case strings.EqualFold("ResourceNotFoundException", errorCode): return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) case strings.EqualFold("ServiceUnavailableException", errorCode): return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) + case strings.EqualFold("ValidationException", errorCode): + return awsAwsjson11_deserializeErrorValidationException(response, errorBody) + default: genericError := &smithy.GenericAPIError{ Code: errorCode, @@ -2145,14 +2248,14 @@ func awsAwsjson11_deserializeOpErrorDeleteMetricFilter(response *smithyhttp.Resp } } -type awsAwsjson11_deserializeOpDeleteQueryDefinition struct { +type awsAwsjson11_deserializeOpDeleteLogAnomalyDetector struct { } -func (*awsAwsjson11_deserializeOpDeleteQueryDefinition) ID() string { +func (*awsAwsjson11_deserializeOpDeleteLogAnomalyDetector) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpDeleteQueryDefinition) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpDeleteLogAnomalyDetector) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -2170,43 +2273,21 @@ func (m *awsAwsjson11_deserializeOpDeleteQueryDefinition) HandleDeserialize(ctx } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorDeleteQueryDefinition(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorDeleteLogAnomalyDetector(response, &metadata) } - output := &DeleteQueryDefinitionOutput{} + output := &DeleteLogAnomalyDetectorOutput{} out.Result = output - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - - body := io.TeeReader(response.Body, ringBuffer) - decoder := json.NewDecoder(body) - decoder.UseNumber() - var shape interface{} - if err := decoder.Decode(&shape); err != nil && err != io.EOF { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return out, metadata, err - } - - err = awsAwsjson11_deserializeOpDocumentDeleteQueryDefinitionOutput(&output, shape) - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), + if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { + return out, metadata, &smithy.DeserializationError{ + Err: fmt.Errorf("failed to discard response body, %w", err), } - return out, metadata, err } return out, metadata, err } -func awsAwsjson11_deserializeOpErrorDeleteQueryDefinition(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorDeleteLogAnomalyDetector(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -2246,6 +2327,9 @@ func awsAwsjson11_deserializeOpErrorDeleteQueryDefinition(response *smithyhttp.R case strings.EqualFold("InvalidParameterException", errorCode): return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) + case strings.EqualFold("OperationAbortedException", errorCode): + return awsAwsjson11_deserializeErrorOperationAbortedException(response, errorBody) + case strings.EqualFold("ResourceNotFoundException", errorCode): return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) @@ -2262,14 +2346,14 @@ func awsAwsjson11_deserializeOpErrorDeleteQueryDefinition(response *smithyhttp.R } } -type awsAwsjson11_deserializeOpDeleteResourcePolicy struct { +type awsAwsjson11_deserializeOpDeleteLogGroup struct { } -func (*awsAwsjson11_deserializeOpDeleteResourcePolicy) ID() string { +func (*awsAwsjson11_deserializeOpDeleteLogGroup) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpDeleteResourcePolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpDeleteLogGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -2287,9 +2371,9 @@ func (m *awsAwsjson11_deserializeOpDeleteResourcePolicy) HandleDeserialize(ctx c } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorDeleteResourcePolicy(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorDeleteLogGroup(response, &metadata) } - output := &DeleteResourcePolicyOutput{} + output := &DeleteLogGroupOutput{} out.Result = output if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { @@ -2301,7 +2385,7 @@ func (m *awsAwsjson11_deserializeOpDeleteResourcePolicy) HandleDeserialize(ctx c return out, metadata, err } -func awsAwsjson11_deserializeOpErrorDeleteResourcePolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorDeleteLogGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -2341,12 +2425,18 @@ func awsAwsjson11_deserializeOpErrorDeleteResourcePolicy(response *smithyhttp.Re case strings.EqualFold("InvalidParameterException", errorCode): return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) + case strings.EqualFold("OperationAbortedException", errorCode): + return awsAwsjson11_deserializeErrorOperationAbortedException(response, errorBody) + case strings.EqualFold("ResourceNotFoundException", errorCode): return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) case strings.EqualFold("ServiceUnavailableException", errorCode): return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) + case strings.EqualFold("ValidationException", errorCode): + return awsAwsjson11_deserializeErrorValidationException(response, errorBody) + default: genericError := &smithy.GenericAPIError{ Code: errorCode, @@ -2357,14 +2447,14 @@ func awsAwsjson11_deserializeOpErrorDeleteResourcePolicy(response *smithyhttp.Re } } -type awsAwsjson11_deserializeOpDeleteRetentionPolicy struct { +type awsAwsjson11_deserializeOpDeleteLogStream struct { } -func (*awsAwsjson11_deserializeOpDeleteRetentionPolicy) ID() string { +func (*awsAwsjson11_deserializeOpDeleteLogStream) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpDeleteRetentionPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpDeleteLogStream) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -2382,9 +2472,9 @@ func (m *awsAwsjson11_deserializeOpDeleteRetentionPolicy) HandleDeserialize(ctx } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorDeleteRetentionPolicy(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorDeleteLogStream(response, &metadata) } - output := &DeleteRetentionPolicyOutput{} + output := &DeleteLogStreamOutput{} out.Result = output if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { @@ -2396,7 +2486,7 @@ func (m *awsAwsjson11_deserializeOpDeleteRetentionPolicy) HandleDeserialize(ctx return out, metadata, err } -func awsAwsjson11_deserializeOpErrorDeleteRetentionPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorDeleteLogStream(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -2445,6 +2535,9 @@ func awsAwsjson11_deserializeOpErrorDeleteRetentionPolicy(response *smithyhttp.R case strings.EqualFold("ServiceUnavailableException", errorCode): return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) + case strings.EqualFold("ValidationException", errorCode): + return awsAwsjson11_deserializeErrorValidationException(response, errorBody) + default: genericError := &smithy.GenericAPIError{ Code: errorCode, @@ -2455,14 +2548,14 @@ func awsAwsjson11_deserializeOpErrorDeleteRetentionPolicy(response *smithyhttp.R } } -type awsAwsjson11_deserializeOpDeleteSubscriptionFilter struct { +type awsAwsjson11_deserializeOpDeleteMetricFilter struct { } -func (*awsAwsjson11_deserializeOpDeleteSubscriptionFilter) ID() string { +func (*awsAwsjson11_deserializeOpDeleteMetricFilter) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpDeleteSubscriptionFilter) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpDeleteMetricFilter) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -2480,9 +2573,9 @@ func (m *awsAwsjson11_deserializeOpDeleteSubscriptionFilter) HandleDeserialize(c } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorDeleteSubscriptionFilter(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorDeleteMetricFilter(response, &metadata) } - output := &DeleteSubscriptionFilterOutput{} + output := &DeleteMetricFilterOutput{} out.Result = output if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { @@ -2494,7 +2587,7 @@ func (m *awsAwsjson11_deserializeOpDeleteSubscriptionFilter) HandleDeserialize(c return out, metadata, err } -func awsAwsjson11_deserializeOpErrorDeleteSubscriptionFilter(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorDeleteMetricFilter(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -2553,14 +2646,14 @@ func awsAwsjson11_deserializeOpErrorDeleteSubscriptionFilter(response *smithyhtt } } -type awsAwsjson11_deserializeOpDeleteTransformer struct { +type awsAwsjson11_deserializeOpDeleteQueryDefinition struct { } -func (*awsAwsjson11_deserializeOpDeleteTransformer) ID() string { +func (*awsAwsjson11_deserializeOpDeleteQueryDefinition) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpDeleteTransformer) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpDeleteQueryDefinition) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -2578,21 +2671,43 @@ func (m *awsAwsjson11_deserializeOpDeleteTransformer) HandleDeserialize(ctx cont } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorDeleteTransformer(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorDeleteQueryDefinition(response, &metadata) } - output := &DeleteTransformerOutput{} + output := &DeleteQueryDefinitionOutput{} out.Result = output - if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { - return out, metadata, &smithy.DeserializationError{ - Err: fmt.Errorf("failed to discard response body, %w", err), + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(response.Body, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + var shape interface{} + if err := decoder.Decode(&shape); err != nil && err != io.EOF { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), } + return out, metadata, err + } + + err = awsAwsjson11_deserializeOpDocumentDeleteQueryDefinitionOutput(&output, shape) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return out, metadata, err } return out, metadata, err } -func awsAwsjson11_deserializeOpErrorDeleteTransformer(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorDeleteQueryDefinition(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -2629,15 +2744,9 @@ func awsAwsjson11_deserializeOpErrorDeleteTransformer(response *smithyhttp.Respo errorMessage = bodyInfo.Message } switch { - case strings.EqualFold("InvalidOperationException", errorCode): - return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody) - case strings.EqualFold("InvalidParameterException", errorCode): return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) - case strings.EqualFold("OperationAbortedException", errorCode): - return awsAwsjson11_deserializeErrorOperationAbortedException(response, errorBody) - case strings.EqualFold("ResourceNotFoundException", errorCode): return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) @@ -2654,14 +2763,14 @@ func awsAwsjson11_deserializeOpErrorDeleteTransformer(response *smithyhttp.Respo } } -type awsAwsjson11_deserializeOpDescribeAccountPolicies struct { +type awsAwsjson11_deserializeOpDeleteResourcePolicy struct { } -func (*awsAwsjson11_deserializeOpDescribeAccountPolicies) ID() string { +func (*awsAwsjson11_deserializeOpDeleteResourcePolicy) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpDescribeAccountPolicies) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpDeleteResourcePolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -2679,43 +2788,21 @@ func (m *awsAwsjson11_deserializeOpDescribeAccountPolicies) HandleDeserialize(ct } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorDescribeAccountPolicies(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorDeleteResourcePolicy(response, &metadata) } - output := &DescribeAccountPoliciesOutput{} + output := &DeleteResourcePolicyOutput{} out.Result = output - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - - body := io.TeeReader(response.Body, ringBuffer) - decoder := json.NewDecoder(body) - decoder.UseNumber() - var shape interface{} - if err := decoder.Decode(&shape); err != nil && err != io.EOF { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return out, metadata, err - } - - err = awsAwsjson11_deserializeOpDocumentDescribeAccountPoliciesOutput(&output, shape) - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), + if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { + return out, metadata, &smithy.DeserializationError{ + Err: fmt.Errorf("failed to discard response body, %w", err), } - return out, metadata, err } return out, metadata, err } -func awsAwsjson11_deserializeOpErrorDescribeAccountPolicies(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorDeleteResourcePolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -2774,14 +2861,14 @@ func awsAwsjson11_deserializeOpErrorDescribeAccountPolicies(response *smithyhttp } } -type awsAwsjson11_deserializeOpDescribeConfigurationTemplates struct { +type awsAwsjson11_deserializeOpDeleteRetentionPolicy struct { } -func (*awsAwsjson11_deserializeOpDescribeConfigurationTemplates) ID() string { +func (*awsAwsjson11_deserializeOpDeleteRetentionPolicy) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpDescribeConfigurationTemplates) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpDeleteRetentionPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -2799,43 +2886,21 @@ func (m *awsAwsjson11_deserializeOpDescribeConfigurationTemplates) HandleDeseria } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorDescribeConfigurationTemplates(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorDeleteRetentionPolicy(response, &metadata) } - output := &DescribeConfigurationTemplatesOutput{} + output := &DeleteRetentionPolicyOutput{} out.Result = output - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - - body := io.TeeReader(response.Body, ringBuffer) - decoder := json.NewDecoder(body) - decoder.UseNumber() - var shape interface{} - if err := decoder.Decode(&shape); err != nil && err != io.EOF { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return out, metadata, err - } - - err = awsAwsjson11_deserializeOpDocumentDescribeConfigurationTemplatesOutput(&output, shape) - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), + if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { + return out, metadata, &smithy.DeserializationError{ + Err: fmt.Errorf("failed to discard response body, %w", err), } - return out, metadata, err } return out, metadata, err } -func awsAwsjson11_deserializeOpErrorDescribeConfigurationTemplates(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorDeleteRetentionPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -2872,18 +2937,18 @@ func awsAwsjson11_deserializeOpErrorDescribeConfigurationTemplates(response *smi errorMessage = bodyInfo.Message } switch { + case strings.EqualFold("InvalidParameterException", errorCode): + return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) + + case strings.EqualFold("OperationAbortedException", errorCode): + return awsAwsjson11_deserializeErrorOperationAbortedException(response, errorBody) + case strings.EqualFold("ResourceNotFoundException", errorCode): return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) case strings.EqualFold("ServiceUnavailableException", errorCode): return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) - case strings.EqualFold("ThrottlingException", errorCode): - return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) - - case strings.EqualFold("ValidationException", errorCode): - return awsAwsjson11_deserializeErrorValidationException(response, errorBody) - default: genericError := &smithy.GenericAPIError{ Code: errorCode, @@ -2894,14 +2959,14 @@ func awsAwsjson11_deserializeOpErrorDescribeConfigurationTemplates(response *smi } } -type awsAwsjson11_deserializeOpDescribeDeliveries struct { +type awsAwsjson11_deserializeOpDeleteScheduledQuery struct { } -func (*awsAwsjson11_deserializeOpDescribeDeliveries) ID() string { +func (*awsAwsjson11_deserializeOpDeleteScheduledQuery) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpDescribeDeliveries) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpDeleteScheduledQuery) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -2919,9 +2984,9 @@ func (m *awsAwsjson11_deserializeOpDescribeDeliveries) HandleDeserialize(ctx con } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorDescribeDeliveries(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorDeleteScheduledQuery(response, &metadata) } - output := &DescribeDeliveriesOutput{} + output := &DeleteScheduledQueryOutput{} out.Result = output var buff [1024]byte @@ -2941,7 +3006,7 @@ func (m *awsAwsjson11_deserializeOpDescribeDeliveries) HandleDeserialize(ctx con return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentDescribeDeliveriesOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentDeleteScheduledQueryOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -2955,7 +3020,7 @@ func (m *awsAwsjson11_deserializeOpDescribeDeliveries) HandleDeserialize(ctx con return out, metadata, err } -func awsAwsjson11_deserializeOpErrorDescribeDeliveries(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorDeleteScheduledQuery(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -2992,11 +3057,14 @@ func awsAwsjson11_deserializeOpErrorDescribeDeliveries(response *smithyhttp.Resp errorMessage = bodyInfo.Message } switch { - case strings.EqualFold("ServiceQuotaExceededException", errorCode): - return awsAwsjson11_deserializeErrorServiceQuotaExceededException(response, errorBody) + case strings.EqualFold("AccessDeniedException", errorCode): + return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) - case strings.EqualFold("ServiceUnavailableException", errorCode): - return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) + case strings.EqualFold("InternalServerException", errorCode): + return awsAwsjson11_deserializeErrorInternalServerException(response, errorBody) + + case strings.EqualFold("ResourceNotFoundException", errorCode): + return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) case strings.EqualFold("ThrottlingException", errorCode): return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) @@ -3014,14 +3082,14 @@ func awsAwsjson11_deserializeOpErrorDescribeDeliveries(response *smithyhttp.Resp } } -type awsAwsjson11_deserializeOpDescribeDeliveryDestinations struct { +type awsAwsjson11_deserializeOpDeleteSubscriptionFilter struct { } -func (*awsAwsjson11_deserializeOpDescribeDeliveryDestinations) ID() string { +func (*awsAwsjson11_deserializeOpDeleteSubscriptionFilter) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpDescribeDeliveryDestinations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpDeleteSubscriptionFilter) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -3039,43 +3107,21 @@ func (m *awsAwsjson11_deserializeOpDescribeDeliveryDestinations) HandleDeseriali } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorDescribeDeliveryDestinations(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorDeleteSubscriptionFilter(response, &metadata) } - output := &DescribeDeliveryDestinationsOutput{} + output := &DeleteSubscriptionFilterOutput{} out.Result = output - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - - body := io.TeeReader(response.Body, ringBuffer) - decoder := json.NewDecoder(body) - decoder.UseNumber() - var shape interface{} - if err := decoder.Decode(&shape); err != nil && err != io.EOF { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return out, metadata, err - } - - err = awsAwsjson11_deserializeOpDocumentDescribeDeliveryDestinationsOutput(&output, shape) - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), + if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { + return out, metadata, &smithy.DeserializationError{ + Err: fmt.Errorf("failed to discard response body, %w", err), } - return out, metadata, err } return out, metadata, err } -func awsAwsjson11_deserializeOpErrorDescribeDeliveryDestinations(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorDeleteSubscriptionFilter(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -3112,17 +3158,17 @@ func awsAwsjson11_deserializeOpErrorDescribeDeliveryDestinations(response *smith errorMessage = bodyInfo.Message } switch { - case strings.EqualFold("ServiceQuotaExceededException", errorCode): - return awsAwsjson11_deserializeErrorServiceQuotaExceededException(response, errorBody) + case strings.EqualFold("InvalidParameterException", errorCode): + return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) - case strings.EqualFold("ServiceUnavailableException", errorCode): - return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) + case strings.EqualFold("OperationAbortedException", errorCode): + return awsAwsjson11_deserializeErrorOperationAbortedException(response, errorBody) - case strings.EqualFold("ThrottlingException", errorCode): - return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) + case strings.EqualFold("ResourceNotFoundException", errorCode): + return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) - case strings.EqualFold("ValidationException", errorCode): - return awsAwsjson11_deserializeErrorValidationException(response, errorBody) + case strings.EqualFold("ServiceUnavailableException", errorCode): + return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) default: genericError := &smithy.GenericAPIError{ @@ -3134,14 +3180,14 @@ func awsAwsjson11_deserializeOpErrorDescribeDeliveryDestinations(response *smith } } -type awsAwsjson11_deserializeOpDescribeDeliverySources struct { +type awsAwsjson11_deserializeOpDeleteTransformer struct { } -func (*awsAwsjson11_deserializeOpDescribeDeliverySources) ID() string { +func (*awsAwsjson11_deserializeOpDeleteTransformer) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpDescribeDeliverySources) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpDeleteTransformer) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -3159,43 +3205,21 @@ func (m *awsAwsjson11_deserializeOpDescribeDeliverySources) HandleDeserialize(ct } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorDescribeDeliverySources(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorDeleteTransformer(response, &metadata) } - output := &DescribeDeliverySourcesOutput{} + output := &DeleteTransformerOutput{} out.Result = output - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - - body := io.TeeReader(response.Body, ringBuffer) - decoder := json.NewDecoder(body) - decoder.UseNumber() - var shape interface{} - if err := decoder.Decode(&shape); err != nil && err != io.EOF { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return out, metadata, err - } - - err = awsAwsjson11_deserializeOpDocumentDescribeDeliverySourcesOutput(&output, shape) - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return out, metadata, err - } + if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { + return out, metadata, &smithy.DeserializationError{ + Err: fmt.Errorf("failed to discard response body, %w", err), + } + } return out, metadata, err } -func awsAwsjson11_deserializeOpErrorDescribeDeliverySources(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorDeleteTransformer(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -3232,17 +3256,20 @@ func awsAwsjson11_deserializeOpErrorDescribeDeliverySources(response *smithyhttp errorMessage = bodyInfo.Message } switch { - case strings.EqualFold("ServiceQuotaExceededException", errorCode): - return awsAwsjson11_deserializeErrorServiceQuotaExceededException(response, errorBody) + case strings.EqualFold("InvalidOperationException", errorCode): + return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody) - case strings.EqualFold("ServiceUnavailableException", errorCode): - return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) + case strings.EqualFold("InvalidParameterException", errorCode): + return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) - case strings.EqualFold("ThrottlingException", errorCode): - return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) + case strings.EqualFold("OperationAbortedException", errorCode): + return awsAwsjson11_deserializeErrorOperationAbortedException(response, errorBody) - case strings.EqualFold("ValidationException", errorCode): - return awsAwsjson11_deserializeErrorValidationException(response, errorBody) + case strings.EqualFold("ResourceNotFoundException", errorCode): + return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) + + case strings.EqualFold("ServiceUnavailableException", errorCode): + return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) default: genericError := &smithy.GenericAPIError{ @@ -3254,14 +3281,14 @@ func awsAwsjson11_deserializeOpErrorDescribeDeliverySources(response *smithyhttp } } -type awsAwsjson11_deserializeOpDescribeDestinations struct { +type awsAwsjson11_deserializeOpDescribeAccountPolicies struct { } -func (*awsAwsjson11_deserializeOpDescribeDestinations) ID() string { +func (*awsAwsjson11_deserializeOpDescribeAccountPolicies) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpDescribeDestinations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpDescribeAccountPolicies) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -3279,9 +3306,9 @@ func (m *awsAwsjson11_deserializeOpDescribeDestinations) HandleDeserialize(ctx c } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorDescribeDestinations(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorDescribeAccountPolicies(response, &metadata) } - output := &DescribeDestinationsOutput{} + output := &DescribeAccountPoliciesOutput{} out.Result = output var buff [1024]byte @@ -3301,7 +3328,7 @@ func (m *awsAwsjson11_deserializeOpDescribeDestinations) HandleDeserialize(ctx c return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentDescribeDestinationsOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentDescribeAccountPoliciesOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -3315,7 +3342,7 @@ func (m *awsAwsjson11_deserializeOpDescribeDestinations) HandleDeserialize(ctx c return out, metadata, err } -func awsAwsjson11_deserializeOpErrorDescribeDestinations(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorDescribeAccountPolicies(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -3355,6 +3382,12 @@ func awsAwsjson11_deserializeOpErrorDescribeDestinations(response *smithyhttp.Re case strings.EqualFold("InvalidParameterException", errorCode): return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) + case strings.EqualFold("OperationAbortedException", errorCode): + return awsAwsjson11_deserializeErrorOperationAbortedException(response, errorBody) + + case strings.EqualFold("ResourceNotFoundException", errorCode): + return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) + case strings.EqualFold("ServiceUnavailableException", errorCode): return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) @@ -3368,14 +3401,14 @@ func awsAwsjson11_deserializeOpErrorDescribeDestinations(response *smithyhttp.Re } } -type awsAwsjson11_deserializeOpDescribeExportTasks struct { +type awsAwsjson11_deserializeOpDescribeConfigurationTemplates struct { } -func (*awsAwsjson11_deserializeOpDescribeExportTasks) ID() string { +func (*awsAwsjson11_deserializeOpDescribeConfigurationTemplates) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpDescribeExportTasks) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpDescribeConfigurationTemplates) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -3393,9 +3426,9 @@ func (m *awsAwsjson11_deserializeOpDescribeExportTasks) HandleDeserialize(ctx co } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorDescribeExportTasks(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorDescribeConfigurationTemplates(response, &metadata) } - output := &DescribeExportTasksOutput{} + output := &DescribeConfigurationTemplatesOutput{} out.Result = output var buff [1024]byte @@ -3415,7 +3448,7 @@ func (m *awsAwsjson11_deserializeOpDescribeExportTasks) HandleDeserialize(ctx co return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentDescribeExportTasksOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentDescribeConfigurationTemplatesOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -3429,7 +3462,7 @@ func (m *awsAwsjson11_deserializeOpDescribeExportTasks) HandleDeserialize(ctx co return out, metadata, err } -func awsAwsjson11_deserializeOpErrorDescribeExportTasks(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorDescribeConfigurationTemplates(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -3466,12 +3499,18 @@ func awsAwsjson11_deserializeOpErrorDescribeExportTasks(response *smithyhttp.Res errorMessage = bodyInfo.Message } switch { - case strings.EqualFold("InvalidParameterException", errorCode): - return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) + case strings.EqualFold("ResourceNotFoundException", errorCode): + return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) case strings.EqualFold("ServiceUnavailableException", errorCode): return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) + case strings.EqualFold("ThrottlingException", errorCode): + return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) + + case strings.EqualFold("ValidationException", errorCode): + return awsAwsjson11_deserializeErrorValidationException(response, errorBody) + default: genericError := &smithy.GenericAPIError{ Code: errorCode, @@ -3482,14 +3521,14 @@ func awsAwsjson11_deserializeOpErrorDescribeExportTasks(response *smithyhttp.Res } } -type awsAwsjson11_deserializeOpDescribeFieldIndexes struct { +type awsAwsjson11_deserializeOpDescribeDeliveries struct { } -func (*awsAwsjson11_deserializeOpDescribeFieldIndexes) ID() string { +func (*awsAwsjson11_deserializeOpDescribeDeliveries) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpDescribeFieldIndexes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpDescribeDeliveries) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -3507,9 +3546,9 @@ func (m *awsAwsjson11_deserializeOpDescribeFieldIndexes) HandleDeserialize(ctx c } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorDescribeFieldIndexes(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorDescribeDeliveries(response, &metadata) } - output := &DescribeFieldIndexesOutput{} + output := &DescribeDeliveriesOutput{} out.Result = output var buff [1024]byte @@ -3529,7 +3568,7 @@ func (m *awsAwsjson11_deserializeOpDescribeFieldIndexes) HandleDeserialize(ctx c return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentDescribeFieldIndexesOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentDescribeDeliveriesOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -3543,7 +3582,7 @@ func (m *awsAwsjson11_deserializeOpDescribeFieldIndexes) HandleDeserialize(ctx c return out, metadata, err } -func awsAwsjson11_deserializeOpErrorDescribeFieldIndexes(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorDescribeDeliveries(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -3580,21 +3619,18 @@ func awsAwsjson11_deserializeOpErrorDescribeFieldIndexes(response *smithyhttp.Re errorMessage = bodyInfo.Message } switch { - case strings.EqualFold("InvalidParameterException", errorCode): - return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) - - case strings.EqualFold("LimitExceededException", errorCode): - return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) - - case strings.EqualFold("OperationAbortedException", errorCode): - return awsAwsjson11_deserializeErrorOperationAbortedException(response, errorBody) - - case strings.EqualFold("ResourceNotFoundException", errorCode): - return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) + case strings.EqualFold("ServiceQuotaExceededException", errorCode): + return awsAwsjson11_deserializeErrorServiceQuotaExceededException(response, errorBody) case strings.EqualFold("ServiceUnavailableException", errorCode): return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) + case strings.EqualFold("ThrottlingException", errorCode): + return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) + + case strings.EqualFold("ValidationException", errorCode): + return awsAwsjson11_deserializeErrorValidationException(response, errorBody) + default: genericError := &smithy.GenericAPIError{ Code: errorCode, @@ -3605,14 +3641,14 @@ func awsAwsjson11_deserializeOpErrorDescribeFieldIndexes(response *smithyhttp.Re } } -type awsAwsjson11_deserializeOpDescribeIndexPolicies struct { +type awsAwsjson11_deserializeOpDescribeDeliveryDestinations struct { } -func (*awsAwsjson11_deserializeOpDescribeIndexPolicies) ID() string { +func (*awsAwsjson11_deserializeOpDescribeDeliveryDestinations) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpDescribeIndexPolicies) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpDescribeDeliveryDestinations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -3630,9 +3666,9 @@ func (m *awsAwsjson11_deserializeOpDescribeIndexPolicies) HandleDeserialize(ctx } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorDescribeIndexPolicies(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorDescribeDeliveryDestinations(response, &metadata) } - output := &DescribeIndexPoliciesOutput{} + output := &DescribeDeliveryDestinationsOutput{} out.Result = output var buff [1024]byte @@ -3652,7 +3688,7 @@ func (m *awsAwsjson11_deserializeOpDescribeIndexPolicies) HandleDeserialize(ctx return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentDescribeIndexPoliciesOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentDescribeDeliveryDestinationsOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -3666,7 +3702,7 @@ func (m *awsAwsjson11_deserializeOpDescribeIndexPolicies) HandleDeserialize(ctx return out, metadata, err } -func awsAwsjson11_deserializeOpErrorDescribeIndexPolicies(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorDescribeDeliveryDestinations(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -3703,21 +3739,18 @@ func awsAwsjson11_deserializeOpErrorDescribeIndexPolicies(response *smithyhttp.R errorMessage = bodyInfo.Message } switch { - case strings.EqualFold("InvalidParameterException", errorCode): - return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) - - case strings.EqualFold("LimitExceededException", errorCode): - return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) - - case strings.EqualFold("OperationAbortedException", errorCode): - return awsAwsjson11_deserializeErrorOperationAbortedException(response, errorBody) - - case strings.EqualFold("ResourceNotFoundException", errorCode): - return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) + case strings.EqualFold("ServiceQuotaExceededException", errorCode): + return awsAwsjson11_deserializeErrorServiceQuotaExceededException(response, errorBody) case strings.EqualFold("ServiceUnavailableException", errorCode): return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) + case strings.EqualFold("ThrottlingException", errorCode): + return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) + + case strings.EqualFold("ValidationException", errorCode): + return awsAwsjson11_deserializeErrorValidationException(response, errorBody) + default: genericError := &smithy.GenericAPIError{ Code: errorCode, @@ -3728,14 +3761,14 @@ func awsAwsjson11_deserializeOpErrorDescribeIndexPolicies(response *smithyhttp.R } } -type awsAwsjson11_deserializeOpDescribeLogGroups struct { +type awsAwsjson11_deserializeOpDescribeDeliverySources struct { } -func (*awsAwsjson11_deserializeOpDescribeLogGroups) ID() string { +func (*awsAwsjson11_deserializeOpDescribeDeliverySources) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpDescribeLogGroups) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpDescribeDeliverySources) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -3753,9 +3786,9 @@ func (m *awsAwsjson11_deserializeOpDescribeLogGroups) HandleDeserialize(ctx cont } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorDescribeLogGroups(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorDescribeDeliverySources(response, &metadata) } - output := &DescribeLogGroupsOutput{} + output := &DescribeDeliverySourcesOutput{} out.Result = output var buff [1024]byte @@ -3775,7 +3808,7 @@ func (m *awsAwsjson11_deserializeOpDescribeLogGroups) HandleDeserialize(ctx cont return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentDescribeLogGroupsOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentDescribeDeliverySourcesOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -3789,7 +3822,7 @@ func (m *awsAwsjson11_deserializeOpDescribeLogGroups) HandleDeserialize(ctx cont return out, metadata, err } -func awsAwsjson11_deserializeOpErrorDescribeLogGroups(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorDescribeDeliverySources(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -3826,12 +3859,18 @@ func awsAwsjson11_deserializeOpErrorDescribeLogGroups(response *smithyhttp.Respo errorMessage = bodyInfo.Message } switch { - case strings.EqualFold("InvalidParameterException", errorCode): - return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) + case strings.EqualFold("ServiceQuotaExceededException", errorCode): + return awsAwsjson11_deserializeErrorServiceQuotaExceededException(response, errorBody) case strings.EqualFold("ServiceUnavailableException", errorCode): return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) + case strings.EqualFold("ThrottlingException", errorCode): + return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) + + case strings.EqualFold("ValidationException", errorCode): + return awsAwsjson11_deserializeErrorValidationException(response, errorBody) + default: genericError := &smithy.GenericAPIError{ Code: errorCode, @@ -3842,14 +3881,14 @@ func awsAwsjson11_deserializeOpErrorDescribeLogGroups(response *smithyhttp.Respo } } -type awsAwsjson11_deserializeOpDescribeLogStreams struct { +type awsAwsjson11_deserializeOpDescribeDestinations struct { } -func (*awsAwsjson11_deserializeOpDescribeLogStreams) ID() string { +func (*awsAwsjson11_deserializeOpDescribeDestinations) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpDescribeLogStreams) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpDescribeDestinations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -3867,9 +3906,9 @@ func (m *awsAwsjson11_deserializeOpDescribeLogStreams) HandleDeserialize(ctx con } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorDescribeLogStreams(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorDescribeDestinations(response, &metadata) } - output := &DescribeLogStreamsOutput{} + output := &DescribeDestinationsOutput{} out.Result = output var buff [1024]byte @@ -3889,7 +3928,7 @@ func (m *awsAwsjson11_deserializeOpDescribeLogStreams) HandleDeserialize(ctx con return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentDescribeLogStreamsOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentDescribeDestinationsOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -3903,7 +3942,7 @@ func (m *awsAwsjson11_deserializeOpDescribeLogStreams) HandleDeserialize(ctx con return out, metadata, err } -func awsAwsjson11_deserializeOpErrorDescribeLogStreams(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorDescribeDestinations(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -3943,9 +3982,6 @@ func awsAwsjson11_deserializeOpErrorDescribeLogStreams(response *smithyhttp.Resp case strings.EqualFold("InvalidParameterException", errorCode): return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) - case strings.EqualFold("ResourceNotFoundException", errorCode): - return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) - case strings.EqualFold("ServiceUnavailableException", errorCode): return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) @@ -3959,14 +3995,14 @@ func awsAwsjson11_deserializeOpErrorDescribeLogStreams(response *smithyhttp.Resp } } -type awsAwsjson11_deserializeOpDescribeMetricFilters struct { +type awsAwsjson11_deserializeOpDescribeExportTasks struct { } -func (*awsAwsjson11_deserializeOpDescribeMetricFilters) ID() string { +func (*awsAwsjson11_deserializeOpDescribeExportTasks) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpDescribeMetricFilters) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpDescribeExportTasks) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -3984,9 +4020,9 @@ func (m *awsAwsjson11_deserializeOpDescribeMetricFilters) HandleDeserialize(ctx } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorDescribeMetricFilters(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorDescribeExportTasks(response, &metadata) } - output := &DescribeMetricFiltersOutput{} + output := &DescribeExportTasksOutput{} out.Result = output var buff [1024]byte @@ -4006,7 +4042,7 @@ func (m *awsAwsjson11_deserializeOpDescribeMetricFilters) HandleDeserialize(ctx return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentDescribeMetricFiltersOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentDescribeExportTasksOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -4020,7 +4056,7 @@ func (m *awsAwsjson11_deserializeOpDescribeMetricFilters) HandleDeserialize(ctx return out, metadata, err } -func awsAwsjson11_deserializeOpErrorDescribeMetricFilters(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorDescribeExportTasks(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -4060,9 +4096,6 @@ func awsAwsjson11_deserializeOpErrorDescribeMetricFilters(response *smithyhttp.R case strings.EqualFold("InvalidParameterException", errorCode): return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) - case strings.EqualFold("ResourceNotFoundException", errorCode): - return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) - case strings.EqualFold("ServiceUnavailableException", errorCode): return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) @@ -4076,14 +4109,14 @@ func awsAwsjson11_deserializeOpErrorDescribeMetricFilters(response *smithyhttp.R } } -type awsAwsjson11_deserializeOpDescribeQueries struct { +type awsAwsjson11_deserializeOpDescribeFieldIndexes struct { } -func (*awsAwsjson11_deserializeOpDescribeQueries) ID() string { +func (*awsAwsjson11_deserializeOpDescribeFieldIndexes) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpDescribeQueries) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpDescribeFieldIndexes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -4101,9 +4134,9 @@ func (m *awsAwsjson11_deserializeOpDescribeQueries) HandleDeserialize(ctx contex } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorDescribeQueries(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorDescribeFieldIndexes(response, &metadata) } - output := &DescribeQueriesOutput{} + output := &DescribeFieldIndexesOutput{} out.Result = output var buff [1024]byte @@ -4123,7 +4156,7 @@ func (m *awsAwsjson11_deserializeOpDescribeQueries) HandleDeserialize(ctx contex return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentDescribeQueriesOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentDescribeFieldIndexesOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -4137,7 +4170,7 @@ func (m *awsAwsjson11_deserializeOpDescribeQueries) HandleDeserialize(ctx contex return out, metadata, err } -func awsAwsjson11_deserializeOpErrorDescribeQueries(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorDescribeFieldIndexes(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -4177,6 +4210,12 @@ func awsAwsjson11_deserializeOpErrorDescribeQueries(response *smithyhttp.Respons case strings.EqualFold("InvalidParameterException", errorCode): return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) + case strings.EqualFold("LimitExceededException", errorCode): + return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) + + case strings.EqualFold("OperationAbortedException", errorCode): + return awsAwsjson11_deserializeErrorOperationAbortedException(response, errorBody) + case strings.EqualFold("ResourceNotFoundException", errorCode): return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) @@ -4193,14 +4232,14 @@ func awsAwsjson11_deserializeOpErrorDescribeQueries(response *smithyhttp.Respons } } -type awsAwsjson11_deserializeOpDescribeQueryDefinitions struct { +type awsAwsjson11_deserializeOpDescribeImportTaskBatches struct { } -func (*awsAwsjson11_deserializeOpDescribeQueryDefinitions) ID() string { +func (*awsAwsjson11_deserializeOpDescribeImportTaskBatches) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpDescribeQueryDefinitions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpDescribeImportTaskBatches) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -4218,9 +4257,9 @@ func (m *awsAwsjson11_deserializeOpDescribeQueryDefinitions) HandleDeserialize(c } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorDescribeQueryDefinitions(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorDescribeImportTaskBatches(response, &metadata) } - output := &DescribeQueryDefinitionsOutput{} + output := &DescribeImportTaskBatchesOutput{} out.Result = output var buff [1024]byte @@ -4240,7 +4279,7 @@ func (m *awsAwsjson11_deserializeOpDescribeQueryDefinitions) HandleDeserialize(c return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentDescribeQueryDefinitionsOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentDescribeImportTaskBatchesOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -4254,7 +4293,7 @@ func (m *awsAwsjson11_deserializeOpDescribeQueryDefinitions) HandleDeserialize(c return out, metadata, err } -func awsAwsjson11_deserializeOpErrorDescribeQueryDefinitions(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorDescribeImportTaskBatches(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -4291,11 +4330,20 @@ func awsAwsjson11_deserializeOpErrorDescribeQueryDefinitions(response *smithyhtt errorMessage = bodyInfo.Message } switch { + case strings.EqualFold("AccessDeniedException", errorCode): + return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) + + case strings.EqualFold("InvalidOperationException", errorCode): + return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody) + case strings.EqualFold("InvalidParameterException", errorCode): return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) - case strings.EqualFold("ServiceUnavailableException", errorCode): - return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) + case strings.EqualFold("ResourceNotFoundException", errorCode): + return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) + + case strings.EqualFold("ThrottlingException", errorCode): + return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) default: genericError := &smithy.GenericAPIError{ @@ -4307,14 +4355,14 @@ func awsAwsjson11_deserializeOpErrorDescribeQueryDefinitions(response *smithyhtt } } -type awsAwsjson11_deserializeOpDescribeResourcePolicies struct { +type awsAwsjson11_deserializeOpDescribeImportTasks struct { } -func (*awsAwsjson11_deserializeOpDescribeResourcePolicies) ID() string { +func (*awsAwsjson11_deserializeOpDescribeImportTasks) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpDescribeResourcePolicies) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpDescribeImportTasks) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -4332,9 +4380,9 @@ func (m *awsAwsjson11_deserializeOpDescribeResourcePolicies) HandleDeserialize(c } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorDescribeResourcePolicies(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorDescribeImportTasks(response, &metadata) } - output := &DescribeResourcePoliciesOutput{} + output := &DescribeImportTasksOutput{} out.Result = output var buff [1024]byte @@ -4354,7 +4402,7 @@ func (m *awsAwsjson11_deserializeOpDescribeResourcePolicies) HandleDeserialize(c return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentDescribeResourcePoliciesOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentDescribeImportTasksOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -4368,7 +4416,7 @@ func (m *awsAwsjson11_deserializeOpDescribeResourcePolicies) HandleDeserialize(c return out, metadata, err } -func awsAwsjson11_deserializeOpErrorDescribeResourcePolicies(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorDescribeImportTasks(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -4405,11 +4453,20 @@ func awsAwsjson11_deserializeOpErrorDescribeResourcePolicies(response *smithyhtt errorMessage = bodyInfo.Message } switch { - case strings.EqualFold("InvalidParameterException", errorCode): - return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) + case strings.EqualFold("AccessDeniedException", errorCode): + return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) - case strings.EqualFold("ServiceUnavailableException", errorCode): - return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) + case strings.EqualFold("InvalidOperationException", errorCode): + return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody) + + case strings.EqualFold("InvalidParameterException", errorCode): + return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) + + case strings.EqualFold("ResourceNotFoundException", errorCode): + return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) + + case strings.EqualFold("ThrottlingException", errorCode): + return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) default: genericError := &smithy.GenericAPIError{ @@ -4421,14 +4478,14 @@ func awsAwsjson11_deserializeOpErrorDescribeResourcePolicies(response *smithyhtt } } -type awsAwsjson11_deserializeOpDescribeSubscriptionFilters struct { +type awsAwsjson11_deserializeOpDescribeIndexPolicies struct { } -func (*awsAwsjson11_deserializeOpDescribeSubscriptionFilters) ID() string { +func (*awsAwsjson11_deserializeOpDescribeIndexPolicies) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpDescribeSubscriptionFilters) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpDescribeIndexPolicies) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -4446,9 +4503,9 @@ func (m *awsAwsjson11_deserializeOpDescribeSubscriptionFilters) HandleDeserializ } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorDescribeSubscriptionFilters(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorDescribeIndexPolicies(response, &metadata) } - output := &DescribeSubscriptionFiltersOutput{} + output := &DescribeIndexPoliciesOutput{} out.Result = output var buff [1024]byte @@ -4468,7 +4525,7 @@ func (m *awsAwsjson11_deserializeOpDescribeSubscriptionFilters) HandleDeserializ return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentDescribeSubscriptionFiltersOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentDescribeIndexPoliciesOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -4482,7 +4539,7 @@ func (m *awsAwsjson11_deserializeOpDescribeSubscriptionFilters) HandleDeserializ return out, metadata, err } -func awsAwsjson11_deserializeOpErrorDescribeSubscriptionFilters(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorDescribeIndexPolicies(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -4522,6 +4579,12 @@ func awsAwsjson11_deserializeOpErrorDescribeSubscriptionFilters(response *smithy case strings.EqualFold("InvalidParameterException", errorCode): return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) + case strings.EqualFold("LimitExceededException", errorCode): + return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) + + case strings.EqualFold("OperationAbortedException", errorCode): + return awsAwsjson11_deserializeErrorOperationAbortedException(response, errorBody) + case strings.EqualFold("ResourceNotFoundException", errorCode): return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) @@ -4538,14 +4601,14 @@ func awsAwsjson11_deserializeOpErrorDescribeSubscriptionFilters(response *smithy } } -type awsAwsjson11_deserializeOpDisassociateKmsKey struct { +type awsAwsjson11_deserializeOpDescribeLogGroups struct { } -func (*awsAwsjson11_deserializeOpDisassociateKmsKey) ID() string { +func (*awsAwsjson11_deserializeOpDescribeLogGroups) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpDisassociateKmsKey) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpDescribeLogGroups) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -4563,21 +4626,43 @@ func (m *awsAwsjson11_deserializeOpDisassociateKmsKey) HandleDeserialize(ctx con } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorDisassociateKmsKey(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorDescribeLogGroups(response, &metadata) } - output := &DisassociateKmsKeyOutput{} + output := &DescribeLogGroupsOutput{} out.Result = output - if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { - return out, metadata, &smithy.DeserializationError{ - Err: fmt.Errorf("failed to discard response body, %w", err), + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(response.Body, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + var shape interface{} + if err := decoder.Decode(&shape); err != nil && err != io.EOF { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return out, metadata, err + } + + err = awsAwsjson11_deserializeOpDocumentDescribeLogGroupsOutput(&output, shape) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), } + return out, metadata, err } return out, metadata, err } -func awsAwsjson11_deserializeOpErrorDisassociateKmsKey(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorDescribeLogGroups(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -4617,12 +4702,6 @@ func awsAwsjson11_deserializeOpErrorDisassociateKmsKey(response *smithyhttp.Resp case strings.EqualFold("InvalidParameterException", errorCode): return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) - case strings.EqualFold("OperationAbortedException", errorCode): - return awsAwsjson11_deserializeErrorOperationAbortedException(response, errorBody) - - case strings.EqualFold("ResourceNotFoundException", errorCode): - return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) - case strings.EqualFold("ServiceUnavailableException", errorCode): return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) @@ -4636,14 +4715,14 @@ func awsAwsjson11_deserializeOpErrorDisassociateKmsKey(response *smithyhttp.Resp } } -type awsAwsjson11_deserializeOpFilterLogEvents struct { +type awsAwsjson11_deserializeOpDescribeLogStreams struct { } -func (*awsAwsjson11_deserializeOpFilterLogEvents) ID() string { +func (*awsAwsjson11_deserializeOpDescribeLogStreams) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpFilterLogEvents) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpDescribeLogStreams) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -4661,9 +4740,9 @@ func (m *awsAwsjson11_deserializeOpFilterLogEvents) HandleDeserialize(ctx contex } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorFilterLogEvents(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorDescribeLogStreams(response, &metadata) } - output := &FilterLogEventsOutput{} + output := &DescribeLogStreamsOutput{} out.Result = output var buff [1024]byte @@ -4683,7 +4762,7 @@ func (m *awsAwsjson11_deserializeOpFilterLogEvents) HandleDeserialize(ctx contex return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentFilterLogEventsOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentDescribeLogStreamsOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -4697,7 +4776,7 @@ func (m *awsAwsjson11_deserializeOpFilterLogEvents) HandleDeserialize(ctx contex return out, metadata, err } -func awsAwsjson11_deserializeOpErrorFilterLogEvents(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorDescribeLogStreams(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -4753,14 +4832,14 @@ func awsAwsjson11_deserializeOpErrorFilterLogEvents(response *smithyhttp.Respons } } -type awsAwsjson11_deserializeOpGetDataProtectionPolicy struct { +type awsAwsjson11_deserializeOpDescribeMetricFilters struct { } -func (*awsAwsjson11_deserializeOpGetDataProtectionPolicy) ID() string { +func (*awsAwsjson11_deserializeOpDescribeMetricFilters) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpGetDataProtectionPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpDescribeMetricFilters) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -4778,9 +4857,9 @@ func (m *awsAwsjson11_deserializeOpGetDataProtectionPolicy) HandleDeserialize(ct } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorGetDataProtectionPolicy(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorDescribeMetricFilters(response, &metadata) } - output := &GetDataProtectionPolicyOutput{} + output := &DescribeMetricFiltersOutput{} out.Result = output var buff [1024]byte @@ -4800,7 +4879,7 @@ func (m *awsAwsjson11_deserializeOpGetDataProtectionPolicy) HandleDeserialize(ct return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentGetDataProtectionPolicyOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentDescribeMetricFiltersOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -4814,7 +4893,7 @@ func (m *awsAwsjson11_deserializeOpGetDataProtectionPolicy) HandleDeserialize(ct return out, metadata, err } -func awsAwsjson11_deserializeOpErrorGetDataProtectionPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorDescribeMetricFilters(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -4854,9 +4933,6 @@ func awsAwsjson11_deserializeOpErrorGetDataProtectionPolicy(response *smithyhttp case strings.EqualFold("InvalidParameterException", errorCode): return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) - case strings.EqualFold("OperationAbortedException", errorCode): - return awsAwsjson11_deserializeErrorOperationAbortedException(response, errorBody) - case strings.EqualFold("ResourceNotFoundException", errorCode): return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) @@ -4873,14 +4949,14 @@ func awsAwsjson11_deserializeOpErrorGetDataProtectionPolicy(response *smithyhttp } } -type awsAwsjson11_deserializeOpGetDelivery struct { +type awsAwsjson11_deserializeOpDescribeQueries struct { } -func (*awsAwsjson11_deserializeOpGetDelivery) ID() string { +func (*awsAwsjson11_deserializeOpDescribeQueries) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpGetDelivery) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpDescribeQueries) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -4898,9 +4974,9 @@ func (m *awsAwsjson11_deserializeOpGetDelivery) HandleDeserialize(ctx context.Co } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorGetDelivery(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorDescribeQueries(response, &metadata) } - output := &GetDeliveryOutput{} + output := &DescribeQueriesOutput{} out.Result = output var buff [1024]byte @@ -4920,7 +4996,7 @@ func (m *awsAwsjson11_deserializeOpGetDelivery) HandleDeserialize(ctx context.Co return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentGetDeliveryOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentDescribeQueriesOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -4934,7 +5010,7 @@ func (m *awsAwsjson11_deserializeOpGetDelivery) HandleDeserialize(ctx context.Co return out, metadata, err } -func awsAwsjson11_deserializeOpErrorGetDelivery(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorDescribeQueries(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -4971,21 +5047,15 @@ func awsAwsjson11_deserializeOpErrorGetDelivery(response *smithyhttp.Response, m errorMessage = bodyInfo.Message } switch { + case strings.EqualFold("InvalidParameterException", errorCode): + return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) + case strings.EqualFold("ResourceNotFoundException", errorCode): return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) - case strings.EqualFold("ServiceQuotaExceededException", errorCode): - return awsAwsjson11_deserializeErrorServiceQuotaExceededException(response, errorBody) - case strings.EqualFold("ServiceUnavailableException", errorCode): return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) - case strings.EqualFold("ThrottlingException", errorCode): - return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) - - case strings.EqualFold("ValidationException", errorCode): - return awsAwsjson11_deserializeErrorValidationException(response, errorBody) - default: genericError := &smithy.GenericAPIError{ Code: errorCode, @@ -4996,14 +5066,14 @@ func awsAwsjson11_deserializeOpErrorGetDelivery(response *smithyhttp.Response, m } } -type awsAwsjson11_deserializeOpGetDeliveryDestination struct { +type awsAwsjson11_deserializeOpDescribeQueryDefinitions struct { } -func (*awsAwsjson11_deserializeOpGetDeliveryDestination) ID() string { +func (*awsAwsjson11_deserializeOpDescribeQueryDefinitions) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpGetDeliveryDestination) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpDescribeQueryDefinitions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -5021,9 +5091,9 @@ func (m *awsAwsjson11_deserializeOpGetDeliveryDestination) HandleDeserialize(ctx } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorGetDeliveryDestination(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorDescribeQueryDefinitions(response, &metadata) } - output := &GetDeliveryDestinationOutput{} + output := &DescribeQueryDefinitionsOutput{} out.Result = output var buff [1024]byte @@ -5043,7 +5113,7 @@ func (m *awsAwsjson11_deserializeOpGetDeliveryDestination) HandleDeserialize(ctx return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentGetDeliveryDestinationOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentDescribeQueryDefinitionsOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -5057,7 +5127,7 @@ func (m *awsAwsjson11_deserializeOpGetDeliveryDestination) HandleDeserialize(ctx return out, metadata, err } -func awsAwsjson11_deserializeOpErrorGetDeliveryDestination(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorDescribeQueryDefinitions(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -5094,21 +5164,12 @@ func awsAwsjson11_deserializeOpErrorGetDeliveryDestination(response *smithyhttp. errorMessage = bodyInfo.Message } switch { - case strings.EqualFold("ResourceNotFoundException", errorCode): - return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) - - case strings.EqualFold("ServiceQuotaExceededException", errorCode): - return awsAwsjson11_deserializeErrorServiceQuotaExceededException(response, errorBody) + case strings.EqualFold("InvalidParameterException", errorCode): + return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) case strings.EqualFold("ServiceUnavailableException", errorCode): return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) - case strings.EqualFold("ThrottlingException", errorCode): - return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) - - case strings.EqualFold("ValidationException", errorCode): - return awsAwsjson11_deserializeErrorValidationException(response, errorBody) - default: genericError := &smithy.GenericAPIError{ Code: errorCode, @@ -5119,14 +5180,14 @@ func awsAwsjson11_deserializeOpErrorGetDeliveryDestination(response *smithyhttp. } } -type awsAwsjson11_deserializeOpGetDeliveryDestinationPolicy struct { +type awsAwsjson11_deserializeOpDescribeResourcePolicies struct { } -func (*awsAwsjson11_deserializeOpGetDeliveryDestinationPolicy) ID() string { +func (*awsAwsjson11_deserializeOpDescribeResourcePolicies) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpGetDeliveryDestinationPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpDescribeResourcePolicies) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -5144,9 +5205,9 @@ func (m *awsAwsjson11_deserializeOpGetDeliveryDestinationPolicy) HandleDeseriali } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorGetDeliveryDestinationPolicy(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorDescribeResourcePolicies(response, &metadata) } - output := &GetDeliveryDestinationPolicyOutput{} + output := &DescribeResourcePoliciesOutput{} out.Result = output var buff [1024]byte @@ -5166,7 +5227,7 @@ func (m *awsAwsjson11_deserializeOpGetDeliveryDestinationPolicy) HandleDeseriali return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentGetDeliveryDestinationPolicyOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentDescribeResourcePoliciesOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -5180,7 +5241,7 @@ func (m *awsAwsjson11_deserializeOpGetDeliveryDestinationPolicy) HandleDeseriali return out, metadata, err } -func awsAwsjson11_deserializeOpErrorGetDeliveryDestinationPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorDescribeResourcePolicies(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -5217,15 +5278,12 @@ func awsAwsjson11_deserializeOpErrorGetDeliveryDestinationPolicy(response *smith errorMessage = bodyInfo.Message } switch { - case strings.EqualFold("ResourceNotFoundException", errorCode): - return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) + case strings.EqualFold("InvalidParameterException", errorCode): + return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) case strings.EqualFold("ServiceUnavailableException", errorCode): return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) - case strings.EqualFold("ValidationException", errorCode): - return awsAwsjson11_deserializeErrorValidationException(response, errorBody) - default: genericError := &smithy.GenericAPIError{ Code: errorCode, @@ -5236,14 +5294,14 @@ func awsAwsjson11_deserializeOpErrorGetDeliveryDestinationPolicy(response *smith } } -type awsAwsjson11_deserializeOpGetDeliverySource struct { +type awsAwsjson11_deserializeOpDescribeSubscriptionFilters struct { } -func (*awsAwsjson11_deserializeOpGetDeliverySource) ID() string { +func (*awsAwsjson11_deserializeOpDescribeSubscriptionFilters) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpGetDeliverySource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpDescribeSubscriptionFilters) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -5261,9 +5319,9 @@ func (m *awsAwsjson11_deserializeOpGetDeliverySource) HandleDeserialize(ctx cont } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorGetDeliverySource(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorDescribeSubscriptionFilters(response, &metadata) } - output := &GetDeliverySourceOutput{} + output := &DescribeSubscriptionFiltersOutput{} out.Result = output var buff [1024]byte @@ -5283,7 +5341,7 @@ func (m *awsAwsjson11_deserializeOpGetDeliverySource) HandleDeserialize(ctx cont return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentGetDeliverySourceOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentDescribeSubscriptionFiltersOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -5297,7 +5355,7 @@ func (m *awsAwsjson11_deserializeOpGetDeliverySource) HandleDeserialize(ctx cont return out, metadata, err } -func awsAwsjson11_deserializeOpErrorGetDeliverySource(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorDescribeSubscriptionFilters(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -5334,21 +5392,15 @@ func awsAwsjson11_deserializeOpErrorGetDeliverySource(response *smithyhttp.Respo errorMessage = bodyInfo.Message } switch { + case strings.EqualFold("InvalidParameterException", errorCode): + return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) + case strings.EqualFold("ResourceNotFoundException", errorCode): return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) - case strings.EqualFold("ServiceQuotaExceededException", errorCode): - return awsAwsjson11_deserializeErrorServiceQuotaExceededException(response, errorBody) - case strings.EqualFold("ServiceUnavailableException", errorCode): return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) - case strings.EqualFold("ThrottlingException", errorCode): - return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) - - case strings.EqualFold("ValidationException", errorCode): - return awsAwsjson11_deserializeErrorValidationException(response, errorBody) - default: genericError := &smithy.GenericAPIError{ Code: errorCode, @@ -5359,14 +5411,14 @@ func awsAwsjson11_deserializeOpErrorGetDeliverySource(response *smithyhttp.Respo } } -type awsAwsjson11_deserializeOpGetIntegration struct { +type awsAwsjson11_deserializeOpDisassociateKmsKey struct { } -func (*awsAwsjson11_deserializeOpGetIntegration) ID() string { +func (*awsAwsjson11_deserializeOpDisassociateKmsKey) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpGetIntegration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpDisassociateKmsKey) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -5384,43 +5436,21 @@ func (m *awsAwsjson11_deserializeOpGetIntegration) HandleDeserialize(ctx context } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorGetIntegration(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorDisassociateKmsKey(response, &metadata) } - output := &GetIntegrationOutput{} + output := &DisassociateKmsKeyOutput{} out.Result = output - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - - body := io.TeeReader(response.Body, ringBuffer) - decoder := json.NewDecoder(body) - decoder.UseNumber() - var shape interface{} - if err := decoder.Decode(&shape); err != nil && err != io.EOF { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return out, metadata, err - } - - err = awsAwsjson11_deserializeOpDocumentGetIntegrationOutput(&output, shape) - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), + if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { + return out, metadata, &smithy.DeserializationError{ + Err: fmt.Errorf("failed to discard response body, %w", err), } - return out, metadata, err } return out, metadata, err } -func awsAwsjson11_deserializeOpErrorGetIntegration(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorDisassociateKmsKey(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -5460,6 +5490,9 @@ func awsAwsjson11_deserializeOpErrorGetIntegration(response *smithyhttp.Response case strings.EqualFold("InvalidParameterException", errorCode): return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) + case strings.EqualFold("OperationAbortedException", errorCode): + return awsAwsjson11_deserializeErrorOperationAbortedException(response, errorBody) + case strings.EqualFold("ResourceNotFoundException", errorCode): return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) @@ -5476,14 +5509,14 @@ func awsAwsjson11_deserializeOpErrorGetIntegration(response *smithyhttp.Response } } -type awsAwsjson11_deserializeOpGetLogAnomalyDetector struct { +type awsAwsjson11_deserializeOpDisassociateSourceFromS3TableIntegration struct { } -func (*awsAwsjson11_deserializeOpGetLogAnomalyDetector) ID() string { +func (*awsAwsjson11_deserializeOpDisassociateSourceFromS3TableIntegration) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpGetLogAnomalyDetector) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpDisassociateSourceFromS3TableIntegration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -5501,9 +5534,9 @@ func (m *awsAwsjson11_deserializeOpGetLogAnomalyDetector) HandleDeserialize(ctx } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorGetLogAnomalyDetector(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorDisassociateSourceFromS3TableIntegration(response, &metadata) } - output := &GetLogAnomalyDetectorOutput{} + output := &DisassociateSourceFromS3TableIntegrationOutput{} out.Result = output var buff [1024]byte @@ -5523,7 +5556,7 @@ func (m *awsAwsjson11_deserializeOpGetLogAnomalyDetector) HandleDeserialize(ctx return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentGetLogAnomalyDetectorOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentDisassociateSourceFromS3TableIntegrationOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -5537,7 +5570,7 @@ func (m *awsAwsjson11_deserializeOpGetLogAnomalyDetector) HandleDeserialize(ctx return out, metadata, err } -func awsAwsjson11_deserializeOpErrorGetLogAnomalyDetector(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorDisassociateSourceFromS3TableIntegration(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -5574,17 +5607,20 @@ func awsAwsjson11_deserializeOpErrorGetLogAnomalyDetector(response *smithyhttp.R errorMessage = bodyInfo.Message } switch { - case strings.EqualFold("InvalidParameterException", errorCode): - return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) + case strings.EqualFold("AccessDeniedException", errorCode): + return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) - case strings.EqualFold("OperationAbortedException", errorCode): - return awsAwsjson11_deserializeErrorOperationAbortedException(response, errorBody) + case strings.EqualFold("InternalServerException", errorCode): + return awsAwsjson11_deserializeErrorInternalServerException(response, errorBody) case strings.EqualFold("ResourceNotFoundException", errorCode): return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) - case strings.EqualFold("ServiceUnavailableException", errorCode): - return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) + case strings.EqualFold("ThrottlingException", errorCode): + return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) + + case strings.EqualFold("ValidationException", errorCode): + return awsAwsjson11_deserializeErrorValidationException(response, errorBody) default: genericError := &smithy.GenericAPIError{ @@ -5596,14 +5632,14 @@ func awsAwsjson11_deserializeOpErrorGetLogAnomalyDetector(response *smithyhttp.R } } -type awsAwsjson11_deserializeOpGetLogEvents struct { +type awsAwsjson11_deserializeOpFilterLogEvents struct { } -func (*awsAwsjson11_deserializeOpGetLogEvents) ID() string { +func (*awsAwsjson11_deserializeOpFilterLogEvents) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpGetLogEvents) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpFilterLogEvents) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -5621,9 +5657,9 @@ func (m *awsAwsjson11_deserializeOpGetLogEvents) HandleDeserialize(ctx context.C } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorGetLogEvents(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorFilterLogEvents(response, &metadata) } - output := &GetLogEventsOutput{} + output := &FilterLogEventsOutput{} out.Result = output var buff [1024]byte @@ -5643,7 +5679,7 @@ func (m *awsAwsjson11_deserializeOpGetLogEvents) HandleDeserialize(ctx context.C return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentGetLogEventsOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentFilterLogEventsOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -5657,7 +5693,7 @@ func (m *awsAwsjson11_deserializeOpGetLogEvents) HandleDeserialize(ctx context.C return out, metadata, err } -func awsAwsjson11_deserializeOpErrorGetLogEvents(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorFilterLogEvents(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -5713,14 +5749,14 @@ func awsAwsjson11_deserializeOpErrorGetLogEvents(response *smithyhttp.Response, } } -type awsAwsjson11_deserializeOpGetLogGroupFields struct { +type awsAwsjson11_deserializeOpGetDataProtectionPolicy struct { } -func (*awsAwsjson11_deserializeOpGetLogGroupFields) ID() string { +func (*awsAwsjson11_deserializeOpGetDataProtectionPolicy) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpGetLogGroupFields) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpGetDataProtectionPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -5738,9 +5774,9 @@ func (m *awsAwsjson11_deserializeOpGetLogGroupFields) HandleDeserialize(ctx cont } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorGetLogGroupFields(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorGetDataProtectionPolicy(response, &metadata) } - output := &GetLogGroupFieldsOutput{} + output := &GetDataProtectionPolicyOutput{} out.Result = output var buff [1024]byte @@ -5760,7 +5796,7 @@ func (m *awsAwsjson11_deserializeOpGetLogGroupFields) HandleDeserialize(ctx cont return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentGetLogGroupFieldsOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentGetDataProtectionPolicyOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -5774,7 +5810,7 @@ func (m *awsAwsjson11_deserializeOpGetLogGroupFields) HandleDeserialize(ctx cont return out, metadata, err } -func awsAwsjson11_deserializeOpErrorGetLogGroupFields(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorGetDataProtectionPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -5814,8 +5850,8 @@ func awsAwsjson11_deserializeOpErrorGetLogGroupFields(response *smithyhttp.Respo case strings.EqualFold("InvalidParameterException", errorCode): return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) - case strings.EqualFold("LimitExceededException", errorCode): - return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) + case strings.EqualFold("OperationAbortedException", errorCode): + return awsAwsjson11_deserializeErrorOperationAbortedException(response, errorBody) case strings.EqualFold("ResourceNotFoundException", errorCode): return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) @@ -5833,14 +5869,14 @@ func awsAwsjson11_deserializeOpErrorGetLogGroupFields(response *smithyhttp.Respo } } -type awsAwsjson11_deserializeOpGetLogRecord struct { +type awsAwsjson11_deserializeOpGetDelivery struct { } -func (*awsAwsjson11_deserializeOpGetLogRecord) ID() string { +func (*awsAwsjson11_deserializeOpGetDelivery) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpGetLogRecord) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpGetDelivery) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -5858,9 +5894,9 @@ func (m *awsAwsjson11_deserializeOpGetLogRecord) HandleDeserialize(ctx context.C } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorGetLogRecord(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorGetDelivery(response, &metadata) } - output := &GetLogRecordOutput{} + output := &GetDeliveryOutput{} out.Result = output var buff [1024]byte @@ -5880,7 +5916,7 @@ func (m *awsAwsjson11_deserializeOpGetLogRecord) HandleDeserialize(ctx context.C return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentGetLogRecordOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentGetDeliveryOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -5894,7 +5930,7 @@ func (m *awsAwsjson11_deserializeOpGetLogRecord) HandleDeserialize(ctx context.C return out, metadata, err } -func awsAwsjson11_deserializeOpErrorGetLogRecord(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorGetDelivery(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -5931,18 +5967,21 @@ func awsAwsjson11_deserializeOpErrorGetLogRecord(response *smithyhttp.Response, errorMessage = bodyInfo.Message } switch { - case strings.EqualFold("InvalidParameterException", errorCode): - return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) - - case strings.EqualFold("LimitExceededException", errorCode): - return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) - case strings.EqualFold("ResourceNotFoundException", errorCode): return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) + case strings.EqualFold("ServiceQuotaExceededException", errorCode): + return awsAwsjson11_deserializeErrorServiceQuotaExceededException(response, errorBody) + case strings.EqualFold("ServiceUnavailableException", errorCode): return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) + case strings.EqualFold("ThrottlingException", errorCode): + return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) + + case strings.EqualFold("ValidationException", errorCode): + return awsAwsjson11_deserializeErrorValidationException(response, errorBody) + default: genericError := &smithy.GenericAPIError{ Code: errorCode, @@ -5953,14 +5992,14 @@ func awsAwsjson11_deserializeOpErrorGetLogRecord(response *smithyhttp.Response, } } -type awsAwsjson11_deserializeOpGetQueryResults struct { +type awsAwsjson11_deserializeOpGetDeliveryDestination struct { } -func (*awsAwsjson11_deserializeOpGetQueryResults) ID() string { +func (*awsAwsjson11_deserializeOpGetDeliveryDestination) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpGetQueryResults) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpGetDeliveryDestination) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -5978,9 +6017,9 @@ func (m *awsAwsjson11_deserializeOpGetQueryResults) HandleDeserialize(ctx contex } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorGetQueryResults(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorGetDeliveryDestination(response, &metadata) } - output := &GetQueryResultsOutput{} + output := &GetDeliveryDestinationOutput{} out.Result = output var buff [1024]byte @@ -6000,7 +6039,7 @@ func (m *awsAwsjson11_deserializeOpGetQueryResults) HandleDeserialize(ctx contex return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentGetQueryResultsOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentGetDeliveryDestinationOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -6014,7 +6053,7 @@ func (m *awsAwsjson11_deserializeOpGetQueryResults) HandleDeserialize(ctx contex return out, metadata, err } -func awsAwsjson11_deserializeOpErrorGetQueryResults(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorGetDeliveryDestination(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -6051,15 +6090,21 @@ func awsAwsjson11_deserializeOpErrorGetQueryResults(response *smithyhttp.Respons errorMessage = bodyInfo.Message } switch { - case strings.EqualFold("InvalidParameterException", errorCode): - return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) - case strings.EqualFold("ResourceNotFoundException", errorCode): return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) + case strings.EqualFold("ServiceQuotaExceededException", errorCode): + return awsAwsjson11_deserializeErrorServiceQuotaExceededException(response, errorBody) + case strings.EqualFold("ServiceUnavailableException", errorCode): return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) + case strings.EqualFold("ThrottlingException", errorCode): + return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) + + case strings.EqualFold("ValidationException", errorCode): + return awsAwsjson11_deserializeErrorValidationException(response, errorBody) + default: genericError := &smithy.GenericAPIError{ Code: errorCode, @@ -6070,14 +6115,14 @@ func awsAwsjson11_deserializeOpErrorGetQueryResults(response *smithyhttp.Respons } } -type awsAwsjson11_deserializeOpGetTransformer struct { +type awsAwsjson11_deserializeOpGetDeliveryDestinationPolicy struct { } -func (*awsAwsjson11_deserializeOpGetTransformer) ID() string { +func (*awsAwsjson11_deserializeOpGetDeliveryDestinationPolicy) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpGetTransformer) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpGetDeliveryDestinationPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -6095,9 +6140,9 @@ func (m *awsAwsjson11_deserializeOpGetTransformer) HandleDeserialize(ctx context } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorGetTransformer(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorGetDeliveryDestinationPolicy(response, &metadata) } - output := &GetTransformerOutput{} + output := &GetDeliveryDestinationPolicyOutput{} out.Result = output var buff [1024]byte @@ -6117,7 +6162,7 @@ func (m *awsAwsjson11_deserializeOpGetTransformer) HandleDeserialize(ctx context return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentGetTransformerOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentGetDeliveryDestinationPolicyOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -6131,7 +6176,7 @@ func (m *awsAwsjson11_deserializeOpGetTransformer) HandleDeserialize(ctx context return out, metadata, err } -func awsAwsjson11_deserializeOpErrorGetTransformer(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorGetDeliveryDestinationPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -6168,18 +6213,15 @@ func awsAwsjson11_deserializeOpErrorGetTransformer(response *smithyhttp.Response errorMessage = bodyInfo.Message } switch { - case strings.EqualFold("InvalidOperationException", errorCode): - return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody) - - case strings.EqualFold("InvalidParameterException", errorCode): - return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) - case strings.EqualFold("ResourceNotFoundException", errorCode): return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) case strings.EqualFold("ServiceUnavailableException", errorCode): return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) + case strings.EqualFold("ValidationException", errorCode): + return awsAwsjson11_deserializeErrorValidationException(response, errorBody) + default: genericError := &smithy.GenericAPIError{ Code: errorCode, @@ -6190,14 +6232,14 @@ func awsAwsjson11_deserializeOpErrorGetTransformer(response *smithyhttp.Response } } -type awsAwsjson11_deserializeOpListAnomalies struct { +type awsAwsjson11_deserializeOpGetDeliverySource struct { } -func (*awsAwsjson11_deserializeOpListAnomalies) ID() string { +func (*awsAwsjson11_deserializeOpGetDeliverySource) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpListAnomalies) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpGetDeliverySource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -6215,9 +6257,9 @@ func (m *awsAwsjson11_deserializeOpListAnomalies) HandleDeserialize(ctx context. } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorListAnomalies(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorGetDeliverySource(response, &metadata) } - output := &ListAnomaliesOutput{} + output := &GetDeliverySourceOutput{} out.Result = output var buff [1024]byte @@ -6237,7 +6279,7 @@ func (m *awsAwsjson11_deserializeOpListAnomalies) HandleDeserialize(ctx context. return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentListAnomaliesOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentGetDeliverySourceOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -6251,7 +6293,7 @@ func (m *awsAwsjson11_deserializeOpListAnomalies) HandleDeserialize(ctx context. return out, metadata, err } -func awsAwsjson11_deserializeOpErrorListAnomalies(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorGetDeliverySource(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -6288,18 +6330,21 @@ func awsAwsjson11_deserializeOpErrorListAnomalies(response *smithyhttp.Response, errorMessage = bodyInfo.Message } switch { - case strings.EqualFold("InvalidParameterException", errorCode): - return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) - - case strings.EqualFold("OperationAbortedException", errorCode): - return awsAwsjson11_deserializeErrorOperationAbortedException(response, errorBody) - case strings.EqualFold("ResourceNotFoundException", errorCode): return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) + case strings.EqualFold("ServiceQuotaExceededException", errorCode): + return awsAwsjson11_deserializeErrorServiceQuotaExceededException(response, errorBody) + case strings.EqualFold("ServiceUnavailableException", errorCode): return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) + case strings.EqualFold("ThrottlingException", errorCode): + return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) + + case strings.EqualFold("ValidationException", errorCode): + return awsAwsjson11_deserializeErrorValidationException(response, errorBody) + default: genericError := &smithy.GenericAPIError{ Code: errorCode, @@ -6310,14 +6355,14 @@ func awsAwsjson11_deserializeOpErrorListAnomalies(response *smithyhttp.Response, } } -type awsAwsjson11_deserializeOpListIntegrations struct { +type awsAwsjson11_deserializeOpGetIntegration struct { } -func (*awsAwsjson11_deserializeOpListIntegrations) ID() string { +func (*awsAwsjson11_deserializeOpGetIntegration) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpListIntegrations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpGetIntegration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -6335,9 +6380,9 @@ func (m *awsAwsjson11_deserializeOpListIntegrations) HandleDeserialize(ctx conte } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorListIntegrations(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorGetIntegration(response, &metadata) } - output := &ListIntegrationsOutput{} + output := &GetIntegrationOutput{} out.Result = output var buff [1024]byte @@ -6357,7 +6402,7 @@ func (m *awsAwsjson11_deserializeOpListIntegrations) HandleDeserialize(ctx conte return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentListIntegrationsOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentGetIntegrationOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -6371,7 +6416,7 @@ func (m *awsAwsjson11_deserializeOpListIntegrations) HandleDeserialize(ctx conte return out, metadata, err } -func awsAwsjson11_deserializeOpErrorListIntegrations(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorGetIntegration(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -6411,6 +6456,9 @@ func awsAwsjson11_deserializeOpErrorListIntegrations(response *smithyhttp.Respon case strings.EqualFold("InvalidParameterException", errorCode): return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) + case strings.EqualFold("ResourceNotFoundException", errorCode): + return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) + case strings.EqualFold("ServiceUnavailableException", errorCode): return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) @@ -6424,14 +6472,14 @@ func awsAwsjson11_deserializeOpErrorListIntegrations(response *smithyhttp.Respon } } -type awsAwsjson11_deserializeOpListLogAnomalyDetectors struct { +type awsAwsjson11_deserializeOpGetLogAnomalyDetector struct { } -func (*awsAwsjson11_deserializeOpListLogAnomalyDetectors) ID() string { +func (*awsAwsjson11_deserializeOpGetLogAnomalyDetector) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpListLogAnomalyDetectors) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpGetLogAnomalyDetector) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -6449,9 +6497,9 @@ func (m *awsAwsjson11_deserializeOpListLogAnomalyDetectors) HandleDeserialize(ct } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorListLogAnomalyDetectors(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorGetLogAnomalyDetector(response, &metadata) } - output := &ListLogAnomalyDetectorsOutput{} + output := &GetLogAnomalyDetectorOutput{} out.Result = output var buff [1024]byte @@ -6471,7 +6519,7 @@ func (m *awsAwsjson11_deserializeOpListLogAnomalyDetectors) HandleDeserialize(ct return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentListLogAnomalyDetectorsOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentGetLogAnomalyDetectorOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -6485,7 +6533,7 @@ func (m *awsAwsjson11_deserializeOpListLogAnomalyDetectors) HandleDeserialize(ct return out, metadata, err } -func awsAwsjson11_deserializeOpErrorListLogAnomalyDetectors(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorGetLogAnomalyDetector(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -6544,14 +6592,14 @@ func awsAwsjson11_deserializeOpErrorListLogAnomalyDetectors(response *smithyhttp } } -type awsAwsjson11_deserializeOpListLogGroupsForQuery struct { +type awsAwsjson11_deserializeOpGetLogEvents struct { } -func (*awsAwsjson11_deserializeOpListLogGroupsForQuery) ID() string { +func (*awsAwsjson11_deserializeOpGetLogEvents) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpListLogGroupsForQuery) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpGetLogEvents) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -6569,9 +6617,9 @@ func (m *awsAwsjson11_deserializeOpListLogGroupsForQuery) HandleDeserialize(ctx } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorListLogGroupsForQuery(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorGetLogEvents(response, &metadata) } - output := &ListLogGroupsForQueryOutput{} + output := &GetLogEventsOutput{} out.Result = output var buff [1024]byte @@ -6591,7 +6639,7 @@ func (m *awsAwsjson11_deserializeOpListLogGroupsForQuery) HandleDeserialize(ctx return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentListLogGroupsForQueryOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentGetLogEventsOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -6605,7 +6653,7 @@ func (m *awsAwsjson11_deserializeOpListLogGroupsForQuery) HandleDeserialize(ctx return out, metadata, err } -func awsAwsjson11_deserializeOpErrorListLogGroupsForQuery(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorGetLogEvents(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -6642,9 +6690,6 @@ func awsAwsjson11_deserializeOpErrorListLogGroupsForQuery(response *smithyhttp.R errorMessage = bodyInfo.Message } switch { - case strings.EqualFold("AccessDeniedException", errorCode): - return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) - case strings.EqualFold("InvalidParameterException", errorCode): return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) @@ -6664,14 +6709,14 @@ func awsAwsjson11_deserializeOpErrorListLogGroupsForQuery(response *smithyhttp.R } } -type awsAwsjson11_deserializeOpListTagsForResource struct { +type awsAwsjson11_deserializeOpGetLogFields struct { } -func (*awsAwsjson11_deserializeOpListTagsForResource) ID() string { +func (*awsAwsjson11_deserializeOpGetLogFields) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpListTagsForResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpGetLogFields) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -6689,9 +6734,9 @@ func (m *awsAwsjson11_deserializeOpListTagsForResource) HandleDeserialize(ctx co } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorListTagsForResource(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorGetLogFields(response, &metadata) } - output := &ListTagsForResourceOutput{} + output := &GetLogFieldsOutput{} out.Result = output var buff [1024]byte @@ -6711,7 +6756,7 @@ func (m *awsAwsjson11_deserializeOpListTagsForResource) HandleDeserialize(ctx co return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentListTagsForResourceOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentGetLogFieldsOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -6725,7 +6770,7 @@ func (m *awsAwsjson11_deserializeOpListTagsForResource) HandleDeserialize(ctx co return out, metadata, err } -func awsAwsjson11_deserializeOpErrorListTagsForResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorGetLogFields(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -6765,6 +6810,9 @@ func awsAwsjson11_deserializeOpErrorListTagsForResource(response *smithyhttp.Res case strings.EqualFold("InvalidParameterException", errorCode): return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) + case strings.EqualFold("OperationAbortedException", errorCode): + return awsAwsjson11_deserializeErrorOperationAbortedException(response, errorBody) + case strings.EqualFold("ResourceNotFoundException", errorCode): return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) @@ -6781,14 +6829,14 @@ func awsAwsjson11_deserializeOpErrorListTagsForResource(response *smithyhttp.Res } } -type awsAwsjson11_deserializeOpListTagsLogGroup struct { +type awsAwsjson11_deserializeOpGetLogGroupFields struct { } -func (*awsAwsjson11_deserializeOpListTagsLogGroup) ID() string { +func (*awsAwsjson11_deserializeOpGetLogGroupFields) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpListTagsLogGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpGetLogGroupFields) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -6806,9 +6854,9 @@ func (m *awsAwsjson11_deserializeOpListTagsLogGroup) HandleDeserialize(ctx conte } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorListTagsLogGroup(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorGetLogGroupFields(response, &metadata) } - output := &ListTagsLogGroupOutput{} + output := &GetLogGroupFieldsOutput{} out.Result = output var buff [1024]byte @@ -6828,7 +6876,7 @@ func (m *awsAwsjson11_deserializeOpListTagsLogGroup) HandleDeserialize(ctx conte return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentListTagsLogGroupOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentGetLogGroupFieldsOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -6842,7 +6890,7 @@ func (m *awsAwsjson11_deserializeOpListTagsLogGroup) HandleDeserialize(ctx conte return out, metadata, err } -func awsAwsjson11_deserializeOpErrorListTagsLogGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorGetLogGroupFields(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -6879,6 +6927,12 @@ func awsAwsjson11_deserializeOpErrorListTagsLogGroup(response *smithyhttp.Respon errorMessage = bodyInfo.Message } switch { + case strings.EqualFold("InvalidParameterException", errorCode): + return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) + + case strings.EqualFold("LimitExceededException", errorCode): + return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) + case strings.EqualFold("ResourceNotFoundException", errorCode): return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) @@ -6895,14 +6949,14 @@ func awsAwsjson11_deserializeOpErrorListTagsLogGroup(response *smithyhttp.Respon } } -type awsAwsjson11_deserializeOpPutAccountPolicy struct { +type awsAwsjson11_deserializeOpGetLogObject struct { } -func (*awsAwsjson11_deserializeOpPutAccountPolicy) ID() string { +func (*awsAwsjson11_deserializeOpGetLogObject) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpPutAccountPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpGetLogObject) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -6920,53 +6974,25 @@ func (m *awsAwsjson11_deserializeOpPutAccountPolicy) HandleDeserialize(ctx conte } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorPutAccountPolicy(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorGetLogObject(response, &metadata) } - output := &PutAccountPolicyOutput{} + output := &GetLogObjectOutput{} out.Result = output - - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - - body := io.TeeReader(response.Body, ringBuffer) - decoder := json.NewDecoder(body) - decoder.UseNumber() - var shape interface{} - if err := decoder.Decode(&shape); err != nil && err != io.EOF { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return out, metadata, err - } - - err = awsAwsjson11_deserializeOpDocumentPutAccountPolicyOutput(&output, shape) - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return out, metadata, err - } - - return out, metadata, err -} - -func awsAwsjson11_deserializeOpErrorPutAccountPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { - var errorBuffer bytes.Buffer - if _, err := io.Copy(&errorBuffer, response.Body); err != nil { - return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} - } - errorBody := bytes.NewReader(errorBuffer.Bytes()) - - errorCode := "UnknownError" - errorMessage := errorCode - - headerCode := response.Header.Get("X-Amzn-ErrorType") + + return out, metadata, err +} + +func awsAwsjson11_deserializeOpErrorGetLogObject(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.Buffer + if _, err := io.Copy(&errorBuffer, response.Body); err != nil { + return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} + } + errorBody := bytes.NewReader(errorBuffer.Bytes()) + + errorCode := "UnknownError" + errorMessage := errorCode + + headerCode := response.Header.Get("X-Amzn-ErrorType") var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) @@ -6993,17 +7019,20 @@ func awsAwsjson11_deserializeOpErrorPutAccountPolicy(response *smithyhttp.Respon errorMessage = bodyInfo.Message } switch { + case strings.EqualFold("AccessDeniedException", errorCode): + return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) + + case strings.EqualFold("InvalidOperationException", errorCode): + return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody) + case strings.EqualFold("InvalidParameterException", errorCode): return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) case strings.EqualFold("LimitExceededException", errorCode): return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) - case strings.EqualFold("OperationAbortedException", errorCode): - return awsAwsjson11_deserializeErrorOperationAbortedException(response, errorBody) - - case strings.EqualFold("ServiceUnavailableException", errorCode): - return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) + case strings.EqualFold("ResourceNotFoundException", errorCode): + return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) default: genericError := &smithy.GenericAPIError{ @@ -7015,14 +7044,14 @@ func awsAwsjson11_deserializeOpErrorPutAccountPolicy(response *smithyhttp.Respon } } -type awsAwsjson11_deserializeOpPutDataProtectionPolicy struct { +type awsAwsjson11_deserializeOpGetLogRecord struct { } -func (*awsAwsjson11_deserializeOpPutDataProtectionPolicy) ID() string { +func (*awsAwsjson11_deserializeOpGetLogRecord) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpPutDataProtectionPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpGetLogRecord) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -7040,9 +7069,9 @@ func (m *awsAwsjson11_deserializeOpPutDataProtectionPolicy) HandleDeserialize(ct } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorPutDataProtectionPolicy(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorGetLogRecord(response, &metadata) } - output := &PutDataProtectionPolicyOutput{} + output := &GetLogRecordOutput{} out.Result = output var buff [1024]byte @@ -7062,7 +7091,7 @@ func (m *awsAwsjson11_deserializeOpPutDataProtectionPolicy) HandleDeserialize(ct return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentPutDataProtectionPolicyOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentGetLogRecordOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -7076,7 +7105,7 @@ func (m *awsAwsjson11_deserializeOpPutDataProtectionPolicy) HandleDeserialize(ct return out, metadata, err } -func awsAwsjson11_deserializeOpErrorPutDataProtectionPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorGetLogRecord(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -7119,9 +7148,6 @@ func awsAwsjson11_deserializeOpErrorPutDataProtectionPolicy(response *smithyhttp case strings.EqualFold("LimitExceededException", errorCode): return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) - case strings.EqualFold("OperationAbortedException", errorCode): - return awsAwsjson11_deserializeErrorOperationAbortedException(response, errorBody) - case strings.EqualFold("ResourceNotFoundException", errorCode): return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) @@ -7138,14 +7164,14 @@ func awsAwsjson11_deserializeOpErrorPutDataProtectionPolicy(response *smithyhttp } } -type awsAwsjson11_deserializeOpPutDeliveryDestination struct { +type awsAwsjson11_deserializeOpGetQueryResults struct { } -func (*awsAwsjson11_deserializeOpPutDeliveryDestination) ID() string { +func (*awsAwsjson11_deserializeOpGetQueryResults) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpPutDeliveryDestination) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpGetQueryResults) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -7163,9 +7189,9 @@ func (m *awsAwsjson11_deserializeOpPutDeliveryDestination) HandleDeserialize(ctx } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorPutDeliveryDestination(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorGetQueryResults(response, &metadata) } - output := &PutDeliveryDestinationOutput{} + output := &GetQueryResultsOutput{} out.Result = output var buff [1024]byte @@ -7185,7 +7211,7 @@ func (m *awsAwsjson11_deserializeOpPutDeliveryDestination) HandleDeserialize(ctx return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentPutDeliveryDestinationOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentGetQueryResultsOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -7199,7 +7225,7 @@ func (m *awsAwsjson11_deserializeOpPutDeliveryDestination) HandleDeserialize(ctx return out, metadata, err } -func awsAwsjson11_deserializeOpErrorPutDeliveryDestination(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorGetQueryResults(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -7236,24 +7262,15 @@ func awsAwsjson11_deserializeOpErrorPutDeliveryDestination(response *smithyhttp. errorMessage = bodyInfo.Message } switch { - case strings.EqualFold("ConflictException", errorCode): - return awsAwsjson11_deserializeErrorConflictException(response, errorBody) + case strings.EqualFold("InvalidParameterException", errorCode): + return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) case strings.EqualFold("ResourceNotFoundException", errorCode): return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) - case strings.EqualFold("ServiceQuotaExceededException", errorCode): - return awsAwsjson11_deserializeErrorServiceQuotaExceededException(response, errorBody) - case strings.EqualFold("ServiceUnavailableException", errorCode): return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) - case strings.EqualFold("ThrottlingException", errorCode): - return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) - - case strings.EqualFold("ValidationException", errorCode): - return awsAwsjson11_deserializeErrorValidationException(response, errorBody) - default: genericError := &smithy.GenericAPIError{ Code: errorCode, @@ -7264,14 +7281,14 @@ func awsAwsjson11_deserializeOpErrorPutDeliveryDestination(response *smithyhttp. } } -type awsAwsjson11_deserializeOpPutDeliveryDestinationPolicy struct { +type awsAwsjson11_deserializeOpGetScheduledQuery struct { } -func (*awsAwsjson11_deserializeOpPutDeliveryDestinationPolicy) ID() string { +func (*awsAwsjson11_deserializeOpGetScheduledQuery) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpPutDeliveryDestinationPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpGetScheduledQuery) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -7289,9 +7306,9 @@ func (m *awsAwsjson11_deserializeOpPutDeliveryDestinationPolicy) HandleDeseriali } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorPutDeliveryDestinationPolicy(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorGetScheduledQuery(response, &metadata) } - output := &PutDeliveryDestinationPolicyOutput{} + output := &GetScheduledQueryOutput{} out.Result = output var buff [1024]byte @@ -7311,7 +7328,7 @@ func (m *awsAwsjson11_deserializeOpPutDeliveryDestinationPolicy) HandleDeseriali return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentPutDeliveryDestinationPolicyOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentGetScheduledQueryOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -7325,7 +7342,7 @@ func (m *awsAwsjson11_deserializeOpPutDeliveryDestinationPolicy) HandleDeseriali return out, metadata, err } -func awsAwsjson11_deserializeOpErrorPutDeliveryDestinationPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorGetScheduledQuery(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -7362,14 +7379,17 @@ func awsAwsjson11_deserializeOpErrorPutDeliveryDestinationPolicy(response *smith errorMessage = bodyInfo.Message } switch { - case strings.EqualFold("ConflictException", errorCode): - return awsAwsjson11_deserializeErrorConflictException(response, errorBody) + case strings.EqualFold("AccessDeniedException", errorCode): + return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) + + case strings.EqualFold("InternalServerException", errorCode): + return awsAwsjson11_deserializeErrorInternalServerException(response, errorBody) case strings.EqualFold("ResourceNotFoundException", errorCode): return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) - case strings.EqualFold("ServiceUnavailableException", errorCode): - return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) + case strings.EqualFold("ThrottlingException", errorCode): + return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) case strings.EqualFold("ValidationException", errorCode): return awsAwsjson11_deserializeErrorValidationException(response, errorBody) @@ -7384,14 +7404,14 @@ func awsAwsjson11_deserializeOpErrorPutDeliveryDestinationPolicy(response *smith } } -type awsAwsjson11_deserializeOpPutDeliverySource struct { +type awsAwsjson11_deserializeOpGetScheduledQueryHistory struct { } -func (*awsAwsjson11_deserializeOpPutDeliverySource) ID() string { +func (*awsAwsjson11_deserializeOpGetScheduledQueryHistory) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpPutDeliverySource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpGetScheduledQueryHistory) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -7409,9 +7429,9 @@ func (m *awsAwsjson11_deserializeOpPutDeliverySource) HandleDeserialize(ctx cont } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorPutDeliverySource(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorGetScheduledQueryHistory(response, &metadata) } - output := &PutDeliverySourceOutput{} + output := &GetScheduledQueryHistoryOutput{} out.Result = output var buff [1024]byte @@ -7431,7 +7451,7 @@ func (m *awsAwsjson11_deserializeOpPutDeliverySource) HandleDeserialize(ctx cont return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentPutDeliverySourceOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentGetScheduledQueryHistoryOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -7445,7 +7465,7 @@ func (m *awsAwsjson11_deserializeOpPutDeliverySource) HandleDeserialize(ctx cont return out, metadata, err } -func awsAwsjson11_deserializeOpErrorPutDeliverySource(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorGetScheduledQueryHistory(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -7482,18 +7502,15 @@ func awsAwsjson11_deserializeOpErrorPutDeliverySource(response *smithyhttp.Respo errorMessage = bodyInfo.Message } switch { - case strings.EqualFold("ConflictException", errorCode): - return awsAwsjson11_deserializeErrorConflictException(response, errorBody) + case strings.EqualFold("AccessDeniedException", errorCode): + return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) + + case strings.EqualFold("InternalServerException", errorCode): + return awsAwsjson11_deserializeErrorInternalServerException(response, errorBody) case strings.EqualFold("ResourceNotFoundException", errorCode): return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) - case strings.EqualFold("ServiceQuotaExceededException", errorCode): - return awsAwsjson11_deserializeErrorServiceQuotaExceededException(response, errorBody) - - case strings.EqualFold("ServiceUnavailableException", errorCode): - return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) - case strings.EqualFold("ThrottlingException", errorCode): return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) @@ -7510,14 +7527,14 @@ func awsAwsjson11_deserializeOpErrorPutDeliverySource(response *smithyhttp.Respo } } -type awsAwsjson11_deserializeOpPutDestination struct { +type awsAwsjson11_deserializeOpGetTransformer struct { } -func (*awsAwsjson11_deserializeOpPutDestination) ID() string { +func (*awsAwsjson11_deserializeOpGetTransformer) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpPutDestination) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpGetTransformer) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -7535,9 +7552,9 @@ func (m *awsAwsjson11_deserializeOpPutDestination) HandleDeserialize(ctx context } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorPutDestination(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorGetTransformer(response, &metadata) } - output := &PutDestinationOutput{} + output := &GetTransformerOutput{} out.Result = output var buff [1024]byte @@ -7557,7 +7574,7 @@ func (m *awsAwsjson11_deserializeOpPutDestination) HandleDeserialize(ctx context return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentPutDestinationOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentGetTransformerOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -7571,7 +7588,7 @@ func (m *awsAwsjson11_deserializeOpPutDestination) HandleDeserialize(ctx context return out, metadata, err } -func awsAwsjson11_deserializeOpErrorPutDestination(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorGetTransformer(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -7608,11 +7625,14 @@ func awsAwsjson11_deserializeOpErrorPutDestination(response *smithyhttp.Response errorMessage = bodyInfo.Message } switch { + case strings.EqualFold("InvalidOperationException", errorCode): + return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody) + case strings.EqualFold("InvalidParameterException", errorCode): return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) - case strings.EqualFold("OperationAbortedException", errorCode): - return awsAwsjson11_deserializeErrorOperationAbortedException(response, errorBody) + case strings.EqualFold("ResourceNotFoundException", errorCode): + return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) case strings.EqualFold("ServiceUnavailableException", errorCode): return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) @@ -7627,14 +7647,14 @@ func awsAwsjson11_deserializeOpErrorPutDestination(response *smithyhttp.Response } } -type awsAwsjson11_deserializeOpPutDestinationPolicy struct { +type awsAwsjson11_deserializeOpListAggregateLogGroupSummaries struct { } -func (*awsAwsjson11_deserializeOpPutDestinationPolicy) ID() string { +func (*awsAwsjson11_deserializeOpListAggregateLogGroupSummaries) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpPutDestinationPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpListAggregateLogGroupSummaries) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -7652,21 +7672,43 @@ func (m *awsAwsjson11_deserializeOpPutDestinationPolicy) HandleDeserialize(ctx c } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorPutDestinationPolicy(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorListAggregateLogGroupSummaries(response, &metadata) } - output := &PutDestinationPolicyOutput{} + output := &ListAggregateLogGroupSummariesOutput{} out.Result = output - if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { - return out, metadata, &smithy.DeserializationError{ - Err: fmt.Errorf("failed to discard response body, %w", err), + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(response.Body, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + var shape interface{} + if err := decoder.Decode(&shape); err != nil && err != io.EOF { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return out, metadata, err + } + + err = awsAwsjson11_deserializeOpDocumentListAggregateLogGroupSummariesOutput(&output, shape) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), } + return out, metadata, err } return out, metadata, err } -func awsAwsjson11_deserializeOpErrorPutDestinationPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorListAggregateLogGroupSummaries(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -7706,12 +7748,12 @@ func awsAwsjson11_deserializeOpErrorPutDestinationPolicy(response *smithyhttp.Re case strings.EqualFold("InvalidParameterException", errorCode): return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) - case strings.EqualFold("OperationAbortedException", errorCode): - return awsAwsjson11_deserializeErrorOperationAbortedException(response, errorBody) - case strings.EqualFold("ServiceUnavailableException", errorCode): return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) + case strings.EqualFold("ValidationException", errorCode): + return awsAwsjson11_deserializeErrorValidationException(response, errorBody) + default: genericError := &smithy.GenericAPIError{ Code: errorCode, @@ -7722,14 +7764,14 @@ func awsAwsjson11_deserializeOpErrorPutDestinationPolicy(response *smithyhttp.Re } } -type awsAwsjson11_deserializeOpPutIndexPolicy struct { +type awsAwsjson11_deserializeOpListAnomalies struct { } -func (*awsAwsjson11_deserializeOpPutIndexPolicy) ID() string { +func (*awsAwsjson11_deserializeOpListAnomalies) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpPutIndexPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpListAnomalies) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -7747,9 +7789,9 @@ func (m *awsAwsjson11_deserializeOpPutIndexPolicy) HandleDeserialize(ctx context } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorPutIndexPolicy(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorListAnomalies(response, &metadata) } - output := &PutIndexPolicyOutput{} + output := &ListAnomaliesOutput{} out.Result = output var buff [1024]byte @@ -7769,7 +7811,7 @@ func (m *awsAwsjson11_deserializeOpPutIndexPolicy) HandleDeserialize(ctx context return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentPutIndexPolicyOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentListAnomaliesOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -7783,7 +7825,7 @@ func (m *awsAwsjson11_deserializeOpPutIndexPolicy) HandleDeserialize(ctx context return out, metadata, err } -func awsAwsjson11_deserializeOpErrorPutIndexPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorListAnomalies(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -7823,9 +7865,6 @@ func awsAwsjson11_deserializeOpErrorPutIndexPolicy(response *smithyhttp.Response case strings.EqualFold("InvalidParameterException", errorCode): return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) - case strings.EqualFold("LimitExceededException", errorCode): - return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) - case strings.EqualFold("OperationAbortedException", errorCode): return awsAwsjson11_deserializeErrorOperationAbortedException(response, errorBody) @@ -7845,14 +7884,14 @@ func awsAwsjson11_deserializeOpErrorPutIndexPolicy(response *smithyhttp.Response } } -type awsAwsjson11_deserializeOpPutIntegration struct { +type awsAwsjson11_deserializeOpListIntegrations struct { } -func (*awsAwsjson11_deserializeOpPutIntegration) ID() string { +func (*awsAwsjson11_deserializeOpListIntegrations) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpPutIntegration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpListIntegrations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -7870,9 +7909,9 @@ func (m *awsAwsjson11_deserializeOpPutIntegration) HandleDeserialize(ctx context } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorPutIntegration(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorListIntegrations(response, &metadata) } - output := &PutIntegrationOutput{} + output := &ListIntegrationsOutput{} out.Result = output var buff [1024]byte @@ -7892,7 +7931,7 @@ func (m *awsAwsjson11_deserializeOpPutIntegration) HandleDeserialize(ctx context return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentPutIntegrationOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentListIntegrationsOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -7906,7 +7945,7 @@ func (m *awsAwsjson11_deserializeOpPutIntegration) HandleDeserialize(ctx context return out, metadata, err } -func awsAwsjson11_deserializeOpErrorPutIntegration(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorListIntegrations(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -7946,15 +7985,9 @@ func awsAwsjson11_deserializeOpErrorPutIntegration(response *smithyhttp.Response case strings.EqualFold("InvalidParameterException", errorCode): return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) - case strings.EqualFold("LimitExceededException", errorCode): - return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) - case strings.EqualFold("ServiceUnavailableException", errorCode): return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) - case strings.EqualFold("ValidationException", errorCode): - return awsAwsjson11_deserializeErrorValidationException(response, errorBody) - default: genericError := &smithy.GenericAPIError{ Code: errorCode, @@ -7965,14 +7998,14 @@ func awsAwsjson11_deserializeOpErrorPutIntegration(response *smithyhttp.Response } } -type awsAwsjson11_deserializeOpPutLogEvents struct { +type awsAwsjson11_deserializeOpListLogAnomalyDetectors struct { } -func (*awsAwsjson11_deserializeOpPutLogEvents) ID() string { +func (*awsAwsjson11_deserializeOpListLogAnomalyDetectors) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpPutLogEvents) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpListLogAnomalyDetectors) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -7990,9 +8023,9 @@ func (m *awsAwsjson11_deserializeOpPutLogEvents) HandleDeserialize(ctx context.C } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorPutLogEvents(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorListLogAnomalyDetectors(response, &metadata) } - output := &PutLogEventsOutput{} + output := &ListLogAnomalyDetectorsOutput{} out.Result = output var buff [1024]byte @@ -8012,7 +8045,7 @@ func (m *awsAwsjson11_deserializeOpPutLogEvents) HandleDeserialize(ctx context.C return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentPutLogEventsOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentListLogAnomalyDetectorsOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -8026,7 +8059,7 @@ func (m *awsAwsjson11_deserializeOpPutLogEvents) HandleDeserialize(ctx context.C return out, metadata, err } -func awsAwsjson11_deserializeOpErrorPutLogEvents(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorListLogAnomalyDetectors(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -8063,14 +8096,11 @@ func awsAwsjson11_deserializeOpErrorPutLogEvents(response *smithyhttp.Response, errorMessage = bodyInfo.Message } switch { - case strings.EqualFold("DataAlreadyAcceptedException", errorCode): - return awsAwsjson11_deserializeErrorDataAlreadyAcceptedException(response, errorBody) - case strings.EqualFold("InvalidParameterException", errorCode): return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) - case strings.EqualFold("InvalidSequenceTokenException", errorCode): - return awsAwsjson11_deserializeErrorInvalidSequenceTokenException(response, errorBody) + case strings.EqualFold("OperationAbortedException", errorCode): + return awsAwsjson11_deserializeErrorOperationAbortedException(response, errorBody) case strings.EqualFold("ResourceNotFoundException", errorCode): return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) @@ -8078,9 +8108,6 @@ func awsAwsjson11_deserializeOpErrorPutLogEvents(response *smithyhttp.Response, case strings.EqualFold("ServiceUnavailableException", errorCode): return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) - case strings.EqualFold("UnrecognizedClientException", errorCode): - return awsAwsjson11_deserializeErrorUnrecognizedClientException(response, errorBody) - default: genericError := &smithy.GenericAPIError{ Code: errorCode, @@ -8091,14 +8118,14 @@ func awsAwsjson11_deserializeOpErrorPutLogEvents(response *smithyhttp.Response, } } -type awsAwsjson11_deserializeOpPutMetricFilter struct { +type awsAwsjson11_deserializeOpListLogGroups struct { } -func (*awsAwsjson11_deserializeOpPutMetricFilter) ID() string { +func (*awsAwsjson11_deserializeOpListLogGroups) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpPutMetricFilter) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpListLogGroups) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -8116,21 +8143,43 @@ func (m *awsAwsjson11_deserializeOpPutMetricFilter) HandleDeserialize(ctx contex } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorPutMetricFilter(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorListLogGroups(response, &metadata) } - output := &PutMetricFilterOutput{} + output := &ListLogGroupsOutput{} out.Result = output - if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { - return out, metadata, &smithy.DeserializationError{ - Err: fmt.Errorf("failed to discard response body, %w", err), + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(response.Body, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + var shape interface{} + if err := decoder.Decode(&shape); err != nil && err != io.EOF { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return out, metadata, err + } + + err = awsAwsjson11_deserializeOpDocumentListLogGroupsOutput(&output, shape) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), } + return out, metadata, err } return out, metadata, err } -func awsAwsjson11_deserializeOpErrorPutMetricFilter(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorListLogGroups(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -8167,21 +8216,9 @@ func awsAwsjson11_deserializeOpErrorPutMetricFilter(response *smithyhttp.Respons errorMessage = bodyInfo.Message } switch { - case strings.EqualFold("InvalidOperationException", errorCode): - return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody) - case strings.EqualFold("InvalidParameterException", errorCode): return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) - case strings.EqualFold("LimitExceededException", errorCode): - return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) - - case strings.EqualFold("OperationAbortedException", errorCode): - return awsAwsjson11_deserializeErrorOperationAbortedException(response, errorBody) - - case strings.EqualFold("ResourceNotFoundException", errorCode): - return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) - case strings.EqualFold("ServiceUnavailableException", errorCode): return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) @@ -8195,14 +8232,14 @@ func awsAwsjson11_deserializeOpErrorPutMetricFilter(response *smithyhttp.Respons } } -type awsAwsjson11_deserializeOpPutQueryDefinition struct { +type awsAwsjson11_deserializeOpListLogGroupsForQuery struct { } -func (*awsAwsjson11_deserializeOpPutQueryDefinition) ID() string { +func (*awsAwsjson11_deserializeOpListLogGroupsForQuery) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpPutQueryDefinition) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpListLogGroupsForQuery) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -8220,9 +8257,9 @@ func (m *awsAwsjson11_deserializeOpPutQueryDefinition) HandleDeserialize(ctx con } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorPutQueryDefinition(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorListLogGroupsForQuery(response, &metadata) } - output := &PutQueryDefinitionOutput{} + output := &ListLogGroupsForQueryOutput{} out.Result = output var buff [1024]byte @@ -8242,7 +8279,7 @@ func (m *awsAwsjson11_deserializeOpPutQueryDefinition) HandleDeserialize(ctx con return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentPutQueryDefinitionOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentListLogGroupsForQueryOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -8256,7 +8293,7 @@ func (m *awsAwsjson11_deserializeOpPutQueryDefinition) HandleDeserialize(ctx con return out, metadata, err } -func awsAwsjson11_deserializeOpErrorPutQueryDefinition(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorListLogGroupsForQuery(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -8293,12 +8330,12 @@ func awsAwsjson11_deserializeOpErrorPutQueryDefinition(response *smithyhttp.Resp errorMessage = bodyInfo.Message } switch { + case strings.EqualFold("AccessDeniedException", errorCode): + return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) + case strings.EqualFold("InvalidParameterException", errorCode): return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) - case strings.EqualFold("LimitExceededException", errorCode): - return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) - case strings.EqualFold("ResourceNotFoundException", errorCode): return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) @@ -8315,14 +8352,14 @@ func awsAwsjson11_deserializeOpErrorPutQueryDefinition(response *smithyhttp.Resp } } -type awsAwsjson11_deserializeOpPutResourcePolicy struct { +type awsAwsjson11_deserializeOpListScheduledQueries struct { } -func (*awsAwsjson11_deserializeOpPutResourcePolicy) ID() string { +func (*awsAwsjson11_deserializeOpListScheduledQueries) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpPutResourcePolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpListScheduledQueries) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -8340,9 +8377,9 @@ func (m *awsAwsjson11_deserializeOpPutResourcePolicy) HandleDeserialize(ctx cont } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorPutResourcePolicy(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorListScheduledQueries(response, &metadata) } - output := &PutResourcePolicyOutput{} + output := &ListScheduledQueriesOutput{} out.Result = output var buff [1024]byte @@ -8362,7 +8399,7 @@ func (m *awsAwsjson11_deserializeOpPutResourcePolicy) HandleDeserialize(ctx cont return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentPutResourcePolicyOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentListScheduledQueriesOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -8376,7 +8413,7 @@ func (m *awsAwsjson11_deserializeOpPutResourcePolicy) HandleDeserialize(ctx cont return out, metadata, err } -func awsAwsjson11_deserializeOpErrorPutResourcePolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorListScheduledQueries(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -8413,14 +8450,17 @@ func awsAwsjson11_deserializeOpErrorPutResourcePolicy(response *smithyhttp.Respo errorMessage = bodyInfo.Message } switch { - case strings.EqualFold("InvalidParameterException", errorCode): - return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) + case strings.EqualFold("AccessDeniedException", errorCode): + return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) - case strings.EqualFold("LimitExceededException", errorCode): - return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) + case strings.EqualFold("InternalServerException", errorCode): + return awsAwsjson11_deserializeErrorInternalServerException(response, errorBody) - case strings.EqualFold("ServiceUnavailableException", errorCode): - return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) + case strings.EqualFold("ThrottlingException", errorCode): + return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) + + case strings.EqualFold("ValidationException", errorCode): + return awsAwsjson11_deserializeErrorValidationException(response, errorBody) default: genericError := &smithy.GenericAPIError{ @@ -8432,14 +8472,14 @@ func awsAwsjson11_deserializeOpErrorPutResourcePolicy(response *smithyhttp.Respo } } -type awsAwsjson11_deserializeOpPutRetentionPolicy struct { +type awsAwsjson11_deserializeOpListSourcesForS3TableIntegration struct { } -func (*awsAwsjson11_deserializeOpPutRetentionPolicy) ID() string { +func (*awsAwsjson11_deserializeOpListSourcesForS3TableIntegration) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpPutRetentionPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpListSourcesForS3TableIntegration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -8457,21 +8497,43 @@ func (m *awsAwsjson11_deserializeOpPutRetentionPolicy) HandleDeserialize(ctx con } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorPutRetentionPolicy(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorListSourcesForS3TableIntegration(response, &metadata) } - output := &PutRetentionPolicyOutput{} + output := &ListSourcesForS3TableIntegrationOutput{} out.Result = output - if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { - return out, metadata, &smithy.DeserializationError{ - Err: fmt.Errorf("failed to discard response body, %w", err), + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(response.Body, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + var shape interface{} + if err := decoder.Decode(&shape); err != nil && err != io.EOF { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return out, metadata, err + } + + err = awsAwsjson11_deserializeOpDocumentListSourcesForS3TableIntegrationOutput(&output, shape) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), } + return out, metadata, err } return out, metadata, err } -func awsAwsjson11_deserializeOpErrorPutRetentionPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorListSourcesForS3TableIntegration(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -8508,17 +8570,20 @@ func awsAwsjson11_deserializeOpErrorPutRetentionPolicy(response *smithyhttp.Resp errorMessage = bodyInfo.Message } switch { - case strings.EqualFold("InvalidParameterException", errorCode): - return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) + case strings.EqualFold("AccessDeniedException", errorCode): + return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) - case strings.EqualFold("OperationAbortedException", errorCode): - return awsAwsjson11_deserializeErrorOperationAbortedException(response, errorBody) + case strings.EqualFold("InternalServerException", errorCode): + return awsAwsjson11_deserializeErrorInternalServerException(response, errorBody) case strings.EqualFold("ResourceNotFoundException", errorCode): return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) - case strings.EqualFold("ServiceUnavailableException", errorCode): - return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) + case strings.EqualFold("ThrottlingException", errorCode): + return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) + + case strings.EqualFold("ValidationException", errorCode): + return awsAwsjson11_deserializeErrorValidationException(response, errorBody) default: genericError := &smithy.GenericAPIError{ @@ -8530,14 +8595,14 @@ func awsAwsjson11_deserializeOpErrorPutRetentionPolicy(response *smithyhttp.Resp } } -type awsAwsjson11_deserializeOpPutSubscriptionFilter struct { +type awsAwsjson11_deserializeOpListTagsForResource struct { } -func (*awsAwsjson11_deserializeOpPutSubscriptionFilter) ID() string { +func (*awsAwsjson11_deserializeOpListTagsForResource) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpPutSubscriptionFilter) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpListTagsForResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -8555,21 +8620,43 @@ func (m *awsAwsjson11_deserializeOpPutSubscriptionFilter) HandleDeserialize(ctx } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorPutSubscriptionFilter(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorListTagsForResource(response, &metadata) } - output := &PutSubscriptionFilterOutput{} + output := &ListTagsForResourceOutput{} out.Result = output - if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { - return out, metadata, &smithy.DeserializationError{ - Err: fmt.Errorf("failed to discard response body, %w", err), + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(response.Body, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + var shape interface{} + if err := decoder.Decode(&shape); err != nil && err != io.EOF { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return out, metadata, err + } + + err = awsAwsjson11_deserializeOpDocumentListTagsForResourceOutput(&output, shape) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), } + return out, metadata, err } return out, metadata, err } -func awsAwsjson11_deserializeOpErrorPutSubscriptionFilter(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorListTagsForResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -8606,18 +8693,9 @@ func awsAwsjson11_deserializeOpErrorPutSubscriptionFilter(response *smithyhttp.R errorMessage = bodyInfo.Message } switch { - case strings.EqualFold("InvalidOperationException", errorCode): - return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody) - case strings.EqualFold("InvalidParameterException", errorCode): return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) - case strings.EqualFold("LimitExceededException", errorCode): - return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) - - case strings.EqualFold("OperationAbortedException", errorCode): - return awsAwsjson11_deserializeErrorOperationAbortedException(response, errorBody) - case strings.EqualFold("ResourceNotFoundException", errorCode): return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) @@ -8634,14 +8712,14 @@ func awsAwsjson11_deserializeOpErrorPutSubscriptionFilter(response *smithyhttp.R } } -type awsAwsjson11_deserializeOpPutTransformer struct { +type awsAwsjson11_deserializeOpListTagsLogGroup struct { } -func (*awsAwsjson11_deserializeOpPutTransformer) ID() string { +func (*awsAwsjson11_deserializeOpListTagsLogGroup) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpPutTransformer) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpListTagsLogGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -8659,21 +8737,43 @@ func (m *awsAwsjson11_deserializeOpPutTransformer) HandleDeserialize(ctx context } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorPutTransformer(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorListTagsLogGroup(response, &metadata) } - output := &PutTransformerOutput{} + output := &ListTagsLogGroupOutput{} out.Result = output - if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { - return out, metadata, &smithy.DeserializationError{ - Err: fmt.Errorf("failed to discard response body, %w", err), + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(response.Body, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + var shape interface{} + if err := decoder.Decode(&shape); err != nil && err != io.EOF { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return out, metadata, err + } + + err = awsAwsjson11_deserializeOpDocumentListTagsLogGroupOutput(&output, shape) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), } + return out, metadata, err } return out, metadata, err } -func awsAwsjson11_deserializeOpErrorPutTransformer(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorListTagsLogGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -8710,18 +8810,6 @@ func awsAwsjson11_deserializeOpErrorPutTransformer(response *smithyhttp.Response errorMessage = bodyInfo.Message } switch { - case strings.EqualFold("InvalidOperationException", errorCode): - return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody) - - case strings.EqualFold("InvalidParameterException", errorCode): - return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) - - case strings.EqualFold("LimitExceededException", errorCode): - return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) - - case strings.EqualFold("OperationAbortedException", errorCode): - return awsAwsjson11_deserializeErrorOperationAbortedException(response, errorBody) - case strings.EqualFold("ResourceNotFoundException", errorCode): return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) @@ -8738,14 +8826,14 @@ func awsAwsjson11_deserializeOpErrorPutTransformer(response *smithyhttp.Response } } -type awsAwsjson11_deserializeOpStartLiveTail struct { +type awsAwsjson11_deserializeOpPutAccountPolicy struct { } -func (*awsAwsjson11_deserializeOpStartLiveTail) ID() string { +func (*awsAwsjson11_deserializeOpPutAccountPolicy) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpStartLiveTail) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpPutAccountPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -8763,30 +8851,58 @@ func (m *awsAwsjson11_deserializeOpStartLiveTail) HandleDeserialize(ctx context. } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorStartLiveTail(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorPutAccountPolicy(response, &metadata) } - output := &StartLiveTailOutput{} + output := &PutAccountPolicyOutput{} out.Result = output - return out, metadata, err -} - -func awsAwsjson11_deserializeOpErrorStartLiveTail(response *smithyhttp.Response, metadata *middleware.Metadata) error { - var errorBuffer bytes.Buffer - if _, err := io.Copy(&errorBuffer, response.Body); err != nil { - return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} - } - errorBody := bytes.NewReader(errorBuffer.Bytes()) - - errorCode := "UnknownError" - errorMessage := errorCode - - headerCode := response.Header.Get("X-Amzn-ErrorType") - var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) - body := io.TeeReader(errorBody, ringBuffer) + body := io.TeeReader(response.Body, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + var shape interface{} + if err := decoder.Decode(&shape); err != nil && err != io.EOF { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return out, metadata, err + } + + err = awsAwsjson11_deserializeOpDocumentPutAccountPolicyOutput(&output, shape) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return out, metadata, err + } + + return out, metadata, err +} + +func awsAwsjson11_deserializeOpErrorPutAccountPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.Buffer + if _, err := io.Copy(&errorBuffer, response.Body); err != nil { + return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} + } + errorBody := bytes.NewReader(errorBuffer.Bytes()) + + errorCode := "UnknownError" + errorMessage := errorCode + + headerCode := response.Header.Get("X-Amzn-ErrorType") + + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(errorBody, ringBuffer) decoder := json.NewDecoder(body) decoder.UseNumber() bodyInfo, err := getProtocolErrorInfo(decoder) @@ -8808,20 +8924,17 @@ func awsAwsjson11_deserializeOpErrorStartLiveTail(response *smithyhttp.Response, errorMessage = bodyInfo.Message } switch { - case strings.EqualFold("AccessDeniedException", errorCode): - return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) - - case strings.EqualFold("InvalidOperationException", errorCode): - return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody) - case strings.EqualFold("InvalidParameterException", errorCode): return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) case strings.EqualFold("LimitExceededException", errorCode): return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) - case strings.EqualFold("ResourceNotFoundException", errorCode): - return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) + case strings.EqualFold("OperationAbortedException", errorCode): + return awsAwsjson11_deserializeErrorOperationAbortedException(response, errorBody) + + case strings.EqualFold("ServiceUnavailableException", errorCode): + return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) default: genericError := &smithy.GenericAPIError{ @@ -8833,14 +8946,14 @@ func awsAwsjson11_deserializeOpErrorStartLiveTail(response *smithyhttp.Response, } } -type awsAwsjson11_deserializeOpStartQuery struct { +type awsAwsjson11_deserializeOpPutBearerTokenAuthentication struct { } -func (*awsAwsjson11_deserializeOpStartQuery) ID() string { +func (*awsAwsjson11_deserializeOpPutBearerTokenAuthentication) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpStartQuery) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpPutBearerTokenAuthentication) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -8858,43 +8971,21 @@ func (m *awsAwsjson11_deserializeOpStartQuery) HandleDeserialize(ctx context.Con } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorStartQuery(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorPutBearerTokenAuthentication(response, &metadata) } - output := &StartQueryOutput{} + output := &PutBearerTokenAuthenticationOutput{} out.Result = output - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - - body := io.TeeReader(response.Body, ringBuffer) - decoder := json.NewDecoder(body) - decoder.UseNumber() - var shape interface{} - if err := decoder.Decode(&shape); err != nil && err != io.EOF { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return out, metadata, err - } - - err = awsAwsjson11_deserializeOpDocumentStartQueryOutput(&output, shape) - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), + if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { + return out, metadata, &smithy.DeserializationError{ + Err: fmt.Errorf("failed to discard response body, %w", err), } - return out, metadata, err } return out, metadata, err } -func awsAwsjson11_deserializeOpErrorStartQuery(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorPutBearerTokenAuthentication(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -8931,14 +9022,17 @@ func awsAwsjson11_deserializeOpErrorStartQuery(response *smithyhttp.Response, me errorMessage = bodyInfo.Message } switch { + case strings.EqualFold("AccessDeniedException", errorCode): + return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) + + case strings.EqualFold("InvalidOperationException", errorCode): + return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody) + case strings.EqualFold("InvalidParameterException", errorCode): return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) - case strings.EqualFold("LimitExceededException", errorCode): - return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) - - case strings.EqualFold("MalformedQueryException", errorCode): - return awsAwsjson11_deserializeErrorMalformedQueryException(response, errorBody) + case strings.EqualFold("OperationAbortedException", errorCode): + return awsAwsjson11_deserializeErrorOperationAbortedException(response, errorBody) case strings.EqualFold("ResourceNotFoundException", errorCode): return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) @@ -8956,14 +9050,14 @@ func awsAwsjson11_deserializeOpErrorStartQuery(response *smithyhttp.Response, me } } -type awsAwsjson11_deserializeOpStopQuery struct { +type awsAwsjson11_deserializeOpPutDataProtectionPolicy struct { } -func (*awsAwsjson11_deserializeOpStopQuery) ID() string { +func (*awsAwsjson11_deserializeOpPutDataProtectionPolicy) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpStopQuery) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpPutDataProtectionPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -8981,9 +9075,9 @@ func (m *awsAwsjson11_deserializeOpStopQuery) HandleDeserialize(ctx context.Cont } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorStopQuery(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorPutDataProtectionPolicy(response, &metadata) } - output := &StopQueryOutput{} + output := &PutDataProtectionPolicyOutput{} out.Result = output var buff [1024]byte @@ -9003,7 +9097,7 @@ func (m *awsAwsjson11_deserializeOpStopQuery) HandleDeserialize(ctx context.Cont return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentStopQueryOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentPutDataProtectionPolicyOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -9017,7 +9111,7 @@ func (m *awsAwsjson11_deserializeOpStopQuery) HandleDeserialize(ctx context.Cont return out, metadata, err } -func awsAwsjson11_deserializeOpErrorStopQuery(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorPutDataProtectionPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -9057,6 +9151,12 @@ func awsAwsjson11_deserializeOpErrorStopQuery(response *smithyhttp.Response, met case strings.EqualFold("InvalidParameterException", errorCode): return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) + case strings.EqualFold("LimitExceededException", errorCode): + return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) + + case strings.EqualFold("OperationAbortedException", errorCode): + return awsAwsjson11_deserializeErrorOperationAbortedException(response, errorBody) + case strings.EqualFold("ResourceNotFoundException", errorCode): return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) @@ -9073,14 +9173,14 @@ func awsAwsjson11_deserializeOpErrorStopQuery(response *smithyhttp.Response, met } } -type awsAwsjson11_deserializeOpTagLogGroup struct { +type awsAwsjson11_deserializeOpPutDeliveryDestination struct { } -func (*awsAwsjson11_deserializeOpTagLogGroup) ID() string { +func (*awsAwsjson11_deserializeOpPutDeliveryDestination) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpTagLogGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpPutDeliveryDestination) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -9098,21 +9198,43 @@ func (m *awsAwsjson11_deserializeOpTagLogGroup) HandleDeserialize(ctx context.Co } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorTagLogGroup(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorPutDeliveryDestination(response, &metadata) } - output := &TagLogGroupOutput{} + output := &PutDeliveryDestinationOutput{} out.Result = output - if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { - return out, metadata, &smithy.DeserializationError{ - Err: fmt.Errorf("failed to discard response body, %w", err), + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(response.Body, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + var shape interface{} + if err := decoder.Decode(&shape); err != nil && err != io.EOF { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return out, metadata, err + } + + err = awsAwsjson11_deserializeOpDocumentPutDeliveryDestinationOutput(&output, shape) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), } + return out, metadata, err } return out, metadata, err } -func awsAwsjson11_deserializeOpErrorTagLogGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorPutDeliveryDestination(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -9149,12 +9271,24 @@ func awsAwsjson11_deserializeOpErrorTagLogGroup(response *smithyhttp.Response, m errorMessage = bodyInfo.Message } switch { - case strings.EqualFold("InvalidParameterException", errorCode): - return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) + case strings.EqualFold("ConflictException", errorCode): + return awsAwsjson11_deserializeErrorConflictException(response, errorBody) case strings.EqualFold("ResourceNotFoundException", errorCode): return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) + case strings.EqualFold("ServiceQuotaExceededException", errorCode): + return awsAwsjson11_deserializeErrorServiceQuotaExceededException(response, errorBody) + + case strings.EqualFold("ServiceUnavailableException", errorCode): + return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) + + case strings.EqualFold("ThrottlingException", errorCode): + return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) + + case strings.EqualFold("ValidationException", errorCode): + return awsAwsjson11_deserializeErrorValidationException(response, errorBody) + default: genericError := &smithy.GenericAPIError{ Code: errorCode, @@ -9165,14 +9299,14 @@ func awsAwsjson11_deserializeOpErrorTagLogGroup(response *smithyhttp.Response, m } } -type awsAwsjson11_deserializeOpTagResource struct { +type awsAwsjson11_deserializeOpPutDeliveryDestinationPolicy struct { } -func (*awsAwsjson11_deserializeOpTagResource) ID() string { +func (*awsAwsjson11_deserializeOpPutDeliveryDestinationPolicy) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpTagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpPutDeliveryDestinationPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -9190,21 +9324,43 @@ func (m *awsAwsjson11_deserializeOpTagResource) HandleDeserialize(ctx context.Co } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorTagResource(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorPutDeliveryDestinationPolicy(response, &metadata) } - output := &TagResourceOutput{} + output := &PutDeliveryDestinationPolicyOutput{} out.Result = output - if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { - return out, metadata, &smithy.DeserializationError{ - Err: fmt.Errorf("failed to discard response body, %w", err), + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(response.Body, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + var shape interface{} + if err := decoder.Decode(&shape); err != nil && err != io.EOF { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return out, metadata, err + } + + err = awsAwsjson11_deserializeOpDocumentPutDeliveryDestinationPolicyOutput(&output, shape) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), } + return out, metadata, err } return out, metadata, err } -func awsAwsjson11_deserializeOpErrorTagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorPutDeliveryDestinationPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -9241,8 +9397,8 @@ func awsAwsjson11_deserializeOpErrorTagResource(response *smithyhttp.Response, m errorMessage = bodyInfo.Message } switch { - case strings.EqualFold("InvalidParameterException", errorCode): - return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) + case strings.EqualFold("ConflictException", errorCode): + return awsAwsjson11_deserializeErrorConflictException(response, errorBody) case strings.EqualFold("ResourceNotFoundException", errorCode): return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) @@ -9250,8 +9406,8 @@ func awsAwsjson11_deserializeOpErrorTagResource(response *smithyhttp.Response, m case strings.EqualFold("ServiceUnavailableException", errorCode): return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) - case strings.EqualFold("TooManyTagsException", errorCode): - return awsAwsjson11_deserializeErrorTooManyTagsException(response, errorBody) + case strings.EqualFold("ValidationException", errorCode): + return awsAwsjson11_deserializeErrorValidationException(response, errorBody) default: genericError := &smithy.GenericAPIError{ @@ -9263,14 +9419,14 @@ func awsAwsjson11_deserializeOpErrorTagResource(response *smithyhttp.Response, m } } -type awsAwsjson11_deserializeOpTestMetricFilter struct { +type awsAwsjson11_deserializeOpPutDeliverySource struct { } -func (*awsAwsjson11_deserializeOpTestMetricFilter) ID() string { +func (*awsAwsjson11_deserializeOpPutDeliverySource) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpTestMetricFilter) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpPutDeliverySource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -9288,9 +9444,9 @@ func (m *awsAwsjson11_deserializeOpTestMetricFilter) HandleDeserialize(ctx conte } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorTestMetricFilter(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorPutDeliverySource(response, &metadata) } - output := &TestMetricFilterOutput{} + output := &PutDeliverySourceOutput{} out.Result = output var buff [1024]byte @@ -9310,7 +9466,7 @@ func (m *awsAwsjson11_deserializeOpTestMetricFilter) HandleDeserialize(ctx conte return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentTestMetricFilterOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentPutDeliverySourceOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -9324,7 +9480,7 @@ func (m *awsAwsjson11_deserializeOpTestMetricFilter) HandleDeserialize(ctx conte return out, metadata, err } -func awsAwsjson11_deserializeOpErrorTestMetricFilter(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorPutDeliverySource(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -9361,30 +9517,42 @@ func awsAwsjson11_deserializeOpErrorTestMetricFilter(response *smithyhttp.Respon errorMessage = bodyInfo.Message } switch { - case strings.EqualFold("InvalidParameterException", errorCode): - return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) + case strings.EqualFold("ConflictException", errorCode): + return awsAwsjson11_deserializeErrorConflictException(response, errorBody) + + case strings.EqualFold("ResourceNotFoundException", errorCode): + return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) + + case strings.EqualFold("ServiceQuotaExceededException", errorCode): + return awsAwsjson11_deserializeErrorServiceQuotaExceededException(response, errorBody) case strings.EqualFold("ServiceUnavailableException", errorCode): return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) - default: - genericError := &smithy.GenericAPIError{ - Code: errorCode, - Message: errorMessage, + case strings.EqualFold("ThrottlingException", errorCode): + return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) + + case strings.EqualFold("ValidationException", errorCode): + return awsAwsjson11_deserializeErrorValidationException(response, errorBody) + + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, } return genericError } } -type awsAwsjson11_deserializeOpTestTransformer struct { +type awsAwsjson11_deserializeOpPutDestination struct { } -func (*awsAwsjson11_deserializeOpTestTransformer) ID() string { +func (*awsAwsjson11_deserializeOpPutDestination) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpTestTransformer) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpPutDestination) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -9402,9 +9570,9 @@ func (m *awsAwsjson11_deserializeOpTestTransformer) HandleDeserialize(ctx contex } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorTestTransformer(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorPutDestination(response, &metadata) } - output := &TestTransformerOutput{} + output := &PutDestinationOutput{} out.Result = output var buff [1024]byte @@ -9424,7 +9592,7 @@ func (m *awsAwsjson11_deserializeOpTestTransformer) HandleDeserialize(ctx contex return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentTestTransformerOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentPutDestinationOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -9438,7 +9606,7 @@ func (m *awsAwsjson11_deserializeOpTestTransformer) HandleDeserialize(ctx contex return out, metadata, err } -func awsAwsjson11_deserializeOpErrorTestTransformer(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorPutDestination(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -9475,12 +9643,12 @@ func awsAwsjson11_deserializeOpErrorTestTransformer(response *smithyhttp.Respons errorMessage = bodyInfo.Message } switch { - case strings.EqualFold("InvalidOperationException", errorCode): - return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody) - case strings.EqualFold("InvalidParameterException", errorCode): return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) + case strings.EqualFold("OperationAbortedException", errorCode): + return awsAwsjson11_deserializeErrorOperationAbortedException(response, errorBody) + case strings.EqualFold("ServiceUnavailableException", errorCode): return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) @@ -9494,14 +9662,14 @@ func awsAwsjson11_deserializeOpErrorTestTransformer(response *smithyhttp.Respons } } -type awsAwsjson11_deserializeOpUntagLogGroup struct { +type awsAwsjson11_deserializeOpPutDestinationPolicy struct { } -func (*awsAwsjson11_deserializeOpUntagLogGroup) ID() string { +func (*awsAwsjson11_deserializeOpPutDestinationPolicy) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpUntagLogGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpPutDestinationPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -9519,9 +9687,9 @@ func (m *awsAwsjson11_deserializeOpUntagLogGroup) HandleDeserialize(ctx context. } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorUntagLogGroup(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorPutDestinationPolicy(response, &metadata) } - output := &UntagLogGroupOutput{} + output := &PutDestinationPolicyOutput{} out.Result = output if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { @@ -9533,7 +9701,7 @@ func (m *awsAwsjson11_deserializeOpUntagLogGroup) HandleDeserialize(ctx context. return out, metadata, err } -func awsAwsjson11_deserializeOpErrorUntagLogGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorPutDestinationPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -9570,8 +9738,14 @@ func awsAwsjson11_deserializeOpErrorUntagLogGroup(response *smithyhttp.Response, errorMessage = bodyInfo.Message } switch { - case strings.EqualFold("ResourceNotFoundException", errorCode): - return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) + case strings.EqualFold("InvalidParameterException", errorCode): + return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) + + case strings.EqualFold("OperationAbortedException", errorCode): + return awsAwsjson11_deserializeErrorOperationAbortedException(response, errorBody) + + case strings.EqualFold("ServiceUnavailableException", errorCode): + return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) default: genericError := &smithy.GenericAPIError{ @@ -9583,14 +9757,14 @@ func awsAwsjson11_deserializeOpErrorUntagLogGroup(response *smithyhttp.Response, } } -type awsAwsjson11_deserializeOpUntagResource struct { +type awsAwsjson11_deserializeOpPutIndexPolicy struct { } -func (*awsAwsjson11_deserializeOpUntagResource) ID() string { +func (*awsAwsjson11_deserializeOpPutIndexPolicy) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpUntagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpPutIndexPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -9608,21 +9782,43 @@ func (m *awsAwsjson11_deserializeOpUntagResource) HandleDeserialize(ctx context. } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorUntagResource(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorPutIndexPolicy(response, &metadata) } - output := &UntagResourceOutput{} + output := &PutIndexPolicyOutput{} out.Result = output - if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { - return out, metadata, &smithy.DeserializationError{ - Err: fmt.Errorf("failed to discard response body, %w", err), + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(response.Body, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + var shape interface{} + if err := decoder.Decode(&shape); err != nil && err != io.EOF { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return out, metadata, err + } + + err = awsAwsjson11_deserializeOpDocumentPutIndexPolicyOutput(&output, shape) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), } + return out, metadata, err } return out, metadata, err } -func awsAwsjson11_deserializeOpErrorUntagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorPutIndexPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -9662,6 +9858,12 @@ func awsAwsjson11_deserializeOpErrorUntagResource(response *smithyhttp.Response, case strings.EqualFold("InvalidParameterException", errorCode): return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) + case strings.EqualFold("LimitExceededException", errorCode): + return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) + + case strings.EqualFold("OperationAbortedException", errorCode): + return awsAwsjson11_deserializeErrorOperationAbortedException(response, errorBody) + case strings.EqualFold("ResourceNotFoundException", errorCode): return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) @@ -9678,14 +9880,14 @@ func awsAwsjson11_deserializeOpErrorUntagResource(response *smithyhttp.Response, } } -type awsAwsjson11_deserializeOpUpdateAnomaly struct { +type awsAwsjson11_deserializeOpPutIntegration struct { } -func (*awsAwsjson11_deserializeOpUpdateAnomaly) ID() string { +func (*awsAwsjson11_deserializeOpPutIntegration) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpUpdateAnomaly) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpPutIntegration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -9703,21 +9905,43 @@ func (m *awsAwsjson11_deserializeOpUpdateAnomaly) HandleDeserialize(ctx context. } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorUpdateAnomaly(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorPutIntegration(response, &metadata) } - output := &UpdateAnomalyOutput{} + output := &PutIntegrationOutput{} out.Result = output - if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { - return out, metadata, &smithy.DeserializationError{ - Err: fmt.Errorf("failed to discard response body, %w", err), + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(response.Body, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + var shape interface{} + if err := decoder.Decode(&shape); err != nil && err != io.EOF { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return out, metadata, err + } + + err = awsAwsjson11_deserializeOpDocumentPutIntegrationOutput(&output, shape) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), } + return out, metadata, err } return out, metadata, err } -func awsAwsjson11_deserializeOpErrorUpdateAnomaly(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorPutIntegration(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -9757,15 +9981,15 @@ func awsAwsjson11_deserializeOpErrorUpdateAnomaly(response *smithyhttp.Response, case strings.EqualFold("InvalidParameterException", errorCode): return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) - case strings.EqualFold("OperationAbortedException", errorCode): - return awsAwsjson11_deserializeErrorOperationAbortedException(response, errorBody) - - case strings.EqualFold("ResourceNotFoundException", errorCode): - return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) + case strings.EqualFold("LimitExceededException", errorCode): + return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) case strings.EqualFold("ServiceUnavailableException", errorCode): return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) + case strings.EqualFold("ValidationException", errorCode): + return awsAwsjson11_deserializeErrorValidationException(response, errorBody) + default: genericError := &smithy.GenericAPIError{ Code: errorCode, @@ -9776,14 +10000,14 @@ func awsAwsjson11_deserializeOpErrorUpdateAnomaly(response *smithyhttp.Response, } } -type awsAwsjson11_deserializeOpUpdateDeliveryConfiguration struct { +type awsAwsjson11_deserializeOpPutLogEvents struct { } -func (*awsAwsjson11_deserializeOpUpdateDeliveryConfiguration) ID() string { +func (*awsAwsjson11_deserializeOpPutLogEvents) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpUpdateDeliveryConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpPutLogEvents) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -9801,9 +10025,9 @@ func (m *awsAwsjson11_deserializeOpUpdateDeliveryConfiguration) HandleDeserializ } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorUpdateDeliveryConfiguration(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorPutLogEvents(response, &metadata) } - output := &UpdateDeliveryConfigurationOutput{} + output := &PutLogEventsOutput{} out.Result = output var buff [1024]byte @@ -9823,7 +10047,7 @@ func (m *awsAwsjson11_deserializeOpUpdateDeliveryConfiguration) HandleDeserializ return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentUpdateDeliveryConfigurationOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentPutLogEventsOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -9837,7 +10061,7 @@ func (m *awsAwsjson11_deserializeOpUpdateDeliveryConfiguration) HandleDeserializ return out, metadata, err } -func awsAwsjson11_deserializeOpErrorUpdateDeliveryConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorPutLogEvents(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -9874,11 +10098,14 @@ func awsAwsjson11_deserializeOpErrorUpdateDeliveryConfiguration(response *smithy errorMessage = bodyInfo.Message } switch { - case strings.EqualFold("AccessDeniedException", errorCode): - return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) + case strings.EqualFold("DataAlreadyAcceptedException", errorCode): + return awsAwsjson11_deserializeErrorDataAlreadyAcceptedException(response, errorBody) - case strings.EqualFold("ConflictException", errorCode): - return awsAwsjson11_deserializeErrorConflictException(response, errorBody) + case strings.EqualFold("InvalidParameterException", errorCode): + return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) + + case strings.EqualFold("InvalidSequenceTokenException", errorCode): + return awsAwsjson11_deserializeErrorInvalidSequenceTokenException(response, errorBody) case strings.EqualFold("ResourceNotFoundException", errorCode): return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) @@ -9886,11 +10113,8 @@ func awsAwsjson11_deserializeOpErrorUpdateDeliveryConfiguration(response *smithy case strings.EqualFold("ServiceUnavailableException", errorCode): return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) - case strings.EqualFold("ThrottlingException", errorCode): - return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) - - case strings.EqualFold("ValidationException", errorCode): - return awsAwsjson11_deserializeErrorValidationException(response, errorBody) + case strings.EqualFold("UnrecognizedClientException", errorCode): + return awsAwsjson11_deserializeErrorUnrecognizedClientException(response, errorBody) default: genericError := &smithy.GenericAPIError{ @@ -9902,14 +10126,14 @@ func awsAwsjson11_deserializeOpErrorUpdateDeliveryConfiguration(response *smithy } } -type awsAwsjson11_deserializeOpUpdateLogAnomalyDetector struct { +type awsAwsjson11_deserializeOpPutLogGroupDeletionProtection struct { } -func (*awsAwsjson11_deserializeOpUpdateLogAnomalyDetector) ID() string { +func (*awsAwsjson11_deserializeOpPutLogGroupDeletionProtection) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpUpdateLogAnomalyDetector) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpPutLogGroupDeletionProtection) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -9927,9 +10151,9 @@ func (m *awsAwsjson11_deserializeOpUpdateLogAnomalyDetector) HandleDeserialize(c } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorUpdateLogAnomalyDetector(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorPutLogGroupDeletionProtection(response, &metadata) } - output := &UpdateLogAnomalyDetectorOutput{} + output := &PutLogGroupDeletionProtectionOutput{} out.Result = output if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { @@ -9941,7 +10165,7 @@ func (m *awsAwsjson11_deserializeOpUpdateLogAnomalyDetector) HandleDeserialize(c return out, metadata, err } -func awsAwsjson11_deserializeOpErrorUpdateLogAnomalyDetector(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorPutLogGroupDeletionProtection(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -9978,6 +10202,12 @@ func awsAwsjson11_deserializeOpErrorUpdateLogAnomalyDetector(response *smithyhtt errorMessage = bodyInfo.Message } switch { + case strings.EqualFold("AccessDeniedException", errorCode): + return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) + + case strings.EqualFold("InvalidOperationException", errorCode): + return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody) + case strings.EqualFold("InvalidParameterException", errorCode): return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) @@ -10000,102 +10230,65 @@ func awsAwsjson11_deserializeOpErrorUpdateLogAnomalyDetector(response *smithyhtt } } -func awsAwsjson11_deserializeEventStreamStartLiveTailResponseStream(v *types.StartLiveTailResponseStream, msg *eventstream.Message) error { - if v == nil { - return fmt.Errorf("unexpected serialization of nil %T", v) - } +type awsAwsjson11_deserializeOpPutMetricFilter struct { +} - eventType := msg.Headers.Get(eventstreamapi.EventTypeHeader) - if eventType == nil { - return fmt.Errorf("%s event header not present", eventstreamapi.EventTypeHeader) +func (*awsAwsjson11_deserializeOpPutMetricFilter) ID() string { + return "OperationDeserializer" +} + +func (m *awsAwsjson11_deserializeOpPutMetricFilter) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( + out middleware.DeserializeOutput, metadata middleware.Metadata, err error, +) { + out, metadata, err = next.HandleDeserialize(ctx, in) + if err != nil { + return out, metadata, err } - switch { - case strings.EqualFold("sessionStart", eventType.String()): - vv := &types.StartLiveTailResponseStreamMemberSessionStart{} - if err := awsAwsjson11_deserializeEventMessageLiveTailSessionStart(&vv.Value, msg); err != nil { - return err - } - *v = vv - return nil + _, span := tracing.StartSpan(ctx, "OperationDeserializer") + endTimer := startMetricTimer(ctx, "client.call.deserialization_duration") + defer endTimer() + defer span.End() + response, ok := out.RawResponse.(*smithyhttp.Response) + if !ok { + return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} + } - case strings.EqualFold("sessionUpdate", eventType.String()): - vv := &types.StartLiveTailResponseStreamMemberSessionUpdate{} - if err := awsAwsjson11_deserializeEventMessageLiveTailSessionUpdate(&vv.Value, msg); err != nil { - return err - } - *v = vv - return nil + if response.StatusCode < 200 || response.StatusCode >= 300 { + return out, metadata, awsAwsjson11_deserializeOpErrorPutMetricFilter(response, &metadata) + } + output := &PutMetricFilterOutput{} + out.Result = output - default: - buffer := bytes.NewBuffer(nil) - eventstream.NewEncoder().Encode(buffer, *msg) - *v = &types.UnknownUnionMember{ - Tag: eventType.String(), - Value: buffer.Bytes(), + if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { + return out, metadata, &smithy.DeserializationError{ + Err: fmt.Errorf("failed to discard response body, %w", err), } - return nil - } + + return out, metadata, err } -func awsAwsjson11_deserializeEventStreamExceptionStartLiveTailResponseStream(msg *eventstream.Message) error { - exceptionType := msg.Headers.Get(eventstreamapi.ExceptionTypeHeader) - if exceptionType == nil { - return fmt.Errorf("%s event header not present", eventstreamapi.ExceptionTypeHeader) +func awsAwsjson11_deserializeOpErrorPutMetricFilter(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.Buffer + if _, err := io.Copy(&errorBuffer, response.Body); err != nil { + return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} } + errorBody := bytes.NewReader(errorBuffer.Bytes()) - switch { - case strings.EqualFold("SessionStreamingException", exceptionType.String()): - return awsAwsjson11_deserializeEventMessageExceptionSessionStreamingException(msg) - - case strings.EqualFold("SessionTimeoutException", exceptionType.String()): - return awsAwsjson11_deserializeEventMessageExceptionSessionTimeoutException(msg) - - default: - br := bytes.NewReader(msg.Payload) - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - - body := io.TeeReader(br, ringBuffer) - decoder := json.NewDecoder(body) - decoder.UseNumber() - code, message, err := restjson.GetErrorInfo(decoder) - if err != nil { - return err - } - errorCode := "UnknownError" - errorMessage := errorCode - if ev := exceptionType.String(); len(ev) > 0 { - errorCode = ev - } else if ev := code; len(ev) > 0 { - errorCode = ev - } - if ev := message; len(ev) > 0 { - errorMessage = ev - } - return &smithy.GenericAPIError{ - Code: errorCode, - Message: errorMessage, - } - - } -} + errorCode := "UnknownError" + errorMessage := errorCode -func awsAwsjson11_deserializeEventMessageLiveTailSessionStart(v *types.LiveTailSessionStart, msg *eventstream.Message) error { - if v == nil { - return fmt.Errorf("unexpected serialization of nil %T", v) - } + headerCode := response.Header.Get("X-Amzn-ErrorType") - br := bytes.NewReader(msg.Payload) var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) - body := io.TeeReader(br, ringBuffer) + body := io.TeeReader(errorBody, ringBuffer) decoder := json.NewDecoder(body) decoder.UseNumber() - var shape interface{} - if err := decoder.Decode(&shape); err != nil && err != io.EOF { + bodyInfo, err := getProtocolErrorInfo(decoder) + if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) err = &smithy.DeserializationError{ @@ -10105,31 +10298,76 @@ func awsAwsjson11_deserializeEventMessageLiveTailSessionStart(v *types.LiveTailS return err } - if err := awsAwsjson11_deserializeDocumentLiveTailSessionStart(&v, shape); err != nil { - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return err + errorBody.Seek(0, io.SeekStart) + if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok { + errorCode = restjson.SanitizeErrorCode(typ) + } + if len(bodyInfo.Message) != 0 { + errorMessage = bodyInfo.Message + } + switch { + case strings.EqualFold("InvalidOperationException", errorCode): + return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody) + + case strings.EqualFold("InvalidParameterException", errorCode): + return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) + + case strings.EqualFold("LimitExceededException", errorCode): + return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) + + case strings.EqualFold("OperationAbortedException", errorCode): + return awsAwsjson11_deserializeErrorOperationAbortedException(response, errorBody) + + case strings.EqualFold("ResourceNotFoundException", errorCode): + return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) + + case strings.EqualFold("ServiceUnavailableException", errorCode): + return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) + + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, } + return genericError } - return nil } -func awsAwsjson11_deserializeEventMessageLiveTailSessionUpdate(v *types.LiveTailSessionUpdate, msg *eventstream.Message) error { - if v == nil { - return fmt.Errorf("unexpected serialization of nil %T", v) +type awsAwsjson11_deserializeOpPutQueryDefinition struct { +} + +func (*awsAwsjson11_deserializeOpPutQueryDefinition) ID() string { + return "OperationDeserializer" +} + +func (m *awsAwsjson11_deserializeOpPutQueryDefinition) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( + out middleware.DeserializeOutput, metadata middleware.Metadata, err error, +) { + out, metadata, err = next.HandleDeserialize(ctx, in) + if err != nil { + return out, metadata, err } - br := bytes.NewReader(msg.Payload) + _, span := tracing.StartSpan(ctx, "OperationDeserializer") + endTimer := startMetricTimer(ctx, "client.call.deserialization_duration") + defer endTimer() + defer span.End() + response, ok := out.RawResponse.(*smithyhttp.Response) + if !ok { + return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} + } + + if response.StatusCode < 200 || response.StatusCode >= 300 { + return out, metadata, awsAwsjson11_deserializeOpErrorPutQueryDefinition(response, &metadata) + } + output := &PutQueryDefinitionOutput{} + out.Result = output + var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) - body := io.TeeReader(br, ringBuffer) + body := io.TeeReader(response.Body, ringBuffer) decoder := json.NewDecoder(body) decoder.UseNumber() var shape interface{} @@ -10140,34 +10378,43 @@ func awsAwsjson11_deserializeEventMessageLiveTailSessionUpdate(v *types.LiveTail Err: fmt.Errorf("failed to decode response body, %w", err), Snapshot: snapshot.Bytes(), } - return err + return out, metadata, err } - if err := awsAwsjson11_deserializeDocumentLiveTailSessionUpdate(&v, shape); err != nil { - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return err + err = awsAwsjson11_deserializeOpDocumentPutQueryDefinitionOutput(&output, shape) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), } - + return out, metadata, err } - return nil + + return out, metadata, err } -func awsAwsjson11_deserializeEventMessageExceptionSessionTimeoutException(msg *eventstream.Message) error { - br := bytes.NewReader(msg.Payload) +func awsAwsjson11_deserializeOpErrorPutQueryDefinition(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.Buffer + if _, err := io.Copy(&errorBuffer, response.Body); err != nil { + return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} + } + errorBody := bytes.NewReader(errorBuffer.Bytes()) + + errorCode := "UnknownError" + errorMessage := errorCode + + headerCode := response.Header.Get("X-Amzn-ErrorType") + var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) - body := io.TeeReader(br, ringBuffer) + body := io.TeeReader(errorBody, ringBuffer) decoder := json.NewDecoder(body) decoder.UseNumber() - var shape interface{} - if err := decoder.Decode(&shape); err != nil && err != io.EOF { + bodyInfo, err := getProtocolErrorInfo(decoder) + if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) err = &smithy.DeserializationError{ @@ -10177,28 +10424,70 @@ func awsAwsjson11_deserializeEventMessageExceptionSessionTimeoutException(msg *e return err } - v := &types.SessionTimeoutException{} - if err := awsAwsjson11_deserializeDocumentSessionTimeoutException(&v, shape); err != nil { - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return err + errorBody.Seek(0, io.SeekStart) + if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok { + errorCode = restjson.SanitizeErrorCode(typ) + } + if len(bodyInfo.Message) != 0 { + errorMessage = bodyInfo.Message + } + switch { + case strings.EqualFold("InvalidParameterException", errorCode): + return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) + + case strings.EqualFold("LimitExceededException", errorCode): + return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) + + case strings.EqualFold("ResourceNotFoundException", errorCode): + return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) + + case strings.EqualFold("ServiceUnavailableException", errorCode): + return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) + + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, } + return genericError } - return v } -func awsAwsjson11_deserializeEventMessageExceptionSessionStreamingException(msg *eventstream.Message) error { - br := bytes.NewReader(msg.Payload) +type awsAwsjson11_deserializeOpPutResourcePolicy struct { +} + +func (*awsAwsjson11_deserializeOpPutResourcePolicy) ID() string { + return "OperationDeserializer" +} + +func (m *awsAwsjson11_deserializeOpPutResourcePolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( + out middleware.DeserializeOutput, metadata middleware.Metadata, err error, +) { + out, metadata, err = next.HandleDeserialize(ctx, in) + if err != nil { + return out, metadata, err + } + + _, span := tracing.StartSpan(ctx, "OperationDeserializer") + endTimer := startMetricTimer(ctx, "client.call.deserialization_duration") + defer endTimer() + defer span.End() + response, ok := out.RawResponse.(*smithyhttp.Response) + if !ok { + return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} + } + + if response.StatusCode < 200 || response.StatusCode >= 300 { + return out, metadata, awsAwsjson11_deserializeOpErrorPutResourcePolicy(response, &metadata) + } + output := &PutResourcePolicyOutput{} + out.Result = output + var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) - body := io.TeeReader(br, ringBuffer) + body := io.TeeReader(response.Body, ringBuffer) decoder := json.NewDecoder(body) decoder.UseNumber() var shape interface{} @@ -10209,525 +10498,444 @@ func awsAwsjson11_deserializeEventMessageExceptionSessionStreamingException(msg Err: fmt.Errorf("failed to decode response body, %w", err), Snapshot: snapshot.Bytes(), } - return err + return out, metadata, err } - v := &types.SessionStreamingException{} - if err := awsAwsjson11_deserializeDocumentSessionStreamingException(&v, shape); err != nil { - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return err - } - + err = awsAwsjson11_deserializeOpDocumentPutResourcePolicyOutput(&output, shape) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return out, metadata, err } - return v + + return out, metadata, err } -func awsAwsjson11_deserializeDocumentInputLogStreamNames(v *[]string, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil +func awsAwsjson11_deserializeOpErrorPutResourcePolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.Buffer + if _, err := io.Copy(&errorBuffer, response.Body); err != nil { + return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} } + errorBody := bytes.NewReader(errorBuffer.Bytes()) - shape, ok := value.([]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } + errorCode := "UnknownError" + errorMessage := errorCode - var cv []string - if *v == nil { - cv = []string{} - } else { - cv = *v - } + headerCode := response.Header.Get("X-Amzn-ErrorType") - for _, value := range shape { - var col string - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected LogStreamName to be of type string, got %T instead", value) - } - col = jtv - } - cv = append(cv, col) + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + body := io.TeeReader(errorBody, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + bodyInfo, err := getProtocolErrorInfo(decoder) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err } - *v = cv - return nil -} -func awsAwsjson11_deserializeDocumentLiveTailSessionLogEvent(v **types.LiveTailSessionLogEvent, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil + errorBody.Seek(0, io.SeekStart) + if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok { + errorCode = restjson.SanitizeErrorCode(typ) } - - shape, ok := value.(map[string]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) + if len(bodyInfo.Message) != 0 { + errorMessage = bodyInfo.Message } + switch { + case strings.EqualFold("InvalidParameterException", errorCode): + return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) - var sv *types.LiveTailSessionLogEvent - if *v == nil { - sv = &types.LiveTailSessionLogEvent{} - } else { - sv = *v - } + case strings.EqualFold("LimitExceededException", errorCode): + return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) - for key, value := range shape { - switch key { - case "ingestionTime": - if value != nil { - jtv, ok := value.(json.Number) - if !ok { - return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) - } - i64, err := jtv.Int64() - if err != nil { - return err - } - sv.IngestionTime = ptr.Int64(i64) - } + case strings.EqualFold("OperationAbortedException", errorCode): + return awsAwsjson11_deserializeErrorOperationAbortedException(response, errorBody) - case "logGroupIdentifier": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected LogGroupIdentifier to be of type string, got %T instead", value) - } - sv.LogGroupIdentifier = ptr.String(jtv) - } + case strings.EqualFold("ResourceNotFoundException", errorCode): + return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) - case "logStreamName": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected LogStreamName to be of type string, got %T instead", value) - } - sv.LogStreamName = ptr.String(jtv) - } + case strings.EqualFold("ServiceUnavailableException", errorCode): + return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) - case "message": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected EventMessage to be of type string, got %T instead", value) - } - sv.Message = ptr.String(jtv) - } + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, + } + return genericError - case "timestamp": - if value != nil { - jtv, ok := value.(json.Number) - if !ok { - return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) - } - i64, err := jtv.Int64() - if err != nil { - return err - } - sv.Timestamp = ptr.Int64(i64) - } + } +} - default: - _, _ = key, value +type awsAwsjson11_deserializeOpPutRetentionPolicy struct { +} - } - } - *v = sv - return nil +func (*awsAwsjson11_deserializeOpPutRetentionPolicy) ID() string { + return "OperationDeserializer" } -func awsAwsjson11_deserializeDocumentLiveTailSessionMetadata(v **types.LiveTailSessionMetadata, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil +func (m *awsAwsjson11_deserializeOpPutRetentionPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( + out middleware.DeserializeOutput, metadata middleware.Metadata, err error, +) { + out, metadata, err = next.HandleDeserialize(ctx, in) + if err != nil { + return out, metadata, err } - shape, ok := value.(map[string]interface{}) + _, span := tracing.StartSpan(ctx, "OperationDeserializer") + endTimer := startMetricTimer(ctx, "client.call.deserialization_duration") + defer endTimer() + defer span.End() + response, ok := out.RawResponse.(*smithyhttp.Response) if !ok { - return fmt.Errorf("unexpected JSON type %v", value) + return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} } - var sv *types.LiveTailSessionMetadata - if *v == nil { - sv = &types.LiveTailSessionMetadata{} - } else { - sv = *v + if response.StatusCode < 200 || response.StatusCode >= 300 { + return out, metadata, awsAwsjson11_deserializeOpErrorPutRetentionPolicy(response, &metadata) } + output := &PutRetentionPolicyOutput{} + out.Result = output - for key, value := range shape { - switch key { - case "sampled": - if value != nil { - jtv, ok := value.(bool) - if !ok { - return fmt.Errorf("expected IsSampled to be of type *bool, got %T instead", value) - } - sv.Sampled = jtv - } - - default: - _, _ = key, value - + if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { + return out, metadata, &smithy.DeserializationError{ + Err: fmt.Errorf("failed to discard response body, %w", err), } } - *v = sv - return nil -} -func awsAwsjson11_deserializeDocumentLiveTailSessionResults(v *[]types.LiveTailSessionLogEvent, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } + return out, metadata, err +} - shape, ok := value.([]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) +func awsAwsjson11_deserializeOpErrorPutRetentionPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.Buffer + if _, err := io.Copy(&errorBuffer, response.Body); err != nil { + return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} } + errorBody := bytes.NewReader(errorBuffer.Bytes()) - var cv []types.LiveTailSessionLogEvent - if *v == nil { - cv = []types.LiveTailSessionLogEvent{} - } else { - cv = *v - } + errorCode := "UnknownError" + errorMessage := errorCode - for _, value := range shape { - var col types.LiveTailSessionLogEvent - destAddr := &col - if err := awsAwsjson11_deserializeDocumentLiveTailSessionLogEvent(&destAddr, value); err != nil { - return err - } - col = *destAddr - cv = append(cv, col) + headerCode := response.Header.Get("X-Amzn-ErrorType") - } - *v = cv - return nil -} + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) -func awsAwsjson11_deserializeDocumentLiveTailSessionStart(v **types.LiveTailSessionStart, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil + body := io.TeeReader(errorBody, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + bodyInfo, err := getProtocolErrorInfo(decoder) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err } - shape, ok := value.(map[string]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) + errorBody.Seek(0, io.SeekStart) + if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok { + errorCode = restjson.SanitizeErrorCode(typ) } - - var sv *types.LiveTailSessionStart - if *v == nil { - sv = &types.LiveTailSessionStart{} - } else { - sv = *v + if len(bodyInfo.Message) != 0 { + errorMessage = bodyInfo.Message } + switch { + case strings.EqualFold("InvalidParameterException", errorCode): + return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) - for key, value := range shape { - switch key { - case "logEventFilterPattern": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected FilterPattern to be of type string, got %T instead", value) - } - sv.LogEventFilterPattern = ptr.String(jtv) - } - - case "logGroupIdentifiers": - if err := awsAwsjson11_deserializeDocumentStartLiveTailLogGroupIdentifiers(&sv.LogGroupIdentifiers, value); err != nil { - return err - } + case strings.EqualFold("OperationAbortedException", errorCode): + return awsAwsjson11_deserializeErrorOperationAbortedException(response, errorBody) - case "logStreamNamePrefixes": - if err := awsAwsjson11_deserializeDocumentInputLogStreamNames(&sv.LogStreamNamePrefixes, value); err != nil { - return err - } + case strings.EqualFold("ResourceNotFoundException", errorCode): + return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) - case "logStreamNames": - if err := awsAwsjson11_deserializeDocumentInputLogStreamNames(&sv.LogStreamNames, value); err != nil { - return err - } + case strings.EqualFold("ServiceUnavailableException", errorCode): + return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) - case "requestId": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected RequestId to be of type string, got %T instead", value) - } - sv.RequestId = ptr.String(jtv) - } + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, + } + return genericError - case "sessionId": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected SessionId to be of type string, got %T instead", value) - } - sv.SessionId = ptr.String(jtv) - } + } +} - default: - _, _ = key, value +type awsAwsjson11_deserializeOpPutSubscriptionFilter struct { +} - } - } - *v = sv - return nil +func (*awsAwsjson11_deserializeOpPutSubscriptionFilter) ID() string { + return "OperationDeserializer" } -func awsAwsjson11_deserializeDocumentLiveTailSessionUpdate(v **types.LiveTailSessionUpdate, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil +func (m *awsAwsjson11_deserializeOpPutSubscriptionFilter) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( + out middleware.DeserializeOutput, metadata middleware.Metadata, err error, +) { + out, metadata, err = next.HandleDeserialize(ctx, in) + if err != nil { + return out, metadata, err } - shape, ok := value.(map[string]interface{}) + _, span := tracing.StartSpan(ctx, "OperationDeserializer") + endTimer := startMetricTimer(ctx, "client.call.deserialization_duration") + defer endTimer() + defer span.End() + response, ok := out.RawResponse.(*smithyhttp.Response) if !ok { - return fmt.Errorf("unexpected JSON type %v", value) + return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} } - var sv *types.LiveTailSessionUpdate - if *v == nil { - sv = &types.LiveTailSessionUpdate{} - } else { - sv = *v + if response.StatusCode < 200 || response.StatusCode >= 300 { + return out, metadata, awsAwsjson11_deserializeOpErrorPutSubscriptionFilter(response, &metadata) } + output := &PutSubscriptionFilterOutput{} + out.Result = output - for key, value := range shape { - switch key { - case "sessionMetadata": - if err := awsAwsjson11_deserializeDocumentLiveTailSessionMetadata(&sv.SessionMetadata, value); err != nil { - return err - } - - case "sessionResults": - if err := awsAwsjson11_deserializeDocumentLiveTailSessionResults(&sv.SessionResults, value); err != nil { - return err - } - - default: - _, _ = key, value - + if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { + return out, metadata, &smithy.DeserializationError{ + Err: fmt.Errorf("failed to discard response body, %w", err), } } - *v = sv - return nil -} -func awsAwsjson11_deserializeDocumentSessionStreamingException(v **types.SessionStreamingException, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } + return out, metadata, err +} - shape, ok := value.(map[string]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) +func awsAwsjson11_deserializeOpErrorPutSubscriptionFilter(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.Buffer + if _, err := io.Copy(&errorBuffer, response.Body); err != nil { + return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} } + errorBody := bytes.NewReader(errorBuffer.Bytes()) - var sv *types.SessionStreamingException - if *v == nil { - sv = &types.SessionStreamingException{} - } else { - sv = *v - } + errorCode := "UnknownError" + errorMessage := errorCode - for key, value := range shape { - switch key { - case "message", "Message": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected Message to be of type string, got %T instead", value) - } - sv.Message = ptr.String(jtv) - } + headerCode := response.Header.Get("X-Amzn-ErrorType") - default: - _, _ = key, value + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + body := io.TeeReader(errorBody, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + bodyInfo, err := getProtocolErrorInfo(decoder) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), } + return err } - *v = sv - return nil -} -func awsAwsjson11_deserializeDocumentSessionTimeoutException(v **types.SessionTimeoutException, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) + errorBody.Seek(0, io.SeekStart) + if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok { + errorCode = restjson.SanitizeErrorCode(typ) } - if value == nil { - return nil + if len(bodyInfo.Message) != 0 { + errorMessage = bodyInfo.Message } + switch { + case strings.EqualFold("InvalidOperationException", errorCode): + return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody) - shape, ok := value.(map[string]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } + case strings.EqualFold("InvalidParameterException", errorCode): + return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) - var sv *types.SessionTimeoutException - if *v == nil { - sv = &types.SessionTimeoutException{} - } else { - sv = *v - } + case strings.EqualFold("LimitExceededException", errorCode): + return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) - for key, value := range shape { - switch key { - case "message", "Message": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected Message to be of type string, got %T instead", value) - } - sv.Message = ptr.String(jtv) - } + case strings.EqualFold("OperationAbortedException", errorCode): + return awsAwsjson11_deserializeErrorOperationAbortedException(response, errorBody) - default: - _, _ = key, value + case strings.EqualFold("ResourceNotFoundException", errorCode): + return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) + + case strings.EqualFold("ServiceUnavailableException", errorCode): + return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, } + return genericError + } - *v = sv - return nil } -func awsAwsjson11_deserializeDocumentStartLiveTailLogGroupIdentifiers(v *[]string, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil +type awsAwsjson11_deserializeOpPutTransformer struct { +} + +func (*awsAwsjson11_deserializeOpPutTransformer) ID() string { + return "OperationDeserializer" +} + +func (m *awsAwsjson11_deserializeOpPutTransformer) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( + out middleware.DeserializeOutput, metadata middleware.Metadata, err error, +) { + out, metadata, err = next.HandleDeserialize(ctx, in) + if err != nil { + return out, metadata, err } - shape, ok := value.([]interface{}) + _, span := tracing.StartSpan(ctx, "OperationDeserializer") + endTimer := startMetricTimer(ctx, "client.call.deserialization_duration") + defer endTimer() + defer span.End() + response, ok := out.RawResponse.(*smithyhttp.Response) if !ok { - return fmt.Errorf("unexpected JSON type %v", value) + return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} } - var cv []string - if *v == nil { - cv = []string{} - } else { - cv = *v + if response.StatusCode < 200 || response.StatusCode >= 300 { + return out, metadata, awsAwsjson11_deserializeOpErrorPutTransformer(response, &metadata) } + output := &PutTransformerOutput{} + out.Result = output - for _, value := range shape { - var col string - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected LogGroupIdentifier to be of type string, got %T instead", value) - } - col = jtv + if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { + return out, metadata, &smithy.DeserializationError{ + Err: fmt.Errorf("failed to discard response body, %w", err), } - cv = append(cv, col) - } - *v = cv - return nil + + return out, metadata, err } -func awsAwsjson11_deserializeEventMessageResponseStartLiveTailOutput(msg *eventstream.Message) (interface{}, error) { - v := &StartLiveTailOutput{} +func awsAwsjson11_deserializeOpErrorPutTransformer(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.Buffer + if _, err := io.Copy(&errorBuffer, response.Body); err != nil { + return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} + } + errorBody := bytes.NewReader(errorBuffer.Bytes()) + + errorCode := "UnknownError" + errorMessage := errorCode + + headerCode := response.Header.Get("X-Amzn-ErrorType") - br := bytes.NewReader(msg.Payload) var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) - body := io.TeeReader(br, ringBuffer) + body := io.TeeReader(errorBody, ringBuffer) decoder := json.NewDecoder(body) decoder.UseNumber() - var shape interface{} - if err := decoder.Decode(&shape); err != nil && err != io.EOF { + bodyInfo, err := getProtocolErrorInfo(decoder) + if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) err = &smithy.DeserializationError{ Err: fmt.Errorf("failed to decode response body, %w", err), Snapshot: snapshot.Bytes(), } - return nil, err + return err } - if err := awsAwsjson11_deserializeOpDocumentStartLiveTailOutput(&v, shape); err != nil { - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return nil, err + errorBody.Seek(0, io.SeekStart) + if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok { + errorCode = restjson.SanitizeErrorCode(typ) + } + if len(bodyInfo.Message) != 0 { + errorMessage = bodyInfo.Message + } + switch { + case strings.EqualFold("InvalidOperationException", errorCode): + return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody) + + case strings.EqualFold("InvalidParameterException", errorCode): + return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) + + case strings.EqualFold("LimitExceededException", errorCode): + return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) + + case strings.EqualFold("OperationAbortedException", errorCode): + return awsAwsjson11_deserializeErrorOperationAbortedException(response, errorBody) + + case strings.EqualFold("ResourceNotFoundException", errorCode): + return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) + + case strings.EqualFold("ServiceUnavailableException", errorCode): + return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) + + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, } + return genericError } - return v, nil } -func awsAwsjson11_deserializeOpDocumentStartLiveTailOutput(v **StartLiveTailOutput, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil +type awsAwsjson11_deserializeOpStartLiveTail struct { +} + +func (*awsAwsjson11_deserializeOpStartLiveTail) ID() string { + return "OperationDeserializer" +} + +func (m *awsAwsjson11_deserializeOpStartLiveTail) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( + out middleware.DeserializeOutput, metadata middleware.Metadata, err error, +) { + out, metadata, err = next.HandleDeserialize(ctx, in) + if err != nil { + return out, metadata, err } - shape, ok := value.(map[string]interface{}) + _, span := tracing.StartSpan(ctx, "OperationDeserializer") + endTimer := startMetricTimer(ctx, "client.call.deserialization_duration") + defer endTimer() + defer span.End() + response, ok := out.RawResponse.(*smithyhttp.Response) if !ok { - return fmt.Errorf("unexpected JSON type %v", value) + return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} } - var sv *StartLiveTailOutput - if *v == nil { - sv = &StartLiveTailOutput{} - } else { - sv = *v + if response.StatusCode < 200 || response.StatusCode >= 300 { + return out, metadata, awsAwsjson11_deserializeOpErrorStartLiveTail(response, &metadata) } + output := &StartLiveTailOutput{} + out.Result = output - for key, value := range shape { - switch key { - default: - _, _ = key, value + return out, metadata, err +} - } +func awsAwsjson11_deserializeOpErrorStartLiveTail(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.Buffer + if _, err := io.Copy(&errorBuffer, response.Body); err != nil { + return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} } - *v = sv - return nil -} + errorBody := bytes.NewReader(errorBuffer.Bytes()) + + errorCode := "UnknownError" + errorMessage := errorCode + + headerCode := response.Header.Get("X-Amzn-ErrorType") -func awsAwsjson11_deserializeErrorAccessDeniedException(response *smithyhttp.Response, errorBody *bytes.Reader) error { var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) decoder := json.NewDecoder(body) decoder.UseNumber() - var shape interface{} - if err := decoder.Decode(&shape); err != nil && err != io.EOF { + bodyInfo, err := getProtocolErrorInfo(decoder) + if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) err = &smithy.DeserializationError{ @@ -10737,28 +10945,73 @@ func awsAwsjson11_deserializeErrorAccessDeniedException(response *smithyhttp.Res return err } - output := &types.AccessDeniedException{} - err := awsAwsjson11_deserializeDocumentAccessDeniedException(&output, shape) + errorBody.Seek(0, io.SeekStart) + if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok { + errorCode = restjson.SanitizeErrorCode(typ) + } + if len(bodyInfo.Message) != 0 { + errorMessage = bodyInfo.Message + } + switch { + case strings.EqualFold("AccessDeniedException", errorCode): + return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), + case strings.EqualFold("InvalidOperationException", errorCode): + return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody) + + case strings.EqualFold("InvalidParameterException", errorCode): + return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) + + case strings.EqualFold("LimitExceededException", errorCode): + return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) + + case strings.EqualFold("ResourceNotFoundException", errorCode): + return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) + + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, } - return err + return genericError + } +} - errorBody.Seek(0, io.SeekStart) - return output +type awsAwsjson11_deserializeOpStartQuery struct { } -func awsAwsjson11_deserializeErrorConflictException(response *smithyhttp.Response, errorBody *bytes.Reader) error { +func (*awsAwsjson11_deserializeOpStartQuery) ID() string { + return "OperationDeserializer" +} + +func (m *awsAwsjson11_deserializeOpStartQuery) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( + out middleware.DeserializeOutput, metadata middleware.Metadata, err error, +) { + out, metadata, err = next.HandleDeserialize(ctx, in) + if err != nil { + return out, metadata, err + } + + _, span := tracing.StartSpan(ctx, "OperationDeserializer") + endTimer := startMetricTimer(ctx, "client.call.deserialization_duration") + defer endTimer() + defer span.End() + response, ok := out.RawResponse.(*smithyhttp.Response) + if !ok { + return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} + } + + if response.StatusCode < 200 || response.StatusCode >= 300 { + return out, metadata, awsAwsjson11_deserializeOpErrorStartQuery(response, &metadata) + } + output := &StartQueryOutput{} + out.Result = output + var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) - body := io.TeeReader(errorBody, ringBuffer) + body := io.TeeReader(response.Body, ringBuffer) decoder := json.NewDecoder(body) decoder.UseNumber() var shape interface{} @@ -10769,12 +11022,10 @@ func awsAwsjson11_deserializeErrorConflictException(response *smithyhttp.Respons Err: fmt.Errorf("failed to decode response body, %w", err), Snapshot: snapshot.Bytes(), } - return err + return out, metadata, err } - output := &types.ConflictException{} - err := awsAwsjson11_deserializeDocumentConflictException(&output, shape) - + err = awsAwsjson11_deserializeOpDocumentStartQueryOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -10782,34 +11033,31 @@ func awsAwsjson11_deserializeErrorConflictException(response *smithyhttp.Respons Err: fmt.Errorf("failed to decode response body, %w", err), Snapshot: snapshot.Bytes(), } - return err + return out, metadata, err } - errorBody.Seek(0, io.SeekStart) - return output + return out, metadata, err } -func awsAwsjson11_deserializeErrorDataAlreadyAcceptedException(response *smithyhttp.Response, errorBody *bytes.Reader) error { +func awsAwsjson11_deserializeOpErrorStartQuery(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.Buffer + if _, err := io.Copy(&errorBuffer, response.Body); err != nil { + return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} + } + errorBody := bytes.NewReader(errorBuffer.Bytes()) + + errorCode := "UnknownError" + errorMessage := errorCode + + headerCode := response.Header.Get("X-Amzn-ErrorType") + var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) decoder := json.NewDecoder(body) decoder.UseNumber() - var shape interface{} - if err := decoder.Decode(&shape); err != nil && err != io.EOF { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return err - } - - output := &types.DataAlreadyAcceptedException{} - err := awsAwsjson11_deserializeDocumentDataAlreadyAcceptedException(&output, shape) - + bodyInfo, err := getProtocolErrorInfo(decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -10821,49 +11069,72 @@ func awsAwsjson11_deserializeErrorDataAlreadyAcceptedException(response *smithyh } errorBody.Seek(0, io.SeekStart) - return output -} + if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok { + errorCode = restjson.SanitizeErrorCode(typ) + } + if len(bodyInfo.Message) != 0 { + errorMessage = bodyInfo.Message + } + switch { + case strings.EqualFold("InvalidParameterException", errorCode): + return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) -func awsAwsjson11_deserializeErrorInvalidOperationException(response *smithyhttp.Response, errorBody *bytes.Reader) error { - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) + case strings.EqualFold("LimitExceededException", errorCode): + return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) - body := io.TeeReader(errorBody, ringBuffer) - decoder := json.NewDecoder(body) - decoder.UseNumber() - var shape interface{} - if err := decoder.Decode(&shape); err != nil && err != io.EOF { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), + case strings.EqualFold("MalformedQueryException", errorCode): + return awsAwsjson11_deserializeErrorMalformedQueryException(response, errorBody) + + case strings.EqualFold("ResourceNotFoundException", errorCode): + return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) + + case strings.EqualFold("ServiceUnavailableException", errorCode): + return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) + + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, } - return err + return genericError + } +} - output := &types.InvalidOperationException{} - err := awsAwsjson11_deserializeDocumentInvalidOperationException(&output, shape) +type awsAwsjson11_deserializeOpStopQuery struct { +} + +func (*awsAwsjson11_deserializeOpStopQuery) ID() string { + return "OperationDeserializer" +} +func (m *awsAwsjson11_deserializeOpStopQuery) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( + out middleware.DeserializeOutput, metadata middleware.Metadata, err error, +) { + out, metadata, err = next.HandleDeserialize(ctx, in) if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return err + return out, metadata, err } - errorBody.Seek(0, io.SeekStart) - return output -} + _, span := tracing.StartSpan(ctx, "OperationDeserializer") + endTimer := startMetricTimer(ctx, "client.call.deserialization_duration") + defer endTimer() + defer span.End() + response, ok := out.RawResponse.(*smithyhttp.Response) + if !ok { + return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} + } + + if response.StatusCode < 200 || response.StatusCode >= 300 { + return out, metadata, awsAwsjson11_deserializeOpErrorStopQuery(response, &metadata) + } + output := &StopQueryOutput{} + out.Result = output -func awsAwsjson11_deserializeErrorInvalidParameterException(response *smithyhttp.Response, errorBody *bytes.Reader) error { var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) - body := io.TeeReader(errorBody, ringBuffer) + body := io.TeeReader(response.Body, ringBuffer) decoder := json.NewDecoder(body) decoder.UseNumber() var shape interface{} @@ -10874,12 +11145,10 @@ func awsAwsjson11_deserializeErrorInvalidParameterException(response *smithyhttp Err: fmt.Errorf("failed to decode response body, %w", err), Snapshot: snapshot.Bytes(), } - return err + return out, metadata, err } - output := &types.InvalidParameterException{} - err := awsAwsjson11_deserializeDocumentInvalidParameterException(&output, shape) - + err = awsAwsjson11_deserializeOpDocumentStopQueryOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -10887,22 +11156,32 @@ func awsAwsjson11_deserializeErrorInvalidParameterException(response *smithyhttp Err: fmt.Errorf("failed to decode response body, %w", err), Snapshot: snapshot.Bytes(), } - return err + return out, metadata, err } - errorBody.Seek(0, io.SeekStart) - return output + return out, metadata, err } -func awsAwsjson11_deserializeErrorInvalidSequenceTokenException(response *smithyhttp.Response, errorBody *bytes.Reader) error { +func awsAwsjson11_deserializeOpErrorStopQuery(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.Buffer + if _, err := io.Copy(&errorBuffer, response.Body); err != nil { + return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} + } + errorBody := bytes.NewReader(errorBuffer.Bytes()) + + errorCode := "UnknownError" + errorMessage := errorCode + + headerCode := response.Header.Get("X-Amzn-ErrorType") + var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) decoder := json.NewDecoder(body) decoder.UseNumber() - var shape interface{} - if err := decoder.Decode(&shape); err != nil && err != io.EOF { + bodyInfo, err := getProtocolErrorInfo(decoder) + if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) err = &smithy.DeserializationError{ @@ -10912,79 +11191,91 @@ func awsAwsjson11_deserializeErrorInvalidSequenceTokenException(response *smithy return err } - output := &types.InvalidSequenceTokenException{} - err := awsAwsjson11_deserializeDocumentInvalidSequenceTokenException(&output, shape) + errorBody.Seek(0, io.SeekStart) + if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok { + errorCode = restjson.SanitizeErrorCode(typ) + } + if len(bodyInfo.Message) != 0 { + errorMessage = bodyInfo.Message + } + switch { + case strings.EqualFold("InvalidParameterException", errorCode): + return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), + case strings.EqualFold("ResourceNotFoundException", errorCode): + return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) + + case strings.EqualFold("ServiceUnavailableException", errorCode): + return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) + + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, } - return err + return genericError + } +} - errorBody.Seek(0, io.SeekStart) - return output +type awsAwsjson11_deserializeOpTagLogGroup struct { } -func awsAwsjson11_deserializeErrorLimitExceededException(response *smithyhttp.Response, errorBody *bytes.Reader) error { - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) +func (*awsAwsjson11_deserializeOpTagLogGroup) ID() string { + return "OperationDeserializer" +} - body := io.TeeReader(errorBody, ringBuffer) - decoder := json.NewDecoder(body) - decoder.UseNumber() - var shape interface{} - if err := decoder.Decode(&shape); err != nil && err != io.EOF { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return err +func (m *awsAwsjson11_deserializeOpTagLogGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( + out middleware.DeserializeOutput, metadata middleware.Metadata, err error, +) { + out, metadata, err = next.HandleDeserialize(ctx, in) + if err != nil { + return out, metadata, err } - output := &types.LimitExceededException{} - err := awsAwsjson11_deserializeDocumentLimitExceededException(&output, shape) + _, span := tracing.StartSpan(ctx, "OperationDeserializer") + endTimer := startMetricTimer(ctx, "client.call.deserialization_duration") + defer endTimer() + defer span.End() + response, ok := out.RawResponse.(*smithyhttp.Response) + if !ok { + return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} + } - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), + if response.StatusCode < 200 || response.StatusCode >= 300 { + return out, metadata, awsAwsjson11_deserializeOpErrorTagLogGroup(response, &metadata) + } + output := &TagLogGroupOutput{} + out.Result = output + + if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { + return out, metadata, &smithy.DeserializationError{ + Err: fmt.Errorf("failed to discard response body, %w", err), } - return err } - errorBody.Seek(0, io.SeekStart) - return output + return out, metadata, err } -func awsAwsjson11_deserializeErrorMalformedQueryException(response *smithyhttp.Response, errorBody *bytes.Reader) error { +func awsAwsjson11_deserializeOpErrorTagLogGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.Buffer + if _, err := io.Copy(&errorBuffer, response.Body); err != nil { + return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} + } + errorBody := bytes.NewReader(errorBuffer.Bytes()) + + errorCode := "UnknownError" + errorMessage := errorCode + + headerCode := response.Header.Get("X-Amzn-ErrorType") + var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) decoder := json.NewDecoder(body) decoder.UseNumber() - var shape interface{} - if err := decoder.Decode(&shape); err != nil && err != io.EOF { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return err - } - - output := &types.MalformedQueryException{} - err := awsAwsjson11_deserializeDocumentMalformedQueryException(&output, shape) - + bodyInfo, err := getProtocolErrorInfo(decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -10996,53 +11287,88 @@ func awsAwsjson11_deserializeErrorMalformedQueryException(response *smithyhttp.R } errorBody.Seek(0, io.SeekStart) - return output -} + if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok { + errorCode = restjson.SanitizeErrorCode(typ) + } + if len(bodyInfo.Message) != 0 { + errorMessage = bodyInfo.Message + } + switch { + case strings.EqualFold("InvalidParameterException", errorCode): + return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) -func awsAwsjson11_deserializeErrorOperationAbortedException(response *smithyhttp.Response, errorBody *bytes.Reader) error { - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) + case strings.EqualFold("ResourceNotFoundException", errorCode): + return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) - body := io.TeeReader(errorBody, ringBuffer) - decoder := json.NewDecoder(body) - decoder.UseNumber() - var shape interface{} - if err := decoder.Decode(&shape); err != nil && err != io.EOF { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, } - return err + return genericError + } +} - output := &types.OperationAbortedException{} - err := awsAwsjson11_deserializeDocumentOperationAbortedException(&output, shape) +type awsAwsjson11_deserializeOpTagResource struct { +} + +func (*awsAwsjson11_deserializeOpTagResource) ID() string { + return "OperationDeserializer" +} +func (m *awsAwsjson11_deserializeOpTagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( + out middleware.DeserializeOutput, metadata middleware.Metadata, err error, +) { + out, metadata, err = next.HandleDeserialize(ctx, in) if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), + return out, metadata, err + } + + _, span := tracing.StartSpan(ctx, "OperationDeserializer") + endTimer := startMetricTimer(ctx, "client.call.deserialization_duration") + defer endTimer() + defer span.End() + response, ok := out.RawResponse.(*smithyhttp.Response) + if !ok { + return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} + } + + if response.StatusCode < 200 || response.StatusCode >= 300 { + return out, metadata, awsAwsjson11_deserializeOpErrorTagResource(response, &metadata) + } + output := &TagResourceOutput{} + out.Result = output + + if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { + return out, metadata, &smithy.DeserializationError{ + Err: fmt.Errorf("failed to discard response body, %w", err), } - return err } - errorBody.Seek(0, io.SeekStart) - return output + return out, metadata, err } -func awsAwsjson11_deserializeErrorResourceAlreadyExistsException(response *smithyhttp.Response, errorBody *bytes.Reader) error { +func awsAwsjson11_deserializeOpErrorTagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.Buffer + if _, err := io.Copy(&errorBuffer, response.Body); err != nil { + return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} + } + errorBody := bytes.NewReader(errorBuffer.Bytes()) + + errorCode := "UnknownError" + errorMessage := errorCode + + headerCode := response.Header.Get("X-Amzn-ErrorType") + var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) decoder := json.NewDecoder(body) decoder.UseNumber() - var shape interface{} - if err := decoder.Decode(&shape); err != nil && err != io.EOF { + bodyInfo, err := getProtocolErrorInfo(decoder) + if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) err = &smithy.DeserializationError{ @@ -11052,28 +11378,70 @@ func awsAwsjson11_deserializeErrorResourceAlreadyExistsException(response *smith return err } - output := &types.ResourceAlreadyExistsException{} - err := awsAwsjson11_deserializeDocumentResourceAlreadyExistsException(&output, shape) + errorBody.Seek(0, io.SeekStart) + if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok { + errorCode = restjson.SanitizeErrorCode(typ) + } + if len(bodyInfo.Message) != 0 { + errorMessage = bodyInfo.Message + } + switch { + case strings.EqualFold("InvalidParameterException", errorCode): + return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), + case strings.EqualFold("ResourceNotFoundException", errorCode): + return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) + + case strings.EqualFold("ServiceUnavailableException", errorCode): + return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) + + case strings.EqualFold("TooManyTagsException", errorCode): + return awsAwsjson11_deserializeErrorTooManyTagsException(response, errorBody) + + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, } - return err + return genericError + } +} - errorBody.Seek(0, io.SeekStart) - return output +type awsAwsjson11_deserializeOpTestMetricFilter struct { } -func awsAwsjson11_deserializeErrorResourceNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { +func (*awsAwsjson11_deserializeOpTestMetricFilter) ID() string { + return "OperationDeserializer" +} + +func (m *awsAwsjson11_deserializeOpTestMetricFilter) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( + out middleware.DeserializeOutput, metadata middleware.Metadata, err error, +) { + out, metadata, err = next.HandleDeserialize(ctx, in) + if err != nil { + return out, metadata, err + } + + _, span := tracing.StartSpan(ctx, "OperationDeserializer") + endTimer := startMetricTimer(ctx, "client.call.deserialization_duration") + defer endTimer() + defer span.End() + response, ok := out.RawResponse.(*smithyhttp.Response) + if !ok { + return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} + } + + if response.StatusCode < 200 || response.StatusCode >= 300 { + return out, metadata, awsAwsjson11_deserializeOpErrorTestMetricFilter(response, &metadata) + } + output := &TestMetricFilterOutput{} + out.Result = output + var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) - body := io.TeeReader(errorBody, ringBuffer) + body := io.TeeReader(response.Body, ringBuffer) decoder := json.NewDecoder(body) decoder.UseNumber() var shape interface{} @@ -11084,12 +11452,10 @@ func awsAwsjson11_deserializeErrorResourceNotFoundException(response *smithyhttp Err: fmt.Errorf("failed to decode response body, %w", err), Snapshot: snapshot.Bytes(), } - return err + return out, metadata, err } - output := &types.ResourceNotFoundException{} - err := awsAwsjson11_deserializeDocumentResourceNotFoundException(&output, shape) - + err = awsAwsjson11_deserializeOpDocumentTestMetricFilterOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -11097,22 +11463,32 @@ func awsAwsjson11_deserializeErrorResourceNotFoundException(response *smithyhttp Err: fmt.Errorf("failed to decode response body, %w", err), Snapshot: snapshot.Bytes(), } - return err + return out, metadata, err } - errorBody.Seek(0, io.SeekStart) - return output + return out, metadata, err } -func awsAwsjson11_deserializeErrorServiceQuotaExceededException(response *smithyhttp.Response, errorBody *bytes.Reader) error { +func awsAwsjson11_deserializeOpErrorTestMetricFilter(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.Buffer + if _, err := io.Copy(&errorBuffer, response.Body); err != nil { + return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} + } + errorBody := bytes.NewReader(errorBuffer.Bytes()) + + errorCode := "UnknownError" + errorMessage := errorCode + + headerCode := response.Header.Get("X-Amzn-ErrorType") + var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) decoder := json.NewDecoder(body) decoder.UseNumber() - var shape interface{} - if err := decoder.Decode(&shape); err != nil && err != io.EOF { + bodyInfo, err := getProtocolErrorInfo(decoder) + if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) err = &smithy.DeserializationError{ @@ -11122,28 +11498,64 @@ func awsAwsjson11_deserializeErrorServiceQuotaExceededException(response *smithy return err } - output := &types.ServiceQuotaExceededException{} - err := awsAwsjson11_deserializeDocumentServiceQuotaExceededException(&output, shape) + errorBody.Seek(0, io.SeekStart) + if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok { + errorCode = restjson.SanitizeErrorCode(typ) + } + if len(bodyInfo.Message) != 0 { + errorMessage = bodyInfo.Message + } + switch { + case strings.EqualFold("InvalidParameterException", errorCode): + return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), + case strings.EqualFold("ServiceUnavailableException", errorCode): + return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) + + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, } - return err + return genericError + } +} - errorBody.Seek(0, io.SeekStart) - return output +type awsAwsjson11_deserializeOpTestTransformer struct { } -func awsAwsjson11_deserializeErrorServiceUnavailableException(response *smithyhttp.Response, errorBody *bytes.Reader) error { +func (*awsAwsjson11_deserializeOpTestTransformer) ID() string { + return "OperationDeserializer" +} + +func (m *awsAwsjson11_deserializeOpTestTransformer) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( + out middleware.DeserializeOutput, metadata middleware.Metadata, err error, +) { + out, metadata, err = next.HandleDeserialize(ctx, in) + if err != nil { + return out, metadata, err + } + + _, span := tracing.StartSpan(ctx, "OperationDeserializer") + endTimer := startMetricTimer(ctx, "client.call.deserialization_duration") + defer endTimer() + defer span.End() + response, ok := out.RawResponse.(*smithyhttp.Response) + if !ok { + return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} + } + + if response.StatusCode < 200 || response.StatusCode >= 300 { + return out, metadata, awsAwsjson11_deserializeOpErrorTestTransformer(response, &metadata) + } + output := &TestTransformerOutput{} + out.Result = output + var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) - body := io.TeeReader(errorBody, ringBuffer) + body := io.TeeReader(response.Body, ringBuffer) decoder := json.NewDecoder(body) decoder.UseNumber() var shape interface{} @@ -11154,12 +11566,10 @@ func awsAwsjson11_deserializeErrorServiceUnavailableException(response *smithyht Err: fmt.Errorf("failed to decode response body, %w", err), Snapshot: snapshot.Bytes(), } - return err + return out, metadata, err } - output := &types.ServiceUnavailableException{} - err := awsAwsjson11_deserializeDocumentServiceUnavailableException(&output, shape) - + err = awsAwsjson11_deserializeOpDocumentTestTransformerOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -11167,22 +11577,32 @@ func awsAwsjson11_deserializeErrorServiceUnavailableException(response *smithyht Err: fmt.Errorf("failed to decode response body, %w", err), Snapshot: snapshot.Bytes(), } - return err + return out, metadata, err } - errorBody.Seek(0, io.SeekStart) - return output + return out, metadata, err } -func awsAwsjson11_deserializeErrorThrottlingException(response *smithyhttp.Response, errorBody *bytes.Reader) error { +func awsAwsjson11_deserializeOpErrorTestTransformer(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.Buffer + if _, err := io.Copy(&errorBuffer, response.Body); err != nil { + return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} + } + errorBody := bytes.NewReader(errorBuffer.Bytes()) + + errorCode := "UnknownError" + errorMessage := errorCode + + headerCode := response.Header.Get("X-Amzn-ErrorType") + var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) decoder := json.NewDecoder(body) decoder.UseNumber() - var shape interface{} - if err := decoder.Decode(&shape); err != nil && err != io.EOF { + bodyInfo, err := getProtocolErrorInfo(decoder) + if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) err = &smithy.DeserializationError{ @@ -11192,32 +11612,92 @@ func awsAwsjson11_deserializeErrorThrottlingException(response *smithyhttp.Respo return err } - output := &types.ThrottlingException{} - err := awsAwsjson11_deserializeDocumentThrottlingException(&output, shape) + errorBody.Seek(0, io.SeekStart) + if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok { + errorCode = restjson.SanitizeErrorCode(typ) + } + if len(bodyInfo.Message) != 0 { + errorMessage = bodyInfo.Message + } + switch { + case strings.EqualFold("InvalidOperationException", errorCode): + return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody) + + case strings.EqualFold("InvalidParameterException", errorCode): + return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) + + case strings.EqualFold("ServiceUnavailableException", errorCode): + return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) + + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, + } + return genericError + + } +} + +type awsAwsjson11_deserializeOpUntagLogGroup struct { +} + +func (*awsAwsjson11_deserializeOpUntagLogGroup) ID() string { + return "OperationDeserializer" +} +func (m *awsAwsjson11_deserializeOpUntagLogGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( + out middleware.DeserializeOutput, metadata middleware.Metadata, err error, +) { + out, metadata, err = next.HandleDeserialize(ctx, in) if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), + return out, metadata, err + } + + _, span := tracing.StartSpan(ctx, "OperationDeserializer") + endTimer := startMetricTimer(ctx, "client.call.deserialization_duration") + defer endTimer() + defer span.End() + response, ok := out.RawResponse.(*smithyhttp.Response) + if !ok { + return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} + } + + if response.StatusCode < 200 || response.StatusCode >= 300 { + return out, metadata, awsAwsjson11_deserializeOpErrorUntagLogGroup(response, &metadata) + } + output := &UntagLogGroupOutput{} + out.Result = output + + if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { + return out, metadata, &smithy.DeserializationError{ + Err: fmt.Errorf("failed to discard response body, %w", err), } - return err } - errorBody.Seek(0, io.SeekStart) - return output + return out, metadata, err } -func awsAwsjson11_deserializeErrorTooManyTagsException(response *smithyhttp.Response, errorBody *bytes.Reader) error { +func awsAwsjson11_deserializeOpErrorUntagLogGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.Buffer + if _, err := io.Copy(&errorBuffer, response.Body); err != nil { + return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} + } + errorBody := bytes.NewReader(errorBuffer.Bytes()) + + errorCode := "UnknownError" + errorMessage := errorCode + + headerCode := response.Header.Get("X-Amzn-ErrorType") + var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) decoder := json.NewDecoder(body) decoder.UseNumber() - var shape interface{} - if err := decoder.Decode(&shape); err != nil && err != io.EOF { + bodyInfo, err := getProtocolErrorInfo(decoder) + if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) err = &smithy.DeserializationError{ @@ -11227,32 +11707,86 @@ func awsAwsjson11_deserializeErrorTooManyTagsException(response *smithyhttp.Resp return err } - output := &types.TooManyTagsException{} - err := awsAwsjson11_deserializeDocumentTooManyTagsException(&output, shape) + errorBody.Seek(0, io.SeekStart) + if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok { + errorCode = restjson.SanitizeErrorCode(typ) + } + if len(bodyInfo.Message) != 0 { + errorMessage = bodyInfo.Message + } + switch { + case strings.EqualFold("ResourceNotFoundException", errorCode): + return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) + + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, + } + return genericError + + } +} + +type awsAwsjson11_deserializeOpUntagResource struct { +} + +func (*awsAwsjson11_deserializeOpUntagResource) ID() string { + return "OperationDeserializer" +} +func (m *awsAwsjson11_deserializeOpUntagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( + out middleware.DeserializeOutput, metadata middleware.Metadata, err error, +) { + out, metadata, err = next.HandleDeserialize(ctx, in) if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), + return out, metadata, err + } + + _, span := tracing.StartSpan(ctx, "OperationDeserializer") + endTimer := startMetricTimer(ctx, "client.call.deserialization_duration") + defer endTimer() + defer span.End() + response, ok := out.RawResponse.(*smithyhttp.Response) + if !ok { + return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} + } + + if response.StatusCode < 200 || response.StatusCode >= 300 { + return out, metadata, awsAwsjson11_deserializeOpErrorUntagResource(response, &metadata) + } + output := &UntagResourceOutput{} + out.Result = output + + if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { + return out, metadata, &smithy.DeserializationError{ + Err: fmt.Errorf("failed to discard response body, %w", err), } - return err } - errorBody.Seek(0, io.SeekStart) - return output + return out, metadata, err } -func awsAwsjson11_deserializeErrorUnrecognizedClientException(response *smithyhttp.Response, errorBody *bytes.Reader) error { +func awsAwsjson11_deserializeOpErrorUntagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.Buffer + if _, err := io.Copy(&errorBuffer, response.Body); err != nil { + return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} + } + errorBody := bytes.NewReader(errorBuffer.Bytes()) + + errorCode := "UnknownError" + errorMessage := errorCode + + headerCode := response.Header.Get("X-Amzn-ErrorType") + var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) decoder := json.NewDecoder(body) decoder.UseNumber() - var shape interface{} - if err := decoder.Decode(&shape); err != nil && err != io.EOF { + bodyInfo, err := getProtocolErrorInfo(decoder) + if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) err = &smithy.DeserializationError{ @@ -11262,59 +11796,4557 @@ func awsAwsjson11_deserializeErrorUnrecognizedClientException(response *smithyht return err } - output := &types.UnrecognizedClientException{} - err := awsAwsjson11_deserializeDocumentUnrecognizedClientException(&output, shape) + errorBody.Seek(0, io.SeekStart) + if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok { + errorCode = restjson.SanitizeErrorCode(typ) + } + if len(bodyInfo.Message) != 0 { + errorMessage = bodyInfo.Message + } + switch { + case strings.EqualFold("InvalidParameterException", errorCode): + return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), + case strings.EqualFold("ResourceNotFoundException", errorCode): + return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) + + case strings.EqualFold("ServiceUnavailableException", errorCode): + return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) + + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, } - return err + return genericError + } +} - errorBody.Seek(0, io.SeekStart) - return output +type awsAwsjson11_deserializeOpUpdateAnomaly struct { } -func awsAwsjson11_deserializeErrorValidationException(response *smithyhttp.Response, errorBody *bytes.Reader) error { - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) +func (*awsAwsjson11_deserializeOpUpdateAnomaly) ID() string { + return "OperationDeserializer" +} - body := io.TeeReader(errorBody, ringBuffer) - decoder := json.NewDecoder(body) - decoder.UseNumber() - var shape interface{} - if err := decoder.Decode(&shape); err != nil && err != io.EOF { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return err +func (m *awsAwsjson11_deserializeOpUpdateAnomaly) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( + out middleware.DeserializeOutput, metadata middleware.Metadata, err error, +) { + out, metadata, err = next.HandleDeserialize(ctx, in) + if err != nil { + return out, metadata, err + } + + _, span := tracing.StartSpan(ctx, "OperationDeserializer") + endTimer := startMetricTimer(ctx, "client.call.deserialization_duration") + defer endTimer() + defer span.End() + response, ok := out.RawResponse.(*smithyhttp.Response) + if !ok { + return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} + } + + if response.StatusCode < 200 || response.StatusCode >= 300 { + return out, metadata, awsAwsjson11_deserializeOpErrorUpdateAnomaly(response, &metadata) + } + output := &UpdateAnomalyOutput{} + out.Result = output + + if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { + return out, metadata, &smithy.DeserializationError{ + Err: fmt.Errorf("failed to discard response body, %w", err), + } + } + + return out, metadata, err +} + +func awsAwsjson11_deserializeOpErrorUpdateAnomaly(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.Buffer + if _, err := io.Copy(&errorBuffer, response.Body); err != nil { + return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} + } + errorBody := bytes.NewReader(errorBuffer.Bytes()) + + errorCode := "UnknownError" + errorMessage := errorCode + + headerCode := response.Header.Get("X-Amzn-ErrorType") + + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(errorBody, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + bodyInfo, err := getProtocolErrorInfo(decoder) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + errorBody.Seek(0, io.SeekStart) + if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok { + errorCode = restjson.SanitizeErrorCode(typ) + } + if len(bodyInfo.Message) != 0 { + errorMessage = bodyInfo.Message + } + switch { + case strings.EqualFold("InvalidParameterException", errorCode): + return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) + + case strings.EqualFold("OperationAbortedException", errorCode): + return awsAwsjson11_deserializeErrorOperationAbortedException(response, errorBody) + + case strings.EqualFold("ResourceNotFoundException", errorCode): + return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) + + case strings.EqualFold("ServiceUnavailableException", errorCode): + return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) + + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, + } + return genericError + + } +} + +type awsAwsjson11_deserializeOpUpdateDeliveryConfiguration struct { +} + +func (*awsAwsjson11_deserializeOpUpdateDeliveryConfiguration) ID() string { + return "OperationDeserializer" +} + +func (m *awsAwsjson11_deserializeOpUpdateDeliveryConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( + out middleware.DeserializeOutput, metadata middleware.Metadata, err error, +) { + out, metadata, err = next.HandleDeserialize(ctx, in) + if err != nil { + return out, metadata, err + } + + _, span := tracing.StartSpan(ctx, "OperationDeserializer") + endTimer := startMetricTimer(ctx, "client.call.deserialization_duration") + defer endTimer() + defer span.End() + response, ok := out.RawResponse.(*smithyhttp.Response) + if !ok { + return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} + } + + if response.StatusCode < 200 || response.StatusCode >= 300 { + return out, metadata, awsAwsjson11_deserializeOpErrorUpdateDeliveryConfiguration(response, &metadata) + } + output := &UpdateDeliveryConfigurationOutput{} + out.Result = output + + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(response.Body, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + var shape interface{} + if err := decoder.Decode(&shape); err != nil && err != io.EOF { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return out, metadata, err + } + + err = awsAwsjson11_deserializeOpDocumentUpdateDeliveryConfigurationOutput(&output, shape) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return out, metadata, err + } + + return out, metadata, err +} + +func awsAwsjson11_deserializeOpErrorUpdateDeliveryConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.Buffer + if _, err := io.Copy(&errorBuffer, response.Body); err != nil { + return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} + } + errorBody := bytes.NewReader(errorBuffer.Bytes()) + + errorCode := "UnknownError" + errorMessage := errorCode + + headerCode := response.Header.Get("X-Amzn-ErrorType") + + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(errorBody, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + bodyInfo, err := getProtocolErrorInfo(decoder) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + errorBody.Seek(0, io.SeekStart) + if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok { + errorCode = restjson.SanitizeErrorCode(typ) + } + if len(bodyInfo.Message) != 0 { + errorMessage = bodyInfo.Message + } + switch { + case strings.EqualFold("AccessDeniedException", errorCode): + return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) + + case strings.EqualFold("ConflictException", errorCode): + return awsAwsjson11_deserializeErrorConflictException(response, errorBody) + + case strings.EqualFold("ResourceNotFoundException", errorCode): + return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) + + case strings.EqualFold("ServiceUnavailableException", errorCode): + return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) + + case strings.EqualFold("ThrottlingException", errorCode): + return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) + + case strings.EqualFold("ValidationException", errorCode): + return awsAwsjson11_deserializeErrorValidationException(response, errorBody) + + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, + } + return genericError + + } +} + +type awsAwsjson11_deserializeOpUpdateLogAnomalyDetector struct { +} + +func (*awsAwsjson11_deserializeOpUpdateLogAnomalyDetector) ID() string { + return "OperationDeserializer" +} + +func (m *awsAwsjson11_deserializeOpUpdateLogAnomalyDetector) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( + out middleware.DeserializeOutput, metadata middleware.Metadata, err error, +) { + out, metadata, err = next.HandleDeserialize(ctx, in) + if err != nil { + return out, metadata, err + } + + _, span := tracing.StartSpan(ctx, "OperationDeserializer") + endTimer := startMetricTimer(ctx, "client.call.deserialization_duration") + defer endTimer() + defer span.End() + response, ok := out.RawResponse.(*smithyhttp.Response) + if !ok { + return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} + } + + if response.StatusCode < 200 || response.StatusCode >= 300 { + return out, metadata, awsAwsjson11_deserializeOpErrorUpdateLogAnomalyDetector(response, &metadata) + } + output := &UpdateLogAnomalyDetectorOutput{} + out.Result = output + + if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { + return out, metadata, &smithy.DeserializationError{ + Err: fmt.Errorf("failed to discard response body, %w", err), + } + } + + return out, metadata, err +} + +func awsAwsjson11_deserializeOpErrorUpdateLogAnomalyDetector(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.Buffer + if _, err := io.Copy(&errorBuffer, response.Body); err != nil { + return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} + } + errorBody := bytes.NewReader(errorBuffer.Bytes()) + + errorCode := "UnknownError" + errorMessage := errorCode + + headerCode := response.Header.Get("X-Amzn-ErrorType") + + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(errorBody, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + bodyInfo, err := getProtocolErrorInfo(decoder) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + errorBody.Seek(0, io.SeekStart) + if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok { + errorCode = restjson.SanitizeErrorCode(typ) + } + if len(bodyInfo.Message) != 0 { + errorMessage = bodyInfo.Message + } + switch { + case strings.EqualFold("InvalidParameterException", errorCode): + return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) + + case strings.EqualFold("OperationAbortedException", errorCode): + return awsAwsjson11_deserializeErrorOperationAbortedException(response, errorBody) + + case strings.EqualFold("ResourceNotFoundException", errorCode): + return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) + + case strings.EqualFold("ServiceUnavailableException", errorCode): + return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) + + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, + } + return genericError + + } +} + +type awsAwsjson11_deserializeOpUpdateScheduledQuery struct { +} + +func (*awsAwsjson11_deserializeOpUpdateScheduledQuery) ID() string { + return "OperationDeserializer" +} + +func (m *awsAwsjson11_deserializeOpUpdateScheduledQuery) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( + out middleware.DeserializeOutput, metadata middleware.Metadata, err error, +) { + out, metadata, err = next.HandleDeserialize(ctx, in) + if err != nil { + return out, metadata, err + } + + _, span := tracing.StartSpan(ctx, "OperationDeserializer") + endTimer := startMetricTimer(ctx, "client.call.deserialization_duration") + defer endTimer() + defer span.End() + response, ok := out.RawResponse.(*smithyhttp.Response) + if !ok { + return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} + } + + if response.StatusCode < 200 || response.StatusCode >= 300 { + return out, metadata, awsAwsjson11_deserializeOpErrorUpdateScheduledQuery(response, &metadata) + } + output := &UpdateScheduledQueryOutput{} + out.Result = output + + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(response.Body, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + var shape interface{} + if err := decoder.Decode(&shape); err != nil && err != io.EOF { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return out, metadata, err + } + + err = awsAwsjson11_deserializeOpDocumentUpdateScheduledQueryOutput(&output, shape) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return out, metadata, err + } + + return out, metadata, err +} + +func awsAwsjson11_deserializeOpErrorUpdateScheduledQuery(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.Buffer + if _, err := io.Copy(&errorBuffer, response.Body); err != nil { + return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} + } + errorBody := bytes.NewReader(errorBuffer.Bytes()) + + errorCode := "UnknownError" + errorMessage := errorCode + + headerCode := response.Header.Get("X-Amzn-ErrorType") + + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(errorBody, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + bodyInfo, err := getProtocolErrorInfo(decoder) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + errorBody.Seek(0, io.SeekStart) + if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok { + errorCode = restjson.SanitizeErrorCode(typ) + } + if len(bodyInfo.Message) != 0 { + errorMessage = bodyInfo.Message + } + switch { + case strings.EqualFold("AccessDeniedException", errorCode): + return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) + + case strings.EqualFold("InternalServerException", errorCode): + return awsAwsjson11_deserializeErrorInternalServerException(response, errorBody) + + case strings.EqualFold("ResourceNotFoundException", errorCode): + return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) + + case strings.EqualFold("ThrottlingException", errorCode): + return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) + + case strings.EqualFold("ValidationException", errorCode): + return awsAwsjson11_deserializeErrorValidationException(response, errorBody) + + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, + } + return genericError + + } +} + +func awsAwsjson11_deserializeEventStreamStartLiveTailResponseStream(v *types.StartLiveTailResponseStream, msg *eventstream.Message) error { + if v == nil { + return fmt.Errorf("unexpected serialization of nil %T", v) + } + + eventType := msg.Headers.Get(eventstreamapi.EventTypeHeader) + if eventType == nil { + return fmt.Errorf("%s event header not present", eventstreamapi.EventTypeHeader) + } + + switch { + case strings.EqualFold("sessionStart", eventType.String()): + vv := &types.StartLiveTailResponseStreamMemberSessionStart{} + if err := awsAwsjson11_deserializeEventMessageLiveTailSessionStart(&vv.Value, msg); err != nil { + return err + } + *v = vv + return nil + + case strings.EqualFold("sessionUpdate", eventType.String()): + vv := &types.StartLiveTailResponseStreamMemberSessionUpdate{} + if err := awsAwsjson11_deserializeEventMessageLiveTailSessionUpdate(&vv.Value, msg); err != nil { + return err + } + *v = vv + return nil + + default: + buffer := bytes.NewBuffer(nil) + eventstream.NewEncoder().Encode(buffer, *msg) + *v = &types.UnknownUnionMember{ + Tag: eventType.String(), + Value: buffer.Bytes(), + } + return nil + + } +} + +func awsAwsjson11_deserializeEventStreamExceptionStartLiveTailResponseStream(msg *eventstream.Message) error { + exceptionType := msg.Headers.Get(eventstreamapi.ExceptionTypeHeader) + if exceptionType == nil { + return fmt.Errorf("%s event header not present", eventstreamapi.ExceptionTypeHeader) + } + + switch { + case strings.EqualFold("SessionStreamingException", exceptionType.String()): + return awsAwsjson11_deserializeEventMessageExceptionSessionStreamingException(msg) + + case strings.EqualFold("SessionTimeoutException", exceptionType.String()): + return awsAwsjson11_deserializeEventMessageExceptionSessionTimeoutException(msg) + + default: + br := bytes.NewReader(msg.Payload) + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(br, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + code, message, err := restjson.GetErrorInfo(decoder) + if err != nil { + return err + } + errorCode := "UnknownError" + errorMessage := errorCode + if ev := exceptionType.String(); len(ev) > 0 { + errorCode = ev + } else if ev := code; len(ev) > 0 { + errorCode = ev + } + if ev := message; len(ev) > 0 { + errorMessage = ev + } + return &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, + } + + } +} + +func awsAwsjson11_deserializeEventMessageLiveTailSessionStart(v *types.LiveTailSessionStart, msg *eventstream.Message) error { + if v == nil { + return fmt.Errorf("unexpected serialization of nil %T", v) + } + + br := bytes.NewReader(msg.Payload) + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(br, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + var shape interface{} + if err := decoder.Decode(&shape); err != nil && err != io.EOF { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + if err := awsAwsjson11_deserializeDocumentLiveTailSessionStart(&v, shape); err != nil { + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + } + return nil +} + +func awsAwsjson11_deserializeEventMessageLiveTailSessionUpdate(v *types.LiveTailSessionUpdate, msg *eventstream.Message) error { + if v == nil { + return fmt.Errorf("unexpected serialization of nil %T", v) + } + + br := bytes.NewReader(msg.Payload) + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(br, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + var shape interface{} + if err := decoder.Decode(&shape); err != nil && err != io.EOF { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + if err := awsAwsjson11_deserializeDocumentLiveTailSessionUpdate(&v, shape); err != nil { + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + } + return nil +} + +func awsAwsjson11_deserializeEventMessageExceptionSessionTimeoutException(msg *eventstream.Message) error { + br := bytes.NewReader(msg.Payload) + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(br, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + var shape interface{} + if err := decoder.Decode(&shape); err != nil && err != io.EOF { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + v := &types.SessionTimeoutException{} + if err := awsAwsjson11_deserializeDocumentSessionTimeoutException(&v, shape); err != nil { + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + } + return v +} + +func awsAwsjson11_deserializeEventMessageExceptionSessionStreamingException(msg *eventstream.Message) error { + br := bytes.NewReader(msg.Payload) + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(br, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + var shape interface{} + if err := decoder.Decode(&shape); err != nil && err != io.EOF { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + v := &types.SessionStreamingException{} + if err := awsAwsjson11_deserializeDocumentSessionStreamingException(&v, shape); err != nil { + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + } + return v +} + +func awsAwsjson11_deserializeDocumentInputLogStreamNames(v *[]string, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.([]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var cv []string + if *v == nil { + cv = []string{} + } else { + cv = *v + } + + for _, value := range shape { + var col string + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected LogStreamName to be of type string, got %T instead", value) + } + col = jtv + } + cv = append(cv, col) + + } + *v = cv + return nil +} + +func awsAwsjson11_deserializeDocumentLiveTailSessionLogEvent(v **types.LiveTailSessionLogEvent, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.(map[string]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var sv *types.LiveTailSessionLogEvent + if *v == nil { + sv = &types.LiveTailSessionLogEvent{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "ingestionTime": + if value != nil { + jtv, ok := value.(json.Number) + if !ok { + return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) + } + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.IngestionTime = ptr.Int64(i64) + } + + case "logGroupIdentifier": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected LogGroupIdentifier to be of type string, got %T instead", value) + } + sv.LogGroupIdentifier = ptr.String(jtv) + } + + case "logStreamName": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected LogStreamName to be of type string, got %T instead", value) + } + sv.LogStreamName = ptr.String(jtv) + } + + case "message": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected EventMessage to be of type string, got %T instead", value) + } + sv.Message = ptr.String(jtv) + } + + case "timestamp": + if value != nil { + jtv, ok := value.(json.Number) + if !ok { + return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) + } + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.Timestamp = ptr.Int64(i64) + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + +func awsAwsjson11_deserializeDocumentLiveTailSessionMetadata(v **types.LiveTailSessionMetadata, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.(map[string]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var sv *types.LiveTailSessionMetadata + if *v == nil { + sv = &types.LiveTailSessionMetadata{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "sampled": + if value != nil { + jtv, ok := value.(bool) + if !ok { + return fmt.Errorf("expected IsSampled to be of type *bool, got %T instead", value) + } + sv.Sampled = jtv + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + +func awsAwsjson11_deserializeDocumentLiveTailSessionResults(v *[]types.LiveTailSessionLogEvent, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.([]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var cv []types.LiveTailSessionLogEvent + if *v == nil { + cv = []types.LiveTailSessionLogEvent{} + } else { + cv = *v + } + + for _, value := range shape { + var col types.LiveTailSessionLogEvent + destAddr := &col + if err := awsAwsjson11_deserializeDocumentLiveTailSessionLogEvent(&destAddr, value); err != nil { + return err + } + col = *destAddr + cv = append(cv, col) + + } + *v = cv + return nil +} + +func awsAwsjson11_deserializeDocumentLiveTailSessionStart(v **types.LiveTailSessionStart, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.(map[string]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var sv *types.LiveTailSessionStart + if *v == nil { + sv = &types.LiveTailSessionStart{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "logEventFilterPattern": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected FilterPattern to be of type string, got %T instead", value) + } + sv.LogEventFilterPattern = ptr.String(jtv) + } + + case "logGroupIdentifiers": + if err := awsAwsjson11_deserializeDocumentStartLiveTailLogGroupIdentifiers(&sv.LogGroupIdentifiers, value); err != nil { + return err + } + + case "logStreamNamePrefixes": + if err := awsAwsjson11_deserializeDocumentInputLogStreamNames(&sv.LogStreamNamePrefixes, value); err != nil { + return err + } + + case "logStreamNames": + if err := awsAwsjson11_deserializeDocumentInputLogStreamNames(&sv.LogStreamNames, value); err != nil { + return err + } + + case "requestId": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected RequestId to be of type string, got %T instead", value) + } + sv.RequestId = ptr.String(jtv) + } + + case "sessionId": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected SessionId to be of type string, got %T instead", value) + } + sv.SessionId = ptr.String(jtv) + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + +func awsAwsjson11_deserializeDocumentLiveTailSessionUpdate(v **types.LiveTailSessionUpdate, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.(map[string]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var sv *types.LiveTailSessionUpdate + if *v == nil { + sv = &types.LiveTailSessionUpdate{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "sessionMetadata": + if err := awsAwsjson11_deserializeDocumentLiveTailSessionMetadata(&sv.SessionMetadata, value); err != nil { + return err + } + + case "sessionResults": + if err := awsAwsjson11_deserializeDocumentLiveTailSessionResults(&sv.SessionResults, value); err != nil { + return err + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + +func awsAwsjson11_deserializeDocumentSessionStreamingException(v **types.SessionStreamingException, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.(map[string]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var sv *types.SessionStreamingException + if *v == nil { + sv = &types.SessionStreamingException{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "message", "Message": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected Message to be of type string, got %T instead", value) + } + sv.Message = ptr.String(jtv) + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + +func awsAwsjson11_deserializeDocumentSessionTimeoutException(v **types.SessionTimeoutException, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.(map[string]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var sv *types.SessionTimeoutException + if *v == nil { + sv = &types.SessionTimeoutException{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "message", "Message": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected Message to be of type string, got %T instead", value) + } + sv.Message = ptr.String(jtv) + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + +func awsAwsjson11_deserializeDocumentStartLiveTailLogGroupIdentifiers(v *[]string, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.([]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var cv []string + if *v == nil { + cv = []string{} + } else { + cv = *v + } + + for _, value := range shape { + var col string + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected LogGroupIdentifier to be of type string, got %T instead", value) + } + col = jtv + } + cv = append(cv, col) + + } + *v = cv + return nil +} + +func awsAwsjson11_deserializeEventMessageResponseStartLiveTailOutput(msg *eventstream.Message) (interface{}, error) { + v := &StartLiveTailOutput{} + + br := bytes.NewReader(msg.Payload) + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(br, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + var shape interface{} + if err := decoder.Decode(&shape); err != nil && err != io.EOF { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return nil, err + } + + if err := awsAwsjson11_deserializeOpDocumentStartLiveTailOutput(&v, shape); err != nil { + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return nil, err + } + + } + return v, nil +} + +func awsAwsjson11_deserializeOpDocumentStartLiveTailOutput(v **StartLiveTailOutput, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.(map[string]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var sv *StartLiveTailOutput + if *v == nil { + sv = &StartLiveTailOutput{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + +func awsAwsjson11_deserializeEventStreamGetLogObjectResponseStream(v *types.GetLogObjectResponseStream, msg *eventstream.Message) error { + if v == nil { + return fmt.Errorf("unexpected serialization of nil %T", v) + } + + eventType := msg.Headers.Get(eventstreamapi.EventTypeHeader) + if eventType == nil { + return fmt.Errorf("%s event header not present", eventstreamapi.EventTypeHeader) + } + + switch { + case strings.EqualFold("fields", eventType.String()): + vv := &types.GetLogObjectResponseStreamMemberFields{} + if err := awsAwsjson11_deserializeEventMessageFieldsData(&vv.Value, msg); err != nil { + return err + } + *v = vv + return nil + + default: + buffer := bytes.NewBuffer(nil) + eventstream.NewEncoder().Encode(buffer, *msg) + *v = &types.UnknownUnionMember{ + Tag: eventType.String(), + Value: buffer.Bytes(), + } + return nil + + } +} + +func awsAwsjson11_deserializeEventStreamExceptionGetLogObjectResponseStream(msg *eventstream.Message) error { + exceptionType := msg.Headers.Get(eventstreamapi.ExceptionTypeHeader) + if exceptionType == nil { + return fmt.Errorf("%s event header not present", eventstreamapi.ExceptionTypeHeader) + } + + switch { + case strings.EqualFold("InternalStreamingException", exceptionType.String()): + return awsAwsjson11_deserializeEventMessageExceptionInternalStreamingException(msg) + + default: + br := bytes.NewReader(msg.Payload) + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(br, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + code, message, err := restjson.GetErrorInfo(decoder) + if err != nil { + return err + } + errorCode := "UnknownError" + errorMessage := errorCode + if ev := exceptionType.String(); len(ev) > 0 { + errorCode = ev + } else if ev := code; len(ev) > 0 { + errorCode = ev + } + if ev := message; len(ev) > 0 { + errorMessage = ev + } + return &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, + } + + } +} + +func awsAwsjson11_deserializeEventMessageFieldsData(v *types.FieldsData, msg *eventstream.Message) error { + if v == nil { + return fmt.Errorf("unexpected serialization of nil %T", v) + } + + br := bytes.NewReader(msg.Payload) + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(br, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + var shape interface{} + if err := decoder.Decode(&shape); err != nil && err != io.EOF { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + if err := awsAwsjson11_deserializeDocumentFieldsData(&v, shape); err != nil { + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + } + return nil +} + +func awsAwsjson11_deserializeEventMessageExceptionInternalStreamingException(msg *eventstream.Message) error { + br := bytes.NewReader(msg.Payload) + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(br, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + var shape interface{} + if err := decoder.Decode(&shape); err != nil && err != io.EOF { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + v := &types.InternalStreamingException{} + if err := awsAwsjson11_deserializeDocumentInternalStreamingException(&v, shape); err != nil { + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + } + return v +} + +func awsAwsjson11_deserializeDocumentFieldsData(v **types.FieldsData, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.(map[string]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var sv *types.FieldsData + if *v == nil { + sv = &types.FieldsData{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "data": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected Data to be []byte, got %T instead", value) + } + dv, err := base64.StdEncoding.DecodeString(jtv) + if err != nil { + return fmt.Errorf("failed to base64 decode Data, %w", err) + } + sv.Data = dv + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + +func awsAwsjson11_deserializeDocumentInternalStreamingException(v **types.InternalStreamingException, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.(map[string]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var sv *types.InternalStreamingException + if *v == nil { + sv = &types.InternalStreamingException{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "message", "Message": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected Message to be of type string, got %T instead", value) + } + sv.Message = ptr.String(jtv) + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + +func awsAwsjson11_deserializeEventMessageResponseGetLogObjectOutput(msg *eventstream.Message) (interface{}, error) { + v := &GetLogObjectOutput{} + + br := bytes.NewReader(msg.Payload) + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(br, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + var shape interface{} + if err := decoder.Decode(&shape); err != nil && err != io.EOF { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return nil, err + } + + if err := awsAwsjson11_deserializeOpDocumentGetLogObjectOutput(&v, shape); err != nil { + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return nil, err + } + + } + return v, nil +} + +func awsAwsjson11_deserializeOpDocumentGetLogObjectOutput(v **GetLogObjectOutput, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.(map[string]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var sv *GetLogObjectOutput + if *v == nil { + sv = &GetLogObjectOutput{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + +func awsAwsjson11_deserializeErrorAccessDeniedException(response *smithyhttp.Response, errorBody *bytes.Reader) error { + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(errorBody, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + var shape interface{} + if err := decoder.Decode(&shape); err != nil && err != io.EOF { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + output := &types.AccessDeniedException{} + err := awsAwsjson11_deserializeDocumentAccessDeniedException(&output, shape) + + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + errorBody.Seek(0, io.SeekStart) + return output +} + +func awsAwsjson11_deserializeErrorConflictException(response *smithyhttp.Response, errorBody *bytes.Reader) error { + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(errorBody, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + var shape interface{} + if err := decoder.Decode(&shape); err != nil && err != io.EOF { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + output := &types.ConflictException{} + err := awsAwsjson11_deserializeDocumentConflictException(&output, shape) + + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + errorBody.Seek(0, io.SeekStart) + return output +} + +func awsAwsjson11_deserializeErrorDataAlreadyAcceptedException(response *smithyhttp.Response, errorBody *bytes.Reader) error { + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(errorBody, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + var shape interface{} + if err := decoder.Decode(&shape); err != nil && err != io.EOF { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + output := &types.DataAlreadyAcceptedException{} + err := awsAwsjson11_deserializeDocumentDataAlreadyAcceptedException(&output, shape) + + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + errorBody.Seek(0, io.SeekStart) + return output +} + +func awsAwsjson11_deserializeErrorInternalServerException(response *smithyhttp.Response, errorBody *bytes.Reader) error { + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(errorBody, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + var shape interface{} + if err := decoder.Decode(&shape); err != nil && err != io.EOF { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + output := &types.InternalServerException{} + err := awsAwsjson11_deserializeDocumentInternalServerException(&output, shape) + + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + errorBody.Seek(0, io.SeekStart) + return output +} + +func awsAwsjson11_deserializeErrorInvalidOperationException(response *smithyhttp.Response, errorBody *bytes.Reader) error { + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(errorBody, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + var shape interface{} + if err := decoder.Decode(&shape); err != nil && err != io.EOF { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + output := &types.InvalidOperationException{} + err := awsAwsjson11_deserializeDocumentInvalidOperationException(&output, shape) + + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + errorBody.Seek(0, io.SeekStart) + return output +} + +func awsAwsjson11_deserializeErrorInvalidParameterException(response *smithyhttp.Response, errorBody *bytes.Reader) error { + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(errorBody, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + var shape interface{} + if err := decoder.Decode(&shape); err != nil && err != io.EOF { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + output := &types.InvalidParameterException{} + err := awsAwsjson11_deserializeDocumentInvalidParameterException(&output, shape) + + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + errorBody.Seek(0, io.SeekStart) + return output +} + +func awsAwsjson11_deserializeErrorInvalidSequenceTokenException(response *smithyhttp.Response, errorBody *bytes.Reader) error { + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(errorBody, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + var shape interface{} + if err := decoder.Decode(&shape); err != nil && err != io.EOF { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + output := &types.InvalidSequenceTokenException{} + err := awsAwsjson11_deserializeDocumentInvalidSequenceTokenException(&output, shape) + + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + errorBody.Seek(0, io.SeekStart) + return output +} + +func awsAwsjson11_deserializeErrorLimitExceededException(response *smithyhttp.Response, errorBody *bytes.Reader) error { + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(errorBody, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + var shape interface{} + if err := decoder.Decode(&shape); err != nil && err != io.EOF { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + output := &types.LimitExceededException{} + err := awsAwsjson11_deserializeDocumentLimitExceededException(&output, shape) + + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + errorBody.Seek(0, io.SeekStart) + return output +} + +func awsAwsjson11_deserializeErrorMalformedQueryException(response *smithyhttp.Response, errorBody *bytes.Reader) error { + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(errorBody, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + var shape interface{} + if err := decoder.Decode(&shape); err != nil && err != io.EOF { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + output := &types.MalformedQueryException{} + err := awsAwsjson11_deserializeDocumentMalformedQueryException(&output, shape) + + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + errorBody.Seek(0, io.SeekStart) + return output +} + +func awsAwsjson11_deserializeErrorOperationAbortedException(response *smithyhttp.Response, errorBody *bytes.Reader) error { + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(errorBody, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + var shape interface{} + if err := decoder.Decode(&shape); err != nil && err != io.EOF { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + output := &types.OperationAbortedException{} + err := awsAwsjson11_deserializeDocumentOperationAbortedException(&output, shape) + + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + errorBody.Seek(0, io.SeekStart) + return output +} + +func awsAwsjson11_deserializeErrorResourceAlreadyExistsException(response *smithyhttp.Response, errorBody *bytes.Reader) error { + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(errorBody, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + var shape interface{} + if err := decoder.Decode(&shape); err != nil && err != io.EOF { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + output := &types.ResourceAlreadyExistsException{} + err := awsAwsjson11_deserializeDocumentResourceAlreadyExistsException(&output, shape) + + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + errorBody.Seek(0, io.SeekStart) + return output +} + +func awsAwsjson11_deserializeErrorResourceNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(errorBody, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + var shape interface{} + if err := decoder.Decode(&shape); err != nil && err != io.EOF { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + output := &types.ResourceNotFoundException{} + err := awsAwsjson11_deserializeDocumentResourceNotFoundException(&output, shape) + + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + errorBody.Seek(0, io.SeekStart) + return output +} + +func awsAwsjson11_deserializeErrorServiceQuotaExceededException(response *smithyhttp.Response, errorBody *bytes.Reader) error { + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(errorBody, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + var shape interface{} + if err := decoder.Decode(&shape); err != nil && err != io.EOF { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + output := &types.ServiceQuotaExceededException{} + err := awsAwsjson11_deserializeDocumentServiceQuotaExceededException(&output, shape) + + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + errorBody.Seek(0, io.SeekStart) + return output +} + +func awsAwsjson11_deserializeErrorServiceUnavailableException(response *smithyhttp.Response, errorBody *bytes.Reader) error { + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(errorBody, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + var shape interface{} + if err := decoder.Decode(&shape); err != nil && err != io.EOF { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + output := &types.ServiceUnavailableException{} + err := awsAwsjson11_deserializeDocumentServiceUnavailableException(&output, shape) + + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + errorBody.Seek(0, io.SeekStart) + return output +} + +func awsAwsjson11_deserializeErrorThrottlingException(response *smithyhttp.Response, errorBody *bytes.Reader) error { + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(errorBody, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + var shape interface{} + if err := decoder.Decode(&shape); err != nil && err != io.EOF { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + output := &types.ThrottlingException{} + err := awsAwsjson11_deserializeDocumentThrottlingException(&output, shape) + + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + errorBody.Seek(0, io.SeekStart) + return output +} + +func awsAwsjson11_deserializeErrorTooManyTagsException(response *smithyhttp.Response, errorBody *bytes.Reader) error { + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(errorBody, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + var shape interface{} + if err := decoder.Decode(&shape); err != nil && err != io.EOF { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + output := &types.TooManyTagsException{} + err := awsAwsjson11_deserializeDocumentTooManyTagsException(&output, shape) + + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + errorBody.Seek(0, io.SeekStart) + return output +} + +func awsAwsjson11_deserializeErrorUnrecognizedClientException(response *smithyhttp.Response, errorBody *bytes.Reader) error { + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(errorBody, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + var shape interface{} + if err := decoder.Decode(&shape); err != nil && err != io.EOF { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + output := &types.UnrecognizedClientException{} + err := awsAwsjson11_deserializeDocumentUnrecognizedClientException(&output, shape) + + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + errorBody.Seek(0, io.SeekStart) + return output +} + +func awsAwsjson11_deserializeErrorValidationException(response *smithyhttp.Response, errorBody *bytes.Reader) error { + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(errorBody, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + var shape interface{} + if err := decoder.Decode(&shape); err != nil && err != io.EOF { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + output := &types.ValidationException{} + err := awsAwsjson11_deserializeDocumentValidationException(&output, shape) + + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + errorBody.Seek(0, io.SeekStart) + return output +} + +func awsAwsjson11_deserializeDocumentAccessDeniedException(v **types.AccessDeniedException, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.(map[string]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var sv *types.AccessDeniedException + if *v == nil { + sv = &types.AccessDeniedException{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "message", "Message": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected Message to be of type string, got %T instead", value) + } + sv.Message = ptr.String(jtv) + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + +func awsAwsjson11_deserializeDocumentAccountPolicies(v *[]types.AccountPolicy, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.([]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var cv []types.AccountPolicy + if *v == nil { + cv = []types.AccountPolicy{} + } else { + cv = *v + } + + for _, value := range shape { + var col types.AccountPolicy + destAddr := &col + if err := awsAwsjson11_deserializeDocumentAccountPolicy(&destAddr, value); err != nil { + return err + } + col = *destAddr + cv = append(cv, col) + + } + *v = cv + return nil +} + +func awsAwsjson11_deserializeDocumentAccountPolicy(v **types.AccountPolicy, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.(map[string]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var sv *types.AccountPolicy + if *v == nil { + sv = &types.AccountPolicy{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "accountId": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected AccountId to be of type string, got %T instead", value) + } + sv.AccountId = ptr.String(jtv) + } + + case "lastUpdatedTime": + if value != nil { + jtv, ok := value.(json.Number) + if !ok { + return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) + } + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.LastUpdatedTime = ptr.Int64(i64) + } + + case "policyDocument": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected AccountPolicyDocument to be of type string, got %T instead", value) + } + sv.PolicyDocument = ptr.String(jtv) + } + + case "policyName": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected PolicyName to be of type string, got %T instead", value) + } + sv.PolicyName = ptr.String(jtv) + } + + case "policyType": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected PolicyType to be of type string, got %T instead", value) + } + sv.PolicyType = types.PolicyType(jtv) + } + + case "scope": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected Scope to be of type string, got %T instead", value) + } + sv.Scope = types.Scope(jtv) + } + + case "selectionCriteria": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected SelectionCriteria to be of type string, got %T instead", value) + } + sv.SelectionCriteria = ptr.String(jtv) + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + +func awsAwsjson11_deserializeDocumentAddKeyEntries(v *[]types.AddKeyEntry, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.([]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var cv []types.AddKeyEntry + if *v == nil { + cv = []types.AddKeyEntry{} + } else { + cv = *v + } + + for _, value := range shape { + var col types.AddKeyEntry + destAddr := &col + if err := awsAwsjson11_deserializeDocumentAddKeyEntry(&destAddr, value); err != nil { + return err + } + col = *destAddr + cv = append(cv, col) + + } + *v = cv + return nil +} + +func awsAwsjson11_deserializeDocumentAddKeyEntry(v **types.AddKeyEntry, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.(map[string]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var sv *types.AddKeyEntry + if *v == nil { + sv = &types.AddKeyEntry{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "key": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected Key to be of type string, got %T instead", value) + } + sv.Key = ptr.String(jtv) + } + + case "overwriteIfExists": + if value != nil { + jtv, ok := value.(bool) + if !ok { + return fmt.Errorf("expected OverwriteIfExists to be of type *bool, got %T instead", value) + } + sv.OverwriteIfExists = jtv + } + + case "value": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected AddKeyValue to be of type string, got %T instead", value) + } + sv.Value = ptr.String(jtv) + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + +func awsAwsjson11_deserializeDocumentAddKeys(v **types.AddKeys, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.(map[string]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var sv *types.AddKeys + if *v == nil { + sv = &types.AddKeys{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "entries": + if err := awsAwsjson11_deserializeDocumentAddKeyEntries(&sv.Entries, value); err != nil { + return err + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + +func awsAwsjson11_deserializeDocumentAggregateLogGroupSummaries(v *[]types.AggregateLogGroupSummary, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.([]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var cv []types.AggregateLogGroupSummary + if *v == nil { + cv = []types.AggregateLogGroupSummary{} + } else { + cv = *v + } + + for _, value := range shape { + var col types.AggregateLogGroupSummary + destAddr := &col + if err := awsAwsjson11_deserializeDocumentAggregateLogGroupSummary(&destAddr, value); err != nil { + return err + } + col = *destAddr + cv = append(cv, col) + + } + *v = cv + return nil +} + +func awsAwsjson11_deserializeDocumentAggregateLogGroupSummary(v **types.AggregateLogGroupSummary, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.(map[string]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var sv *types.AggregateLogGroupSummary + if *v == nil { + sv = &types.AggregateLogGroupSummary{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "groupingIdentifiers": + if err := awsAwsjson11_deserializeDocumentGroupingIdentifiers(&sv.GroupingIdentifiers, value); err != nil { + return err + } + + case "logGroupCount": + if value != nil { + jtv, ok := value.(json.Number) + if !ok { + return fmt.Errorf("expected LogGroupCount to be json.Number, got %T instead", value) + } + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.LogGroupCount = ptr.Int32(int32(i64)) + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + +func awsAwsjson11_deserializeDocumentAllowedFieldDelimiters(v *[]string, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.([]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var cv []string + if *v == nil { + cv = []string{} + } else { + cv = *v + } + + for _, value := range shape { + var col string + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected FieldDelimiter to be of type string, got %T instead", value) + } + col = jtv + } + cv = append(cv, col) + + } + *v = cv + return nil +} + +func awsAwsjson11_deserializeDocumentAllowedFields(v *[]types.RecordField, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.([]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var cv []types.RecordField + if *v == nil { + cv = []types.RecordField{} + } else { + cv = *v + } + + for _, value := range shape { + var col types.RecordField + destAddr := &col + if err := awsAwsjson11_deserializeDocumentRecordField(&destAddr, value); err != nil { + return err + } + col = *destAddr + cv = append(cv, col) + + } + *v = cv + return nil +} + +func awsAwsjson11_deserializeDocumentAnomalies(v *[]types.Anomaly, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.([]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var cv []types.Anomaly + if *v == nil { + cv = []types.Anomaly{} + } else { + cv = *v + } + + for _, value := range shape { + var col types.Anomaly + destAddr := &col + if err := awsAwsjson11_deserializeDocumentAnomaly(&destAddr, value); err != nil { + return err + } + col = *destAddr + cv = append(cv, col) + + } + *v = cv + return nil +} + +func awsAwsjson11_deserializeDocumentAnomaly(v **types.Anomaly, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.(map[string]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var sv *types.Anomaly + if *v == nil { + sv = &types.Anomaly{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "active": + if value != nil { + jtv, ok := value.(bool) + if !ok { + return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) + } + sv.Active = ptr.Bool(jtv) + } + + case "anomalyDetectorArn": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected AnomalyDetectorArn to be of type string, got %T instead", value) + } + sv.AnomalyDetectorArn = ptr.String(jtv) + } + + case "anomalyId": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected AnomalyId to be of type string, got %T instead", value) + } + sv.AnomalyId = ptr.String(jtv) + } + + case "description": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected Description to be of type string, got %T instead", value) + } + sv.Description = ptr.String(jtv) + } + + case "firstSeen": + if value != nil { + jtv, ok := value.(json.Number) + if !ok { + return fmt.Errorf("expected EpochMillis to be json.Number, got %T instead", value) + } + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.FirstSeen = i64 + } + + case "histogram": + if err := awsAwsjson11_deserializeDocumentHistogram(&sv.Histogram, value); err != nil { + return err + } + + case "isPatternLevelSuppression": + if value != nil { + jtv, ok := value.(bool) + if !ok { + return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) + } + sv.IsPatternLevelSuppression = ptr.Bool(jtv) + } + + case "lastSeen": + if value != nil { + jtv, ok := value.(json.Number) + if !ok { + return fmt.Errorf("expected EpochMillis to be json.Number, got %T instead", value) + } + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.LastSeen = i64 + } + + case "logGroupArnList": + if err := awsAwsjson11_deserializeDocumentLogGroupArnList(&sv.LogGroupArnList, value); err != nil { + return err + } + + case "logSamples": + if err := awsAwsjson11_deserializeDocumentLogSamples(&sv.LogSamples, value); err != nil { + return err + } + + case "patternId": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected PatternId to be of type string, got %T instead", value) + } + sv.PatternId = ptr.String(jtv) + } + + case "patternRegex": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected PatternRegex to be of type string, got %T instead", value) + } + sv.PatternRegex = ptr.String(jtv) + } + + case "patternString": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected PatternString to be of type string, got %T instead", value) + } + sv.PatternString = ptr.String(jtv) + } + + case "patternTokens": + if err := awsAwsjson11_deserializeDocumentPatternTokens(&sv.PatternTokens, value); err != nil { + return err + } + + case "priority": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected Priority to be of type string, got %T instead", value) + } + sv.Priority = ptr.String(jtv) + } + + case "state": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected State to be of type string, got %T instead", value) + } + sv.State = types.State(jtv) + } + + case "suppressed": + if value != nil { + jtv, ok := value.(bool) + if !ok { + return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) + } + sv.Suppressed = ptr.Bool(jtv) + } + + case "suppressedDate": + if value != nil { + jtv, ok := value.(json.Number) + if !ok { + return fmt.Errorf("expected EpochMillis to be json.Number, got %T instead", value) + } + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.SuppressedDate = i64 + } + + case "suppressedUntil": + if value != nil { + jtv, ok := value.(json.Number) + if !ok { + return fmt.Errorf("expected EpochMillis to be json.Number, got %T instead", value) + } + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.SuppressedUntil = i64 + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + +func awsAwsjson11_deserializeDocumentAnomalyDetector(v **types.AnomalyDetector, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.(map[string]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var sv *types.AnomalyDetector + if *v == nil { + sv = &types.AnomalyDetector{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "anomalyDetectorArn": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected AnomalyDetectorArn to be of type string, got %T instead", value) + } + sv.AnomalyDetectorArn = ptr.String(jtv) + } + + case "anomalyDetectorStatus": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected AnomalyDetectorStatus to be of type string, got %T instead", value) + } + sv.AnomalyDetectorStatus = types.AnomalyDetectorStatus(jtv) + } + + case "anomalyVisibilityTime": + if value != nil { + jtv, ok := value.(json.Number) + if !ok { + return fmt.Errorf("expected AnomalyVisibilityTime to be json.Number, got %T instead", value) + } + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.AnomalyVisibilityTime = ptr.Int64(i64) + } + + case "creationTimeStamp": + if value != nil { + jtv, ok := value.(json.Number) + if !ok { + return fmt.Errorf("expected EpochMillis to be json.Number, got %T instead", value) + } + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.CreationTimeStamp = i64 + } + + case "detectorName": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected DetectorName to be of type string, got %T instead", value) + } + sv.DetectorName = ptr.String(jtv) + } + + case "evaluationFrequency": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected EvaluationFrequency to be of type string, got %T instead", value) + } + sv.EvaluationFrequency = types.EvaluationFrequency(jtv) + } + + case "filterPattern": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected FilterPattern to be of type string, got %T instead", value) + } + sv.FilterPattern = ptr.String(jtv) + } + + case "kmsKeyId": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected KmsKeyId to be of type string, got %T instead", value) + } + sv.KmsKeyId = ptr.String(jtv) + } + + case "lastModifiedTimeStamp": + if value != nil { + jtv, ok := value.(json.Number) + if !ok { + return fmt.Errorf("expected EpochMillis to be json.Number, got %T instead", value) + } + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.LastModifiedTimeStamp = i64 + } + + case "logGroupArnList": + if err := awsAwsjson11_deserializeDocumentLogGroupArnList(&sv.LogGroupArnList, value); err != nil { + return err + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + +func awsAwsjson11_deserializeDocumentAnomalyDetectors(v *[]types.AnomalyDetector, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.([]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var cv []types.AnomalyDetector + if *v == nil { + cv = []types.AnomalyDetector{} + } else { + cv = *v + } + + for _, value := range shape { + var col types.AnomalyDetector + destAddr := &col + if err := awsAwsjson11_deserializeDocumentAnomalyDetector(&destAddr, value); err != nil { + return err + } + col = *destAddr + cv = append(cv, col) + + } + *v = cv + return nil +} + +func awsAwsjson11_deserializeDocumentColumns(v *[]string, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.([]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var cv []string + if *v == nil { + cv = []string{} + } else { + cv = *v + } + + for _, value := range shape { + var col string + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected Column to be of type string, got %T instead", value) + } + col = jtv + } + cv = append(cv, col) + + } + *v = cv + return nil +} + +func awsAwsjson11_deserializeDocumentConfigurationTemplate(v **types.ConfigurationTemplate, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.(map[string]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var sv *types.ConfigurationTemplate + if *v == nil { + sv = &types.ConfigurationTemplate{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "allowedActionForAllowVendedLogsDeliveryForResource": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected AllowedActionForAllowVendedLogsDeliveryForResource to be of type string, got %T instead", value) + } + sv.AllowedActionForAllowVendedLogsDeliveryForResource = ptr.String(jtv) + } + + case "allowedFieldDelimiters": + if err := awsAwsjson11_deserializeDocumentAllowedFieldDelimiters(&sv.AllowedFieldDelimiters, value); err != nil { + return err + } + + case "allowedFields": + if err := awsAwsjson11_deserializeDocumentAllowedFields(&sv.AllowedFields, value); err != nil { + return err + } + + case "allowedOutputFormats": + if err := awsAwsjson11_deserializeDocumentOutputFormats(&sv.AllowedOutputFormats, value); err != nil { + return err + } + + case "allowedSuffixPathFields": + if err := awsAwsjson11_deserializeDocumentRecordFields(&sv.AllowedSuffixPathFields, value); err != nil { + return err + } + + case "defaultDeliveryConfigValues": + if err := awsAwsjson11_deserializeDocumentConfigurationTemplateDeliveryConfigValues(&sv.DefaultDeliveryConfigValues, value); err != nil { + return err + } + + case "deliveryDestinationType": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected DeliveryDestinationType to be of type string, got %T instead", value) + } + sv.DeliveryDestinationType = types.DeliveryDestinationType(jtv) + } + + case "logType": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected LogType to be of type string, got %T instead", value) + } + sv.LogType = ptr.String(jtv) + } + + case "resourceType": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value) + } + sv.ResourceType = ptr.String(jtv) + } + + case "service": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected Service to be of type string, got %T instead", value) + } + sv.Service = ptr.String(jtv) + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + +func awsAwsjson11_deserializeDocumentConfigurationTemplateDeliveryConfigValues(v **types.ConfigurationTemplateDeliveryConfigValues, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.(map[string]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var sv *types.ConfigurationTemplateDeliveryConfigValues + if *v == nil { + sv = &types.ConfigurationTemplateDeliveryConfigValues{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "fieldDelimiter": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected FieldDelimiter to be of type string, got %T instead", value) + } + sv.FieldDelimiter = ptr.String(jtv) + } + + case "recordFields": + if err := awsAwsjson11_deserializeDocumentRecordFields(&sv.RecordFields, value); err != nil { + return err + } + + case "s3DeliveryConfiguration": + if err := awsAwsjson11_deserializeDocumentS3DeliveryConfiguration(&sv.S3DeliveryConfiguration, value); err != nil { + return err + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + +func awsAwsjson11_deserializeDocumentConfigurationTemplates(v *[]types.ConfigurationTemplate, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.([]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var cv []types.ConfigurationTemplate + if *v == nil { + cv = []types.ConfigurationTemplate{} + } else { + cv = *v + } + + for _, value := range shape { + var col types.ConfigurationTemplate + destAddr := &col + if err := awsAwsjson11_deserializeDocumentConfigurationTemplate(&destAddr, value); err != nil { + return err + } + col = *destAddr + cv = append(cv, col) + + } + *v = cv + return nil +} + +func awsAwsjson11_deserializeDocumentConflictException(v **types.ConflictException, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.(map[string]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var sv *types.ConflictException + if *v == nil { + sv = &types.ConflictException{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "message", "Message": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected Message to be of type string, got %T instead", value) + } + sv.Message = ptr.String(jtv) + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + +func awsAwsjson11_deserializeDocumentCopyValue(v **types.CopyValue, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.(map[string]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var sv *types.CopyValue + if *v == nil { + sv = &types.CopyValue{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "entries": + if err := awsAwsjson11_deserializeDocumentCopyValueEntries(&sv.Entries, value); err != nil { + return err + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + +func awsAwsjson11_deserializeDocumentCopyValueEntries(v *[]types.CopyValueEntry, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.([]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var cv []types.CopyValueEntry + if *v == nil { + cv = []types.CopyValueEntry{} + } else { + cv = *v + } + + for _, value := range shape { + var col types.CopyValueEntry + destAddr := &col + if err := awsAwsjson11_deserializeDocumentCopyValueEntry(&destAddr, value); err != nil { + return err + } + col = *destAddr + cv = append(cv, col) + + } + *v = cv + return nil +} + +func awsAwsjson11_deserializeDocumentCopyValueEntry(v **types.CopyValueEntry, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.(map[string]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var sv *types.CopyValueEntry + if *v == nil { + sv = &types.CopyValueEntry{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "overwriteIfExists": + if value != nil { + jtv, ok := value.(bool) + if !ok { + return fmt.Errorf("expected OverwriteIfExists to be of type *bool, got %T instead", value) + } + sv.OverwriteIfExists = jtv + } + + case "source": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected Source to be of type string, got %T instead", value) + } + sv.Source = ptr.String(jtv) + } + + case "target": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected Target to be of type string, got %T instead", value) + } + sv.Target = ptr.String(jtv) + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + +func awsAwsjson11_deserializeDocumentCSV(v **types.CSV, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.(map[string]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var sv *types.CSV + if *v == nil { + sv = &types.CSV{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "columns": + if err := awsAwsjson11_deserializeDocumentColumns(&sv.Columns, value); err != nil { + return err + } + + case "delimiter": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected Delimiter to be of type string, got %T instead", value) + } + sv.Delimiter = ptr.String(jtv) + } + + case "quoteCharacter": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected QuoteCharacter to be of type string, got %T instead", value) + } + sv.QuoteCharacter = ptr.String(jtv) + } + + case "source": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected Source to be of type string, got %T instead", value) + } + sv.Source = ptr.String(jtv) + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + +func awsAwsjson11_deserializeDocumentDataAlreadyAcceptedException(v **types.DataAlreadyAcceptedException, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.(map[string]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var sv *types.DataAlreadyAcceptedException + if *v == nil { + sv = &types.DataAlreadyAcceptedException{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "expectedSequenceToken": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected SequenceToken to be of type string, got %T instead", value) + } + sv.ExpectedSequenceToken = ptr.String(jtv) + } + + case "message", "Message": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected Message to be of type string, got %T instead", value) + } + sv.Message = ptr.String(jtv) + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + +func awsAwsjson11_deserializeDocumentDataSource(v **types.DataSource, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.(map[string]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var sv *types.DataSource + if *v == nil { + sv = &types.DataSource{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "name": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected DataSourceName to be of type string, got %T instead", value) + } + sv.Name = ptr.String(jtv) + } + + case "type": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected DataSourceType to be of type string, got %T instead", value) + } + sv.Type = ptr.String(jtv) + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + +func awsAwsjson11_deserializeDocumentDateTimeConverter(v **types.DateTimeConverter, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.(map[string]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var sv *types.DateTimeConverter + if *v == nil { + sv = &types.DateTimeConverter{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "locale": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected Locale to be of type string, got %T instead", value) + } + sv.Locale = ptr.String(jtv) + } + + case "matchPatterns": + if err := awsAwsjson11_deserializeDocumentMatchPatterns(&sv.MatchPatterns, value); err != nil { + return err + } + + case "source": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected Source to be of type string, got %T instead", value) + } + sv.Source = ptr.String(jtv) + } + + case "sourceTimezone": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected SourceTimezone to be of type string, got %T instead", value) + } + sv.SourceTimezone = ptr.String(jtv) + } + + case "target": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected Target to be of type string, got %T instead", value) + } + sv.Target = ptr.String(jtv) + } + + case "targetFormat": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected TargetFormat to be of type string, got %T instead", value) + } + sv.TargetFormat = ptr.String(jtv) + } + + case "targetTimezone": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected TargetTimezone to be of type string, got %T instead", value) + } + sv.TargetTimezone = ptr.String(jtv) + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + +func awsAwsjson11_deserializeDocumentDeleteKeys(v **types.DeleteKeys, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.(map[string]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var sv *types.DeleteKeys + if *v == nil { + sv = &types.DeleteKeys{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "withKeys": + if err := awsAwsjson11_deserializeDocumentDeleteWithKeys(&sv.WithKeys, value); err != nil { + return err + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + +func awsAwsjson11_deserializeDocumentDeleteWithKeys(v *[]string, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.([]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var cv []string + if *v == nil { + cv = []string{} + } else { + cv = *v + } + + for _, value := range shape { + var col string + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected WithKey to be of type string, got %T instead", value) + } + col = jtv + } + cv = append(cv, col) + + } + *v = cv + return nil +} + +func awsAwsjson11_deserializeDocumentDeliveries(v *[]types.Delivery, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.([]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var cv []types.Delivery + if *v == nil { + cv = []types.Delivery{} + } else { + cv = *v + } + + for _, value := range shape { + var col types.Delivery + destAddr := &col + if err := awsAwsjson11_deserializeDocumentDelivery(&destAddr, value); err != nil { + return err + } + col = *destAddr + cv = append(cv, col) + + } + *v = cv + return nil +} + +func awsAwsjson11_deserializeDocumentDelivery(v **types.Delivery, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.(map[string]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var sv *types.Delivery + if *v == nil { + sv = &types.Delivery{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "arn": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected Arn to be of type string, got %T instead", value) + } + sv.Arn = ptr.String(jtv) + } + + case "deliveryDestinationArn": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected Arn to be of type string, got %T instead", value) + } + sv.DeliveryDestinationArn = ptr.String(jtv) + } + + case "deliveryDestinationType": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected DeliveryDestinationType to be of type string, got %T instead", value) + } + sv.DeliveryDestinationType = types.DeliveryDestinationType(jtv) + } + + case "deliverySourceName": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected DeliverySourceName to be of type string, got %T instead", value) + } + sv.DeliverySourceName = ptr.String(jtv) + } + + case "fieldDelimiter": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected FieldDelimiter to be of type string, got %T instead", value) + } + sv.FieldDelimiter = ptr.String(jtv) + } + + case "id": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected DeliveryId to be of type string, got %T instead", value) + } + sv.Id = ptr.String(jtv) + } + + case "recordFields": + if err := awsAwsjson11_deserializeDocumentRecordFields(&sv.RecordFields, value); err != nil { + return err + } + + case "s3DeliveryConfiguration": + if err := awsAwsjson11_deserializeDocumentS3DeliveryConfiguration(&sv.S3DeliveryConfiguration, value); err != nil { + return err + } + + case "tags": + if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil { + return err + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + +func awsAwsjson11_deserializeDocumentDeliveryDestination(v **types.DeliveryDestination, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.(map[string]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var sv *types.DeliveryDestination + if *v == nil { + sv = &types.DeliveryDestination{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "arn": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected Arn to be of type string, got %T instead", value) + } + sv.Arn = ptr.String(jtv) + } + + case "deliveryDestinationConfiguration": + if err := awsAwsjson11_deserializeDocumentDeliveryDestinationConfiguration(&sv.DeliveryDestinationConfiguration, value); err != nil { + return err + } + + case "deliveryDestinationType": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected DeliveryDestinationType to be of type string, got %T instead", value) + } + sv.DeliveryDestinationType = types.DeliveryDestinationType(jtv) + } + + case "name": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected DeliveryDestinationName to be of type string, got %T instead", value) + } + sv.Name = ptr.String(jtv) + } + + case "outputFormat": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected OutputFormat to be of type string, got %T instead", value) + } + sv.OutputFormat = types.OutputFormat(jtv) + } + + case "tags": + if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil { + return err + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + +func awsAwsjson11_deserializeDocumentDeliveryDestinationConfiguration(v **types.DeliveryDestinationConfiguration, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.(map[string]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var sv *types.DeliveryDestinationConfiguration + if *v == nil { + sv = &types.DeliveryDestinationConfiguration{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "destinationResourceArn": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected Arn to be of type string, got %T instead", value) + } + sv.DestinationResourceArn = ptr.String(jtv) + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + +func awsAwsjson11_deserializeDocumentDeliveryDestinations(v *[]types.DeliveryDestination, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.([]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var cv []types.DeliveryDestination + if *v == nil { + cv = []types.DeliveryDestination{} + } else { + cv = *v + } + + for _, value := range shape { + var col types.DeliveryDestination + destAddr := &col + if err := awsAwsjson11_deserializeDocumentDeliveryDestination(&destAddr, value); err != nil { + return err + } + col = *destAddr + cv = append(cv, col) + + } + *v = cv + return nil +} + +func awsAwsjson11_deserializeDocumentDeliverySource(v **types.DeliverySource, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.(map[string]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var sv *types.DeliverySource + if *v == nil { + sv = &types.DeliverySource{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "arn": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected Arn to be of type string, got %T instead", value) + } + sv.Arn = ptr.String(jtv) + } + + case "logType": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected LogType to be of type string, got %T instead", value) + } + sv.LogType = ptr.String(jtv) + } + + case "name": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected DeliverySourceName to be of type string, got %T instead", value) + } + sv.Name = ptr.String(jtv) + } + + case "resourceArns": + if err := awsAwsjson11_deserializeDocumentResourceArns(&sv.ResourceArns, value); err != nil { + return err + } + + case "service": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected Service to be of type string, got %T instead", value) + } + sv.Service = ptr.String(jtv) + } + + case "tags": + if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil { + return err + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + +func awsAwsjson11_deserializeDocumentDeliverySources(v *[]types.DeliverySource, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.([]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var cv []types.DeliverySource + if *v == nil { + cv = []types.DeliverySource{} + } else { + cv = *v + } + + for _, value := range shape { + var col types.DeliverySource + destAddr := &col + if err := awsAwsjson11_deserializeDocumentDeliverySource(&destAddr, value); err != nil { + return err + } + col = *destAddr + cv = append(cv, col) + + } + *v = cv + return nil +} + +func awsAwsjson11_deserializeDocumentDestination(v **types.Destination, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.(map[string]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var sv *types.Destination + if *v == nil { + sv = &types.Destination{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "accessPolicy": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected AccessPolicy to be of type string, got %T instead", value) + } + sv.AccessPolicy = ptr.String(jtv) + } + + case "arn": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected Arn to be of type string, got %T instead", value) + } + sv.Arn = ptr.String(jtv) + } + + case "creationTime": + if value != nil { + jtv, ok := value.(json.Number) + if !ok { + return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) + } + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.CreationTime = ptr.Int64(i64) + } + + case "destinationName": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected DestinationName to be of type string, got %T instead", value) + } + sv.DestinationName = ptr.String(jtv) + } + + case "roleArn": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected RoleArn to be of type string, got %T instead", value) + } + sv.RoleArn = ptr.String(jtv) + } + + case "targetArn": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected TargetArn to be of type string, got %T instead", value) + } + sv.TargetArn = ptr.String(jtv) + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + +func awsAwsjson11_deserializeDocumentDestinationConfiguration(v **types.DestinationConfiguration, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.(map[string]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var sv *types.DestinationConfiguration + if *v == nil { + sv = &types.DestinationConfiguration{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "s3Configuration": + if err := awsAwsjson11_deserializeDocumentS3Configuration(&sv.S3Configuration, value); err != nil { + return err + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + +func awsAwsjson11_deserializeDocumentDestinations(v *[]types.Destination, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.([]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var cv []types.Destination + if *v == nil { + cv = []types.Destination{} + } else { + cv = *v + } + + for _, value := range shape { + var col types.Destination + destAddr := &col + if err := awsAwsjson11_deserializeDocumentDestination(&destAddr, value); err != nil { + return err + } + col = *destAddr + cv = append(cv, col) + + } + *v = cv + return nil +} + +func awsAwsjson11_deserializeDocumentDimensions(v *map[string]string, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.(map[string]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var mv map[string]string + if *v == nil { + mv = map[string]string{} + } else { + mv = *v + } + + for key, value := range shape { + var parsedVal string + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected DimensionsValue to be of type string, got %T instead", value) + } + parsedVal = jtv + } + mv[key] = parsedVal + + } + *v = mv + return nil +} + +func awsAwsjson11_deserializeDocumentEmitSystemFields(v *[]string, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.([]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var cv []string + if *v == nil { + cv = []string{} + } else { + cv = *v + } + + for _, value := range shape { + var col string + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected SystemField to be of type string, got %T instead", value) + } + col = jtv + } + cv = append(cv, col) + + } + *v = cv + return nil +} + +func awsAwsjson11_deserializeDocumentEnumerations(v *map[string]int64, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.(map[string]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var mv map[string]int64 + if *v == nil { + mv = map[string]int64{} + } else { + mv = *v + } + + for key, value := range shape { + var parsedVal int64 + if value != nil { + jtv, ok := value.(json.Number) + if !ok { + return fmt.Errorf("expected TokenValue to be json.Number, got %T instead", value) + } + i64, err := jtv.Int64() + if err != nil { + return err + } + parsedVal = i64 + } + mv[key] = parsedVal + + } + *v = mv + return nil +} + +func awsAwsjson11_deserializeDocumentExportTask(v **types.ExportTask, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.(map[string]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var sv *types.ExportTask + if *v == nil { + sv = &types.ExportTask{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "destination": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected ExportDestinationBucket to be of type string, got %T instead", value) + } + sv.Destination = ptr.String(jtv) + } + + case "destinationPrefix": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected ExportDestinationPrefix to be of type string, got %T instead", value) + } + sv.DestinationPrefix = ptr.String(jtv) + } + + case "executionInfo": + if err := awsAwsjson11_deserializeDocumentExportTaskExecutionInfo(&sv.ExecutionInfo, value); err != nil { + return err + } + + case "from": + if value != nil { + jtv, ok := value.(json.Number) + if !ok { + return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) + } + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.From = ptr.Int64(i64) + } + + case "logGroupName": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected LogGroupName to be of type string, got %T instead", value) + } + sv.LogGroupName = ptr.String(jtv) + } + + case "status": + if err := awsAwsjson11_deserializeDocumentExportTaskStatus(&sv.Status, value); err != nil { + return err + } + + case "taskId": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected ExportTaskId to be of type string, got %T instead", value) + } + sv.TaskId = ptr.String(jtv) + } + + case "taskName": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected ExportTaskName to be of type string, got %T instead", value) + } + sv.TaskName = ptr.String(jtv) + } + + case "to": + if value != nil { + jtv, ok := value.(json.Number) + if !ok { + return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) + } + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.To = ptr.Int64(i64) + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + +func awsAwsjson11_deserializeDocumentExportTaskExecutionInfo(v **types.ExportTaskExecutionInfo, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.(map[string]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var sv *types.ExportTaskExecutionInfo + if *v == nil { + sv = &types.ExportTaskExecutionInfo{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "completionTime": + if value != nil { + jtv, ok := value.(json.Number) + if !ok { + return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) + } + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.CompletionTime = ptr.Int64(i64) + } + + case "creationTime": + if value != nil { + jtv, ok := value.(json.Number) + if !ok { + return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) + } + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.CreationTime = ptr.Int64(i64) + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + +func awsAwsjson11_deserializeDocumentExportTasks(v *[]types.ExportTask, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil } - output := &types.ValidationException{} - err := awsAwsjson11_deserializeDocumentValidationException(&output, shape) + shape, ok := value.([]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return err + var cv []types.ExportTask + if *v == nil { + cv = []types.ExportTask{} + } else { + cv = *v } - errorBody.Seek(0, io.SeekStart) - return output + for _, value := range shape { + var col types.ExportTask + destAddr := &col + if err := awsAwsjson11_deserializeDocumentExportTask(&destAddr, value); err != nil { + return err + } + col = *destAddr + cv = append(cv, col) + + } + *v = cv + return nil } -func awsAwsjson11_deserializeDocumentAccessDeniedException(v **types.AccessDeniedException, value interface{}) error { +func awsAwsjson11_deserializeDocumentExportTaskStatus(v **types.ExportTaskStatus, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -11327,20 +16359,29 @@ func awsAwsjson11_deserializeDocumentAccessDeniedException(v **types.AccessDenie return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.AccessDeniedException + var sv *types.ExportTaskStatus if *v == nil { - sv = &types.AccessDeniedException{} + sv = &types.ExportTaskStatus{} } else { sv = *v } for key, value := range shape { switch key { - case "message", "Message": + case "code": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected Message to be of type string, got %T instead", value) + return fmt.Errorf("expected ExportTaskStatusCode to be of type string, got %T instead", value) + } + sv.Code = types.ExportTaskStatusCode(jtv) + } + + case "message": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected ExportTaskStatusMessage to be of type string, got %T instead", value) } sv.Message = ptr.String(jtv) } @@ -11354,7 +16395,7 @@ func awsAwsjson11_deserializeDocumentAccessDeniedException(v **types.AccessDenie return nil } -func awsAwsjson11_deserializeDocumentAccountPolicies(v *[]types.AccountPolicy, value interface{}) error { +func awsAwsjson11_deserializeDocumentExtractedValues(v *map[string]string, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -11362,33 +16403,35 @@ func awsAwsjson11_deserializeDocumentAccountPolicies(v *[]types.AccountPolicy, v return nil } - shape, ok := value.([]interface{}) + shape, ok := value.(map[string]interface{}) if !ok { return fmt.Errorf("unexpected JSON type %v", value) } - var cv []types.AccountPolicy + var mv map[string]string if *v == nil { - cv = []types.AccountPolicy{} + mv = map[string]string{} } else { - cv = *v + mv = *v } - for _, value := range shape { - var col types.AccountPolicy - destAddr := &col - if err := awsAwsjson11_deserializeDocumentAccountPolicy(&destAddr, value); err != nil { - return err + for key, value := range shape { + var parsedVal string + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected Value to be of type string, got %T instead", value) + } + parsedVal = jtv } - col = *destAddr - cv = append(cv, col) + mv[key] = parsedVal } - *v = cv + *v = mv return nil } -func awsAwsjson11_deserializeDocumentAccountPolicy(v **types.AccountPolicy, value interface{}) error { +func awsAwsjson11_deserializeDocumentFieldIndex(v **types.FieldIndex, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -11401,25 +16444,25 @@ func awsAwsjson11_deserializeDocumentAccountPolicy(v **types.AccountPolicy, valu return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.AccountPolicy + var sv *types.FieldIndex if *v == nil { - sv = &types.AccountPolicy{} + sv = &types.FieldIndex{} } else { sv = *v } for key, value := range shape { switch key { - case "accountId": + case "fieldIndexName": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected AccountId to be of type string, got %T instead", value) + return fmt.Errorf("expected FieldIndexName to be of type string, got %T instead", value) } - sv.AccountId = ptr.String(jtv) + sv.FieldIndexName = ptr.String(jtv) } - case "lastUpdatedTime": + case "firstEventTime": if value != nil { jtv, ok := value.(json.Number) if !ok { @@ -11429,52 +16472,51 @@ func awsAwsjson11_deserializeDocumentAccountPolicy(v **types.AccountPolicy, valu if err != nil { return err } - sv.LastUpdatedTime = ptr.Int64(i64) + sv.FirstEventTime = ptr.Int64(i64) } - case "policyDocument": + case "lastEventTime": if value != nil { - jtv, ok := value.(string) + jtv, ok := value.(json.Number) if !ok { - return fmt.Errorf("expected AccountPolicyDocument to be of type string, got %T instead", value) + return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) } - sv.PolicyDocument = ptr.String(jtv) - } - - case "policyName": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected PolicyName to be of type string, got %T instead", value) + i64, err := jtv.Int64() + if err != nil { + return err } - sv.PolicyName = ptr.String(jtv) + sv.LastEventTime = ptr.Int64(i64) } - case "policyType": + case "lastScanTime": if value != nil { - jtv, ok := value.(string) + jtv, ok := value.(json.Number) if !ok { - return fmt.Errorf("expected PolicyType to be of type string, got %T instead", value) + return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) } - sv.PolicyType = types.PolicyType(jtv) + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.LastScanTime = ptr.Int64(i64) } - case "scope": + case "logGroupIdentifier": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected Scope to be of type string, got %T instead", value) + return fmt.Errorf("expected LogGroupIdentifier to be of type string, got %T instead", value) } - sv.Scope = types.Scope(jtv) + sv.LogGroupIdentifier = ptr.String(jtv) } - case "selectionCriteria": + case "type": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected SelectionCriteria to be of type string, got %T instead", value) + return fmt.Errorf("expected IndexType to be of type string, got %T instead", value) } - sv.SelectionCriteria = ptr.String(jtv) + sv.Type = types.IndexType(jtv) } default: @@ -11486,7 +16528,7 @@ func awsAwsjson11_deserializeDocumentAccountPolicy(v **types.AccountPolicy, valu return nil } -func awsAwsjson11_deserializeDocumentAddKeyEntries(v *[]types.AddKeyEntry, value interface{}) error { +func awsAwsjson11_deserializeDocumentFieldIndexes(v *[]types.FieldIndex, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -11499,17 +16541,17 @@ func awsAwsjson11_deserializeDocumentAddKeyEntries(v *[]types.AddKeyEntry, value return fmt.Errorf("unexpected JSON type %v", value) } - var cv []types.AddKeyEntry + var cv []types.FieldIndex if *v == nil { - cv = []types.AddKeyEntry{} + cv = []types.FieldIndex{} } else { cv = *v } for _, value := range shape { - var col types.AddKeyEntry + var col types.FieldIndex destAddr := &col - if err := awsAwsjson11_deserializeDocumentAddKeyEntry(&destAddr, value); err != nil { + if err := awsAwsjson11_deserializeDocumentFieldIndex(&destAddr, value); err != nil { return err } col = *destAddr @@ -11520,7 +16562,7 @@ func awsAwsjson11_deserializeDocumentAddKeyEntries(v *[]types.AddKeyEntry, value return nil } -func awsAwsjson11_deserializeDocumentAddKeyEntry(v **types.AddKeyEntry, value interface{}) error { +func awsAwsjson11_deserializeDocumentFilteredLogEvent(v **types.FilteredLogEvent, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -11533,40 +16575,66 @@ func awsAwsjson11_deserializeDocumentAddKeyEntry(v **types.AddKeyEntry, value in return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.AddKeyEntry + var sv *types.FilteredLogEvent if *v == nil { - sv = &types.AddKeyEntry{} + sv = &types.FilteredLogEvent{} } else { sv = *v } for key, value := range shape { switch key { - case "key": + case "eventId": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected Key to be of type string, got %T instead", value) + return fmt.Errorf("expected EventId to be of type string, got %T instead", value) } - sv.Key = ptr.String(jtv) + sv.EventId = ptr.String(jtv) } - case "overwriteIfExists": + case "ingestionTime": if value != nil { - jtv, ok := value.(bool) + jtv, ok := value.(json.Number) if !ok { - return fmt.Errorf("expected OverwriteIfExists to be of type *bool, got %T instead", value) + return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) } - sv.OverwriteIfExists = jtv + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.IngestionTime = ptr.Int64(i64) } - case "value": + case "logStreamName": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected AddKeyValue to be of type string, got %T instead", value) + return fmt.Errorf("expected LogStreamName to be of type string, got %T instead", value) } - sv.Value = ptr.String(jtv) + sv.LogStreamName = ptr.String(jtv) + } + + case "message": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected EventMessage to be of type string, got %T instead", value) + } + sv.Message = ptr.String(jtv) + } + + case "timestamp": + if value != nil { + jtv, ok := value.(json.Number) + if !ok { + return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) + } + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.Timestamp = ptr.Int64(i64) } default: @@ -11578,7 +16646,41 @@ func awsAwsjson11_deserializeDocumentAddKeyEntry(v **types.AddKeyEntry, value in return nil } -func awsAwsjson11_deserializeDocumentAddKeys(v **types.AddKeys, value interface{}) error { +func awsAwsjson11_deserializeDocumentFilteredLogEvents(v *[]types.FilteredLogEvent, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.([]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var cv []types.FilteredLogEvent + if *v == nil { + cv = []types.FilteredLogEvent{} + } else { + cv = *v + } + + for _, value := range shape { + var col types.FilteredLogEvent + destAddr := &col + if err := awsAwsjson11_deserializeDocumentFilteredLogEvent(&destAddr, value); err != nil { + return err + } + col = *destAddr + cv = append(cv, col) + + } + *v = cv + return nil +} + +func awsAwsjson11_deserializeDocumentGrok(v **types.Grok, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -11591,18 +16693,31 @@ func awsAwsjson11_deserializeDocumentAddKeys(v **types.AddKeys, value interface{ return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.AddKeys + var sv *types.Grok if *v == nil { - sv = &types.AddKeys{} + sv = &types.Grok{} } else { sv = *v } for key, value := range shape { switch key { - case "entries": - if err := awsAwsjson11_deserializeDocumentAddKeyEntries(&sv.Entries, value); err != nil { - return err + case "match": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected GrokMatch to be of type string, got %T instead", value) + } + sv.Match = ptr.String(jtv) + } + + case "source": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected Source to be of type string, got %T instead", value) + } + sv.Source = ptr.String(jtv) } default: @@ -11614,7 +16729,7 @@ func awsAwsjson11_deserializeDocumentAddKeys(v **types.AddKeys, value interface{ return nil } -func awsAwsjson11_deserializeDocumentAllowedFieldDelimiters(v *[]string, value interface{}) error { +func awsAwsjson11_deserializeDocumentGroupingIdentifier(v **types.GroupingIdentifier, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -11622,35 +16737,48 @@ func awsAwsjson11_deserializeDocumentAllowedFieldDelimiters(v *[]string, value i return nil } - shape, ok := value.([]interface{}) + shape, ok := value.(map[string]interface{}) if !ok { return fmt.Errorf("unexpected JSON type %v", value) } - var cv []string + var sv *types.GroupingIdentifier if *v == nil { - cv = []string{} + sv = &types.GroupingIdentifier{} } else { - cv = *v + sv = *v } - for _, value := range shape { - var col string - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected FieldDelimiter to be of type string, got %T instead", value) + for key, value := range shape { + switch key { + case "key": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected GroupingIdentifierKey to be of type string, got %T instead", value) + } + sv.Key = ptr.String(jtv) + } + + case "value": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected GroupingIdentifierValue to be of type string, got %T instead", value) + } + sv.Value = ptr.String(jtv) } - col = jtv - } - cv = append(cv, col) + default: + _, _ = key, value + + } } - *v = cv + *v = sv return nil } -func awsAwsjson11_deserializeDocumentAllowedFields(v *[]types.RecordField, value interface{}) error { +func awsAwsjson11_deserializeDocumentGroupingIdentifiers(v *[]types.GroupingIdentifier, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -11663,17 +16791,17 @@ func awsAwsjson11_deserializeDocumentAllowedFields(v *[]types.RecordField, value return fmt.Errorf("unexpected JSON type %v", value) } - var cv []types.RecordField + var cv []types.GroupingIdentifier if *v == nil { - cv = []types.RecordField{} + cv = []types.GroupingIdentifier{} } else { cv = *v } for _, value := range shape { - var col types.RecordField + var col types.GroupingIdentifier destAddr := &col - if err := awsAwsjson11_deserializeDocumentRecordField(&destAddr, value); err != nil { + if err := awsAwsjson11_deserializeDocumentGroupingIdentifier(&destAddr, value); err != nil { return err } col = *destAddr @@ -11684,7 +16812,7 @@ func awsAwsjson11_deserializeDocumentAllowedFields(v *[]types.RecordField, value return nil } -func awsAwsjson11_deserializeDocumentAnomalies(v *[]types.Anomaly, value interface{}) error { +func awsAwsjson11_deserializeDocumentHistogram(v *map[string]int64, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -11692,33 +16820,39 @@ func awsAwsjson11_deserializeDocumentAnomalies(v *[]types.Anomaly, value interfa return nil } - shape, ok := value.([]interface{}) + shape, ok := value.(map[string]interface{}) if !ok { return fmt.Errorf("unexpected JSON type %v", value) } - var cv []types.Anomaly + var mv map[string]int64 if *v == nil { - cv = []types.Anomaly{} + mv = map[string]int64{} } else { - cv = *v + mv = *v } - for _, value := range shape { - var col types.Anomaly - destAddr := &col - if err := awsAwsjson11_deserializeDocumentAnomaly(&destAddr, value); err != nil { - return err + for key, value := range shape { + var parsedVal int64 + if value != nil { + jtv, ok := value.(json.Number) + if !ok { + return fmt.Errorf("expected Count to be json.Number, got %T instead", value) + } + i64, err := jtv.Int64() + if err != nil { + return err + } + parsedVal = i64 } - col = *destAddr - cv = append(cv, col) + mv[key] = parsedVal } - *v = cv + *v = mv return nil } -func awsAwsjson11_deserializeDocumentAnomaly(v **types.Anomaly, value interface{}) error { +func awsAwsjson11_deserializeDocumentImport(v **types.Import, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -11731,196 +16865,198 @@ func awsAwsjson11_deserializeDocumentAnomaly(v **types.Anomaly, value interface{ return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.Anomaly + var sv *types.Import if *v == nil { - sv = &types.Anomaly{} + sv = &types.Import{} } else { sv = *v } for key, value := range shape { switch key { - case "active": + case "creationTime": if value != nil { - jtv, ok := value.(bool) + jtv, ok := value.(json.Number) if !ok { - return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) + return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) } - sv.Active = ptr.Bool(jtv) + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.CreationTime = ptr.Int64(i64) } - case "anomalyDetectorArn": + case "errorMessage": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected AnomalyDetectorArn to be of type string, got %T instead", value) + return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) } - sv.AnomalyDetectorArn = ptr.String(jtv) + sv.ErrorMessage = ptr.String(jtv) } - case "anomalyId": + case "importDestinationArn": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected AnomalyId to be of type string, got %T instead", value) + return fmt.Errorf("expected Arn to be of type string, got %T instead", value) } - sv.AnomalyId = ptr.String(jtv) + sv.ImportDestinationArn = ptr.String(jtv) } - case "description": + case "importFilter": + if err := awsAwsjson11_deserializeDocumentImportFilter(&sv.ImportFilter, value); err != nil { + return err + } + + case "importId": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected Description to be of type string, got %T instead", value) + return fmt.Errorf("expected ImportId to be of type string, got %T instead", value) } - sv.Description = ptr.String(jtv) + sv.ImportId = ptr.String(jtv) } - case "firstSeen": + case "importSourceArn": if value != nil { - jtv, ok := value.(json.Number) + jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected EpochMillis to be json.Number, got %T instead", value) - } - i64, err := jtv.Int64() - if err != nil { - return err + return fmt.Errorf("expected Arn to be of type string, got %T instead", value) } - sv.FirstSeen = i64 + sv.ImportSourceArn = ptr.String(jtv) } - case "histogram": - if err := awsAwsjson11_deserializeDocumentHistogram(&sv.Histogram, value); err != nil { + case "importStatistics": + if err := awsAwsjson11_deserializeDocumentImportStatistics(&sv.ImportStatistics, value); err != nil { return err } - case "isPatternLevelSuppression": + case "importStatus": if value != nil { - jtv, ok := value.(bool) + jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) + return fmt.Errorf("expected ImportStatus to be of type string, got %T instead", value) } - sv.IsPatternLevelSuppression = ptr.Bool(jtv) + sv.ImportStatus = types.ImportStatus(jtv) } - case "lastSeen": + case "lastUpdatedTime": if value != nil { jtv, ok := value.(json.Number) if !ok { - return fmt.Errorf("expected EpochMillis to be json.Number, got %T instead", value) + return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) } i64, err := jtv.Int64() if err != nil { return err } - sv.LastSeen = i64 + sv.LastUpdatedTime = ptr.Int64(i64) } - case "logGroupArnList": - if err := awsAwsjson11_deserializeDocumentLogGroupArnList(&sv.LogGroupArnList, value); err != nil { - return err - } + default: + _, _ = key, value - case "logSamples": - if err := awsAwsjson11_deserializeDocumentLogSamples(&sv.LogSamples, value); err != nil { - return err - } + } + } + *v = sv + return nil +} - case "patternId": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected PatternId to be of type string, got %T instead", value) - } - sv.PatternId = ptr.String(jtv) - } +func awsAwsjson11_deserializeDocumentImportBatch(v **types.ImportBatch, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } - case "patternRegex": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected PatternRegex to be of type string, got %T instead", value) - } - sv.PatternRegex = ptr.String(jtv) - } + shape, ok := value.(map[string]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } - case "patternString": + var sv *types.ImportBatch + if *v == nil { + sv = &types.ImportBatch{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "batchId": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected PatternString to be of type string, got %T instead", value) + return fmt.Errorf("expected BatchId to be of type string, got %T instead", value) } - sv.PatternString = ptr.String(jtv) - } - - case "patternTokens": - if err := awsAwsjson11_deserializeDocumentPatternTokens(&sv.PatternTokens, value); err != nil { - return err + sv.BatchId = ptr.String(jtv) } - case "priority": + case "errorMessage": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected Priority to be of type string, got %T instead", value) + return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) } - sv.Priority = ptr.String(jtv) + sv.ErrorMessage = ptr.String(jtv) } - case "state": + case "status": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected State to be of type string, got %T instead", value) + return fmt.Errorf("expected ImportStatus to be of type string, got %T instead", value) } - sv.State = types.State(jtv) + sv.Status = types.ImportStatus(jtv) } - case "suppressed": - if value != nil { - jtv, ok := value.(bool) - if !ok { - return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) - } - sv.Suppressed = ptr.Bool(jtv) - } + default: + _, _ = key, value - case "suppressedDate": - if value != nil { - jtv, ok := value.(json.Number) - if !ok { - return fmt.Errorf("expected EpochMillis to be json.Number, got %T instead", value) - } - i64, err := jtv.Int64() - if err != nil { - return err - } - sv.SuppressedDate = i64 - } + } + } + *v = sv + return nil +} - case "suppressedUntil": - if value != nil { - jtv, ok := value.(json.Number) - if !ok { - return fmt.Errorf("expected EpochMillis to be json.Number, got %T instead", value) - } - i64, err := jtv.Int64() - if err != nil { - return err - } - sv.SuppressedUntil = i64 - } +func awsAwsjson11_deserializeDocumentImportBatchList(v *[]types.ImportBatch, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } - default: - _, _ = key, value + shape, ok := value.([]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var cv []types.ImportBatch + if *v == nil { + cv = []types.ImportBatch{} + } else { + cv = *v + } + + for _, value := range shape { + var col types.ImportBatch + destAddr := &col + if err := awsAwsjson11_deserializeDocumentImportBatch(&destAddr, value); err != nil { + return err + } + col = *destAddr + cv = append(cv, col) - } } - *v = sv + *v = cv return nil } -func awsAwsjson11_deserializeDocumentAnomalyDetector(v **types.AnomalyDetector, value interface{}) error { +func awsAwsjson11_deserializeDocumentImportFilter(v **types.ImportFilter, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -11933,111 +17069,39 @@ func awsAwsjson11_deserializeDocumentAnomalyDetector(v **types.AnomalyDetector, return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.AnomalyDetector + var sv *types.ImportFilter if *v == nil { - sv = &types.AnomalyDetector{} + sv = &types.ImportFilter{} } else { sv = *v } for key, value := range shape { switch key { - case "anomalyDetectorArn": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected AnomalyDetectorArn to be of type string, got %T instead", value) - } - sv.AnomalyDetectorArn = ptr.String(jtv) - } - - case "anomalyDetectorStatus": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected AnomalyDetectorStatus to be of type string, got %T instead", value) - } - sv.AnomalyDetectorStatus = types.AnomalyDetectorStatus(jtv) - } - - case "anomalyVisibilityTime": - if value != nil { - jtv, ok := value.(json.Number) - if !ok { - return fmt.Errorf("expected AnomalyVisibilityTime to be json.Number, got %T instead", value) - } - i64, err := jtv.Int64() - if err != nil { - return err - } - sv.AnomalyVisibilityTime = ptr.Int64(i64) - } - - case "creationTimeStamp": + case "endEventTime": if value != nil { jtv, ok := value.(json.Number) if !ok { - return fmt.Errorf("expected EpochMillis to be json.Number, got %T instead", value) + return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) } i64, err := jtv.Int64() if err != nil { return err } - sv.CreationTimeStamp = i64 - } - - case "detectorName": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected DetectorName to be of type string, got %T instead", value) - } - sv.DetectorName = ptr.String(jtv) - } - - case "evaluationFrequency": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected EvaluationFrequency to be of type string, got %T instead", value) - } - sv.EvaluationFrequency = types.EvaluationFrequency(jtv) - } - - case "filterPattern": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected FilterPattern to be of type string, got %T instead", value) - } - sv.FilterPattern = ptr.String(jtv) - } - - case "kmsKeyId": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected KmsKeyId to be of type string, got %T instead", value) - } - sv.KmsKeyId = ptr.String(jtv) + sv.EndEventTime = ptr.Int64(i64) } - case "lastModifiedTimeStamp": + case "startEventTime": if value != nil { jtv, ok := value.(json.Number) if !ok { - return fmt.Errorf("expected EpochMillis to be json.Number, got %T instead", value) + return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) } i64, err := jtv.Int64() if err != nil { return err } - sv.LastModifiedTimeStamp = i64 - } - - case "logGroupArnList": - if err := awsAwsjson11_deserializeDocumentLogGroupArnList(&sv.LogGroupArnList, value); err != nil { - return err + sv.StartEventTime = ptr.Int64(i64) } default: @@ -12049,7 +17113,7 @@ func awsAwsjson11_deserializeDocumentAnomalyDetector(v **types.AnomalyDetector, return nil } -func awsAwsjson11_deserializeDocumentAnomalyDetectors(v *[]types.AnomalyDetector, value interface{}) error { +func awsAwsjson11_deserializeDocumentImportList(v *[]types.Import, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -12062,17 +17126,17 @@ func awsAwsjson11_deserializeDocumentAnomalyDetectors(v *[]types.AnomalyDetector return fmt.Errorf("unexpected JSON type %v", value) } - var cv []types.AnomalyDetector + var cv []types.Import if *v == nil { - cv = []types.AnomalyDetector{} + cv = []types.Import{} } else { cv = *v } for _, value := range shape { - var col types.AnomalyDetector + var col types.Import destAddr := &col - if err := awsAwsjson11_deserializeDocumentAnomalyDetector(&destAddr, value); err != nil { + if err := awsAwsjson11_deserializeDocumentImport(&destAddr, value); err != nil { return err } col = *destAddr @@ -12083,7 +17147,51 @@ func awsAwsjson11_deserializeDocumentAnomalyDetectors(v *[]types.AnomalyDetector return nil } -func awsAwsjson11_deserializeDocumentColumns(v *[]string, value interface{}) error { +func awsAwsjson11_deserializeDocumentImportStatistics(v **types.ImportStatistics, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.(map[string]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var sv *types.ImportStatistics + if *v == nil { + sv = &types.ImportStatistics{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "bytesImported": + if value != nil { + jtv, ok := value.(json.Number) + if !ok { + return fmt.Errorf("expected StoredBytes to be json.Number, got %T instead", value) + } + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.BytesImported = ptr.Int64(i64) + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + +func awsAwsjson11_deserializeDocumentIndexPolicies(v *[]types.IndexPolicy, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -12096,22 +17204,20 @@ func awsAwsjson11_deserializeDocumentColumns(v *[]string, value interface{}) err return fmt.Errorf("unexpected JSON type %v", value) } - var cv []string + var cv []types.IndexPolicy if *v == nil { - cv = []string{} + cv = []types.IndexPolicy{} } else { cv = *v } for _, value := range shape { - var col string - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected Column to be of type string, got %T instead", value) - } - col = jtv + var col types.IndexPolicy + destAddr := &col + if err := awsAwsjson11_deserializeDocumentIndexPolicy(&destAddr, value); err != nil { + return err } + col = *destAddr cv = append(cv, col) } @@ -12119,7 +17225,7 @@ func awsAwsjson11_deserializeDocumentColumns(v *[]string, value interface{}) err return nil } -func awsAwsjson11_deserializeDocumentConfigurationTemplate(v **types.ConfigurationTemplate, value interface{}) error { +func awsAwsjson11_deserializeDocumentIndexPolicy(v **types.IndexPolicy, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -12132,83 +17238,62 @@ func awsAwsjson11_deserializeDocumentConfigurationTemplate(v **types.Configurati return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.ConfigurationTemplate + var sv *types.IndexPolicy if *v == nil { - sv = &types.ConfigurationTemplate{} + sv = &types.IndexPolicy{} } else { sv = *v } for key, value := range shape { switch key { - case "allowedActionForAllowVendedLogsDeliveryForResource": + case "lastUpdateTime": if value != nil { - jtv, ok := value.(string) + jtv, ok := value.(json.Number) if !ok { - return fmt.Errorf("expected AllowedActionForAllowVendedLogsDeliveryForResource to be of type string, got %T instead", value) + return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) } - sv.AllowedActionForAllowVendedLogsDeliveryForResource = ptr.String(jtv) - } - - case "allowedFieldDelimiters": - if err := awsAwsjson11_deserializeDocumentAllowedFieldDelimiters(&sv.AllowedFieldDelimiters, value); err != nil { - return err - } - - case "allowedFields": - if err := awsAwsjson11_deserializeDocumentAllowedFields(&sv.AllowedFields, value); err != nil { - return err - } - - case "allowedOutputFormats": - if err := awsAwsjson11_deserializeDocumentOutputFormats(&sv.AllowedOutputFormats, value); err != nil { - return err - } - - case "allowedSuffixPathFields": - if err := awsAwsjson11_deserializeDocumentRecordFields(&sv.AllowedSuffixPathFields, value); err != nil { - return err - } - - case "defaultDeliveryConfigValues": - if err := awsAwsjson11_deserializeDocumentConfigurationTemplateDeliveryConfigValues(&sv.DefaultDeliveryConfigValues, value); err != nil { - return err + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.LastUpdateTime = ptr.Int64(i64) } - case "deliveryDestinationType": + case "logGroupIdentifier": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected DeliveryDestinationType to be of type string, got %T instead", value) + return fmt.Errorf("expected LogGroupIdentifier to be of type string, got %T instead", value) } - sv.DeliveryDestinationType = types.DeliveryDestinationType(jtv) + sv.LogGroupIdentifier = ptr.String(jtv) } - case "logType": + case "policyDocument": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected LogType to be of type string, got %T instead", value) + return fmt.Errorf("expected PolicyDocument to be of type string, got %T instead", value) } - sv.LogType = ptr.String(jtv) + sv.PolicyDocument = ptr.String(jtv) } - case "resourceType": + case "policyName": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value) + return fmt.Errorf("expected PolicyName to be of type string, got %T instead", value) } - sv.ResourceType = ptr.String(jtv) + sv.PolicyName = ptr.String(jtv) } - case "service": + case "source": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected Service to be of type string, got %T instead", value) + return fmt.Errorf("expected IndexSource to be of type string, got %T instead", value) } - sv.Service = ptr.String(jtv) + sv.Source = types.IndexSource(jtv) } default: @@ -12220,7 +17305,7 @@ func awsAwsjson11_deserializeDocumentConfigurationTemplate(v **types.Configurati return nil } -func awsAwsjson11_deserializeDocumentConfigurationTemplateDeliveryConfigValues(v **types.ConfigurationTemplateDeliveryConfigValues, value interface{}) error { +func awsAwsjson11_deserializeDocumentInheritedProperties(v *[]types.InheritedProperty, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -12228,49 +17313,75 @@ func awsAwsjson11_deserializeDocumentConfigurationTemplateDeliveryConfigValues(v return nil } - shape, ok := value.(map[string]interface{}) + shape, ok := value.([]interface{}) if !ok { return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.ConfigurationTemplateDeliveryConfigValues + var cv []types.InheritedProperty if *v == nil { - sv = &types.ConfigurationTemplateDeliveryConfigValues{} + cv = []types.InheritedProperty{} } else { - sv = *v + cv = *v } - for key, value := range shape { - switch key { - case "fieldDelimiter": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected FieldDelimiter to be of type string, got %T instead", value) - } - sv.FieldDelimiter = ptr.String(jtv) + for _, value := range shape { + var col types.InheritedProperty + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected InheritedProperty to be of type string, got %T instead", value) } + col = types.InheritedProperty(jtv) + } + cv = append(cv, col) + + } + *v = cv + return nil +} + +func awsAwsjson11_deserializeDocumentIntegrationDetails(v *types.IntegrationDetails, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } - case "recordFields": - if err := awsAwsjson11_deserializeDocumentRecordFields(&sv.RecordFields, value); err != nil { - return err - } + shape, ok := value.(map[string]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } - case "s3DeliveryConfiguration": - if err := awsAwsjson11_deserializeDocumentS3DeliveryConfiguration(&sv.S3DeliveryConfiguration, value); err != nil { + var uv types.IntegrationDetails +loop: + for key, value := range shape { + if value == nil { + continue + } + switch key { + case "openSearchIntegrationDetails": + var mv types.OpenSearchIntegrationDetails + destAddr := &mv + if err := awsAwsjson11_deserializeDocumentOpenSearchIntegrationDetails(&destAddr, value); err != nil { return err } + mv = *destAddr + uv = &types.IntegrationDetailsMemberOpenSearchIntegrationDetails{Value: mv} + break loop default: - _, _ = key, value + uv = &types.UnknownUnionMember{Tag: key} + break loop } } - *v = sv + *v = uv return nil } -func awsAwsjson11_deserializeDocumentConfigurationTemplates(v *[]types.ConfigurationTemplate, value interface{}) error { +func awsAwsjson11_deserializeDocumentIntegrationSummaries(v *[]types.IntegrationSummary, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -12283,17 +17394,17 @@ func awsAwsjson11_deserializeDocumentConfigurationTemplates(v *[]types.Configura return fmt.Errorf("unexpected JSON type %v", value) } - var cv []types.ConfigurationTemplate + var cv []types.IntegrationSummary if *v == nil { - cv = []types.ConfigurationTemplate{} + cv = []types.IntegrationSummary{} } else { cv = *v } for _, value := range shape { - var col types.ConfigurationTemplate + var col types.IntegrationSummary destAddr := &col - if err := awsAwsjson11_deserializeDocumentConfigurationTemplate(&destAddr, value); err != nil { + if err := awsAwsjson11_deserializeDocumentIntegrationSummary(&destAddr, value); err != nil { return err } col = *destAddr @@ -12304,7 +17415,7 @@ func awsAwsjson11_deserializeDocumentConfigurationTemplates(v *[]types.Configura return nil } -func awsAwsjson11_deserializeDocumentConflictException(v **types.ConflictException, value interface{}) error { +func awsAwsjson11_deserializeDocumentIntegrationSummary(v **types.IntegrationSummary, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -12317,22 +17428,40 @@ func awsAwsjson11_deserializeDocumentConflictException(v **types.ConflictExcepti return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.ConflictException + var sv *types.IntegrationSummary if *v == nil { - sv = &types.ConflictException{} + sv = &types.IntegrationSummary{} } else { sv = *v } for key, value := range shape { switch key { - case "message", "Message": + case "integrationName": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected Message to be of type string, got %T instead", value) + return fmt.Errorf("expected IntegrationName to be of type string, got %T instead", value) } - sv.Message = ptr.String(jtv) + sv.IntegrationName = ptr.String(jtv) + } + + case "integrationStatus": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected IntegrationStatus to be of type string, got %T instead", value) + } + sv.IntegrationStatus = types.IntegrationStatus(jtv) + } + + case "integrationType": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected IntegrationType to be of type string, got %T instead", value) + } + sv.IntegrationType = types.IntegrationType(jtv) } default: @@ -12344,7 +17473,7 @@ func awsAwsjson11_deserializeDocumentConflictException(v **types.ConflictExcepti return nil } -func awsAwsjson11_deserializeDocumentCopyValue(v **types.CopyValue, value interface{}) error { +func awsAwsjson11_deserializeDocumentInternalServerException(v **types.InternalServerException, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -12357,18 +17486,22 @@ func awsAwsjson11_deserializeDocumentCopyValue(v **types.CopyValue, value interf return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.CopyValue + var sv *types.InternalServerException if *v == nil { - sv = &types.CopyValue{} + sv = &types.InternalServerException{} } else { sv = *v } for key, value := range shape { switch key { - case "entries": - if err := awsAwsjson11_deserializeDocumentCopyValueEntries(&sv.Entries, value); err != nil { - return err + case "message", "Message": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected Message to be of type string, got %T instead", value) + } + sv.Message = ptr.String(jtv) } default: @@ -12380,7 +17513,7 @@ func awsAwsjson11_deserializeDocumentCopyValue(v **types.CopyValue, value interf return nil } -func awsAwsjson11_deserializeDocumentCopyValueEntries(v *[]types.CopyValueEntry, value interface{}) error { +func awsAwsjson11_deserializeDocumentInvalidOperationException(v **types.InvalidOperationException, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -12388,33 +17521,39 @@ func awsAwsjson11_deserializeDocumentCopyValueEntries(v *[]types.CopyValueEntry, return nil } - shape, ok := value.([]interface{}) + shape, ok := value.(map[string]interface{}) if !ok { return fmt.Errorf("unexpected JSON type %v", value) } - var cv []types.CopyValueEntry + var sv *types.InvalidOperationException if *v == nil { - cv = []types.CopyValueEntry{} + sv = &types.InvalidOperationException{} } else { - cv = *v + sv = *v } - for _, value := range shape { - var col types.CopyValueEntry - destAddr := &col - if err := awsAwsjson11_deserializeDocumentCopyValueEntry(&destAddr, value); err != nil { - return err - } - col = *destAddr - cv = append(cv, col) + for key, value := range shape { + switch key { + case "message", "Message": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected Message to be of type string, got %T instead", value) + } + sv.Message = ptr.String(jtv) + } + + default: + _, _ = key, value + } } - *v = cv + *v = sv return nil } -func awsAwsjson11_deserializeDocumentCopyValueEntry(v **types.CopyValueEntry, value interface{}) error { +func awsAwsjson11_deserializeDocumentInvalidParameterException(v **types.InvalidParameterException, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -12427,40 +17566,22 @@ func awsAwsjson11_deserializeDocumentCopyValueEntry(v **types.CopyValueEntry, va return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.CopyValueEntry + var sv *types.InvalidParameterException if *v == nil { - sv = &types.CopyValueEntry{} + sv = &types.InvalidParameterException{} } else { sv = *v } for key, value := range shape { switch key { - case "overwriteIfExists": - if value != nil { - jtv, ok := value.(bool) - if !ok { - return fmt.Errorf("expected OverwriteIfExists to be of type *bool, got %T instead", value) - } - sv.OverwriteIfExists = jtv - } - - case "source": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected Source to be of type string, got %T instead", value) - } - sv.Source = ptr.String(jtv) - } - - case "target": + case "message", "Message": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected Target to be of type string, got %T instead", value) + return fmt.Errorf("expected Message to be of type string, got %T instead", value) } - sv.Target = ptr.String(jtv) + sv.Message = ptr.String(jtv) } default: @@ -12472,7 +17593,7 @@ func awsAwsjson11_deserializeDocumentCopyValueEntry(v **types.CopyValueEntry, va return nil } -func awsAwsjson11_deserializeDocumentCSV(v **types.CSV, value interface{}) error { +func awsAwsjson11_deserializeDocumentInvalidSequenceTokenException(v **types.InvalidSequenceTokenException, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -12485,45 +17606,31 @@ func awsAwsjson11_deserializeDocumentCSV(v **types.CSV, value interface{}) error return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.CSV + var sv *types.InvalidSequenceTokenException if *v == nil { - sv = &types.CSV{} + sv = &types.InvalidSequenceTokenException{} } else { sv = *v } for key, value := range shape { switch key { - case "columns": - if err := awsAwsjson11_deserializeDocumentColumns(&sv.Columns, value); err != nil { - return err - } - - case "delimiter": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected Delimiter to be of type string, got %T instead", value) - } - sv.Delimiter = ptr.String(jtv) - } - - case "quoteCharacter": + case "expectedSequenceToken": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected QuoteCharacter to be of type string, got %T instead", value) + return fmt.Errorf("expected SequenceToken to be of type string, got %T instead", value) } - sv.QuoteCharacter = ptr.String(jtv) + sv.ExpectedSequenceToken = ptr.String(jtv) } - case "source": + case "message", "Message": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected Source to be of type string, got %T instead", value) + return fmt.Errorf("expected Message to be of type string, got %T instead", value) } - sv.Source = ptr.String(jtv) + sv.Message = ptr.String(jtv) } default: @@ -12535,7 +17642,7 @@ func awsAwsjson11_deserializeDocumentCSV(v **types.CSV, value interface{}) error return nil } -func awsAwsjson11_deserializeDocumentDataAlreadyAcceptedException(v **types.DataAlreadyAcceptedException, value interface{}) error { +func awsAwsjson11_deserializeDocumentLimitExceededException(v **types.LimitExceededException, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -12548,24 +17655,15 @@ func awsAwsjson11_deserializeDocumentDataAlreadyAcceptedException(v **types.Data return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.DataAlreadyAcceptedException + var sv *types.LimitExceededException if *v == nil { - sv = &types.DataAlreadyAcceptedException{} + sv = &types.LimitExceededException{} } else { sv = *v } for key, value := range shape { switch key { - case "expectedSequenceToken": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected SequenceToken to be of type string, got %T instead", value) - } - sv.ExpectedSequenceToken = ptr.String(jtv) - } - case "message", "Message": if value != nil { jtv, ok := value.(string) @@ -12584,7 +17682,7 @@ func awsAwsjson11_deserializeDocumentDataAlreadyAcceptedException(v **types.Data return nil } -func awsAwsjson11_deserializeDocumentDateTimeConverter(v **types.DateTimeConverter, value interface{}) error { +func awsAwsjson11_deserializeDocumentListToMap(v **types.ListToMap, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -12597,72 +17695,67 @@ func awsAwsjson11_deserializeDocumentDateTimeConverter(v **types.DateTimeConvert return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.DateTimeConverter + var sv *types.ListToMap if *v == nil { - sv = &types.DateTimeConverter{} + sv = &types.ListToMap{} } else { sv = *v } for key, value := range shape { switch key { - case "locale": + case "flatten": if value != nil { - jtv, ok := value.(string) + jtv, ok := value.(bool) if !ok { - return fmt.Errorf("expected Locale to be of type string, got %T instead", value) + return fmt.Errorf("expected Flatten to be of type *bool, got %T instead", value) } - sv.Locale = ptr.String(jtv) - } - - case "matchPatterns": - if err := awsAwsjson11_deserializeDocumentMatchPatterns(&sv.MatchPatterns, value); err != nil { - return err + sv.Flatten = jtv } - case "source": + case "flattenedElement": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected Source to be of type string, got %T instead", value) + return fmt.Errorf("expected FlattenedElement to be of type string, got %T instead", value) } - sv.Source = ptr.String(jtv) + sv.FlattenedElement = types.FlattenedElement(jtv) } - case "sourceTimezone": + case "key": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected SourceTimezone to be of type string, got %T instead", value) + return fmt.Errorf("expected Key to be of type string, got %T instead", value) } - sv.SourceTimezone = ptr.String(jtv) + sv.Key = ptr.String(jtv) } - case "target": + case "source": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected Target to be of type string, got %T instead", value) + return fmt.Errorf("expected Source to be of type string, got %T instead", value) } - sv.Target = ptr.String(jtv) + sv.Source = ptr.String(jtv) } - case "targetFormat": + case "target": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected TargetFormat to be of type string, got %T instead", value) + return fmt.Errorf("expected Target to be of type string, got %T instead", value) } - sv.TargetFormat = ptr.String(jtv) + sv.Target = ptr.String(jtv) } - case "targetTimezone": + case "valueKey": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected TargetTimezone to be of type string, got %T instead", value) + return fmt.Errorf("expected ValueKey to be of type string, got %T instead", value) } - sv.TargetTimezone = ptr.String(jtv) + sv.ValueKey = ptr.String(jtv) } default: @@ -12674,7 +17767,7 @@ func awsAwsjson11_deserializeDocumentDateTimeConverter(v **types.DateTimeConvert return nil } -func awsAwsjson11_deserializeDocumentDeleteKeys(v **types.DeleteKeys, value interface{}) error { +func awsAwsjson11_deserializeDocumentLogEvent(v **types.LogEvent, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -12687,18 +17780,35 @@ func awsAwsjson11_deserializeDocumentDeleteKeys(v **types.DeleteKeys, value inte return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.DeleteKeys + var sv *types.LogEvent if *v == nil { - sv = &types.DeleteKeys{} + sv = &types.LogEvent{} } else { sv = *v } for key, value := range shape { switch key { - case "withKeys": - if err := awsAwsjson11_deserializeDocumentDeleteWithKeys(&sv.WithKeys, value); err != nil { - return err + case "message": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected EventMessage to be of type string, got %T instead", value) + } + sv.Message = ptr.String(jtv) + } + + case "timestamp": + if value != nil { + jtv, ok := value.(json.Number) + if !ok { + return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) + } + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.Timestamp = ptr.Int64(i64) } default: @@ -12710,7 +17820,7 @@ func awsAwsjson11_deserializeDocumentDeleteKeys(v **types.DeleteKeys, value inte return nil } -func awsAwsjson11_deserializeDocumentDeleteWithKeys(v *[]string, value interface{}) error { +func awsAwsjson11_deserializeDocumentLogFieldsList(v *[]types.LogFieldsListItem, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -12723,22 +17833,20 @@ func awsAwsjson11_deserializeDocumentDeleteWithKeys(v *[]string, value interface return fmt.Errorf("unexpected JSON type %v", value) } - var cv []string + var cv []types.LogFieldsListItem if *v == nil { - cv = []string{} + cv = []types.LogFieldsListItem{} } else { cv = *v } for _, value := range shape { - var col string - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected WithKey to be of type string, got %T instead", value) - } - col = jtv + var col types.LogFieldsListItem + destAddr := &col + if err := awsAwsjson11_deserializeDocumentLogFieldsListItem(&destAddr, value); err != nil { + return err } + col = *destAddr cv = append(cv, col) } @@ -12746,7 +17854,7 @@ func awsAwsjson11_deserializeDocumentDeleteWithKeys(v *[]string, value interface return nil } -func awsAwsjson11_deserializeDocumentDeliveries(v *[]types.Delivery, value interface{}) error { +func awsAwsjson11_deserializeDocumentLogFieldsListItem(v **types.LogFieldsListItem, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -12754,33 +17862,44 @@ func awsAwsjson11_deserializeDocumentDeliveries(v *[]types.Delivery, value inter return nil } - shape, ok := value.([]interface{}) + shape, ok := value.(map[string]interface{}) if !ok { return fmt.Errorf("unexpected JSON type %v", value) } - var cv []types.Delivery + var sv *types.LogFieldsListItem if *v == nil { - cv = []types.Delivery{} + sv = &types.LogFieldsListItem{} } else { - cv = *v + sv = *v } - for _, value := range shape { - var col types.Delivery - destAddr := &col - if err := awsAwsjson11_deserializeDocumentDelivery(&destAddr, value); err != nil { - return err - } - col = *destAddr - cv = append(cv, col) + for key, value := range shape { + switch key { + case "logFieldName": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected LogFieldName to be of type string, got %T instead", value) + } + sv.LogFieldName = ptr.String(jtv) + } + + case "logFieldType": + if err := awsAwsjson11_deserializeDocumentLogFieldType(&sv.LogFieldType, value); err != nil { + return err + } + + default: + _, _ = key, value + } } - *v = cv + *v = sv return nil } -func awsAwsjson11_deserializeDocumentDelivery(v **types.Delivery, value interface{}) error { +func awsAwsjson11_deserializeDocumentLogFieldType(v **types.LogFieldType, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -12793,82 +17912,32 @@ func awsAwsjson11_deserializeDocumentDelivery(v **types.Delivery, value interfac return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.Delivery + var sv *types.LogFieldType if *v == nil { - sv = &types.Delivery{} + sv = &types.LogFieldType{} } else { sv = *v } for key, value := range shape { switch key { - case "arn": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected Arn to be of type string, got %T instead", value) - } - sv.Arn = ptr.String(jtv) - } - - case "deliveryDestinationArn": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected Arn to be of type string, got %T instead", value) - } - sv.DeliveryDestinationArn = ptr.String(jtv) - } - - case "deliveryDestinationType": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected DeliveryDestinationType to be of type string, got %T instead", value) - } - sv.DeliveryDestinationType = types.DeliveryDestinationType(jtv) - } - - case "deliverySourceName": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected DeliverySourceName to be of type string, got %T instead", value) - } - sv.DeliverySourceName = ptr.String(jtv) + case "element": + if err := awsAwsjson11_deserializeDocumentLogFieldType(&sv.Element, value); err != nil { + return err } - case "fieldDelimiter": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected FieldDelimiter to be of type string, got %T instead", value) - } - sv.FieldDelimiter = ptr.String(jtv) + case "fields": + if err := awsAwsjson11_deserializeDocumentLogFieldsList(&sv.Fields, value); err != nil { + return err } - case "id": + case "type": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected DeliveryId to be of type string, got %T instead", value) + return fmt.Errorf("expected DataType to be of type string, got %T instead", value) } - sv.Id = ptr.String(jtv) - } - - case "recordFields": - if err := awsAwsjson11_deserializeDocumentRecordFields(&sv.RecordFields, value); err != nil { - return err - } - - case "s3DeliveryConfiguration": - if err := awsAwsjson11_deserializeDocumentS3DeliveryConfiguration(&sv.S3DeliveryConfiguration, value); err != nil { - return err - } - - case "tags": - if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil { - return err + sv.Type = ptr.String(jtv) } default: @@ -12880,7 +17949,7 @@ func awsAwsjson11_deserializeDocumentDelivery(v **types.Delivery, value interfac return nil } -func awsAwsjson11_deserializeDocumentDeliveryDestination(v **types.DeliveryDestination, value interface{}) error { +func awsAwsjson11_deserializeDocumentLogGroup(v **types.LogGroup, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -12893,9 +17962,9 @@ func awsAwsjson11_deserializeDocumentDeliveryDestination(v **types.DeliveryDesti return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.DeliveryDestination + var sv *types.LogGroup if *v == nil { - sv = &types.DeliveryDestination{} + sv = &types.LogGroup{} } else { sv = *v } @@ -12911,53 +17980,172 @@ func awsAwsjson11_deserializeDocumentDeliveryDestination(v **types.DeliveryDesti sv.Arn = ptr.String(jtv) } - case "deliveryDestinationConfiguration": - if err := awsAwsjson11_deserializeDocumentDeliveryDestinationConfiguration(&sv.DeliveryDestinationConfiguration, value); err != nil { + case "bearerTokenAuthenticationEnabled": + if value != nil { + jtv, ok := value.(bool) + if !ok { + return fmt.Errorf("expected BearerTokenAuthenticationEnabled to be of type *bool, got %T instead", value) + } + sv.BearerTokenAuthenticationEnabled = ptr.Bool(jtv) + } + + case "creationTime": + if value != nil { + jtv, ok := value.(json.Number) + if !ok { + return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) + } + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.CreationTime = ptr.Int64(i64) + } + + case "dataProtectionStatus": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected DataProtectionStatus to be of type string, got %T instead", value) + } + sv.DataProtectionStatus = types.DataProtectionStatus(jtv) + } + + case "deletionProtectionEnabled": + if value != nil { + jtv, ok := value.(bool) + if !ok { + return fmt.Errorf("expected DeletionProtectionEnabled to be of type *bool, got %T instead", value) + } + sv.DeletionProtectionEnabled = ptr.Bool(jtv) + } + + case "inheritedProperties": + if err := awsAwsjson11_deserializeDocumentInheritedProperties(&sv.InheritedProperties, value); err != nil { return err } - case "deliveryDestinationType": + case "kmsKeyId": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected DeliveryDestinationType to be of type string, got %T instead", value) + return fmt.Errorf("expected KmsKeyId to be of type string, got %T instead", value) } - sv.DeliveryDestinationType = types.DeliveryDestinationType(jtv) + sv.KmsKeyId = ptr.String(jtv) } - case "name": + case "logGroupArn": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected DeliveryDestinationName to be of type string, got %T instead", value) + return fmt.Errorf("expected Arn to be of type string, got %T instead", value) } - sv.Name = ptr.String(jtv) + sv.LogGroupArn = ptr.String(jtv) } - case "outputFormat": + case "logGroupClass": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected OutputFormat to be of type string, got %T instead", value) + return fmt.Errorf("expected LogGroupClass to be of type string, got %T instead", value) } - sv.OutputFormat = types.OutputFormat(jtv) + sv.LogGroupClass = types.LogGroupClass(jtv) } - case "tags": - if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil { - return err + case "logGroupName": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected LogGroupName to be of type string, got %T instead", value) + } + sv.LogGroupName = ptr.String(jtv) + } + + case "metricFilterCount": + if value != nil { + jtv, ok := value.(json.Number) + if !ok { + return fmt.Errorf("expected FilterCount to be json.Number, got %T instead", value) + } + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.MetricFilterCount = ptr.Int32(int32(i64)) + } + + case "retentionInDays": + if value != nil { + jtv, ok := value.(json.Number) + if !ok { + return fmt.Errorf("expected Days to be json.Number, got %T instead", value) + } + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.RetentionInDays = ptr.Int32(int32(i64)) + } + + case "storedBytes": + if value != nil { + jtv, ok := value.(json.Number) + if !ok { + return fmt.Errorf("expected StoredBytes to be json.Number, got %T instead", value) + } + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.StoredBytes = ptr.Int64(i64) } - default: - _, _ = key, value + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + +func awsAwsjson11_deserializeDocumentLogGroupArnList(v *[]string, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.([]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var cv []string + if *v == nil { + cv = []string{} + } else { + cv = *v + } + for _, value := range shape { + var col string + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected LogGroupArn to be of type string, got %T instead", value) + } + col = jtv } + cv = append(cv, col) + } - *v = sv + *v = cv return nil } -func awsAwsjson11_deserializeDocumentDeliveryDestinationConfiguration(v **types.DeliveryDestinationConfiguration, value interface{}) error { +func awsAwsjson11_deserializeDocumentLogGroupField(v **types.LogGroupField, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -12970,22 +18158,35 @@ func awsAwsjson11_deserializeDocumentDeliveryDestinationConfiguration(v **types. return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.DeliveryDestinationConfiguration + var sv *types.LogGroupField if *v == nil { - sv = &types.DeliveryDestinationConfiguration{} + sv = &types.LogGroupField{} } else { sv = *v } for key, value := range shape { switch key { - case "destinationResourceArn": + case "name": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected Arn to be of type string, got %T instead", value) + return fmt.Errorf("expected Field to be of type string, got %T instead", value) } - sv.DestinationResourceArn = ptr.String(jtv) + sv.Name = ptr.String(jtv) + } + + case "percent": + if value != nil { + jtv, ok := value.(json.Number) + if !ok { + return fmt.Errorf("expected Percentage to be json.Number, got %T instead", value) + } + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.Percent = int32(i64) } default: @@ -12997,7 +18198,7 @@ func awsAwsjson11_deserializeDocumentDeliveryDestinationConfiguration(v **types. return nil } -func awsAwsjson11_deserializeDocumentDeliveryDestinations(v *[]types.DeliveryDestination, value interface{}) error { +func awsAwsjson11_deserializeDocumentLogGroupFieldList(v *[]types.LogGroupField, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -13010,17 +18211,17 @@ func awsAwsjson11_deserializeDocumentDeliveryDestinations(v *[]types.DeliveryDes return fmt.Errorf("unexpected JSON type %v", value) } - var cv []types.DeliveryDestination + var cv []types.LogGroupField if *v == nil { - cv = []types.DeliveryDestination{} + cv = []types.LogGroupField{} } else { cv = *v } for _, value := range shape { - var col types.DeliveryDestination + var col types.LogGroupField destAddr := &col - if err := awsAwsjson11_deserializeDocumentDeliveryDestination(&destAddr, value); err != nil { + if err := awsAwsjson11_deserializeDocumentLogGroupField(&destAddr, value); err != nil { return err } col = *destAddr @@ -13031,7 +18232,7 @@ func awsAwsjson11_deserializeDocumentDeliveryDestinations(v *[]types.DeliveryDes return nil } -func awsAwsjson11_deserializeDocumentDeliverySource(v **types.DeliverySource, value interface{}) error { +func awsAwsjson11_deserializeDocumentLogGroupIdentifiers(v *[]string, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -13039,76 +18240,105 @@ func awsAwsjson11_deserializeDocumentDeliverySource(v **types.DeliverySource, va return nil } - shape, ok := value.(map[string]interface{}) + shape, ok := value.([]interface{}) if !ok { return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.DeliverySource + var cv []string if *v == nil { - sv = &types.DeliverySource{} + cv = []string{} } else { - sv = *v + cv = *v } - for key, value := range shape { - switch key { - case "arn": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected Arn to be of type string, got %T instead", value) - } - sv.Arn = ptr.String(jtv) + for _, value := range shape { + var col string + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected LogGroupIdentifier to be of type string, got %T instead", value) } + col = jtv + } + cv = append(cv, col) - case "logType": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected LogType to be of type string, got %T instead", value) - } - sv.LogType = ptr.String(jtv) - } + } + *v = cv + return nil +} - case "name": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected DeliverySourceName to be of type string, got %T instead", value) - } - sv.Name = ptr.String(jtv) - } +func awsAwsjson11_deserializeDocumentLogGroupNames(v *[]string, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } - case "resourceArns": - if err := awsAwsjson11_deserializeDocumentResourceArns(&sv.ResourceArns, value); err != nil { - return err - } + shape, ok := value.([]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } - case "service": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected Service to be of type string, got %T instead", value) - } - sv.Service = ptr.String(jtv) - } + var cv []string + if *v == nil { + cv = []string{} + } else { + cv = *v + } - case "tags": - if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil { - return err + for _, value := range shape { + var col string + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected LogGroupName to be of type string, got %T instead", value) } + col = jtv + } + cv = append(cv, col) - default: - _, _ = key, value + } + *v = cv + return nil +} + +func awsAwsjson11_deserializeDocumentLogGroups(v *[]types.LogGroup, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.([]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var cv []types.LogGroup + if *v == nil { + cv = []types.LogGroup{} + } else { + cv = *v + } + for _, value := range shape { + var col types.LogGroup + destAddr := &col + if err := awsAwsjson11_deserializeDocumentLogGroup(&destAddr, value); err != nil { + return err } + col = *destAddr + cv = append(cv, col) + } - *v = sv + *v = cv return nil } -func awsAwsjson11_deserializeDocumentDeliverySources(v *[]types.DeliverySource, value interface{}) error { +func awsAwsjson11_deserializeDocumentLogGroupSummaries(v *[]types.LogGroupSummary, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -13121,17 +18351,17 @@ func awsAwsjson11_deserializeDocumentDeliverySources(v *[]types.DeliverySource, return fmt.Errorf("unexpected JSON type %v", value) } - var cv []types.DeliverySource + var cv []types.LogGroupSummary if *v == nil { - cv = []types.DeliverySource{} + cv = []types.LogGroupSummary{} } else { cv = *v } for _, value := range shape { - var col types.DeliverySource + var col types.LogGroupSummary destAddr := &col - if err := awsAwsjson11_deserializeDocumentDeliverySource(&destAddr, value); err != nil { + if err := awsAwsjson11_deserializeDocumentLogGroupSummary(&destAddr, value); err != nil { return err } col = *destAddr @@ -13142,7 +18372,7 @@ func awsAwsjson11_deserializeDocumentDeliverySources(v *[]types.DeliverySource, return nil } -func awsAwsjson11_deserializeDocumentDestination(v **types.Destination, value interface{}) error { +func awsAwsjson11_deserializeDocumentLogGroupSummary(v **types.LogGroupSummary, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -13155,117 +18385,52 @@ func awsAwsjson11_deserializeDocumentDestination(v **types.Destination, value in return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.Destination + var sv *types.LogGroupSummary if *v == nil { - sv = &types.Destination{} + sv = &types.LogGroupSummary{} } else { sv = *v } for key, value := range shape { switch key { - case "accessPolicy": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected AccessPolicy to be of type string, got %T instead", value) - } - sv.AccessPolicy = ptr.String(jtv) - } - - case "arn": + case "logGroupArn": if value != nil { jtv, ok := value.(string) if !ok { return fmt.Errorf("expected Arn to be of type string, got %T instead", value) } - sv.Arn = ptr.String(jtv) - } - - case "creationTime": - if value != nil { - jtv, ok := value.(json.Number) - if !ok { - return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) - } - i64, err := jtv.Int64() - if err != nil { - return err - } - sv.CreationTime = ptr.Int64(i64) - } - - case "destinationName": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected DestinationName to be of type string, got %T instead", value) - } - sv.DestinationName = ptr.String(jtv) - } - - case "roleArn": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected RoleArn to be of type string, got %T instead", value) - } - sv.RoleArn = ptr.String(jtv) + sv.LogGroupArn = ptr.String(jtv) } - case "targetArn": + case "logGroupClass": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected TargetArn to be of type string, got %T instead", value) + return fmt.Errorf("expected LogGroupClass to be of type string, got %T instead", value) } - sv.TargetArn = ptr.String(jtv) + sv.LogGroupClass = types.LogGroupClass(jtv) } - default: - _, _ = key, value - - } - } - *v = sv - return nil -} - -func awsAwsjson11_deserializeDocumentDestinations(v *[]types.Destination, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.([]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } + case "logGroupName": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected LogGroupName to be of type string, got %T instead", value) + } + sv.LogGroupName = ptr.String(jtv) + } - var cv []types.Destination - if *v == nil { - cv = []types.Destination{} - } else { - cv = *v - } + default: + _, _ = key, value - for _, value := range shape { - var col types.Destination - destAddr := &col - if err := awsAwsjson11_deserializeDocumentDestination(&destAddr, value); err != nil { - return err } - col = *destAddr - cv = append(cv, col) - } - *v = cv + *v = sv return nil } -func awsAwsjson11_deserializeDocumentDimensions(v *map[string]string, value interface{}) error { +func awsAwsjson11_deserializeDocumentLogRecord(v *map[string]string, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -13290,7 +18455,7 @@ func awsAwsjson11_deserializeDocumentDimensions(v *map[string]string, value inte if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected DimensionsValue to be of type string, got %T instead", value) + return fmt.Errorf("expected Value to be of type string, got %T instead", value) } parsedVal = jtv } @@ -13301,7 +18466,7 @@ func awsAwsjson11_deserializeDocumentDimensions(v *map[string]string, value inte return nil } -func awsAwsjson11_deserializeDocumentEnumerations(v *map[string]int64, value interface{}) error { +func awsAwsjson11_deserializeDocumentLogSamples(v *[]types.LogEvent, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -13309,39 +18474,33 @@ func awsAwsjson11_deserializeDocumentEnumerations(v *map[string]int64, value int return nil } - shape, ok := value.(map[string]interface{}) + shape, ok := value.([]interface{}) if !ok { return fmt.Errorf("unexpected JSON type %v", value) } - var mv map[string]int64 + var cv []types.LogEvent if *v == nil { - mv = map[string]int64{} + cv = []types.LogEvent{} } else { - mv = *v + cv = *v } - for key, value := range shape { - var parsedVal int64 - if value != nil { - jtv, ok := value.(json.Number) - if !ok { - return fmt.Errorf("expected TokenValue to be json.Number, got %T instead", value) - } - i64, err := jtv.Int64() - if err != nil { - return err - } - parsedVal = i64 + for _, value := range shape { + var col types.LogEvent + destAddr := &col + if err := awsAwsjson11_deserializeDocumentLogEvent(&destAddr, value); err != nil { + return err } - mv[key] = parsedVal + col = *destAddr + cv = append(cv, col) } - *v = mv + *v = cv return nil } -func awsAwsjson11_deserializeDocumentExportTask(v **types.ExportTask, value interface{}) error { +func awsAwsjson11_deserializeDocumentLogStream(v **types.LogStream, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -13354,39 +18513,38 @@ func awsAwsjson11_deserializeDocumentExportTask(v **types.ExportTask, value inte return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.ExportTask + var sv *types.LogStream if *v == nil { - sv = &types.ExportTask{} + sv = &types.LogStream{} } else { sv = *v } for key, value := range shape { switch key { - case "destination": + case "arn": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected ExportDestinationBucket to be of type string, got %T instead", value) + return fmt.Errorf("expected Arn to be of type string, got %T instead", value) } - sv.Destination = ptr.String(jtv) + sv.Arn = ptr.String(jtv) } - case "destinationPrefix": + case "creationTime": if value != nil { - jtv, ok := value.(string) + jtv, ok := value.(json.Number) if !ok { - return fmt.Errorf("expected ExportDestinationPrefix to be of type string, got %T instead", value) + return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) } - sv.DestinationPrefix = ptr.String(jtv) - } - - case "executionInfo": - if err := awsAwsjson11_deserializeDocumentExportTaskExecutionInfo(&sv.ExecutionInfo, value); err != nil { - return err + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.CreationTime = ptr.Int64(i64) } - case "from": + case "firstEventTimestamp": if value != nil { jtv, ok := value.(json.Number) if !ok { @@ -13396,52 +18554,64 @@ func awsAwsjson11_deserializeDocumentExportTask(v **types.ExportTask, value inte if err != nil { return err } - sv.From = ptr.Int64(i64) + sv.FirstEventTimestamp = ptr.Int64(i64) } - case "logGroupName": + case "lastEventTimestamp": if value != nil { - jtv, ok := value.(string) + jtv, ok := value.(json.Number) if !ok { - return fmt.Errorf("expected LogGroupName to be of type string, got %T instead", value) + return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) } - sv.LogGroupName = ptr.String(jtv) - } - - case "status": - if err := awsAwsjson11_deserializeDocumentExportTaskStatus(&sv.Status, value); err != nil { - return err + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.LastEventTimestamp = ptr.Int64(i64) } - case "taskId": + case "lastIngestionTime": if value != nil { - jtv, ok := value.(string) + jtv, ok := value.(json.Number) if !ok { - return fmt.Errorf("expected ExportTaskId to be of type string, got %T instead", value) + return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) } - sv.TaskId = ptr.String(jtv) + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.LastIngestionTime = ptr.Int64(i64) } - case "taskName": + case "logStreamName": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected ExportTaskName to be of type string, got %T instead", value) + return fmt.Errorf("expected LogStreamName to be of type string, got %T instead", value) } - sv.TaskName = ptr.String(jtv) + sv.LogStreamName = ptr.String(jtv) } - case "to": + case "storedBytes": if value != nil { jtv, ok := value.(json.Number) if !ok { - return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) + return fmt.Errorf("expected StoredBytes to be json.Number, got %T instead", value) } i64, err := jtv.Int64() if err != nil { return err } - sv.To = ptr.Int64(i64) + sv.StoredBytes = ptr.Int64(i64) + } + + case "uploadSequenceToken": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected SequenceToken to be of type string, got %T instead", value) + } + sv.UploadSequenceToken = ptr.String(jtv) } default: @@ -13453,7 +18623,41 @@ func awsAwsjson11_deserializeDocumentExportTask(v **types.ExportTask, value inte return nil } -func awsAwsjson11_deserializeDocumentExportTaskExecutionInfo(v **types.ExportTaskExecutionInfo, value interface{}) error { +func awsAwsjson11_deserializeDocumentLogStreams(v *[]types.LogStream, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.([]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var cv []types.LogStream + if *v == nil { + cv = []types.LogStream{} + } else { + cv = *v + } + + for _, value := range shape { + var col types.LogStream + destAddr := &col + if err := awsAwsjson11_deserializeDocumentLogStream(&destAddr, value); err != nil { + return err + } + col = *destAddr + cv = append(cv, col) + + } + *v = cv + return nil +} + +func awsAwsjson11_deserializeDocumentLowerCaseString(v **types.LowerCaseString, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -13466,39 +18670,18 @@ func awsAwsjson11_deserializeDocumentExportTaskExecutionInfo(v **types.ExportTas return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.ExportTaskExecutionInfo + var sv *types.LowerCaseString if *v == nil { - sv = &types.ExportTaskExecutionInfo{} + sv = &types.LowerCaseString{} } else { sv = *v } for key, value := range shape { switch key { - case "completionTime": - if value != nil { - jtv, ok := value.(json.Number) - if !ok { - return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) - } - i64, err := jtv.Int64() - if err != nil { - return err - } - sv.CompletionTime = ptr.Int64(i64) - } - - case "creationTime": - if value != nil { - jtv, ok := value.(json.Number) - if !ok { - return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) - } - i64, err := jtv.Int64() - if err != nil { - return err - } - sv.CreationTime = ptr.Int64(i64) + case "withKeys": + if err := awsAwsjson11_deserializeDocumentLowerCaseStringWithKeys(&sv.WithKeys, value); err != nil { + return err } default: @@ -13510,7 +18693,7 @@ func awsAwsjson11_deserializeDocumentExportTaskExecutionInfo(v **types.ExportTas return nil } -func awsAwsjson11_deserializeDocumentExportTasks(v *[]types.ExportTask, value interface{}) error { +func awsAwsjson11_deserializeDocumentLowerCaseStringWithKeys(v *[]string, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -13523,20 +18706,22 @@ func awsAwsjson11_deserializeDocumentExportTasks(v *[]types.ExportTask, value in return fmt.Errorf("unexpected JSON type %v", value) } - var cv []types.ExportTask + var cv []string if *v == nil { - cv = []types.ExportTask{} + cv = []string{} } else { cv = *v } for _, value := range shape { - var col types.ExportTask - destAddr := &col - if err := awsAwsjson11_deserializeDocumentExportTask(&destAddr, value); err != nil { - return err + var col string + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected WithKey to be of type string, got %T instead", value) + } + col = jtv } - col = *destAddr cv = append(cv, col) } @@ -13544,7 +18729,7 @@ func awsAwsjson11_deserializeDocumentExportTasks(v *[]types.ExportTask, value in return nil } -func awsAwsjson11_deserializeDocumentExportTaskStatus(v **types.ExportTaskStatus, value interface{}) error { +func awsAwsjson11_deserializeDocumentMalformedQueryException(v **types.MalformedQueryException, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -13557,31 +18742,27 @@ func awsAwsjson11_deserializeDocumentExportTaskStatus(v **types.ExportTaskStatus return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.ExportTaskStatus + var sv *types.MalformedQueryException if *v == nil { - sv = &types.ExportTaskStatus{} + sv = &types.MalformedQueryException{} } else { sv = *v } for key, value := range shape { switch key { - case "code": + case "message", "Message": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected ExportTaskStatusCode to be of type string, got %T instead", value) + return fmt.Errorf("expected Message to be of type string, got %T instead", value) } - sv.Code = types.ExportTaskStatusCode(jtv) + sv.Message = ptr.String(jtv) } - case "message": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected ExportTaskStatusMessage to be of type string, got %T instead", value) - } - sv.Message = ptr.String(jtv) + case "queryCompileError": + if err := awsAwsjson11_deserializeDocumentQueryCompileError(&sv.QueryCompileError, value); err != nil { + return err } default: @@ -13593,7 +18774,7 @@ func awsAwsjson11_deserializeDocumentExportTaskStatus(v **types.ExportTaskStatus return nil } -func awsAwsjson11_deserializeDocumentExtractedValues(v *map[string]string, value interface{}) error { +func awsAwsjson11_deserializeDocumentMatchPatterns(v *[]string, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -13601,35 +18782,35 @@ func awsAwsjson11_deserializeDocumentExtractedValues(v *map[string]string, value return nil } - shape, ok := value.(map[string]interface{}) + shape, ok := value.([]interface{}) if !ok { return fmt.Errorf("unexpected JSON type %v", value) } - var mv map[string]string + var cv []string if *v == nil { - mv = map[string]string{} + cv = []string{} } else { - mv = *v + cv = *v } - for key, value := range shape { - var parsedVal string + for _, value := range shape { + var col string if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected Value to be of type string, got %T instead", value) + return fmt.Errorf("expected MatchPattern to be of type string, got %T instead", value) } - parsedVal = jtv + col = jtv } - mv[key] = parsedVal + cv = append(cv, col) } - *v = mv + *v = cv return nil } -func awsAwsjson11_deserializeDocumentFieldIndex(v **types.FieldIndex, value interface{}) error { +func awsAwsjson11_deserializeDocumentMetricFilter(v **types.MetricFilter, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -13642,25 +18823,25 @@ func awsAwsjson11_deserializeDocumentFieldIndex(v **types.FieldIndex, value inte return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.FieldIndex + var sv *types.MetricFilter if *v == nil { - sv = &types.FieldIndex{} + sv = &types.MetricFilter{} } else { sv = *v } for key, value := range shape { switch key { - case "fieldIndexName": + case "applyOnTransformedLogs": if value != nil { - jtv, ok := value.(string) + jtv, ok := value.(bool) if !ok { - return fmt.Errorf("expected FieldIndexName to be of type string, got %T instead", value) + return fmt.Errorf("expected ApplyOnTransformedLogs to be of type *bool, got %T instead", value) } - sv.FieldIndexName = ptr.String(jtv) + sv.ApplyOnTransformedLogs = jtv } - case "firstEventTime": + case "creationTime": if value != nil { jtv, ok := value.(json.Number) if !ok { @@ -13670,42 +18851,53 @@ func awsAwsjson11_deserializeDocumentFieldIndex(v **types.FieldIndex, value inte if err != nil { return err } - sv.FirstEventTime = ptr.Int64(i64) + sv.CreationTime = ptr.Int64(i64) } - case "lastEventTime": + case "emitSystemFieldDimensions": + if err := awsAwsjson11_deserializeDocumentEmitSystemFields(&sv.EmitSystemFieldDimensions, value); err != nil { + return err + } + + case "fieldSelectionCriteria": if value != nil { - jtv, ok := value.(json.Number) + jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) - } - i64, err := jtv.Int64() - if err != nil { - return err + return fmt.Errorf("expected FieldSelectionCriteria to be of type string, got %T instead", value) } - sv.LastEventTime = ptr.Int64(i64) + sv.FieldSelectionCriteria = ptr.String(jtv) } - case "lastScanTime": + case "filterName": if value != nil { - jtv, ok := value.(json.Number) + jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) + return fmt.Errorf("expected FilterName to be of type string, got %T instead", value) } - i64, err := jtv.Int64() - if err != nil { - return err + sv.FilterName = ptr.String(jtv) + } + + case "filterPattern": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected FilterPattern to be of type string, got %T instead", value) } - sv.LastScanTime = ptr.Int64(i64) + sv.FilterPattern = ptr.String(jtv) } - case "logGroupIdentifier": + case "logGroupName": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected LogGroupIdentifier to be of type string, got %T instead", value) + return fmt.Errorf("expected LogGroupName to be of type string, got %T instead", value) } - sv.LogGroupIdentifier = ptr.String(jtv) + sv.LogGroupName = ptr.String(jtv) + } + + case "metricTransformations": + if err := awsAwsjson11_deserializeDocumentMetricTransformations(&sv.MetricTransformations, value); err != nil { + return err } default: @@ -13717,7 +18909,7 @@ func awsAwsjson11_deserializeDocumentFieldIndex(v **types.FieldIndex, value inte return nil } -func awsAwsjson11_deserializeDocumentFieldIndexes(v *[]types.FieldIndex, value interface{}) error { +func awsAwsjson11_deserializeDocumentMetricFilterMatches(v *[]types.MetricFilterMatchRecord, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -13730,17 +18922,17 @@ func awsAwsjson11_deserializeDocumentFieldIndexes(v *[]types.FieldIndex, value i return fmt.Errorf("unexpected JSON type %v", value) } - var cv []types.FieldIndex + var cv []types.MetricFilterMatchRecord if *v == nil { - cv = []types.FieldIndex{} + cv = []types.MetricFilterMatchRecord{} } else { cv = *v } for _, value := range shape { - var col types.FieldIndex + var col types.MetricFilterMatchRecord destAddr := &col - if err := awsAwsjson11_deserializeDocumentFieldIndex(&destAddr, value); err != nil { + if err := awsAwsjson11_deserializeDocumentMetricFilterMatchRecord(&destAddr, value); err != nil { return err } col = *destAddr @@ -13751,7 +18943,7 @@ func awsAwsjson11_deserializeDocumentFieldIndexes(v *[]types.FieldIndex, value i return nil } -func awsAwsjson11_deserializeDocumentFilteredLogEvent(v **types.FilteredLogEvent, value interface{}) error { +func awsAwsjson11_deserializeDocumentMetricFilterMatchRecord(v **types.MetricFilterMatchRecord, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -13764,66 +18956,40 @@ func awsAwsjson11_deserializeDocumentFilteredLogEvent(v **types.FilteredLogEvent return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.FilteredLogEvent + var sv *types.MetricFilterMatchRecord if *v == nil { - sv = &types.FilteredLogEvent{} + sv = &types.MetricFilterMatchRecord{} } else { sv = *v } for key, value := range shape { switch key { - case "eventId": + case "eventMessage": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected EventId to be of type string, got %T instead", value) + return fmt.Errorf("expected EventMessage to be of type string, got %T instead", value) } - sv.EventId = ptr.String(jtv) + sv.EventMessage = ptr.String(jtv) } - case "ingestionTime": + case "eventNumber": if value != nil { jtv, ok := value.(json.Number) if !ok { - return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) + return fmt.Errorf("expected EventNumber to be json.Number, got %T instead", value) } i64, err := jtv.Int64() if err != nil { return err } - sv.IngestionTime = ptr.Int64(i64) - } - - case "logStreamName": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected LogStreamName to be of type string, got %T instead", value) - } - sv.LogStreamName = ptr.String(jtv) - } - - case "message": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected EventMessage to be of type string, got %T instead", value) - } - sv.Message = ptr.String(jtv) + sv.EventNumber = i64 } - case "timestamp": - if value != nil { - jtv, ok := value.(json.Number) - if !ok { - return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) - } - i64, err := jtv.Int64() - if err != nil { - return err - } - sv.Timestamp = ptr.Int64(i64) + case "extractedValues": + if err := awsAwsjson11_deserializeDocumentExtractedValues(&sv.ExtractedValues, value); err != nil { + return err } default: @@ -13835,7 +19001,7 @@ func awsAwsjson11_deserializeDocumentFilteredLogEvent(v **types.FilteredLogEvent return nil } -func awsAwsjson11_deserializeDocumentFilteredLogEvents(v *[]types.FilteredLogEvent, value interface{}) error { +func awsAwsjson11_deserializeDocumentMetricFilters(v *[]types.MetricFilter, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -13848,17 +19014,17 @@ func awsAwsjson11_deserializeDocumentFilteredLogEvents(v *[]types.FilteredLogEve return fmt.Errorf("unexpected JSON type %v", value) } - var cv []types.FilteredLogEvent + var cv []types.MetricFilter if *v == nil { - cv = []types.FilteredLogEvent{} + cv = []types.MetricFilter{} } else { cv = *v } for _, value := range shape { - var col types.FilteredLogEvent + var col types.MetricFilter destAddr := &col - if err := awsAwsjson11_deserializeDocumentFilteredLogEvent(&destAddr, value); err != nil { + if err := awsAwsjson11_deserializeDocumentMetricFilter(&destAddr, value); err != nil { return err } col = *destAddr @@ -13869,7 +19035,7 @@ func awsAwsjson11_deserializeDocumentFilteredLogEvents(v *[]types.FilteredLogEve return nil } -func awsAwsjson11_deserializeDocumentGrok(v **types.Grok, value interface{}) error { +func awsAwsjson11_deserializeDocumentMetricTransformation(v **types.MetricTransformation, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -13882,31 +19048,88 @@ func awsAwsjson11_deserializeDocumentGrok(v **types.Grok, value interface{}) err return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.Grok + var sv *types.MetricTransformation if *v == nil { - sv = &types.Grok{} + sv = &types.MetricTransformation{} } else { sv = *v } for key, value := range shape { switch key { - case "match": + case "defaultValue": + if value != nil { + switch jtv := value.(type) { + case json.Number: + f64, err := jtv.Float64() + if err != nil { + return err + } + sv.DefaultValue = ptr.Float64(f64) + + case string: + var f64 float64 + switch { + case strings.EqualFold(jtv, "NaN"): + f64 = math.NaN() + + case strings.EqualFold(jtv, "Infinity"): + f64 = math.Inf(1) + + case strings.EqualFold(jtv, "-Infinity"): + f64 = math.Inf(-1) + + default: + return fmt.Errorf("unknown JSON number value: %s", jtv) + + } + sv.DefaultValue = ptr.Float64(f64) + + default: + return fmt.Errorf("expected DefaultValue to be a JSON Number, got %T instead", value) + + } + } + + case "dimensions": + if err := awsAwsjson11_deserializeDocumentDimensions(&sv.Dimensions, value); err != nil { + return err + } + + case "metricName": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected GrokMatch to be of type string, got %T instead", value) + return fmt.Errorf("expected MetricName to be of type string, got %T instead", value) } - sv.Match = ptr.String(jtv) + sv.MetricName = ptr.String(jtv) } - case "source": + case "metricNamespace": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected Source to be of type string, got %T instead", value) + return fmt.Errorf("expected MetricNamespace to be of type string, got %T instead", value) } - sv.Source = ptr.String(jtv) + sv.MetricNamespace = ptr.String(jtv) + } + + case "metricValue": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected MetricValue to be of type string, got %T instead", value) + } + sv.MetricValue = ptr.String(jtv) + } + + case "unit": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected StandardUnit to be of type string, got %T instead", value) + } + sv.Unit = types.StandardUnit(jtv) } default: @@ -13918,7 +19141,7 @@ func awsAwsjson11_deserializeDocumentGrok(v **types.Grok, value interface{}) err return nil } -func awsAwsjson11_deserializeDocumentHistogram(v *map[string]int64, value interface{}) error { +func awsAwsjson11_deserializeDocumentMetricTransformations(v *[]types.MetricTransformation, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -13926,39 +19149,33 @@ func awsAwsjson11_deserializeDocumentHistogram(v *map[string]int64, value interf return nil } - shape, ok := value.(map[string]interface{}) + shape, ok := value.([]interface{}) if !ok { return fmt.Errorf("unexpected JSON type %v", value) } - var mv map[string]int64 + var cv []types.MetricTransformation if *v == nil { - mv = map[string]int64{} + cv = []types.MetricTransformation{} } else { - mv = *v + cv = *v } - for key, value := range shape { - var parsedVal int64 - if value != nil { - jtv, ok := value.(json.Number) - if !ok { - return fmt.Errorf("expected Count to be json.Number, got %T instead", value) - } - i64, err := jtv.Int64() - if err != nil { - return err - } - parsedVal = i64 + for _, value := range shape { + var col types.MetricTransformation + destAddr := &col + if err := awsAwsjson11_deserializeDocumentMetricTransformation(&destAddr, value); err != nil { + return err } - mv[key] = parsedVal + col = *destAddr + cv = append(cv, col) } - *v = mv + *v = cv return nil } -func awsAwsjson11_deserializeDocumentIndexPolicies(v *[]types.IndexPolicy, value interface{}) error { +func awsAwsjson11_deserializeDocumentMoveKeyEntries(v *[]types.MoveKeyEntry, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -13971,17 +19188,17 @@ func awsAwsjson11_deserializeDocumentIndexPolicies(v *[]types.IndexPolicy, value return fmt.Errorf("unexpected JSON type %v", value) } - var cv []types.IndexPolicy + var cv []types.MoveKeyEntry if *v == nil { - cv = []types.IndexPolicy{} + cv = []types.MoveKeyEntry{} } else { cv = *v } for _, value := range shape { - var col types.IndexPolicy + var col types.MoveKeyEntry destAddr := &col - if err := awsAwsjson11_deserializeDocumentIndexPolicy(&destAddr, value); err != nil { + if err := awsAwsjson11_deserializeDocumentMoveKeyEntry(&destAddr, value); err != nil { return err } col = *destAddr @@ -13992,7 +19209,7 @@ func awsAwsjson11_deserializeDocumentIndexPolicies(v *[]types.IndexPolicy, value return nil } -func awsAwsjson11_deserializeDocumentIndexPolicy(v **types.IndexPolicy, value interface{}) error { +func awsAwsjson11_deserializeDocumentMoveKeyEntry(v **types.MoveKeyEntry, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -14005,62 +19222,40 @@ func awsAwsjson11_deserializeDocumentIndexPolicy(v **types.IndexPolicy, value in return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.IndexPolicy + var sv *types.MoveKeyEntry if *v == nil { - sv = &types.IndexPolicy{} + sv = &types.MoveKeyEntry{} } else { sv = *v } for key, value := range shape { switch key { - case "lastUpdateTime": - if value != nil { - jtv, ok := value.(json.Number) - if !ok { - return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) - } - i64, err := jtv.Int64() - if err != nil { - return err - } - sv.LastUpdateTime = ptr.Int64(i64) - } - - case "logGroupIdentifier": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected LogGroupIdentifier to be of type string, got %T instead", value) - } - sv.LogGroupIdentifier = ptr.String(jtv) - } - - case "policyDocument": + case "overwriteIfExists": if value != nil { - jtv, ok := value.(string) + jtv, ok := value.(bool) if !ok { - return fmt.Errorf("expected PolicyDocument to be of type string, got %T instead", value) + return fmt.Errorf("expected OverwriteIfExists to be of type *bool, got %T instead", value) } - sv.PolicyDocument = ptr.String(jtv) + sv.OverwriteIfExists = jtv } - case "policyName": + case "source": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected PolicyName to be of type string, got %T instead", value) + return fmt.Errorf("expected Source to be of type string, got %T instead", value) } - sv.PolicyName = ptr.String(jtv) + sv.Source = ptr.String(jtv) } - case "source": + case "target": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected IndexSource to be of type string, got %T instead", value) + return fmt.Errorf("expected Target to be of type string, got %T instead", value) } - sv.Source = types.IndexSource(jtv) + sv.Target = ptr.String(jtv) } default: @@ -14072,7 +19267,7 @@ func awsAwsjson11_deserializeDocumentIndexPolicy(v **types.IndexPolicy, value in return nil } -func awsAwsjson11_deserializeDocumentInheritedProperties(v *[]types.InheritedProperty, value interface{}) error { +func awsAwsjson11_deserializeDocumentMoveKeys(v **types.MoveKeys, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -14080,109 +19275,35 @@ func awsAwsjson11_deserializeDocumentInheritedProperties(v *[]types.InheritedPro return nil } - shape, ok := value.([]interface{}) + shape, ok := value.(map[string]interface{}) if !ok { return fmt.Errorf("unexpected JSON type %v", value) } - var cv []types.InheritedProperty + var sv *types.MoveKeys if *v == nil { - cv = []types.InheritedProperty{} + sv = &types.MoveKeys{} } else { - cv = *v - } - - for _, value := range shape { - var col types.InheritedProperty - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected InheritedProperty to be of type string, got %T instead", value) - } - col = types.InheritedProperty(jtv) - } - cv = append(cv, col) - - } - *v = cv - return nil -} - -func awsAwsjson11_deserializeDocumentIntegrationDetails(v *types.IntegrationDetails, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.(map[string]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) + sv = *v } - var uv types.IntegrationDetails -loop: for key, value := range shape { - if value == nil { - continue - } switch key { - case "openSearchIntegrationDetails": - var mv types.OpenSearchIntegrationDetails - destAddr := &mv - if err := awsAwsjson11_deserializeDocumentOpenSearchIntegrationDetails(&destAddr, value); err != nil { + case "entries": + if err := awsAwsjson11_deserializeDocumentMoveKeyEntries(&sv.Entries, value); err != nil { return err } - mv = *destAddr - uv = &types.IntegrationDetailsMemberOpenSearchIntegrationDetails{Value: mv} - break loop default: - uv = &types.UnknownUnionMember{Tag: key} - break loop - - } - } - *v = uv - return nil -} - -func awsAwsjson11_deserializeDocumentIntegrationSummaries(v *[]types.IntegrationSummary, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.([]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } - - var cv []types.IntegrationSummary - if *v == nil { - cv = []types.IntegrationSummary{} - } else { - cv = *v - } + _, _ = key, value - for _, value := range shape { - var col types.IntegrationSummary - destAddr := &col - if err := awsAwsjson11_deserializeDocumentIntegrationSummary(&destAddr, value); err != nil { - return err } - col = *destAddr - cv = append(cv, col) - } - *v = cv + *v = sv return nil } -func awsAwsjson11_deserializeDocumentIntegrationSummary(v **types.IntegrationSummary, value interface{}) error { +func awsAwsjson11_deserializeDocumentOpenSearchApplication(v **types.OpenSearchApplication, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -14195,40 +19316,45 @@ func awsAwsjson11_deserializeDocumentIntegrationSummary(v **types.IntegrationSum return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.IntegrationSummary + var sv *types.OpenSearchApplication if *v == nil { - sv = &types.IntegrationSummary{} + sv = &types.OpenSearchApplication{} } else { sv = *v } for key, value := range shape { switch key { - case "integrationName": + case "applicationArn": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected IntegrationName to be of type string, got %T instead", value) + return fmt.Errorf("expected Arn to be of type string, got %T instead", value) } - sv.IntegrationName = ptr.String(jtv) + sv.ApplicationArn = ptr.String(jtv) } - case "integrationStatus": + case "applicationEndpoint": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected IntegrationStatus to be of type string, got %T instead", value) + return fmt.Errorf("expected OpenSearchApplicationEndpoint to be of type string, got %T instead", value) } - sv.IntegrationStatus = types.IntegrationStatus(jtv) + sv.ApplicationEndpoint = ptr.String(jtv) } - case "integrationType": + case "applicationId": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected IntegrationType to be of type string, got %T instead", value) + return fmt.Errorf("expected OpenSearchApplicationId to be of type string, got %T instead", value) } - sv.IntegrationType = types.IntegrationType(jtv) + sv.ApplicationId = ptr.String(jtv) + } + + case "status": + if err := awsAwsjson11_deserializeDocumentOpenSearchResourceStatus(&sv.Status, value); err != nil { + return err } default: @@ -14240,7 +19366,7 @@ func awsAwsjson11_deserializeDocumentIntegrationSummary(v **types.IntegrationSum return nil } -func awsAwsjson11_deserializeDocumentInvalidOperationException(v **types.InvalidOperationException, value interface{}) error { +func awsAwsjson11_deserializeDocumentOpenSearchCollection(v **types.OpenSearchCollection, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -14253,22 +19379,36 @@ func awsAwsjson11_deserializeDocumentInvalidOperationException(v **types.Invalid return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.InvalidOperationException + var sv *types.OpenSearchCollection if *v == nil { - sv = &types.InvalidOperationException{} + sv = &types.OpenSearchCollection{} } else { sv = *v } for key, value := range shape { switch key { - case "message", "Message": + case "collectionArn": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected Message to be of type string, got %T instead", value) + return fmt.Errorf("expected Arn to be of type string, got %T instead", value) } - sv.Message = ptr.String(jtv) + sv.CollectionArn = ptr.String(jtv) + } + + case "collectionEndpoint": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected OpenSearchCollectionEndpoint to be of type string, got %T instead", value) + } + sv.CollectionEndpoint = ptr.String(jtv) + } + + case "status": + if err := awsAwsjson11_deserializeDocumentOpenSearchResourceStatus(&sv.Status, value); err != nil { + return err } default: @@ -14280,7 +19420,7 @@ func awsAwsjson11_deserializeDocumentInvalidOperationException(v **types.Invalid return nil } -func awsAwsjson11_deserializeDocumentInvalidParameterException(v **types.InvalidParameterException, value interface{}) error { +func awsAwsjson11_deserializeDocumentOpenSearchDataAccessPolicy(v **types.OpenSearchDataAccessPolicy, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -14293,22 +19433,27 @@ func awsAwsjson11_deserializeDocumentInvalidParameterException(v **types.Invalid return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.InvalidParameterException + var sv *types.OpenSearchDataAccessPolicy if *v == nil { - sv = &types.InvalidParameterException{} + sv = &types.OpenSearchDataAccessPolicy{} } else { sv = *v } for key, value := range shape { switch key { - case "message", "Message": + case "policyName": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected Message to be of type string, got %T instead", value) + return fmt.Errorf("expected OpenSearchPolicyName to be of type string, got %T instead", value) } - sv.Message = ptr.String(jtv) + sv.PolicyName = ptr.String(jtv) + } + + case "status": + if err := awsAwsjson11_deserializeDocumentOpenSearchResourceStatus(&sv.Status, value); err != nil { + return err } default: @@ -14320,7 +19465,7 @@ func awsAwsjson11_deserializeDocumentInvalidParameterException(v **types.Invalid return nil } -func awsAwsjson11_deserializeDocumentInvalidSequenceTokenException(v **types.InvalidSequenceTokenException, value interface{}) error { +func awsAwsjson11_deserializeDocumentOpenSearchDataSource(v **types.OpenSearchDataSource, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -14333,31 +19478,27 @@ func awsAwsjson11_deserializeDocumentInvalidSequenceTokenException(v **types.Inv return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.InvalidSequenceTokenException + var sv *types.OpenSearchDataSource if *v == nil { - sv = &types.InvalidSequenceTokenException{} + sv = &types.OpenSearchDataSource{} } else { sv = *v } for key, value := range shape { switch key { - case "expectedSequenceToken": + case "dataSourceName": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected SequenceToken to be of type string, got %T instead", value) + return fmt.Errorf("expected OpenSearchDataSourceName to be of type string, got %T instead", value) } - sv.ExpectedSequenceToken = ptr.String(jtv) + sv.DataSourceName = ptr.String(jtv) } - case "message", "Message": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected Message to be of type string, got %T instead", value) - } - sv.Message = ptr.String(jtv) + case "status": + if err := awsAwsjson11_deserializeDocumentOpenSearchResourceStatus(&sv.Status, value); err != nil { + return err } default: @@ -14369,7 +19510,7 @@ func awsAwsjson11_deserializeDocumentInvalidSequenceTokenException(v **types.Inv return nil } -func awsAwsjson11_deserializeDocumentLimitExceededException(v **types.LimitExceededException, value interface{}) error { +func awsAwsjson11_deserializeDocumentOpenSearchEncryptionPolicy(v **types.OpenSearchEncryptionPolicy, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -14382,22 +19523,27 @@ func awsAwsjson11_deserializeDocumentLimitExceededException(v **types.LimitExcee return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.LimitExceededException + var sv *types.OpenSearchEncryptionPolicy if *v == nil { - sv = &types.LimitExceededException{} + sv = &types.OpenSearchEncryptionPolicy{} } else { sv = *v } for key, value := range shape { switch key { - case "message", "Message": + case "policyName": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected Message to be of type string, got %T instead", value) + return fmt.Errorf("expected OpenSearchPolicyName to be of type string, got %T instead", value) } - sv.Message = ptr.String(jtv) + sv.PolicyName = ptr.String(jtv) + } + + case "status": + if err := awsAwsjson11_deserializeDocumentOpenSearchResourceStatus(&sv.Status, value); err != nil { + return err } default: @@ -14409,7 +19555,7 @@ func awsAwsjson11_deserializeDocumentLimitExceededException(v **types.LimitExcee return nil } -func awsAwsjson11_deserializeDocumentListToMap(v **types.ListToMap, value interface{}) error { +func awsAwsjson11_deserializeDocumentOpenSearchIntegrationDetails(v **types.OpenSearchIntegrationDetails, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -14422,67 +19568,53 @@ func awsAwsjson11_deserializeDocumentListToMap(v **types.ListToMap, value interf return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.ListToMap + var sv *types.OpenSearchIntegrationDetails if *v == nil { - sv = &types.ListToMap{} + sv = &types.OpenSearchIntegrationDetails{} } else { sv = *v } for key, value := range shape { switch key { - case "flatten": - if value != nil { - jtv, ok := value.(bool) - if !ok { - return fmt.Errorf("expected Flatten to be of type *bool, got %T instead", value) - } - sv.Flatten = jtv + case "accessPolicy": + if err := awsAwsjson11_deserializeDocumentOpenSearchDataAccessPolicy(&sv.AccessPolicy, value); err != nil { + return err } - case "flattenedElement": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected FlattenedElement to be of type string, got %T instead", value) - } - sv.FlattenedElement = types.FlattenedElement(jtv) + case "application": + if err := awsAwsjson11_deserializeDocumentOpenSearchApplication(&sv.Application, value); err != nil { + return err } - case "key": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected Key to be of type string, got %T instead", value) - } - sv.Key = ptr.String(jtv) + case "collection": + if err := awsAwsjson11_deserializeDocumentOpenSearchCollection(&sv.Collection, value); err != nil { + return err } - case "source": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected Source to be of type string, got %T instead", value) - } - sv.Source = ptr.String(jtv) + case "dataSource": + if err := awsAwsjson11_deserializeDocumentOpenSearchDataSource(&sv.DataSource, value); err != nil { + return err } - case "target": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected Target to be of type string, got %T instead", value) - } - sv.Target = ptr.String(jtv) + case "encryptionPolicy": + if err := awsAwsjson11_deserializeDocumentOpenSearchEncryptionPolicy(&sv.EncryptionPolicy, value); err != nil { + return err } - case "valueKey": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected ValueKey to be of type string, got %T instead", value) - } - sv.ValueKey = ptr.String(jtv) + case "lifecyclePolicy": + if err := awsAwsjson11_deserializeDocumentOpenSearchLifecyclePolicy(&sv.LifecyclePolicy, value); err != nil { + return err + } + + case "networkPolicy": + if err := awsAwsjson11_deserializeDocumentOpenSearchNetworkPolicy(&sv.NetworkPolicy, value); err != nil { + return err + } + + case "workspace": + if err := awsAwsjson11_deserializeDocumentOpenSearchWorkspace(&sv.Workspace, value); err != nil { + return err } default: @@ -14494,7 +19626,7 @@ func awsAwsjson11_deserializeDocumentListToMap(v **types.ListToMap, value interf return nil } -func awsAwsjson11_deserializeDocumentLogEvent(v **types.LogEvent, value interface{}) error { +func awsAwsjson11_deserializeDocumentOpenSearchLifecyclePolicy(v **types.OpenSearchLifecyclePolicy, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -14507,35 +19639,27 @@ func awsAwsjson11_deserializeDocumentLogEvent(v **types.LogEvent, value interfac return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.LogEvent + var sv *types.OpenSearchLifecyclePolicy if *v == nil { - sv = &types.LogEvent{} + sv = &types.OpenSearchLifecyclePolicy{} } else { sv = *v } for key, value := range shape { switch key { - case "message": + case "policyName": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected EventMessage to be of type string, got %T instead", value) + return fmt.Errorf("expected OpenSearchPolicyName to be of type string, got %T instead", value) } - sv.Message = ptr.String(jtv) + sv.PolicyName = ptr.String(jtv) } - case "timestamp": - if value != nil { - jtv, ok := value.(json.Number) - if !ok { - return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) - } - i64, err := jtv.Int64() - if err != nil { - return err - } - sv.Timestamp = ptr.Int64(i64) + case "status": + if err := awsAwsjson11_deserializeDocumentOpenSearchResourceStatus(&sv.Status, value); err != nil { + return err } default: @@ -14547,7 +19671,7 @@ func awsAwsjson11_deserializeDocumentLogEvent(v **types.LogEvent, value interfac return nil } -func awsAwsjson11_deserializeDocumentLogGroup(v **types.LogGroup, value interface{}) error { +func awsAwsjson11_deserializeDocumentOpenSearchNetworkPolicy(v **types.OpenSearchNetworkPolicy, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -14560,126 +19684,29 @@ func awsAwsjson11_deserializeDocumentLogGroup(v **types.LogGroup, value interfac return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.LogGroup + var sv *types.OpenSearchNetworkPolicy if *v == nil { - sv = &types.LogGroup{} + sv = &types.OpenSearchNetworkPolicy{} } else { sv = *v } for key, value := range shape { switch key { - case "arn": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected Arn to be of type string, got %T instead", value) - } - sv.Arn = ptr.String(jtv) - } - - case "creationTime": - if value != nil { - jtv, ok := value.(json.Number) - if !ok { - return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) - } - i64, err := jtv.Int64() - if err != nil { - return err - } - sv.CreationTime = ptr.Int64(i64) - } - - case "dataProtectionStatus": + case "policyName": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected DataProtectionStatus to be of type string, got %T instead", value) + return fmt.Errorf("expected OpenSearchPolicyName to be of type string, got %T instead", value) } - sv.DataProtectionStatus = types.DataProtectionStatus(jtv) + sv.PolicyName = ptr.String(jtv) } - case "inheritedProperties": - if err := awsAwsjson11_deserializeDocumentInheritedProperties(&sv.InheritedProperties, value); err != nil { + case "status": + if err := awsAwsjson11_deserializeDocumentOpenSearchResourceStatus(&sv.Status, value); err != nil { return err } - case "kmsKeyId": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected KmsKeyId to be of type string, got %T instead", value) - } - sv.KmsKeyId = ptr.String(jtv) - } - - case "logGroupArn": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected Arn to be of type string, got %T instead", value) - } - sv.LogGroupArn = ptr.String(jtv) - } - - case "logGroupClass": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected LogGroupClass to be of type string, got %T instead", value) - } - sv.LogGroupClass = types.LogGroupClass(jtv) - } - - case "logGroupName": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected LogGroupName to be of type string, got %T instead", value) - } - sv.LogGroupName = ptr.String(jtv) - } - - case "metricFilterCount": - if value != nil { - jtv, ok := value.(json.Number) - if !ok { - return fmt.Errorf("expected FilterCount to be json.Number, got %T instead", value) - } - i64, err := jtv.Int64() - if err != nil { - return err - } - sv.MetricFilterCount = ptr.Int32(int32(i64)) - } - - case "retentionInDays": - if value != nil { - jtv, ok := value.(json.Number) - if !ok { - return fmt.Errorf("expected Days to be json.Number, got %T instead", value) - } - i64, err := jtv.Int64() - if err != nil { - return err - } - sv.RetentionInDays = ptr.Int32(int32(i64)) - } - - case "storedBytes": - if value != nil { - jtv, ok := value.(json.Number) - if !ok { - return fmt.Errorf("expected StoredBytes to be json.Number, got %T instead", value) - } - i64, err := jtv.Int64() - if err != nil { - return err - } - sv.StoredBytes = ptr.Int64(i64) - } - default: _, _ = key, value @@ -14689,7 +19716,7 @@ func awsAwsjson11_deserializeDocumentLogGroup(v **types.LogGroup, value interfac return nil } -func awsAwsjson11_deserializeDocumentLogGroupArnList(v *[]string, value interface{}) error { +func awsAwsjson11_deserializeDocumentOpenSearchResourceStatus(v **types.OpenSearchResourceStatus, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -14697,35 +19724,48 @@ func awsAwsjson11_deserializeDocumentLogGroupArnList(v *[]string, value interfac return nil } - shape, ok := value.([]interface{}) + shape, ok := value.(map[string]interface{}) if !ok { return fmt.Errorf("unexpected JSON type %v", value) } - var cv []string + var sv *types.OpenSearchResourceStatus if *v == nil { - cv = []string{} + sv = &types.OpenSearchResourceStatus{} } else { - cv = *v + sv = *v } - for _, value := range shape { - var col string - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected LogGroupArn to be of type string, got %T instead", value) + for key, value := range shape { + switch key { + case "status": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected OpenSearchResourceStatusType to be of type string, got %T instead", value) + } + sv.Status = types.OpenSearchResourceStatusType(jtv) + } + + case "statusMessage": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected IntegrationStatusMessage to be of type string, got %T instead", value) + } + sv.StatusMessage = ptr.String(jtv) } - col = jtv - } - cv = append(cv, col) + default: + _, _ = key, value + + } } - *v = cv + *v = sv return nil } -func awsAwsjson11_deserializeDocumentLogGroupField(v **types.LogGroupField, value interface{}) error { +func awsAwsjson11_deserializeDocumentOpenSearchWorkspace(v **types.OpenSearchWorkspace, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -14738,35 +19778,27 @@ func awsAwsjson11_deserializeDocumentLogGroupField(v **types.LogGroupField, valu return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.LogGroupField + var sv *types.OpenSearchWorkspace if *v == nil { - sv = &types.LogGroupField{} + sv = &types.OpenSearchWorkspace{} } else { sv = *v } for key, value := range shape { switch key { - case "name": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected Field to be of type string, got %T instead", value) - } - sv.Name = ptr.String(jtv) + case "status": + if err := awsAwsjson11_deserializeDocumentOpenSearchResourceStatus(&sv.Status, value); err != nil { + return err } - case "percent": + case "workspaceId": if value != nil { - jtv, ok := value.(json.Number) + jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected Percentage to be json.Number, got %T instead", value) - } - i64, err := jtv.Int64() - if err != nil { - return err + return fmt.Errorf("expected OpenSearchWorkspaceId to be of type string, got %T instead", value) } - sv.Percent = int32(i64) + sv.WorkspaceId = ptr.String(jtv) } default: @@ -14778,7 +19810,7 @@ func awsAwsjson11_deserializeDocumentLogGroupField(v **types.LogGroupField, valu return nil } -func awsAwsjson11_deserializeDocumentLogGroupFieldList(v *[]types.LogGroupField, value interface{}) error { +func awsAwsjson11_deserializeDocumentOperationAbortedException(v **types.OperationAbortedException, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -14786,33 +19818,39 @@ func awsAwsjson11_deserializeDocumentLogGroupFieldList(v *[]types.LogGroupField, return nil } - shape, ok := value.([]interface{}) + shape, ok := value.(map[string]interface{}) if !ok { return fmt.Errorf("unexpected JSON type %v", value) } - var cv []types.LogGroupField + var sv *types.OperationAbortedException if *v == nil { - cv = []types.LogGroupField{} + sv = &types.OperationAbortedException{} } else { - cv = *v + sv = *v } - for _, value := range shape { - var col types.LogGroupField - destAddr := &col - if err := awsAwsjson11_deserializeDocumentLogGroupField(&destAddr, value); err != nil { - return err - } - col = *destAddr - cv = append(cv, col) + for key, value := range shape { + switch key { + case "message", "Message": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected Message to be of type string, got %T instead", value) + } + sv.Message = ptr.String(jtv) + } + + default: + _, _ = key, value + } } - *v = cv + *v = sv return nil } -func awsAwsjson11_deserializeDocumentLogGroupIdentifiers(v *[]string, value interface{}) error { +func awsAwsjson11_deserializeDocumentOutputFormats(v *[]types.OutputFormat, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -14825,21 +19863,21 @@ func awsAwsjson11_deserializeDocumentLogGroupIdentifiers(v *[]string, value inte return fmt.Errorf("unexpected JSON type %v", value) } - var cv []string + var cv []types.OutputFormat if *v == nil { - cv = []string{} + cv = []types.OutputFormat{} } else { cv = *v } for _, value := range shape { - var col string + var col types.OutputFormat if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected LogGroupIdentifier to be of type string, got %T instead", value) + return fmt.Errorf("expected OutputFormat to be of type string, got %T instead", value) } - col = jtv + col = types.OutputFormat(jtv) } cv = append(cv, col) @@ -14848,7 +19886,7 @@ func awsAwsjson11_deserializeDocumentLogGroupIdentifiers(v *[]string, value inte return nil } -func awsAwsjson11_deserializeDocumentLogGroupNames(v *[]string, value interface{}) error { +func awsAwsjson11_deserializeDocumentOutputLogEvent(v **types.OutputLogEvent, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -14856,35 +19894,65 @@ func awsAwsjson11_deserializeDocumentLogGroupNames(v *[]string, value interface{ return nil } - shape, ok := value.([]interface{}) + shape, ok := value.(map[string]interface{}) if !ok { return fmt.Errorf("unexpected JSON type %v", value) } - var cv []string + var sv *types.OutputLogEvent if *v == nil { - cv = []string{} + sv = &types.OutputLogEvent{} } else { - cv = *v + sv = *v } - for _, value := range shape { - var col string - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected LogGroupName to be of type string, got %T instead", value) + for key, value := range shape { + switch key { + case "ingestionTime": + if value != nil { + jtv, ok := value.(json.Number) + if !ok { + return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) + } + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.IngestionTime = ptr.Int64(i64) } - col = jtv - } - cv = append(cv, col) + case "message": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected EventMessage to be of type string, got %T instead", value) + } + sv.Message = ptr.String(jtv) + } + + case "timestamp": + if value != nil { + jtv, ok := value.(json.Number) + if !ok { + return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) + } + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.Timestamp = ptr.Int64(i64) + } + + default: + _, _ = key, value + + } } - *v = cv + *v = sv return nil } -func awsAwsjson11_deserializeDocumentLogGroups(v *[]types.LogGroup, value interface{}) error { +func awsAwsjson11_deserializeDocumentOutputLogEvents(v *[]types.OutputLogEvent, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -14897,17 +19965,17 @@ func awsAwsjson11_deserializeDocumentLogGroups(v *[]types.LogGroup, value interf return fmt.Errorf("unexpected JSON type %v", value) } - var cv []types.LogGroup + var cv []types.OutputLogEvent if *v == nil { - cv = []types.LogGroup{} + cv = []types.OutputLogEvent{} } else { cv = *v } for _, value := range shape { - var col types.LogGroup + var col types.OutputLogEvent destAddr := &col - if err := awsAwsjson11_deserializeDocumentLogGroup(&destAddr, value); err != nil { + if err := awsAwsjson11_deserializeDocumentOutputLogEvent(&destAddr, value); err != nil { return err } col = *destAddr @@ -14918,7 +19986,7 @@ func awsAwsjson11_deserializeDocumentLogGroups(v *[]types.LogGroup, value interf return nil } -func awsAwsjson11_deserializeDocumentLogRecord(v *map[string]string, value interface{}) error { +func awsAwsjson11_deserializeDocumentParseCloudfront(v **types.ParseCloudfront, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -14931,30 +19999,34 @@ func awsAwsjson11_deserializeDocumentLogRecord(v *map[string]string, value inter return fmt.Errorf("unexpected JSON type %v", value) } - var mv map[string]string + var sv *types.ParseCloudfront if *v == nil { - mv = map[string]string{} + sv = &types.ParseCloudfront{} } else { - mv = *v + sv = *v } for key, value := range shape { - var parsedVal string - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected Value to be of type string, got %T instead", value) + switch key { + case "source": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected Source to be of type string, got %T instead", value) + } + sv.Source = ptr.String(jtv) } - parsedVal = jtv - } - mv[key] = parsedVal + default: + _, _ = key, value + + } } - *v = mv + *v = sv return nil } -func awsAwsjson11_deserializeDocumentLogSamples(v *[]types.LogEvent, value interface{}) error { +func awsAwsjson11_deserializeDocumentParseJSON(v **types.ParseJSON, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -14962,33 +20034,48 @@ func awsAwsjson11_deserializeDocumentLogSamples(v *[]types.LogEvent, value inter return nil } - shape, ok := value.([]interface{}) + shape, ok := value.(map[string]interface{}) if !ok { return fmt.Errorf("unexpected JSON type %v", value) } - var cv []types.LogEvent + var sv *types.ParseJSON if *v == nil { - cv = []types.LogEvent{} + sv = &types.ParseJSON{} } else { - cv = *v + sv = *v } - for _, value := range shape { - var col types.LogEvent - destAddr := &col - if err := awsAwsjson11_deserializeDocumentLogEvent(&destAddr, value); err != nil { - return err - } - col = *destAddr - cv = append(cv, col) + for key, value := range shape { + switch key { + case "destination": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected DestinationField to be of type string, got %T instead", value) + } + sv.Destination = ptr.String(jtv) + } + + case "source": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected Source to be of type string, got %T instead", value) + } + sv.Source = ptr.String(jtv) + } + + default: + _, _ = key, value + } } - *v = cv + *v = sv return nil } -func awsAwsjson11_deserializeDocumentLogStream(v **types.LogStream, value interface{}) error { +func awsAwsjson11_deserializeDocumentParseKeyValue(v **types.ParseKeyValue, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -15001,105 +20088,76 @@ func awsAwsjson11_deserializeDocumentLogStream(v **types.LogStream, value interf return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.LogStream + var sv *types.ParseKeyValue if *v == nil { - sv = &types.LogStream{} + sv = &types.ParseKeyValue{} } else { sv = *v } for key, value := range shape { switch key { - case "arn": + case "destination": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected Arn to be of type string, got %T instead", value) - } - sv.Arn = ptr.String(jtv) - } - - case "creationTime": - if value != nil { - jtv, ok := value.(json.Number) - if !ok { - return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) - } - i64, err := jtv.Int64() - if err != nil { - return err + return fmt.Errorf("expected DestinationField to be of type string, got %T instead", value) } - sv.CreationTime = ptr.Int64(i64) + sv.Destination = ptr.String(jtv) } - case "firstEventTimestamp": + case "fieldDelimiter": if value != nil { - jtv, ok := value.(json.Number) + jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) - } - i64, err := jtv.Int64() - if err != nil { - return err + return fmt.Errorf("expected ParserFieldDelimiter to be of type string, got %T instead", value) } - sv.FirstEventTimestamp = ptr.Int64(i64) + sv.FieldDelimiter = ptr.String(jtv) } - case "lastEventTimestamp": + case "keyPrefix": if value != nil { - jtv, ok := value.(json.Number) + jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) - } - i64, err := jtv.Int64() - if err != nil { - return err + return fmt.Errorf("expected KeyPrefix to be of type string, got %T instead", value) } - sv.LastEventTimestamp = ptr.Int64(i64) + sv.KeyPrefix = ptr.String(jtv) } - case "lastIngestionTime": + case "keyValueDelimiter": if value != nil { - jtv, ok := value.(json.Number) + jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) - } - i64, err := jtv.Int64() - if err != nil { - return err + return fmt.Errorf("expected KeyValueDelimiter to be of type string, got %T instead", value) } - sv.LastIngestionTime = ptr.Int64(i64) + sv.KeyValueDelimiter = ptr.String(jtv) } - case "logStreamName": + case "nonMatchValue": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected LogStreamName to be of type string, got %T instead", value) + return fmt.Errorf("expected NonMatchValue to be of type string, got %T instead", value) } - sv.LogStreamName = ptr.String(jtv) + sv.NonMatchValue = ptr.String(jtv) } - case "storedBytes": + case "overwriteIfExists": if value != nil { - jtv, ok := value.(json.Number) + jtv, ok := value.(bool) if !ok { - return fmt.Errorf("expected StoredBytes to be json.Number, got %T instead", value) - } - i64, err := jtv.Int64() - if err != nil { - return err + return fmt.Errorf("expected OverwriteIfExists to be of type *bool, got %T instead", value) } - sv.StoredBytes = ptr.Int64(i64) + sv.OverwriteIfExists = jtv } - case "uploadSequenceToken": + case "source": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected SequenceToken to be of type string, got %T instead", value) + return fmt.Errorf("expected Source to be of type string, got %T instead", value) } - sv.UploadSequenceToken = ptr.String(jtv) + sv.Source = ptr.String(jtv) } default: @@ -15111,7 +20169,7 @@ func awsAwsjson11_deserializeDocumentLogStream(v **types.LogStream, value interf return nil } -func awsAwsjson11_deserializeDocumentLogStreams(v *[]types.LogStream, value interface{}) error { +func awsAwsjson11_deserializeDocumentParsePostgres(v **types.ParsePostgres, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -15119,33 +20177,39 @@ func awsAwsjson11_deserializeDocumentLogStreams(v *[]types.LogStream, value inte return nil } - shape, ok := value.([]interface{}) + shape, ok := value.(map[string]interface{}) if !ok { return fmt.Errorf("unexpected JSON type %v", value) } - var cv []types.LogStream + var sv *types.ParsePostgres if *v == nil { - cv = []types.LogStream{} + sv = &types.ParsePostgres{} } else { - cv = *v + sv = *v } - for _, value := range shape { - var col types.LogStream - destAddr := &col - if err := awsAwsjson11_deserializeDocumentLogStream(&destAddr, value); err != nil { - return err - } - col = *destAddr - cv = append(cv, col) + for key, value := range shape { + switch key { + case "source": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected Source to be of type string, got %T instead", value) + } + sv.Source = ptr.String(jtv) + } + default: + _, _ = key, value + + } } - *v = cv + *v = sv return nil } -func awsAwsjson11_deserializeDocumentLowerCaseString(v **types.LowerCaseString, value interface{}) error { +func awsAwsjson11_deserializeDocumentParseRoute53(v **types.ParseRoute53, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -15158,18 +20222,22 @@ func awsAwsjson11_deserializeDocumentLowerCaseString(v **types.LowerCaseString, return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.LowerCaseString + var sv *types.ParseRoute53 if *v == nil { - sv = &types.LowerCaseString{} + sv = &types.ParseRoute53{} } else { sv = *v } for key, value := range shape { switch key { - case "withKeys": - if err := awsAwsjson11_deserializeDocumentLowerCaseStringWithKeys(&sv.WithKeys, value); err != nil { - return err + case "source": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected Source to be of type string, got %T instead", value) + } + sv.Source = ptr.String(jtv) } default: @@ -15181,7 +20249,7 @@ func awsAwsjson11_deserializeDocumentLowerCaseString(v **types.LowerCaseString, return nil } -func awsAwsjson11_deserializeDocumentLowerCaseStringWithKeys(v *[]string, value interface{}) error { +func awsAwsjson11_deserializeDocumentParseToOCSF(v **types.ParseToOCSF, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -15189,35 +20257,66 @@ func awsAwsjson11_deserializeDocumentLowerCaseStringWithKeys(v *[]string, value return nil } - shape, ok := value.([]interface{}) + shape, ok := value.(map[string]interface{}) if !ok { return fmt.Errorf("unexpected JSON type %v", value) } - var cv []string + var sv *types.ParseToOCSF if *v == nil { - cv = []string{} + sv = &types.ParseToOCSF{} } else { - cv = *v + sv = *v } - for _, value := range shape { - var col string - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected WithKey to be of type string, got %T instead", value) + for key, value := range shape { + switch key { + case "eventSource": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected EventSource to be of type string, got %T instead", value) + } + sv.EventSource = types.EventSource(jtv) } - col = jtv - } - cv = append(cv, col) + case "mappingVersion": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected MappingVersion to be of type string, got %T instead", value) + } + sv.MappingVersion = ptr.String(jtv) + } + + case "ocsfVersion": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected OCSFVersion to be of type string, got %T instead", value) + } + sv.OcsfVersion = types.OCSFVersion(jtv) + } + + case "source": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected Source to be of type string, got %T instead", value) + } + sv.Source = ptr.String(jtv) + } + + default: + _, _ = key, value + + } } - *v = cv + *v = sv return nil } -func awsAwsjson11_deserializeDocumentMalformedQueryException(v **types.MalformedQueryException, value interface{}) error { +func awsAwsjson11_deserializeDocumentParseVPC(v **types.ParseVPC, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -15230,27 +20329,22 @@ func awsAwsjson11_deserializeDocumentMalformedQueryException(v **types.Malformed return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.MalformedQueryException + var sv *types.ParseVPC if *v == nil { - sv = &types.MalformedQueryException{} + sv = &types.ParseVPC{} } else { sv = *v } for key, value := range shape { switch key { - case "message", "Message": + case "source": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected Message to be of type string, got %T instead", value) + return fmt.Errorf("expected Source to be of type string, got %T instead", value) } - sv.Message = ptr.String(jtv) - } - - case "queryCompileError": - if err := awsAwsjson11_deserializeDocumentQueryCompileError(&sv.QueryCompileError, value); err != nil { - return err + sv.Source = ptr.String(jtv) } default: @@ -15262,7 +20356,7 @@ func awsAwsjson11_deserializeDocumentMalformedQueryException(v **types.Malformed return nil } -func awsAwsjson11_deserializeDocumentMatchPatterns(v *[]string, value interface{}) error { +func awsAwsjson11_deserializeDocumentParseWAF(v **types.ParseWAF, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -15270,35 +20364,39 @@ func awsAwsjson11_deserializeDocumentMatchPatterns(v *[]string, value interface{ return nil } - shape, ok := value.([]interface{}) + shape, ok := value.(map[string]interface{}) if !ok { return fmt.Errorf("unexpected JSON type %v", value) } - var cv []string + var sv *types.ParseWAF if *v == nil { - cv = []string{} + sv = &types.ParseWAF{} } else { - cv = *v + sv = *v } - for _, value := range shape { - var col string - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected MatchPattern to be of type string, got %T instead", value) + for key, value := range shape { + switch key { + case "source": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected Source to be of type string, got %T instead", value) + } + sv.Source = ptr.String(jtv) } - col = jtv - } - cv = append(cv, col) + default: + _, _ = key, value + + } } - *v = cv + *v = sv return nil } -func awsAwsjson11_deserializeDocumentMetricFilter(v **types.MetricFilter, value interface{}) error { +func awsAwsjson11_deserializeDocumentPatternToken(v **types.PatternToken, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -15311,67 +20409,58 @@ func awsAwsjson11_deserializeDocumentMetricFilter(v **types.MetricFilter, value return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.MetricFilter + var sv *types.PatternToken if *v == nil { - sv = &types.MetricFilter{} + sv = &types.PatternToken{} } else { sv = *v } for key, value := range shape { switch key { - case "applyOnTransformedLogs": - if value != nil { - jtv, ok := value.(bool) - if !ok { - return fmt.Errorf("expected ApplyOnTransformedLogs to be of type *bool, got %T instead", value) - } - sv.ApplyOnTransformedLogs = jtv - } - - case "creationTime": + case "dynamicTokenPosition": if value != nil { jtv, ok := value.(json.Number) if !ok { - return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) + return fmt.Errorf("expected DynamicTokenPosition to be json.Number, got %T instead", value) } i64, err := jtv.Int64() if err != nil { return err } - sv.CreationTime = ptr.Int64(i64) + sv.DynamicTokenPosition = int32(i64) } - case "filterName": + case "enumerations": + if err := awsAwsjson11_deserializeDocumentEnumerations(&sv.Enumerations, value); err != nil { + return err + } + + case "inferredTokenName": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected FilterName to be of type string, got %T instead", value) + return fmt.Errorf("expected InferredTokenName to be of type string, got %T instead", value) } - sv.FilterName = ptr.String(jtv) + sv.InferredTokenName = ptr.String(jtv) } - case "filterPattern": + case "isDynamic": if value != nil { - jtv, ok := value.(string) + jtv, ok := value.(bool) if !ok { - return fmt.Errorf("expected FilterPattern to be of type string, got %T instead", value) + return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) } - sv.FilterPattern = ptr.String(jtv) + sv.IsDynamic = ptr.Bool(jtv) } - case "logGroupName": + case "tokenString": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected LogGroupName to be of type string, got %T instead", value) + return fmt.Errorf("expected TokenString to be of type string, got %T instead", value) } - sv.LogGroupName = ptr.String(jtv) - } - - case "metricTransformations": - if err := awsAwsjson11_deserializeDocumentMetricTransformations(&sv.MetricTransformations, value); err != nil { - return err + sv.TokenString = ptr.String(jtv) } default: @@ -15383,7 +20472,7 @@ func awsAwsjson11_deserializeDocumentMetricFilter(v **types.MetricFilter, value return nil } -func awsAwsjson11_deserializeDocumentMetricFilterMatches(v *[]types.MetricFilterMatchRecord, value interface{}) error { +func awsAwsjson11_deserializeDocumentPatternTokens(v *[]types.PatternToken, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -15396,17 +20485,17 @@ func awsAwsjson11_deserializeDocumentMetricFilterMatches(v *[]types.MetricFilter return fmt.Errorf("unexpected JSON type %v", value) } - var cv []types.MetricFilterMatchRecord + var cv []types.PatternToken if *v == nil { - cv = []types.MetricFilterMatchRecord{} + cv = []types.PatternToken{} } else { cv = *v } for _, value := range shape { - var col types.MetricFilterMatchRecord + var col types.PatternToken destAddr := &col - if err := awsAwsjson11_deserializeDocumentMetricFilterMatchRecord(&destAddr, value); err != nil { + if err := awsAwsjson11_deserializeDocumentPatternToken(&destAddr, value); err != nil { return err } col = *destAddr @@ -15417,7 +20506,7 @@ func awsAwsjson11_deserializeDocumentMetricFilterMatches(v *[]types.MetricFilter return nil } -func awsAwsjson11_deserializeDocumentMetricFilterMatchRecord(v **types.MetricFilterMatchRecord, value interface{}) error { +func awsAwsjson11_deserializeDocumentPolicy(v **types.Policy, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -15430,40 +20519,22 @@ func awsAwsjson11_deserializeDocumentMetricFilterMatchRecord(v **types.MetricFil return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.MetricFilterMatchRecord + var sv *types.Policy if *v == nil { - sv = &types.MetricFilterMatchRecord{} + sv = &types.Policy{} } else { sv = *v } for key, value := range shape { switch key { - case "eventMessage": + case "deliveryDestinationPolicy": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected EventMessage to be of type string, got %T instead", value) - } - sv.EventMessage = ptr.String(jtv) - } - - case "eventNumber": - if value != nil { - jtv, ok := value.(json.Number) - if !ok { - return fmt.Errorf("expected EventNumber to be json.Number, got %T instead", value) - } - i64, err := jtv.Int64() - if err != nil { - return err + return fmt.Errorf("expected DeliveryDestinationPolicy to be of type string, got %T instead", value) } - sv.EventNumber = i64 - } - - case "extractedValues": - if err := awsAwsjson11_deserializeDocumentExtractedValues(&sv.ExtractedValues, value); err != nil { - return err + sv.DeliveryDestinationPolicy = ptr.String(jtv) } default: @@ -15475,7 +20546,7 @@ func awsAwsjson11_deserializeDocumentMetricFilterMatchRecord(v **types.MetricFil return nil } -func awsAwsjson11_deserializeDocumentMetricFilters(v *[]types.MetricFilter, value interface{}) error { +func awsAwsjson11_deserializeDocumentProcessor(v **types.Processor, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -15483,173 +20554,145 @@ func awsAwsjson11_deserializeDocumentMetricFilters(v *[]types.MetricFilter, valu return nil } - shape, ok := value.([]interface{}) + shape, ok := value.(map[string]interface{}) if !ok { return fmt.Errorf("unexpected JSON type %v", value) } - var cv []types.MetricFilter + var sv *types.Processor if *v == nil { - cv = []types.MetricFilter{} + sv = &types.Processor{} } else { - cv = *v + sv = *v } - for _, value := range shape { - var col types.MetricFilter - destAddr := &col - if err := awsAwsjson11_deserializeDocumentMetricFilter(&destAddr, value); err != nil { - return err - } - col = *destAddr - cv = append(cv, col) + for key, value := range shape { + switch key { + case "addKeys": + if err := awsAwsjson11_deserializeDocumentAddKeys(&sv.AddKeys, value); err != nil { + return err + } - } - *v = cv - return nil -} + case "copyValue": + if err := awsAwsjson11_deserializeDocumentCopyValue(&sv.CopyValue, value); err != nil { + return err + } -func awsAwsjson11_deserializeDocumentMetricTransformation(v **types.MetricTransformation, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } + case "csv": + if err := awsAwsjson11_deserializeDocumentCSV(&sv.Csv, value); err != nil { + return err + } - shape, ok := value.(map[string]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } + case "dateTimeConverter": + if err := awsAwsjson11_deserializeDocumentDateTimeConverter(&sv.DateTimeConverter, value); err != nil { + return err + } - var sv *types.MetricTransformation - if *v == nil { - sv = &types.MetricTransformation{} - } else { - sv = *v - } + case "deleteKeys": + if err := awsAwsjson11_deserializeDocumentDeleteKeys(&sv.DeleteKeys, value); err != nil { + return err + } - for key, value := range shape { - switch key { - case "defaultValue": - if value != nil { - switch jtv := value.(type) { - case json.Number: - f64, err := jtv.Float64() - if err != nil { - return err - } - sv.DefaultValue = ptr.Float64(f64) + case "grok": + if err := awsAwsjson11_deserializeDocumentGrok(&sv.Grok, value); err != nil { + return err + } - case string: - var f64 float64 - switch { - case strings.EqualFold(jtv, "NaN"): - f64 = math.NaN() + case "listToMap": + if err := awsAwsjson11_deserializeDocumentListToMap(&sv.ListToMap, value); err != nil { + return err + } - case strings.EqualFold(jtv, "Infinity"): - f64 = math.Inf(1) + case "lowerCaseString": + if err := awsAwsjson11_deserializeDocumentLowerCaseString(&sv.LowerCaseString, value); err != nil { + return err + } - case strings.EqualFold(jtv, "-Infinity"): - f64 = math.Inf(-1) + case "moveKeys": + if err := awsAwsjson11_deserializeDocumentMoveKeys(&sv.MoveKeys, value); err != nil { + return err + } - default: - return fmt.Errorf("unknown JSON number value: %s", jtv) + case "parseCloudfront": + if err := awsAwsjson11_deserializeDocumentParseCloudfront(&sv.ParseCloudfront, value); err != nil { + return err + } - } - sv.DefaultValue = ptr.Float64(f64) + case "parseJSON": + if err := awsAwsjson11_deserializeDocumentParseJSON(&sv.ParseJSON, value); err != nil { + return err + } - default: - return fmt.Errorf("expected DefaultValue to be a JSON Number, got %T instead", value) + case "parseKeyValue": + if err := awsAwsjson11_deserializeDocumentParseKeyValue(&sv.ParseKeyValue, value); err != nil { + return err + } - } + case "parsePostgres": + if err := awsAwsjson11_deserializeDocumentParsePostgres(&sv.ParsePostgres, value); err != nil { + return err } - case "dimensions": - if err := awsAwsjson11_deserializeDocumentDimensions(&sv.Dimensions, value); err != nil { + case "parseRoute53": + if err := awsAwsjson11_deserializeDocumentParseRoute53(&sv.ParseRoute53, value); err != nil { return err } - case "metricName": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected MetricName to be of type string, got %T instead", value) - } - sv.MetricName = ptr.String(jtv) + case "parseToOCSF": + if err := awsAwsjson11_deserializeDocumentParseToOCSF(&sv.ParseToOCSF, value); err != nil { + return err } - case "metricNamespace": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected MetricNamespace to be of type string, got %T instead", value) - } - sv.MetricNamespace = ptr.String(jtv) + case "parseVPC": + if err := awsAwsjson11_deserializeDocumentParseVPC(&sv.ParseVPC, value); err != nil { + return err } - case "metricValue": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected MetricValue to be of type string, got %T instead", value) - } - sv.MetricValue = ptr.String(jtv) + case "parseWAF": + if err := awsAwsjson11_deserializeDocumentParseWAF(&sv.ParseWAF, value); err != nil { + return err } - case "unit": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected StandardUnit to be of type string, got %T instead", value) - } - sv.Unit = types.StandardUnit(jtv) + case "renameKeys": + if err := awsAwsjson11_deserializeDocumentRenameKeys(&sv.RenameKeys, value); err != nil { + return err } - default: - _, _ = key, value + case "splitString": + if err := awsAwsjson11_deserializeDocumentSplitString(&sv.SplitString, value); err != nil { + return err + } - } - } - *v = sv - return nil -} + case "substituteString": + if err := awsAwsjson11_deserializeDocumentSubstituteString(&sv.SubstituteString, value); err != nil { + return err + } -func awsAwsjson11_deserializeDocumentMetricTransformations(v *[]types.MetricTransformation, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } + case "trimString": + if err := awsAwsjson11_deserializeDocumentTrimString(&sv.TrimString, value); err != nil { + return err + } - shape, ok := value.([]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } + case "typeConverter": + if err := awsAwsjson11_deserializeDocumentTypeConverter(&sv.TypeConverter, value); err != nil { + return err + } - var cv []types.MetricTransformation - if *v == nil { - cv = []types.MetricTransformation{} - } else { - cv = *v - } + case "upperCaseString": + if err := awsAwsjson11_deserializeDocumentUpperCaseString(&sv.UpperCaseString, value); err != nil { + return err + } - for _, value := range shape { - var col types.MetricTransformation - destAddr := &col - if err := awsAwsjson11_deserializeDocumentMetricTransformation(&destAddr, value); err != nil { - return err - } - col = *destAddr - cv = append(cv, col) + default: + _, _ = key, value + } } - *v = cv + *v = sv return nil } -func awsAwsjson11_deserializeDocumentMoveKeyEntries(v *[]types.MoveKeyEntry, value interface{}) error { +func awsAwsjson11_deserializeDocumentProcessors(v *[]types.Processor, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -15662,17 +20705,17 @@ func awsAwsjson11_deserializeDocumentMoveKeyEntries(v *[]types.MoveKeyEntry, val return fmt.Errorf("unexpected JSON type %v", value) } - var cv []types.MoveKeyEntry + var cv []types.Processor if *v == nil { - cv = []types.MoveKeyEntry{} + cv = []types.Processor{} } else { cv = *v } for _, value := range shape { - var col types.MoveKeyEntry + var col types.Processor destAddr := &col - if err := awsAwsjson11_deserializeDocumentMoveKeyEntry(&destAddr, value); err != nil { + if err := awsAwsjson11_deserializeDocumentProcessor(&destAddr, value); err != nil { return err } col = *destAddr @@ -15683,7 +20726,7 @@ func awsAwsjson11_deserializeDocumentMoveKeyEntries(v *[]types.MoveKeyEntry, val return nil } -func awsAwsjson11_deserializeDocumentMoveKeyEntry(v **types.MoveKeyEntry, value interface{}) error { +func awsAwsjson11_deserializeDocumentQueryCompileError(v **types.QueryCompileError, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -15696,40 +20739,27 @@ func awsAwsjson11_deserializeDocumentMoveKeyEntry(v **types.MoveKeyEntry, value return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.MoveKeyEntry + var sv *types.QueryCompileError if *v == nil { - sv = &types.MoveKeyEntry{} + sv = &types.QueryCompileError{} } else { sv = *v } for key, value := range shape { switch key { - case "overwriteIfExists": - if value != nil { - jtv, ok := value.(bool) - if !ok { - return fmt.Errorf("expected OverwriteIfExists to be of type *bool, got %T instead", value) - } - sv.OverwriteIfExists = jtv - } - - case "source": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected Source to be of type string, got %T instead", value) - } - sv.Source = ptr.String(jtv) + case "location": + if err := awsAwsjson11_deserializeDocumentQueryCompileErrorLocation(&sv.Location, value); err != nil { + return err } - case "target": + case "message": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected Target to be of type string, got %T instead", value) + return fmt.Errorf("expected Message to be of type string, got %T instead", value) } - sv.Target = ptr.String(jtv) + sv.Message = ptr.String(jtv) } default: @@ -15741,7 +20771,7 @@ func awsAwsjson11_deserializeDocumentMoveKeyEntry(v **types.MoveKeyEntry, value return nil } -func awsAwsjson11_deserializeDocumentMoveKeys(v **types.MoveKeys, value interface{}) error { +func awsAwsjson11_deserializeDocumentQueryCompileErrorLocation(v **types.QueryCompileErrorLocation, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -15754,18 +20784,39 @@ func awsAwsjson11_deserializeDocumentMoveKeys(v **types.MoveKeys, value interfac return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.MoveKeys + var sv *types.QueryCompileErrorLocation if *v == nil { - sv = &types.MoveKeys{} + sv = &types.QueryCompileErrorLocation{} } else { sv = *v } for key, value := range shape { switch key { - case "entries": - if err := awsAwsjson11_deserializeDocumentMoveKeyEntries(&sv.Entries, value); err != nil { - return err + case "endCharOffset": + if value != nil { + jtv, ok := value.(json.Number) + if !ok { + return fmt.Errorf("expected QueryCharOffset to be json.Number, got %T instead", value) + } + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.EndCharOffset = ptr.Int32(int32(i64)) + } + + case "startCharOffset": + if value != nil { + jtv, ok := value.(json.Number) + if !ok { + return fmt.Errorf("expected QueryCharOffset to be json.Number, got %T instead", value) + } + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.StartCharOffset = ptr.Int32(int32(i64)) } default: @@ -15777,7 +20828,7 @@ func awsAwsjson11_deserializeDocumentMoveKeys(v **types.MoveKeys, value interfac return nil } -func awsAwsjson11_deserializeDocumentOpenSearchApplication(v **types.OpenSearchApplication, value interface{}) error { +func awsAwsjson11_deserializeDocumentQueryDefinition(v **types.QueryDefinition, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -15790,45 +20841,72 @@ func awsAwsjson11_deserializeDocumentOpenSearchApplication(v **types.OpenSearchA return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.OpenSearchApplication + var sv *types.QueryDefinition if *v == nil { - sv = &types.OpenSearchApplication{} + sv = &types.QueryDefinition{} } else { sv = *v } for key, value := range shape { switch key { - case "applicationArn": + case "lastModified": + if value != nil { + jtv, ok := value.(json.Number) + if !ok { + return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) + } + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.LastModified = ptr.Int64(i64) + } + + case "logGroupNames": + if err := awsAwsjson11_deserializeDocumentLogGroupNames(&sv.LogGroupNames, value); err != nil { + return err + } + + case "name": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected Arn to be of type string, got %T instead", value) + return fmt.Errorf("expected QueryDefinitionName to be of type string, got %T instead", value) } - sv.ApplicationArn = ptr.String(jtv) + sv.Name = ptr.String(jtv) } - case "applicationEndpoint": + case "parameters": + if err := awsAwsjson11_deserializeDocumentQueryParameterList(&sv.Parameters, value); err != nil { + return err + } + + case "queryDefinitionId": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected OpenSearchApplicationEndpoint to be of type string, got %T instead", value) + return fmt.Errorf("expected QueryId to be of type string, got %T instead", value) } - sv.ApplicationEndpoint = ptr.String(jtv) + sv.QueryDefinitionId = ptr.String(jtv) } - case "applicationId": + case "queryLanguage": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected OpenSearchApplicationId to be of type string, got %T instead", value) + return fmt.Errorf("expected QueryLanguage to be of type string, got %T instead", value) } - sv.ApplicationId = ptr.String(jtv) + sv.QueryLanguage = types.QueryLanguage(jtv) } - case "status": - if err := awsAwsjson11_deserializeDocumentOpenSearchResourceStatus(&sv.Status, value); err != nil { - return err + case "queryString": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected QueryDefinitionString to be of type string, got %T instead", value) + } + sv.QueryString = ptr.String(jtv) } default: @@ -15840,7 +20918,41 @@ func awsAwsjson11_deserializeDocumentOpenSearchApplication(v **types.OpenSearchA return nil } -func awsAwsjson11_deserializeDocumentOpenSearchCollection(v **types.OpenSearchCollection, value interface{}) error { +func awsAwsjson11_deserializeDocumentQueryDefinitionList(v *[]types.QueryDefinition, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.([]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var cv []types.QueryDefinition + if *v == nil { + cv = []types.QueryDefinition{} + } else { + cv = *v + } + + for _, value := range shape { + var col types.QueryDefinition + destAddr := &col + if err := awsAwsjson11_deserializeDocumentQueryDefinition(&destAddr, value); err != nil { + return err + } + col = *destAddr + cv = append(cv, col) + + } + *v = cv + return nil +} + +func awsAwsjson11_deserializeDocumentQueryInfo(v **types.QueryInfo, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -15853,36 +20965,71 @@ func awsAwsjson11_deserializeDocumentOpenSearchCollection(v **types.OpenSearchCo return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.OpenSearchCollection + var sv *types.QueryInfo if *v == nil { - sv = &types.OpenSearchCollection{} + sv = &types.QueryInfo{} } else { sv = *v } for key, value := range shape { switch key { - case "collectionArn": + case "createTime": + if value != nil { + jtv, ok := value.(json.Number) + if !ok { + return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) + } + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.CreateTime = ptr.Int64(i64) + } + + case "logGroupName": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected Arn to be of type string, got %T instead", value) + return fmt.Errorf("expected LogGroupName to be of type string, got %T instead", value) } - sv.CollectionArn = ptr.String(jtv) + sv.LogGroupName = ptr.String(jtv) } - case "collectionEndpoint": + case "queryId": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected OpenSearchCollectionEndpoint to be of type string, got %T instead", value) + return fmt.Errorf("expected QueryId to be of type string, got %T instead", value) } - sv.CollectionEndpoint = ptr.String(jtv) + sv.QueryId = ptr.String(jtv) + } + + case "queryLanguage": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected QueryLanguage to be of type string, got %T instead", value) + } + sv.QueryLanguage = types.QueryLanguage(jtv) + } + + case "queryString": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected QueryString to be of type string, got %T instead", value) + } + sv.QueryString = ptr.String(jtv) } case "status": - if err := awsAwsjson11_deserializeDocumentOpenSearchResourceStatus(&sv.Status, value); err != nil { - return err + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected QueryStatus to be of type string, got %T instead", value) + } + sv.Status = types.QueryStatus(jtv) } default: @@ -15894,7 +21041,41 @@ func awsAwsjson11_deserializeDocumentOpenSearchCollection(v **types.OpenSearchCo return nil } -func awsAwsjson11_deserializeDocumentOpenSearchDataAccessPolicy(v **types.OpenSearchDataAccessPolicy, value interface{}) error { +func awsAwsjson11_deserializeDocumentQueryInfoList(v *[]types.QueryInfo, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.([]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var cv []types.QueryInfo + if *v == nil { + cv = []types.QueryInfo{} + } else { + cv = *v + } + + for _, value := range shape { + var col types.QueryInfo + destAddr := &col + if err := awsAwsjson11_deserializeDocumentQueryInfo(&destAddr, value); err != nil { + return err + } + col = *destAddr + cv = append(cv, col) + + } + *v = cv + return nil +} + +func awsAwsjson11_deserializeDocumentQueryParameter(v **types.QueryParameter, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -15907,27 +21088,40 @@ func awsAwsjson11_deserializeDocumentOpenSearchDataAccessPolicy(v **types.OpenSe return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.OpenSearchDataAccessPolicy + var sv *types.QueryParameter if *v == nil { - sv = &types.OpenSearchDataAccessPolicy{} + sv = &types.QueryParameter{} } else { sv = *v } for key, value := range shape { switch key { - case "policyName": + case "defaultValue": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected OpenSearchPolicyName to be of type string, got %T instead", value) + return fmt.Errorf("expected QueryParameterDefaultValue to be of type string, got %T instead", value) } - sv.PolicyName = ptr.String(jtv) + sv.DefaultValue = ptr.String(jtv) } - case "status": - if err := awsAwsjson11_deserializeDocumentOpenSearchResourceStatus(&sv.Status, value); err != nil { - return err + case "description": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected QueryParameterDescription to be of type string, got %T instead", value) + } + sv.Description = ptr.String(jtv) + } + + case "name": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected QueryParameterName to be of type string, got %T instead", value) + } + sv.Name = ptr.String(jtv) } default: @@ -15939,7 +21133,7 @@ func awsAwsjson11_deserializeDocumentOpenSearchDataAccessPolicy(v **types.OpenSe return nil } -func awsAwsjson11_deserializeDocumentOpenSearchDataSource(v **types.OpenSearchDataSource, value interface{}) error { +func awsAwsjson11_deserializeDocumentQueryParameterList(v *[]types.QueryParameter, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -15947,44 +21141,33 @@ func awsAwsjson11_deserializeDocumentOpenSearchDataSource(v **types.OpenSearchDa return nil } - shape, ok := value.(map[string]interface{}) + shape, ok := value.([]interface{}) if !ok { return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.OpenSearchDataSource + var cv []types.QueryParameter if *v == nil { - sv = &types.OpenSearchDataSource{} + cv = []types.QueryParameter{} } else { - sv = *v + cv = *v } - for key, value := range shape { - switch key { - case "dataSourceName": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected OpenSearchDataSourceName to be of type string, got %T instead", value) - } - sv.DataSourceName = ptr.String(jtv) - } - - case "status": - if err := awsAwsjson11_deserializeDocumentOpenSearchResourceStatus(&sv.Status, value); err != nil { - return err - } - - default: - _, _ = key, value - + for _, value := range shape { + var col types.QueryParameter + destAddr := &col + if err := awsAwsjson11_deserializeDocumentQueryParameter(&destAddr, value); err != nil { + return err } + col = *destAddr + cv = append(cv, col) + } - *v = sv + *v = cv return nil } -func awsAwsjson11_deserializeDocumentOpenSearchEncryptionPolicy(v **types.OpenSearchEncryptionPolicy, value interface{}) error { +func awsAwsjson11_deserializeDocumentQueryResults(v *[][]types.ResultField, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -15992,44 +21175,31 @@ func awsAwsjson11_deserializeDocumentOpenSearchEncryptionPolicy(v **types.OpenSe return nil } - shape, ok := value.(map[string]interface{}) + shape, ok := value.([]interface{}) if !ok { return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.OpenSearchEncryptionPolicy + var cv [][]types.ResultField if *v == nil { - sv = &types.OpenSearchEncryptionPolicy{} + cv = [][]types.ResultField{} } else { - sv = *v + cv = *v } - for key, value := range shape { - switch key { - case "policyName": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected OpenSearchPolicyName to be of type string, got %T instead", value) - } - sv.PolicyName = ptr.String(jtv) - } - - case "status": - if err := awsAwsjson11_deserializeDocumentOpenSearchResourceStatus(&sv.Status, value); err != nil { - return err - } - - default: - _, _ = key, value - + for _, value := range shape { + var col []types.ResultField + if err := awsAwsjson11_deserializeDocumentResultRows(&col, value); err != nil { + return err } + cv = append(cv, col) + } - *v = sv + *v = cv return nil } -func awsAwsjson11_deserializeDocumentOpenSearchIntegrationDetails(v **types.OpenSearchIntegrationDetails, value interface{}) error { +func awsAwsjson11_deserializeDocumentQueryStatistics(v **types.QueryStatistics, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -16042,143 +21212,217 @@ func awsAwsjson11_deserializeDocumentOpenSearchIntegrationDetails(v **types.Open return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.OpenSearchIntegrationDetails + var sv *types.QueryStatistics if *v == nil { - sv = &types.OpenSearchIntegrationDetails{} + sv = &types.QueryStatistics{} } else { sv = *v } for key, value := range shape { switch key { - case "accessPolicy": - if err := awsAwsjson11_deserializeDocumentOpenSearchDataAccessPolicy(&sv.AccessPolicy, value); err != nil { - return err - } + case "bytesScanned": + if value != nil { + switch jtv := value.(type) { + case json.Number: + f64, err := jtv.Float64() + if err != nil { + return err + } + sv.BytesScanned = f64 - case "application": - if err := awsAwsjson11_deserializeDocumentOpenSearchApplication(&sv.Application, value); err != nil { - return err - } + case string: + var f64 float64 + switch { + case strings.EqualFold(jtv, "NaN"): + f64 = math.NaN() - case "collection": - if err := awsAwsjson11_deserializeDocumentOpenSearchCollection(&sv.Collection, value); err != nil { - return err - } + case strings.EqualFold(jtv, "Infinity"): + f64 = math.Inf(1) - case "dataSource": - if err := awsAwsjson11_deserializeDocumentOpenSearchDataSource(&sv.DataSource, value); err != nil { - return err + case strings.EqualFold(jtv, "-Infinity"): + f64 = math.Inf(-1) + + default: + return fmt.Errorf("unknown JSON number value: %s", jtv) + + } + sv.BytesScanned = f64 + + default: + return fmt.Errorf("expected StatsValue to be a JSON Number, got %T instead", value) + + } } - case "encryptionPolicy": - if err := awsAwsjson11_deserializeDocumentOpenSearchEncryptionPolicy(&sv.EncryptionPolicy, value); err != nil { - return err + case "estimatedBytesSkipped": + if value != nil { + switch jtv := value.(type) { + case json.Number: + f64, err := jtv.Float64() + if err != nil { + return err + } + sv.EstimatedBytesSkipped = f64 + + case string: + var f64 float64 + switch { + case strings.EqualFold(jtv, "NaN"): + f64 = math.NaN() + + case strings.EqualFold(jtv, "Infinity"): + f64 = math.Inf(1) + + case strings.EqualFold(jtv, "-Infinity"): + f64 = math.Inf(-1) + + default: + return fmt.Errorf("unknown JSON number value: %s", jtv) + + } + sv.EstimatedBytesSkipped = f64 + + default: + return fmt.Errorf("expected StatsValue to be a JSON Number, got %T instead", value) + + } } - case "lifecyclePolicy": - if err := awsAwsjson11_deserializeDocumentOpenSearchLifecyclePolicy(&sv.LifecyclePolicy, value); err != nil { - return err + case "estimatedRecordsSkipped": + if value != nil { + switch jtv := value.(type) { + case json.Number: + f64, err := jtv.Float64() + if err != nil { + return err + } + sv.EstimatedRecordsSkipped = f64 + + case string: + var f64 float64 + switch { + case strings.EqualFold(jtv, "NaN"): + f64 = math.NaN() + + case strings.EqualFold(jtv, "Infinity"): + f64 = math.Inf(1) + + case strings.EqualFold(jtv, "-Infinity"): + f64 = math.Inf(-1) + + default: + return fmt.Errorf("unknown JSON number value: %s", jtv) + + } + sv.EstimatedRecordsSkipped = f64 + + default: + return fmt.Errorf("expected StatsValue to be a JSON Number, got %T instead", value) + + } } - case "networkPolicy": - if err := awsAwsjson11_deserializeDocumentOpenSearchNetworkPolicy(&sv.NetworkPolicy, value); err != nil { - return err + case "logGroupsScanned": + if value != nil { + switch jtv := value.(type) { + case json.Number: + f64, err := jtv.Float64() + if err != nil { + return err + } + sv.LogGroupsScanned = f64 + + case string: + var f64 float64 + switch { + case strings.EqualFold(jtv, "NaN"): + f64 = math.NaN() + + case strings.EqualFold(jtv, "Infinity"): + f64 = math.Inf(1) + + case strings.EqualFold(jtv, "-Infinity"): + f64 = math.Inf(-1) + + default: + return fmt.Errorf("unknown JSON number value: %s", jtv) + + } + sv.LogGroupsScanned = f64 + + default: + return fmt.Errorf("expected StatsValue to be a JSON Number, got %T instead", value) + + } } - case "workspace": - if err := awsAwsjson11_deserializeDocumentOpenSearchWorkspace(&sv.Workspace, value); err != nil { - return err - } + case "recordsMatched": + if value != nil { + switch jtv := value.(type) { + case json.Number: + f64, err := jtv.Float64() + if err != nil { + return err + } + sv.RecordsMatched = f64 + + case string: + var f64 float64 + switch { + case strings.EqualFold(jtv, "NaN"): + f64 = math.NaN() - default: - _, _ = key, value + case strings.EqualFold(jtv, "Infinity"): + f64 = math.Inf(1) - } - } - *v = sv - return nil -} + case strings.EqualFold(jtv, "-Infinity"): + f64 = math.Inf(-1) -func awsAwsjson11_deserializeDocumentOpenSearchLifecyclePolicy(v **types.OpenSearchLifecyclePolicy, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } + default: + return fmt.Errorf("unknown JSON number value: %s", jtv) - shape, ok := value.(map[string]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } + } + sv.RecordsMatched = f64 - var sv *types.OpenSearchLifecyclePolicy - if *v == nil { - sv = &types.OpenSearchLifecyclePolicy{} - } else { - sv = *v - } + default: + return fmt.Errorf("expected StatsValue to be a JSON Number, got %T instead", value) - for key, value := range shape { - switch key { - case "policyName": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected OpenSearchPolicyName to be of type string, got %T instead", value) } - sv.PolicyName = ptr.String(jtv) } - case "status": - if err := awsAwsjson11_deserializeDocumentOpenSearchResourceStatus(&sv.Status, value); err != nil { - return err - } + case "recordsScanned": + if value != nil { + switch jtv := value.(type) { + case json.Number: + f64, err := jtv.Float64() + if err != nil { + return err + } + sv.RecordsScanned = f64 - default: - _, _ = key, value + case string: + var f64 float64 + switch { + case strings.EqualFold(jtv, "NaN"): + f64 = math.NaN() - } - } - *v = sv - return nil -} + case strings.EqualFold(jtv, "Infinity"): + f64 = math.Inf(1) -func awsAwsjson11_deserializeDocumentOpenSearchNetworkPolicy(v **types.OpenSearchNetworkPolicy, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } + case strings.EqualFold(jtv, "-Infinity"): + f64 = math.Inf(-1) - shape, ok := value.(map[string]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } + default: + return fmt.Errorf("unknown JSON number value: %s", jtv) - var sv *types.OpenSearchNetworkPolicy - if *v == nil { - sv = &types.OpenSearchNetworkPolicy{} - } else { - sv = *v - } + } + sv.RecordsScanned = f64 - for key, value := range shape { - switch key { - case "policyName": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected OpenSearchPolicyName to be of type string, got %T instead", value) - } - sv.PolicyName = ptr.String(jtv) - } + default: + return fmt.Errorf("expected StatsValue to be a JSON Number, got %T instead", value) - case "status": - if err := awsAwsjson11_deserializeDocumentOpenSearchResourceStatus(&sv.Status, value); err != nil { - return err + } } default: @@ -16190,7 +21434,7 @@ func awsAwsjson11_deserializeDocumentOpenSearchNetworkPolicy(v **types.OpenSearc return nil } -func awsAwsjson11_deserializeDocumentOpenSearchResourceStatus(v **types.OpenSearchResourceStatus, value interface{}) error { +func awsAwsjson11_deserializeDocumentRecordField(v **types.RecordField, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -16203,31 +21447,31 @@ func awsAwsjson11_deserializeDocumentOpenSearchResourceStatus(v **types.OpenSear return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.OpenSearchResourceStatus + var sv *types.RecordField if *v == nil { - sv = &types.OpenSearchResourceStatus{} + sv = &types.RecordField{} } else { sv = *v } for key, value := range shape { switch key { - case "status": + case "mandatory": if value != nil { - jtv, ok := value.(string) + jtv, ok := value.(bool) if !ok { - return fmt.Errorf("expected OpenSearchResourceStatusType to be of type string, got %T instead", value) + return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) } - sv.Status = types.OpenSearchResourceStatusType(jtv) + sv.Mandatory = ptr.Bool(jtv) } - case "statusMessage": + case "name": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected IntegrationStatusMessage to be of type string, got %T instead", value) + return fmt.Errorf("expected FieldHeader to be of type string, got %T instead", value) } - sv.StatusMessage = ptr.String(jtv) + sv.Name = ptr.String(jtv) } default: @@ -16239,7 +21483,7 @@ func awsAwsjson11_deserializeDocumentOpenSearchResourceStatus(v **types.OpenSear return nil } -func awsAwsjson11_deserializeDocumentOpenSearchWorkspace(v **types.OpenSearchWorkspace, value interface{}) error { +func awsAwsjson11_deserializeDocumentRecordFields(v *[]string, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -16247,44 +21491,35 @@ func awsAwsjson11_deserializeDocumentOpenSearchWorkspace(v **types.OpenSearchWor return nil } - shape, ok := value.(map[string]interface{}) + shape, ok := value.([]interface{}) if !ok { return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.OpenSearchWorkspace + var cv []string if *v == nil { - sv = &types.OpenSearchWorkspace{} + cv = []string{} } else { - sv = *v + cv = *v } - for key, value := range shape { - switch key { - case "status": - if err := awsAwsjson11_deserializeDocumentOpenSearchResourceStatus(&sv.Status, value); err != nil { - return err - } - - case "workspaceId": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected OpenSearchWorkspaceId to be of type string, got %T instead", value) - } - sv.WorkspaceId = ptr.String(jtv) + for _, value := range shape { + var col string + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected FieldHeader to be of type string, got %T instead", value) } - - default: - _, _ = key, value - + col = jtv } + cv = append(cv, col) + } - *v = sv + *v = cv return nil } -func awsAwsjson11_deserializeDocumentOperationAbortedException(v **types.OperationAbortedException, value interface{}) error { +func awsAwsjson11_deserializeDocumentRejectedEntityInfo(v **types.RejectedEntityInfo, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -16297,22 +21532,22 @@ func awsAwsjson11_deserializeDocumentOperationAbortedException(v **types.Operati return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.OperationAbortedException + var sv *types.RejectedEntityInfo if *v == nil { - sv = &types.OperationAbortedException{} + sv = &types.RejectedEntityInfo{} } else { sv = *v } for key, value := range shape { switch key { - case "message", "Message": + case "errorType": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected Message to be of type string, got %T instead", value) + return fmt.Errorf("expected EntityRejectionErrorType to be of type string, got %T instead", value) } - sv.Message = ptr.String(jtv) + sv.ErrorType = types.EntityRejectionErrorType(jtv) } default: @@ -16324,43 +21559,7 @@ func awsAwsjson11_deserializeDocumentOperationAbortedException(v **types.Operati return nil } -func awsAwsjson11_deserializeDocumentOutputFormats(v *[]types.OutputFormat, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.([]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } - - var cv []types.OutputFormat - if *v == nil { - cv = []types.OutputFormat{} - } else { - cv = *v - } - - for _, value := range shape { - var col types.OutputFormat - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected OutputFormat to be of type string, got %T instead", value) - } - col = types.OutputFormat(jtv) - } - cv = append(cv, col) - - } - *v = cv - return nil -} - -func awsAwsjson11_deserializeDocumentOutputLogEvent(v **types.OutputLogEvent, value interface{}) error { +func awsAwsjson11_deserializeDocumentRejectedLogEventsInfo(v **types.RejectedLogEventsInfo, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -16373,48 +21572,52 @@ func awsAwsjson11_deserializeDocumentOutputLogEvent(v **types.OutputLogEvent, va return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.OutputLogEvent + var sv *types.RejectedLogEventsInfo if *v == nil { - sv = &types.OutputLogEvent{} + sv = &types.RejectedLogEventsInfo{} } else { sv = *v } for key, value := range shape { switch key { - case "ingestionTime": + case "expiredLogEventEndIndex": if value != nil { jtv, ok := value.(json.Number) if !ok { - return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) + return fmt.Errorf("expected LogEventIndex to be json.Number, got %T instead", value) } i64, err := jtv.Int64() if err != nil { return err } - sv.IngestionTime = ptr.Int64(i64) + sv.ExpiredLogEventEndIndex = ptr.Int32(int32(i64)) } - case "message": + case "tooNewLogEventStartIndex": if value != nil { - jtv, ok := value.(string) + jtv, ok := value.(json.Number) if !ok { - return fmt.Errorf("expected EventMessage to be of type string, got %T instead", value) + return fmt.Errorf("expected LogEventIndex to be json.Number, got %T instead", value) } - sv.Message = ptr.String(jtv) + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.TooNewLogEventStartIndex = ptr.Int32(int32(i64)) } - case "timestamp": + case "tooOldLogEventEndIndex": if value != nil { jtv, ok := value.(json.Number) if !ok { - return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) + return fmt.Errorf("expected LogEventIndex to be json.Number, got %T instead", value) } i64, err := jtv.Int64() if err != nil { return err } - sv.Timestamp = ptr.Int64(i64) + sv.TooOldLogEventEndIndex = ptr.Int32(int32(i64)) } default: @@ -16426,7 +21629,7 @@ func awsAwsjson11_deserializeDocumentOutputLogEvent(v **types.OutputLogEvent, va return nil } -func awsAwsjson11_deserializeDocumentOutputLogEvents(v *[]types.OutputLogEvent, value interface{}) error { +func awsAwsjson11_deserializeDocumentRenameKeyEntries(v *[]types.RenameKeyEntry, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -16439,17 +21642,17 @@ func awsAwsjson11_deserializeDocumentOutputLogEvents(v *[]types.OutputLogEvent, return fmt.Errorf("unexpected JSON type %v", value) } - var cv []types.OutputLogEvent + var cv []types.RenameKeyEntry if *v == nil { - cv = []types.OutputLogEvent{} + cv = []types.RenameKeyEntry{} } else { cv = *v } for _, value := range shape { - var col types.OutputLogEvent + var col types.RenameKeyEntry destAddr := &col - if err := awsAwsjson11_deserializeDocumentOutputLogEvent(&destAddr, value); err != nil { + if err := awsAwsjson11_deserializeDocumentRenameKeyEntry(&destAddr, value); err != nil { return err } col = *destAddr @@ -16460,7 +21663,7 @@ func awsAwsjson11_deserializeDocumentOutputLogEvents(v *[]types.OutputLogEvent, return nil } -func awsAwsjson11_deserializeDocumentParseCloudfront(v **types.ParseCloudfront, value interface{}) error { +func awsAwsjson11_deserializeDocumentRenameKeyEntry(v **types.RenameKeyEntry, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -16473,22 +21676,40 @@ func awsAwsjson11_deserializeDocumentParseCloudfront(v **types.ParseCloudfront, return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.ParseCloudfront + var sv *types.RenameKeyEntry if *v == nil { - sv = &types.ParseCloudfront{} + sv = &types.RenameKeyEntry{} } else { sv = *v } for key, value := range shape { switch key { - case "source": + case "key": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected Source to be of type string, got %T instead", value) + return fmt.Errorf("expected Key to be of type string, got %T instead", value) } - sv.Source = ptr.String(jtv) + sv.Key = ptr.String(jtv) + } + + case "overwriteIfExists": + if value != nil { + jtv, ok := value.(bool) + if !ok { + return fmt.Errorf("expected OverwriteIfExists to be of type *bool, got %T instead", value) + } + sv.OverwriteIfExists = jtv + } + + case "renameTo": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected RenameTo to be of type string, got %T instead", value) + } + sv.RenameTo = ptr.String(jtv) } default: @@ -16500,7 +21721,7 @@ func awsAwsjson11_deserializeDocumentParseCloudfront(v **types.ParseCloudfront, return nil } -func awsAwsjson11_deserializeDocumentParseJSON(v **types.ParseJSON, value interface{}) error { +func awsAwsjson11_deserializeDocumentRenameKeys(v **types.RenameKeys, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -16513,31 +21734,18 @@ func awsAwsjson11_deserializeDocumentParseJSON(v **types.ParseJSON, value interf return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.ParseJSON + var sv *types.RenameKeys if *v == nil { - sv = &types.ParseJSON{} + sv = &types.RenameKeys{} } else { sv = *v } for key, value := range shape { switch key { - case "destination": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected DestinationField to be of type string, got %T instead", value) - } - sv.Destination = ptr.String(jtv) - } - - case "source": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected Source to be of type string, got %T instead", value) - } - sv.Source = ptr.String(jtv) + case "entries": + if err := awsAwsjson11_deserializeDocumentRenameKeyEntries(&sv.Entries, value); err != nil { + return err } default: @@ -16549,7 +21757,7 @@ func awsAwsjson11_deserializeDocumentParseJSON(v **types.ParseJSON, value interf return nil } -func awsAwsjson11_deserializeDocumentParseKeyValue(v **types.ParseKeyValue, value interface{}) error { +func awsAwsjson11_deserializeDocumentResourceAlreadyExistsException(v **types.ResourceAlreadyExistsException, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -16562,88 +21770,70 @@ func awsAwsjson11_deserializeDocumentParseKeyValue(v **types.ParseKeyValue, valu return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.ParseKeyValue + var sv *types.ResourceAlreadyExistsException if *v == nil { - sv = &types.ParseKeyValue{} + sv = &types.ResourceAlreadyExistsException{} } else { sv = *v } for key, value := range shape { switch key { - case "destination": + case "message", "Message": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected DestinationField to be of type string, got %T instead", value) + return fmt.Errorf("expected Message to be of type string, got %T instead", value) } - sv.Destination = ptr.String(jtv) + sv.Message = ptr.String(jtv) } - case "fieldDelimiter": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected ParserFieldDelimiter to be of type string, got %T instead", value) - } - sv.FieldDelimiter = ptr.String(jtv) - } + default: + _, _ = key, value - case "keyPrefix": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected KeyPrefix to be of type string, got %T instead", value) - } - sv.KeyPrefix = ptr.String(jtv) - } + } + } + *v = sv + return nil +} - case "keyValueDelimiter": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected KeyValueDelimiter to be of type string, got %T instead", value) - } - sv.KeyValueDelimiter = ptr.String(jtv) - } +func awsAwsjson11_deserializeDocumentResourceArns(v *[]string, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } - case "nonMatchValue": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected NonMatchValue to be of type string, got %T instead", value) - } - sv.NonMatchValue = ptr.String(jtv) - } + shape, ok := value.([]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } - case "overwriteIfExists": - if value != nil { - jtv, ok := value.(bool) - if !ok { - return fmt.Errorf("expected OverwriteIfExists to be of type *bool, got %T instead", value) - } - sv.OverwriteIfExists = jtv - } + var cv []string + if *v == nil { + cv = []string{} + } else { + cv = *v + } - case "source": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected Source to be of type string, got %T instead", value) - } - sv.Source = ptr.String(jtv) + for _, value := range shape { + var col string + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected Arn to be of type string, got %T instead", value) } - - default: - _, _ = key, value - + col = jtv } + cv = append(cv, col) + } - *v = sv + *v = cv return nil } -func awsAwsjson11_deserializeDocumentParsePostgres(v **types.ParsePostgres, value interface{}) error { +func awsAwsjson11_deserializeDocumentResourceNotFoundException(v **types.ResourceNotFoundException, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -16656,22 +21846,22 @@ func awsAwsjson11_deserializeDocumentParsePostgres(v **types.ParsePostgres, valu return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.ParsePostgres + var sv *types.ResourceNotFoundException if *v == nil { - sv = &types.ParsePostgres{} + sv = &types.ResourceNotFoundException{} } else { sv = *v } for key, value := range shape { switch key { - case "source": + case "message", "Message": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected Source to be of type string, got %T instead", value) + return fmt.Errorf("expected Message to be of type string, got %T instead", value) } - sv.Source = ptr.String(jtv) + sv.Message = ptr.String(jtv) } default: @@ -16683,7 +21873,41 @@ func awsAwsjson11_deserializeDocumentParsePostgres(v **types.ParsePostgres, valu return nil } -func awsAwsjson11_deserializeDocumentParseRoute53(v **types.ParseRoute53, value interface{}) error { +func awsAwsjson11_deserializeDocumentResourcePolicies(v *[]types.ResourcePolicy, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.([]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var cv []types.ResourcePolicy + if *v == nil { + cv = []types.ResourcePolicy{} + } else { + cv = *v + } + + for _, value := range shape { + var col types.ResourcePolicy + destAddr := &col + if err := awsAwsjson11_deserializeDocumentResourcePolicy(&destAddr, value); err != nil { + return err + } + col = *destAddr + cv = append(cv, col) + + } + *v = cv + return nil +} + +func awsAwsjson11_deserializeDocumentResourcePolicy(v **types.ResourcePolicy, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -16696,22 +21920,71 @@ func awsAwsjson11_deserializeDocumentParseRoute53(v **types.ParseRoute53, value return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.ParseRoute53 + var sv *types.ResourcePolicy if *v == nil { - sv = &types.ParseRoute53{} + sv = &types.ResourcePolicy{} } else { sv = *v } - for key, value := range shape { - switch key { - case "source": + for key, value := range shape { + switch key { + case "lastUpdatedTime": + if value != nil { + jtv, ok := value.(json.Number) + if !ok { + return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) + } + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.LastUpdatedTime = ptr.Int64(i64) + } + + case "policyDocument": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected PolicyDocument to be of type string, got %T instead", value) + } + sv.PolicyDocument = ptr.String(jtv) + } + + case "policyName": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected PolicyName to be of type string, got %T instead", value) + } + sv.PolicyName = ptr.String(jtv) + } + + case "policyScope": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected PolicyScope to be of type string, got %T instead", value) + } + sv.PolicyScope = types.PolicyScope(jtv) + } + + case "resourceArn": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected Source to be of type string, got %T instead", value) + return fmt.Errorf("expected Arn to be of type string, got %T instead", value) } - sv.Source = ptr.String(jtv) + sv.ResourceArn = ptr.String(jtv) + } + + case "revisionId": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected ExpectedRevisionId to be of type string, got %T instead", value) + } + sv.RevisionId = ptr.String(jtv) } default: @@ -16723,7 +21996,7 @@ func awsAwsjson11_deserializeDocumentParseRoute53(v **types.ParseRoute53, value return nil } -func awsAwsjson11_deserializeDocumentParseVPC(v **types.ParseVPC, value interface{}) error { +func awsAwsjson11_deserializeDocumentResultField(v **types.ResultField, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -16736,22 +22009,31 @@ func awsAwsjson11_deserializeDocumentParseVPC(v **types.ParseVPC, value interfac return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.ParseVPC + var sv *types.ResultField if *v == nil { - sv = &types.ParseVPC{} + sv = &types.ResultField{} } else { sv = *v } for key, value := range shape { switch key { - case "source": + case "field": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected Source to be of type string, got %T instead", value) + return fmt.Errorf("expected Field to be of type string, got %T instead", value) } - sv.Source = ptr.String(jtv) + sv.Field = ptr.String(jtv) + } + + case "value": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected Value to be of type string, got %T instead", value) + } + sv.Value = ptr.String(jtv) } default: @@ -16763,7 +22045,7 @@ func awsAwsjson11_deserializeDocumentParseVPC(v **types.ParseVPC, value interfac return nil } -func awsAwsjson11_deserializeDocumentParseWAF(v **types.ParseWAF, value interface{}) error { +func awsAwsjson11_deserializeDocumentResultRows(v *[]types.ResultField, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -16771,39 +22053,33 @@ func awsAwsjson11_deserializeDocumentParseWAF(v **types.ParseWAF, value interfac return nil } - shape, ok := value.(map[string]interface{}) + shape, ok := value.([]interface{}) if !ok { return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.ParseWAF + var cv []types.ResultField if *v == nil { - sv = &types.ParseWAF{} + cv = []types.ResultField{} } else { - sv = *v + cv = *v } - for key, value := range shape { - switch key { - case "source": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected Source to be of type string, got %T instead", value) - } - sv.Source = ptr.String(jtv) - } - - default: - _, _ = key, value - + for _, value := range shape { + var col types.ResultField + destAddr := &col + if err := awsAwsjson11_deserializeDocumentResultField(&destAddr, value); err != nil { + return err } + col = *destAddr + cv = append(cv, col) + } - *v = sv + *v = cv return nil } -func awsAwsjson11_deserializeDocumentPatternToken(v **types.PatternToken, value interface{}) error { +func awsAwsjson11_deserializeDocumentS3Configuration(v **types.S3Configuration, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -16816,58 +22092,49 @@ func awsAwsjson11_deserializeDocumentPatternToken(v **types.PatternToken, value return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.PatternToken + var sv *types.S3Configuration if *v == nil { - sv = &types.PatternToken{} + sv = &types.S3Configuration{} } else { sv = *v } for key, value := range shape { switch key { - case "dynamicTokenPosition": + case "destinationIdentifier": if value != nil { - jtv, ok := value.(json.Number) + jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected DynamicTokenPosition to be json.Number, got %T instead", value) - } - i64, err := jtv.Int64() - if err != nil { - return err + return fmt.Errorf("expected S3Uri to be of type string, got %T instead", value) } - sv.DynamicTokenPosition = int32(i64) + sv.DestinationIdentifier = ptr.String(jtv) } - case "enumerations": - if err := awsAwsjson11_deserializeDocumentEnumerations(&sv.Enumerations, value); err != nil { - return err - } - - case "inferredTokenName": + case "kmsKeyId": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected InferredTokenName to be of type string, got %T instead", value) + return fmt.Errorf("expected KmsKeyId to be of type string, got %T instead", value) } - sv.InferredTokenName = ptr.String(jtv) + sv.KmsKeyId = ptr.String(jtv) } - case "isDynamic": + case "ownerAccountId": if value != nil { - jtv, ok := value.(bool) + jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) + return fmt.Errorf("expected AccountId to be of type string, got %T instead", value) } - sv.IsDynamic = ptr.Bool(jtv) + sv.OwnerAccountId = ptr.String(jtv) } - case "tokenString": + case "roleArn": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected TokenString to be of type string, got %T instead", value) + return fmt.Errorf("expected RoleArn to be of type string, got %T instead", value) } - sv.TokenString = ptr.String(jtv) + sv.RoleArn = ptr.String(jtv) } default: @@ -16879,41 +22146,7 @@ func awsAwsjson11_deserializeDocumentPatternToken(v **types.PatternToken, value return nil } -func awsAwsjson11_deserializeDocumentPatternTokens(v *[]types.PatternToken, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.([]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } - - var cv []types.PatternToken - if *v == nil { - cv = []types.PatternToken{} - } else { - cv = *v - } - - for _, value := range shape { - var col types.PatternToken - destAddr := &col - if err := awsAwsjson11_deserializeDocumentPatternToken(&destAddr, value); err != nil { - return err - } - col = *destAddr - cv = append(cv, col) - - } - *v = cv - return nil -} - -func awsAwsjson11_deserializeDocumentPolicy(v **types.Policy, value interface{}) error { +func awsAwsjson11_deserializeDocumentS3DeliveryConfiguration(v **types.S3DeliveryConfiguration, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -16926,22 +22159,31 @@ func awsAwsjson11_deserializeDocumentPolicy(v **types.Policy, value interface{}) return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.Policy + var sv *types.S3DeliveryConfiguration if *v == nil { - sv = &types.Policy{} + sv = &types.S3DeliveryConfiguration{} } else { sv = *v } for key, value := range shape { switch key { - case "deliveryDestinationPolicy": + case "enableHiveCompatiblePath": + if value != nil { + jtv, ok := value.(bool) + if !ok { + return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) + } + sv.EnableHiveCompatiblePath = ptr.Bool(jtv) + } + + case "suffixPath": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected DeliveryDestinationPolicy to be of type string, got %T instead", value) + return fmt.Errorf("expected DeliverySuffixPath to be of type string, got %T instead", value) } - sv.DeliveryDestinationPolicy = ptr.String(jtv) + sv.SuffixPath = ptr.String(jtv) } default: @@ -16953,7 +22195,7 @@ func awsAwsjson11_deserializeDocumentPolicy(v **types.Policy, value interface{}) return nil } -func awsAwsjson11_deserializeDocumentProcessor(v **types.Processor, value interface{}) error { +func awsAwsjson11_deserializeDocumentS3TableIntegrationSource(v **types.S3TableIntegrationSource, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -16966,123 +22208,58 @@ func awsAwsjson11_deserializeDocumentProcessor(v **types.Processor, value interf return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.Processor + var sv *types.S3TableIntegrationSource if *v == nil { - sv = &types.Processor{} + sv = &types.S3TableIntegrationSource{} } else { sv = *v } for key, value := range shape { switch key { - case "addKeys": - if err := awsAwsjson11_deserializeDocumentAddKeys(&sv.AddKeys, value); err != nil { - return err - } - - case "copyValue": - if err := awsAwsjson11_deserializeDocumentCopyValue(&sv.CopyValue, value); err != nil { - return err - } - - case "csv": - if err := awsAwsjson11_deserializeDocumentCSV(&sv.Csv, value); err != nil { - return err - } - - case "dateTimeConverter": - if err := awsAwsjson11_deserializeDocumentDateTimeConverter(&sv.DateTimeConverter, value); err != nil { - return err - } - - case "deleteKeys": - if err := awsAwsjson11_deserializeDocumentDeleteKeys(&sv.DeleteKeys, value); err != nil { - return err - } - - case "grok": - if err := awsAwsjson11_deserializeDocumentGrok(&sv.Grok, value); err != nil { - return err - } - - case "listToMap": - if err := awsAwsjson11_deserializeDocumentListToMap(&sv.ListToMap, value); err != nil { - return err - } - - case "lowerCaseString": - if err := awsAwsjson11_deserializeDocumentLowerCaseString(&sv.LowerCaseString, value); err != nil { - return err - } - - case "moveKeys": - if err := awsAwsjson11_deserializeDocumentMoveKeys(&sv.MoveKeys, value); err != nil { - return err - } - - case "parseCloudfront": - if err := awsAwsjson11_deserializeDocumentParseCloudfront(&sv.ParseCloudfront, value); err != nil { - return err - } - - case "parseJSON": - if err := awsAwsjson11_deserializeDocumentParseJSON(&sv.ParseJSON, value); err != nil { - return err - } - - case "parseKeyValue": - if err := awsAwsjson11_deserializeDocumentParseKeyValue(&sv.ParseKeyValue, value); err != nil { - return err - } - - case "parsePostgres": - if err := awsAwsjson11_deserializeDocumentParsePostgres(&sv.ParsePostgres, value); err != nil { - return err - } - - case "parseRoute53": - if err := awsAwsjson11_deserializeDocumentParseRoute53(&sv.ParseRoute53, value); err != nil { - return err - } - - case "parseVPC": - if err := awsAwsjson11_deserializeDocumentParseVPC(&sv.ParseVPC, value); err != nil { - return err - } - - case "parseWAF": - if err := awsAwsjson11_deserializeDocumentParseWAF(&sv.ParseWAF, value); err != nil { - return err - } - - case "renameKeys": - if err := awsAwsjson11_deserializeDocumentRenameKeys(&sv.RenameKeys, value); err != nil { - return err - } - - case "splitString": - if err := awsAwsjson11_deserializeDocumentSplitString(&sv.SplitString, value); err != nil { - return err + case "createdTimeStamp": + if value != nil { + jtv, ok := value.(json.Number) + if !ok { + return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) + } + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.CreatedTimeStamp = ptr.Int64(i64) } - case "substituteString": - if err := awsAwsjson11_deserializeDocumentSubstituteString(&sv.SubstituteString, value); err != nil { + case "dataSource": + if err := awsAwsjson11_deserializeDocumentDataSource(&sv.DataSource, value); err != nil { return err } - case "trimString": - if err := awsAwsjson11_deserializeDocumentTrimString(&sv.TrimString, value); err != nil { - return err + case "identifier": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected S3TableIntegrationSourceIdentifier to be of type string, got %T instead", value) + } + sv.Identifier = ptr.String(jtv) } - case "typeConverter": - if err := awsAwsjson11_deserializeDocumentTypeConverter(&sv.TypeConverter, value); err != nil { - return err + case "status": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected S3TableIntegrationSourceStatus to be of type string, got %T instead", value) + } + sv.Status = types.S3TableIntegrationSourceStatus(jtv) } - case "upperCaseString": - if err := awsAwsjson11_deserializeDocumentUpperCaseString(&sv.UpperCaseString, value); err != nil { - return err + case "statusReason": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected S3TableIntegrationSourceStatusReason to be of type string, got %T instead", value) + } + sv.StatusReason = ptr.String(jtv) } default: @@ -17094,7 +22271,7 @@ func awsAwsjson11_deserializeDocumentProcessor(v **types.Processor, value interf return nil } -func awsAwsjson11_deserializeDocumentProcessors(v *[]types.Processor, value interface{}) error { +func awsAwsjson11_deserializeDocumentS3TableIntegrationSources(v *[]types.S3TableIntegrationSource, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -17107,17 +22284,17 @@ func awsAwsjson11_deserializeDocumentProcessors(v *[]types.Processor, value inte return fmt.Errorf("unexpected JSON type %v", value) } - var cv []types.Processor + var cv []types.S3TableIntegrationSource if *v == nil { - cv = []types.Processor{} + cv = []types.S3TableIntegrationSource{} } else { cv = *v } for _, value := range shape { - var col types.Processor + var col types.S3TableIntegrationSource destAddr := &col - if err := awsAwsjson11_deserializeDocumentProcessor(&destAddr, value); err != nil { + if err := awsAwsjson11_deserializeDocumentS3TableIntegrationSource(&destAddr, value); err != nil { return err } col = *destAddr @@ -17128,7 +22305,7 @@ func awsAwsjson11_deserializeDocumentProcessors(v *[]types.Processor, value inte return nil } -func awsAwsjson11_deserializeDocumentQueryCompileError(v **types.QueryCompileError, value interface{}) error { +func awsAwsjson11_deserializeDocumentScheduledQueryDestination(v **types.ScheduledQueryDestination, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -17141,27 +22318,58 @@ func awsAwsjson11_deserializeDocumentQueryCompileError(v **types.QueryCompileErr return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.QueryCompileError + var sv *types.ScheduledQueryDestination if *v == nil { - sv = &types.QueryCompileError{} + sv = &types.ScheduledQueryDestination{} } else { sv = *v } for key, value := range shape { switch key { - case "location": - if err := awsAwsjson11_deserializeDocumentQueryCompileErrorLocation(&sv.Location, value); err != nil { - return err + case "destinationIdentifier": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected String to be of type string, got %T instead", value) + } + sv.DestinationIdentifier = ptr.String(jtv) } - case "message": + case "destinationType": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected Message to be of type string, got %T instead", value) + return fmt.Errorf("expected ScheduledQueryDestinationType to be of type string, got %T instead", value) } - sv.Message = ptr.String(jtv) + sv.DestinationType = types.ScheduledQueryDestinationType(jtv) + } + + case "errorMessage": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected String to be of type string, got %T instead", value) + } + sv.ErrorMessage = ptr.String(jtv) + } + + case "processedIdentifier": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected String to be of type string, got %T instead", value) + } + sv.ProcessedIdentifier = ptr.String(jtv) + } + + case "status": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected ActionStatus to be of type string, got %T instead", value) + } + sv.Status = types.ActionStatus(jtv) } default: @@ -17173,7 +22381,7 @@ func awsAwsjson11_deserializeDocumentQueryCompileError(v **types.QueryCompileErr return nil } -func awsAwsjson11_deserializeDocumentQueryCompileErrorLocation(v **types.QueryCompileErrorLocation, value interface{}) error { +func awsAwsjson11_deserializeDocumentScheduledQueryDestinationList(v *[]types.ScheduledQueryDestination, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -17181,56 +22389,69 @@ func awsAwsjson11_deserializeDocumentQueryCompileErrorLocation(v **types.QueryCo return nil } - shape, ok := value.(map[string]interface{}) + shape, ok := value.([]interface{}) if !ok { return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.QueryCompileErrorLocation + var cv []types.ScheduledQueryDestination if *v == nil { - sv = &types.QueryCompileErrorLocation{} + cv = []types.ScheduledQueryDestination{} } else { - sv = *v + cv = *v } - for key, value := range shape { - switch key { - case "endCharOffset": - if value != nil { - jtv, ok := value.(json.Number) - if !ok { - return fmt.Errorf("expected QueryCharOffset to be json.Number, got %T instead", value) - } - i64, err := jtv.Int64() - if err != nil { - return err - } - sv.EndCharOffset = ptr.Int32(int32(i64)) - } + for _, value := range shape { + var col types.ScheduledQueryDestination + destAddr := &col + if err := awsAwsjson11_deserializeDocumentScheduledQueryDestination(&destAddr, value); err != nil { + return err + } + col = *destAddr + cv = append(cv, col) - case "startCharOffset": - if value != nil { - jtv, ok := value.(json.Number) - if !ok { - return fmt.Errorf("expected QueryCharOffset to be json.Number, got %T instead", value) - } - i64, err := jtv.Int64() - if err != nil { - return err - } - sv.StartCharOffset = ptr.Int32(int32(i64)) - } + } + *v = cv + return nil +} - default: - _, _ = key, value +func awsAwsjson11_deserializeDocumentScheduledQueryLogGroupIdentifiers(v *[]string, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.([]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + var cv []string + if *v == nil { + cv = []string{} + } else { + cv = *v + } + + for _, value := range shape { + var col string + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected LogGroupIdentifier to be of type string, got %T instead", value) + } + col = jtv } + cv = append(cv, col) + } - *v = sv + *v = cv return nil } -func awsAwsjson11_deserializeDocumentQueryDefinition(v **types.QueryDefinition, value interface{}) error { +func awsAwsjson11_deserializeDocumentScheduledQuerySummary(v **types.ScheduledQuerySummary, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -17243,16 +22464,16 @@ func awsAwsjson11_deserializeDocumentQueryDefinition(v **types.QueryDefinition, return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.QueryDefinition + var sv *types.ScheduledQuerySummary if *v == nil { - sv = &types.QueryDefinition{} + sv = &types.ScheduledQuerySummary{} } else { sv = *v } for key, value := range shape { switch key { - case "lastModified": + case "creationTime": if value != nil { jtv, ok := value.(json.Number) if !ok { @@ -17262,48 +22483,92 @@ func awsAwsjson11_deserializeDocumentQueryDefinition(v **types.QueryDefinition, if err != nil { return err } - sv.LastModified = ptr.Int64(i64) + sv.CreationTime = ptr.Int64(i64) } - case "logGroupNames": - if err := awsAwsjson11_deserializeDocumentLogGroupNames(&sv.LogGroupNames, value); err != nil { + case "destinationConfiguration": + if err := awsAwsjson11_deserializeDocumentDestinationConfiguration(&sv.DestinationConfiguration, value); err != nil { return err } + case "lastExecutionStatus": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected ExecutionStatus to be of type string, got %T instead", value) + } + sv.LastExecutionStatus = types.ExecutionStatus(jtv) + } + + case "lastTriggeredTime": + if value != nil { + jtv, ok := value.(json.Number) + if !ok { + return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) + } + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.LastTriggeredTime = ptr.Int64(i64) + } + + case "lastUpdatedTime": + if value != nil { + jtv, ok := value.(json.Number) + if !ok { + return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) + } + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.LastUpdatedTime = ptr.Int64(i64) + } + case "name": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected QueryDefinitionName to be of type string, got %T instead", value) + return fmt.Errorf("expected ScheduledQueryName to be of type string, got %T instead", value) } sv.Name = ptr.String(jtv) } - case "queryDefinitionId": + case "scheduledQueryArn": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected QueryId to be of type string, got %T instead", value) + return fmt.Errorf("expected Arn to be of type string, got %T instead", value) } - sv.QueryDefinitionId = ptr.String(jtv) + sv.ScheduledQueryArn = ptr.String(jtv) } - case "queryLanguage": + case "scheduleExpression": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected QueryLanguage to be of type string, got %T instead", value) + return fmt.Errorf("expected ScheduleExpression to be of type string, got %T instead", value) } - sv.QueryLanguage = types.QueryLanguage(jtv) + sv.ScheduleExpression = ptr.String(jtv) } - case "queryString": + case "state": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected QueryDefinitionString to be of type string, got %T instead", value) + return fmt.Errorf("expected ScheduledQueryState to be of type string, got %T instead", value) } - sv.QueryString = ptr.String(jtv) + sv.State = types.ScheduledQueryState(jtv) + } + + case "timezone": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected ScheduleTimezone to be of type string, got %T instead", value) + } + sv.Timezone = ptr.String(jtv) } default: @@ -17315,7 +22580,7 @@ func awsAwsjson11_deserializeDocumentQueryDefinition(v **types.QueryDefinition, return nil } -func awsAwsjson11_deserializeDocumentQueryDefinitionList(v *[]types.QueryDefinition, value interface{}) error { +func awsAwsjson11_deserializeDocumentScheduledQuerySummaryList(v *[]types.ScheduledQuerySummary, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -17328,17 +22593,17 @@ func awsAwsjson11_deserializeDocumentQueryDefinitionList(v *[]types.QueryDefinit return fmt.Errorf("unexpected JSON type %v", value) } - var cv []types.QueryDefinition + var cv []types.ScheduledQuerySummary if *v == nil { - cv = []types.QueryDefinition{} + cv = []types.ScheduledQuerySummary{} } else { cv = *v } for _, value := range shape { - var col types.QueryDefinition + var col types.ScheduledQuerySummary destAddr := &col - if err := awsAwsjson11_deserializeDocumentQueryDefinition(&destAddr, value); err != nil { + if err := awsAwsjson11_deserializeDocumentScheduledQuerySummary(&destAddr, value); err != nil { return err } col = *destAddr @@ -17349,7 +22614,7 @@ func awsAwsjson11_deserializeDocumentQueryDefinitionList(v *[]types.QueryDefinit return nil } -func awsAwsjson11_deserializeDocumentQueryInfo(v **types.QueryInfo, value interface{}) error { +func awsAwsjson11_deserializeDocumentSearchedLogStream(v **types.SearchedLogStream, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -17362,71 +22627,31 @@ func awsAwsjson11_deserializeDocumentQueryInfo(v **types.QueryInfo, value interf return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.QueryInfo + var sv *types.SearchedLogStream if *v == nil { - sv = &types.QueryInfo{} + sv = &types.SearchedLogStream{} } else { sv = *v } for key, value := range shape { switch key { - case "createTime": - if value != nil { - jtv, ok := value.(json.Number) - if !ok { - return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) - } - i64, err := jtv.Int64() - if err != nil { - return err - } - sv.CreateTime = ptr.Int64(i64) - } - - case "logGroupName": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected LogGroupName to be of type string, got %T instead", value) - } - sv.LogGroupName = ptr.String(jtv) - } - - case "queryId": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected QueryId to be of type string, got %T instead", value) - } - sv.QueryId = ptr.String(jtv) - } - - case "queryLanguage": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected QueryLanguage to be of type string, got %T instead", value) - } - sv.QueryLanguage = types.QueryLanguage(jtv) - } - - case "queryString": + case "logStreamName": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected QueryString to be of type string, got %T instead", value) + return fmt.Errorf("expected LogStreamName to be of type string, got %T instead", value) } - sv.QueryString = ptr.String(jtv) + sv.LogStreamName = ptr.String(jtv) } - case "status": + case "searchedCompletely": if value != nil { - jtv, ok := value.(string) + jtv, ok := value.(bool) if !ok { - return fmt.Errorf("expected QueryStatus to be of type string, got %T instead", value) + return fmt.Errorf("expected LogStreamSearchedCompletely to be of type *bool, got %T instead", value) } - sv.Status = types.QueryStatus(jtv) + sv.SearchedCompletely = ptr.Bool(jtv) } default: @@ -17438,7 +22663,7 @@ func awsAwsjson11_deserializeDocumentQueryInfo(v **types.QueryInfo, value interf return nil } -func awsAwsjson11_deserializeDocumentQueryInfoList(v *[]types.QueryInfo, value interface{}) error { +func awsAwsjson11_deserializeDocumentSearchedLogStreams(v *[]types.SearchedLogStream, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -17451,17 +22676,17 @@ func awsAwsjson11_deserializeDocumentQueryInfoList(v *[]types.QueryInfo, value i return fmt.Errorf("unexpected JSON type %v", value) } - var cv []types.QueryInfo + var cv []types.SearchedLogStream if *v == nil { - cv = []types.QueryInfo{} + cv = []types.SearchedLogStream{} } else { cv = *v } for _, value := range shape { - var col types.QueryInfo + var col types.SearchedLogStream destAddr := &col - if err := awsAwsjson11_deserializeDocumentQueryInfo(&destAddr, value); err != nil { + if err := awsAwsjson11_deserializeDocumentSearchedLogStream(&destAddr, value); err != nil { return err } col = *destAddr @@ -17472,39 +22697,7 @@ func awsAwsjson11_deserializeDocumentQueryInfoList(v *[]types.QueryInfo, value i return nil } -func awsAwsjson11_deserializeDocumentQueryResults(v *[][]types.ResultField, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.([]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } - - var cv [][]types.ResultField - if *v == nil { - cv = [][]types.ResultField{} - } else { - cv = *v - } - - for _, value := range shape { - var col []types.ResultField - if err := awsAwsjson11_deserializeDocumentResultRows(&col, value); err != nil { - return err - } - cv = append(cv, col) - - } - *v = cv - return nil -} - -func awsAwsjson11_deserializeDocumentQueryStatistics(v **types.QueryStatistics, value interface{}) error { +func awsAwsjson11_deserializeDocumentServiceQuotaExceededException(v **types.ServiceQuotaExceededException, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -17517,217 +22710,22 @@ func awsAwsjson11_deserializeDocumentQueryStatistics(v **types.QueryStatistics, return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.QueryStatistics + var sv *types.ServiceQuotaExceededException if *v == nil { - sv = &types.QueryStatistics{} + sv = &types.ServiceQuotaExceededException{} } else { sv = *v } - for key, value := range shape { - switch key { - case "bytesScanned": - if value != nil { - switch jtv := value.(type) { - case json.Number: - f64, err := jtv.Float64() - if err != nil { - return err - } - sv.BytesScanned = f64 - - case string: - var f64 float64 - switch { - case strings.EqualFold(jtv, "NaN"): - f64 = math.NaN() - - case strings.EqualFold(jtv, "Infinity"): - f64 = math.Inf(1) - - case strings.EqualFold(jtv, "-Infinity"): - f64 = math.Inf(-1) - - default: - return fmt.Errorf("unknown JSON number value: %s", jtv) - - } - sv.BytesScanned = f64 - - default: - return fmt.Errorf("expected StatsValue to be a JSON Number, got %T instead", value) - - } - } - - case "estimatedBytesSkipped": - if value != nil { - switch jtv := value.(type) { - case json.Number: - f64, err := jtv.Float64() - if err != nil { - return err - } - sv.EstimatedBytesSkipped = f64 - - case string: - var f64 float64 - switch { - case strings.EqualFold(jtv, "NaN"): - f64 = math.NaN() - - case strings.EqualFold(jtv, "Infinity"): - f64 = math.Inf(1) - - case strings.EqualFold(jtv, "-Infinity"): - f64 = math.Inf(-1) - - default: - return fmt.Errorf("unknown JSON number value: %s", jtv) - - } - sv.EstimatedBytesSkipped = f64 - - default: - return fmt.Errorf("expected StatsValue to be a JSON Number, got %T instead", value) - - } - } - - case "estimatedRecordsSkipped": - if value != nil { - switch jtv := value.(type) { - case json.Number: - f64, err := jtv.Float64() - if err != nil { - return err - } - sv.EstimatedRecordsSkipped = f64 - - case string: - var f64 float64 - switch { - case strings.EqualFold(jtv, "NaN"): - f64 = math.NaN() - - case strings.EqualFold(jtv, "Infinity"): - f64 = math.Inf(1) - - case strings.EqualFold(jtv, "-Infinity"): - f64 = math.Inf(-1) - - default: - return fmt.Errorf("unknown JSON number value: %s", jtv) - - } - sv.EstimatedRecordsSkipped = f64 - - default: - return fmt.Errorf("expected StatsValue to be a JSON Number, got %T instead", value) - - } - } - - case "logGroupsScanned": - if value != nil { - switch jtv := value.(type) { - case json.Number: - f64, err := jtv.Float64() - if err != nil { - return err - } - sv.LogGroupsScanned = f64 - - case string: - var f64 float64 - switch { - case strings.EqualFold(jtv, "NaN"): - f64 = math.NaN() - - case strings.EqualFold(jtv, "Infinity"): - f64 = math.Inf(1) - - case strings.EqualFold(jtv, "-Infinity"): - f64 = math.Inf(-1) - - default: - return fmt.Errorf("unknown JSON number value: %s", jtv) - - } - sv.LogGroupsScanned = f64 - - default: - return fmt.Errorf("expected StatsValue to be a JSON Number, got %T instead", value) - - } - } - - case "recordsMatched": - if value != nil { - switch jtv := value.(type) { - case json.Number: - f64, err := jtv.Float64() - if err != nil { - return err - } - sv.RecordsMatched = f64 - - case string: - var f64 float64 - switch { - case strings.EqualFold(jtv, "NaN"): - f64 = math.NaN() - - case strings.EqualFold(jtv, "Infinity"): - f64 = math.Inf(1) - - case strings.EqualFold(jtv, "-Infinity"): - f64 = math.Inf(-1) - - default: - return fmt.Errorf("unknown JSON number value: %s", jtv) - - } - sv.RecordsMatched = f64 - - default: - return fmt.Errorf("expected StatsValue to be a JSON Number, got %T instead", value) - - } - } - - case "recordsScanned": - if value != nil { - switch jtv := value.(type) { - case json.Number: - f64, err := jtv.Float64() - if err != nil { - return err - } - sv.RecordsScanned = f64 - - case string: - var f64 float64 - switch { - case strings.EqualFold(jtv, "NaN"): - f64 = math.NaN() - - case strings.EqualFold(jtv, "Infinity"): - f64 = math.Inf(1) - - case strings.EqualFold(jtv, "-Infinity"): - f64 = math.Inf(-1) - - default: - return fmt.Errorf("unknown JSON number value: %s", jtv) - - } - sv.RecordsScanned = f64 - - default: - return fmt.Errorf("expected StatsValue to be a JSON Number, got %T instead", value) - + for key, value := range shape { + switch key { + case "message", "Message": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected Message to be of type string, got %T instead", value) } + sv.Message = ptr.String(jtv) } default: @@ -17739,7 +22737,7 @@ func awsAwsjson11_deserializeDocumentQueryStatistics(v **types.QueryStatistics, return nil } -func awsAwsjson11_deserializeDocumentRecordField(v **types.RecordField, value interface{}) error { +func awsAwsjson11_deserializeDocumentServiceUnavailableException(v **types.ServiceUnavailableException, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -17752,31 +22750,58 @@ func awsAwsjson11_deserializeDocumentRecordField(v **types.RecordField, value in return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.RecordField + var sv *types.ServiceUnavailableException if *v == nil { - sv = &types.RecordField{} + sv = &types.ServiceUnavailableException{} } else { sv = *v } for key, value := range shape { switch key { - case "mandatory": + case "message", "Message": if value != nil { - jtv, ok := value.(bool) + jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) + return fmt.Errorf("expected Message to be of type string, got %T instead", value) } - sv.Mandatory = ptr.Bool(jtv) + sv.Message = ptr.String(jtv) } - case "name": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected FieldHeader to be of type string, got %T instead", value) - } - sv.Name = ptr.String(jtv) + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + +func awsAwsjson11_deserializeDocumentSplitString(v **types.SplitString, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.(map[string]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var sv *types.SplitString + if *v == nil { + sv = &types.SplitString{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "entries": + if err := awsAwsjson11_deserializeDocumentSplitStringEntries(&sv.Entries, value); err != nil { + return err } default: @@ -17788,7 +22813,7 @@ func awsAwsjson11_deserializeDocumentRecordField(v **types.RecordField, value in return nil } -func awsAwsjson11_deserializeDocumentRecordFields(v *[]string, value interface{}) error { +func awsAwsjson11_deserializeDocumentSplitStringEntries(v *[]types.SplitStringEntry, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -17801,22 +22826,20 @@ func awsAwsjson11_deserializeDocumentRecordFields(v *[]string, value interface{} return fmt.Errorf("unexpected JSON type %v", value) } - var cv []string + var cv []types.SplitStringEntry if *v == nil { - cv = []string{} + cv = []types.SplitStringEntry{} } else { cv = *v } for _, value := range shape { - var col string - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected FieldHeader to be of type string, got %T instead", value) - } - col = jtv + var col types.SplitStringEntry + destAddr := &col + if err := awsAwsjson11_deserializeDocumentSplitStringEntry(&destAddr, value); err != nil { + return err } + col = *destAddr cv = append(cv, col) } @@ -17824,7 +22847,7 @@ func awsAwsjson11_deserializeDocumentRecordFields(v *[]string, value interface{} return nil } -func awsAwsjson11_deserializeDocumentRejectedEntityInfo(v **types.RejectedEntityInfo, value interface{}) error { +func awsAwsjson11_deserializeDocumentSplitStringEntry(v **types.SplitStringEntry, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -17837,22 +22860,31 @@ func awsAwsjson11_deserializeDocumentRejectedEntityInfo(v **types.RejectedEntity return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.RejectedEntityInfo + var sv *types.SplitStringEntry if *v == nil { - sv = &types.RejectedEntityInfo{} + sv = &types.SplitStringEntry{} } else { sv = *v } for key, value := range shape { switch key { - case "errorType": + case "delimiter": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected EntityRejectionErrorType to be of type string, got %T instead", value) + return fmt.Errorf("expected SplitStringDelimiter to be of type string, got %T instead", value) } - sv.ErrorType = types.EntityRejectionErrorType(jtv) + sv.Delimiter = ptr.String(jtv) + } + + case "source": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected Source to be of type string, got %T instead", value) + } + sv.Source = ptr.String(jtv) } default: @@ -17864,7 +22896,7 @@ func awsAwsjson11_deserializeDocumentRejectedEntityInfo(v **types.RejectedEntity return nil } -func awsAwsjson11_deserializeDocumentRejectedLogEventsInfo(v **types.RejectedLogEventsInfo, value interface{}) error { +func awsAwsjson11_deserializeDocumentSubscriptionFilter(v **types.SubscriptionFilter, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -17877,52 +22909,103 @@ func awsAwsjson11_deserializeDocumentRejectedLogEventsInfo(v **types.RejectedLog return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.RejectedLogEventsInfo + var sv *types.SubscriptionFilter if *v == nil { - sv = &types.RejectedLogEventsInfo{} + sv = &types.SubscriptionFilter{} } else { sv = *v } for key, value := range shape { switch key { - case "expiredLogEventEndIndex": + case "applyOnTransformedLogs": + if value != nil { + jtv, ok := value.(bool) + if !ok { + return fmt.Errorf("expected ApplyOnTransformedLogs to be of type *bool, got %T instead", value) + } + sv.ApplyOnTransformedLogs = jtv + } + + case "creationTime": if value != nil { jtv, ok := value.(json.Number) if !ok { - return fmt.Errorf("expected LogEventIndex to be json.Number, got %T instead", value) + return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) } i64, err := jtv.Int64() if err != nil { return err } - sv.ExpiredLogEventEndIndex = ptr.Int32(int32(i64)) + sv.CreationTime = ptr.Int64(i64) } - case "tooNewLogEventStartIndex": + case "destinationArn": if value != nil { - jtv, ok := value.(json.Number) + jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected LogEventIndex to be json.Number, got %T instead", value) + return fmt.Errorf("expected DestinationArn to be of type string, got %T instead", value) } - i64, err := jtv.Int64() - if err != nil { - return err + sv.DestinationArn = ptr.String(jtv) + } + + case "distribution": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected Distribution to be of type string, got %T instead", value) } - sv.TooNewLogEventStartIndex = ptr.Int32(int32(i64)) + sv.Distribution = types.Distribution(jtv) } - case "tooOldLogEventEndIndex": + case "emitSystemFields": + if err := awsAwsjson11_deserializeDocumentEmitSystemFields(&sv.EmitSystemFields, value); err != nil { + return err + } + + case "fieldSelectionCriteria": if value != nil { - jtv, ok := value.(json.Number) + jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected LogEventIndex to be json.Number, got %T instead", value) + return fmt.Errorf("expected FieldSelectionCriteria to be of type string, got %T instead", value) } - i64, err := jtv.Int64() - if err != nil { - return err + sv.FieldSelectionCriteria = ptr.String(jtv) + } + + case "filterName": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected FilterName to be of type string, got %T instead", value) } - sv.TooOldLogEventEndIndex = ptr.Int32(int32(i64)) + sv.FilterName = ptr.String(jtv) + } + + case "filterPattern": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected FilterPattern to be of type string, got %T instead", value) + } + sv.FilterPattern = ptr.String(jtv) + } + + case "logGroupName": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected LogGroupName to be of type string, got %T instead", value) + } + sv.LogGroupName = ptr.String(jtv) + } + + case "roleArn": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected RoleArn to be of type string, got %T instead", value) + } + sv.RoleArn = ptr.String(jtv) } default: @@ -17934,7 +23017,7 @@ func awsAwsjson11_deserializeDocumentRejectedLogEventsInfo(v **types.RejectedLog return nil } -func awsAwsjson11_deserializeDocumentRenameKeyEntries(v *[]types.RenameKeyEntry, value interface{}) error { +func awsAwsjson11_deserializeDocumentSubscriptionFilters(v *[]types.SubscriptionFilter, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -17947,86 +23030,28 @@ func awsAwsjson11_deserializeDocumentRenameKeyEntries(v *[]types.RenameKeyEntry, return fmt.Errorf("unexpected JSON type %v", value) } - var cv []types.RenameKeyEntry + var cv []types.SubscriptionFilter if *v == nil { - cv = []types.RenameKeyEntry{} + cv = []types.SubscriptionFilter{} } else { cv = *v } for _, value := range shape { - var col types.RenameKeyEntry + var col types.SubscriptionFilter destAddr := &col - if err := awsAwsjson11_deserializeDocumentRenameKeyEntry(&destAddr, value); err != nil { + if err := awsAwsjson11_deserializeDocumentSubscriptionFilter(&destAddr, value); err != nil { return err } col = *destAddr cv = append(cv, col) } - *v = cv - return nil -} - -func awsAwsjson11_deserializeDocumentRenameKeyEntry(v **types.RenameKeyEntry, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.(map[string]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } - - var sv *types.RenameKeyEntry - if *v == nil { - sv = &types.RenameKeyEntry{} - } else { - sv = *v - } - - for key, value := range shape { - switch key { - case "key": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected Key to be of type string, got %T instead", value) - } - sv.Key = ptr.String(jtv) - } - - case "overwriteIfExists": - if value != nil { - jtv, ok := value.(bool) - if !ok { - return fmt.Errorf("expected OverwriteIfExists to be of type *bool, got %T instead", value) - } - sv.OverwriteIfExists = jtv - } - - case "renameTo": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected RenameTo to be of type string, got %T instead", value) - } - sv.RenameTo = ptr.String(jtv) - } - - default: - _, _ = key, value - - } - } - *v = sv + *v = cv return nil } -func awsAwsjson11_deserializeDocumentRenameKeys(v **types.RenameKeys, value interface{}) error { +func awsAwsjson11_deserializeDocumentSubstituteString(v **types.SubstituteString, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -18039,9 +23064,9 @@ func awsAwsjson11_deserializeDocumentRenameKeys(v **types.RenameKeys, value inte return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.RenameKeys + var sv *types.SubstituteString if *v == nil { - sv = &types.RenameKeys{} + sv = &types.SubstituteString{} } else { sv = *v } @@ -18049,7 +23074,7 @@ func awsAwsjson11_deserializeDocumentRenameKeys(v **types.RenameKeys, value inte for key, value := range shape { switch key { case "entries": - if err := awsAwsjson11_deserializeDocumentRenameKeyEntries(&sv.Entries, value); err != nil { + if err := awsAwsjson11_deserializeDocumentSubstituteStringEntries(&sv.Entries, value); err != nil { return err } @@ -18062,7 +23087,41 @@ func awsAwsjson11_deserializeDocumentRenameKeys(v **types.RenameKeys, value inte return nil } -func awsAwsjson11_deserializeDocumentResourceAlreadyExistsException(v **types.ResourceAlreadyExistsException, value interface{}) error { +func awsAwsjson11_deserializeDocumentSubstituteStringEntries(v *[]types.SubstituteStringEntry, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.([]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var cv []types.SubstituteStringEntry + if *v == nil { + cv = []types.SubstituteStringEntry{} + } else { + cv = *v + } + + for _, value := range shape { + var col types.SubstituteStringEntry + destAddr := &col + if err := awsAwsjson11_deserializeDocumentSubstituteStringEntry(&destAddr, value); err != nil { + return err + } + col = *destAddr + cv = append(cv, col) + + } + *v = cv + return nil +} + +func awsAwsjson11_deserializeDocumentSubstituteStringEntry(v **types.SubstituteStringEntry, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -18075,22 +23134,40 @@ func awsAwsjson11_deserializeDocumentResourceAlreadyExistsException(v **types.Re return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.ResourceAlreadyExistsException + var sv *types.SubstituteStringEntry if *v == nil { - sv = &types.ResourceAlreadyExistsException{} + sv = &types.SubstituteStringEntry{} } else { sv = *v } for key, value := range shape { switch key { - case "message", "Message": + case "from": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected Message to be of type string, got %T instead", value) + return fmt.Errorf("expected FromKey to be of type string, got %T instead", value) } - sv.Message = ptr.String(jtv) + sv.From = ptr.String(jtv) + } + + case "source": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected Source to be of type string, got %T instead", value) + } + sv.Source = ptr.String(jtv) + } + + case "to": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected ToKey to be of type string, got %T instead", value) + } + sv.To = ptr.String(jtv) } default: @@ -18102,7 +23179,7 @@ func awsAwsjson11_deserializeDocumentResourceAlreadyExistsException(v **types.Re return nil } -func awsAwsjson11_deserializeDocumentResourceArns(v *[]string, value interface{}) error { +func awsAwsjson11_deserializeDocumentTags(v *map[string]string, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -18110,35 +23187,35 @@ func awsAwsjson11_deserializeDocumentResourceArns(v *[]string, value interface{} return nil } - shape, ok := value.([]interface{}) + shape, ok := value.(map[string]interface{}) if !ok { return fmt.Errorf("unexpected JSON type %v", value) } - var cv []string + var mv map[string]string if *v == nil { - cv = []string{} + mv = map[string]string{} } else { - cv = *v + mv = *v } - for _, value := range shape { - var col string + for key, value := range shape { + var parsedVal string if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected Arn to be of type string, got %T instead", value) + return fmt.Errorf("expected TagValue to be of type string, got %T instead", value) } - col = jtv + parsedVal = jtv } - cv = append(cv, col) + mv[key] = parsedVal } - *v = cv + *v = mv return nil } -func awsAwsjson11_deserializeDocumentResourceNotFoundException(v **types.ResourceNotFoundException, value interface{}) error { +func awsAwsjson11_deserializeDocumentThrottlingException(v **types.ThrottlingException, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -18151,9 +23228,9 @@ func awsAwsjson11_deserializeDocumentResourceNotFoundException(v **types.Resourc return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.ResourceNotFoundException + var sv *types.ThrottlingException if *v == nil { - sv = &types.ResourceNotFoundException{} + sv = &types.ThrottlingException{} } else { sv = *v } @@ -18178,41 +23255,7 @@ func awsAwsjson11_deserializeDocumentResourceNotFoundException(v **types.Resourc return nil } -func awsAwsjson11_deserializeDocumentResourcePolicies(v *[]types.ResourcePolicy, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.([]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } - - var cv []types.ResourcePolicy - if *v == nil { - cv = []types.ResourcePolicy{} - } else { - cv = *v - } - - for _, value := range shape { - var col types.ResourcePolicy - destAddr := &col - if err := awsAwsjson11_deserializeDocumentResourcePolicy(&destAddr, value); err != nil { - return err - } - col = *destAddr - cv = append(cv, col) - - } - *v = cv - return nil -} - -func awsAwsjson11_deserializeDocumentResourcePolicy(v **types.ResourcePolicy, value interface{}) error { +func awsAwsjson11_deserializeDocumentTooManyTagsException(v **types.TooManyTagsException, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -18225,44 +23268,31 @@ func awsAwsjson11_deserializeDocumentResourcePolicy(v **types.ResourcePolicy, va return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.ResourcePolicy + var sv *types.TooManyTagsException if *v == nil { - sv = &types.ResourcePolicy{} + sv = &types.TooManyTagsException{} } else { sv = *v } for key, value := range shape { switch key { - case "lastUpdatedTime": - if value != nil { - jtv, ok := value.(json.Number) - if !ok { - return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) - } - i64, err := jtv.Int64() - if err != nil { - return err - } - sv.LastUpdatedTime = ptr.Int64(i64) - } - - case "policyDocument": + case "message", "Message": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected PolicyDocument to be of type string, got %T instead", value) + return fmt.Errorf("expected Message to be of type string, got %T instead", value) } - sv.PolicyDocument = ptr.String(jtv) + sv.Message = ptr.String(jtv) } - case "policyName": + case "resourceName": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected PolicyName to be of type string, got %T instead", value) + return fmt.Errorf("expected AmazonResourceName to be of type string, got %T instead", value) } - sv.PolicyName = ptr.String(jtv) + sv.ResourceName = ptr.String(jtv) } default: @@ -18274,7 +23304,7 @@ func awsAwsjson11_deserializeDocumentResourcePolicy(v **types.ResourcePolicy, va return nil } -func awsAwsjson11_deserializeDocumentResultField(v **types.ResultField, value interface{}) error { +func awsAwsjson11_deserializeDocumentTransformedLogRecord(v **types.TransformedLogRecord, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -18287,31 +23317,44 @@ func awsAwsjson11_deserializeDocumentResultField(v **types.ResultField, value in return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.ResultField + var sv *types.TransformedLogRecord if *v == nil { - sv = &types.ResultField{} + sv = &types.TransformedLogRecord{} } else { sv = *v } for key, value := range shape { switch key { - case "field": + case "eventMessage": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected Field to be of type string, got %T instead", value) + return fmt.Errorf("expected EventMessage to be of type string, got %T instead", value) } - sv.Field = ptr.String(jtv) + sv.EventMessage = ptr.String(jtv) } - case "value": + case "eventNumber": + if value != nil { + jtv, ok := value.(json.Number) + if !ok { + return fmt.Errorf("expected EventNumber to be json.Number, got %T instead", value) + } + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.EventNumber = i64 + } + + case "transformedEventMessage": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected Value to be of type string, got %T instead", value) + return fmt.Errorf("expected TransformedEventMessage to be of type string, got %T instead", value) } - sv.Value = ptr.String(jtv) + sv.TransformedEventMessage = ptr.String(jtv) } default: @@ -18323,7 +23366,7 @@ func awsAwsjson11_deserializeDocumentResultField(v **types.ResultField, value in return nil } -func awsAwsjson11_deserializeDocumentResultRows(v *[]types.ResultField, value interface{}) error { +func awsAwsjson11_deserializeDocumentTransformedLogs(v *[]types.TransformedLogRecord, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -18336,17 +23379,17 @@ func awsAwsjson11_deserializeDocumentResultRows(v *[]types.ResultField, value in return fmt.Errorf("unexpected JSON type %v", value) } - var cv []types.ResultField + var cv []types.TransformedLogRecord if *v == nil { - cv = []types.ResultField{} + cv = []types.TransformedLogRecord{} } else { cv = *v } for _, value := range shape { - var col types.ResultField + var col types.TransformedLogRecord destAddr := &col - if err := awsAwsjson11_deserializeDocumentResultField(&destAddr, value); err != nil { + if err := awsAwsjson11_deserializeDocumentTransformedLogRecord(&destAddr, value); err != nil { return err } col = *destAddr @@ -18357,7 +23400,7 @@ func awsAwsjson11_deserializeDocumentResultRows(v *[]types.ResultField, value in return nil } -func awsAwsjson11_deserializeDocumentS3DeliveryConfiguration(v **types.S3DeliveryConfiguration, value interface{}) error { +func awsAwsjson11_deserializeDocumentTriggerHistoryRecord(v **types.TriggerHistoryRecord, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -18370,80 +23413,58 @@ func awsAwsjson11_deserializeDocumentS3DeliveryConfiguration(v **types.S3Deliver return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.S3DeliveryConfiguration + var sv *types.TriggerHistoryRecord if *v == nil { - sv = &types.S3DeliveryConfiguration{} + sv = &types.TriggerHistoryRecord{} } else { sv = *v } for key, value := range shape { switch key { - case "enableHiveCompatiblePath": + case "destinations": + if err := awsAwsjson11_deserializeDocumentScheduledQueryDestinationList(&sv.Destinations, value); err != nil { + return err + } + + case "errorMessage": if value != nil { - jtv, ok := value.(bool) + jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) + return fmt.Errorf("expected String to be of type string, got %T instead", value) } - sv.EnableHiveCompatiblePath = ptr.Bool(jtv) + sv.ErrorMessage = ptr.String(jtv) } - case "suffixPath": + case "executionStatus": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected DeliverySuffixPath to be of type string, got %T instead", value) + return fmt.Errorf("expected ExecutionStatus to be of type string, got %T instead", value) } - sv.SuffixPath = ptr.String(jtv) + sv.ExecutionStatus = types.ExecutionStatus(jtv) } - default: - _, _ = key, value - - } - } - *v = sv - return nil -} - -func awsAwsjson11_deserializeDocumentSearchedLogStream(v **types.SearchedLogStream, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.(map[string]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } - - var sv *types.SearchedLogStream - if *v == nil { - sv = &types.SearchedLogStream{} - } else { - sv = *v - } - - for key, value := range shape { - switch key { - case "logStreamName": + case "queryId": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected LogStreamName to be of type string, got %T instead", value) + return fmt.Errorf("expected QueryId to be of type string, got %T instead", value) } - sv.LogStreamName = ptr.String(jtv) + sv.QueryId = ptr.String(jtv) } - case "searchedCompletely": + case "triggeredTimestamp": if value != nil { - jtv, ok := value.(bool) + jtv, ok := value.(json.Number) if !ok { - return fmt.Errorf("expected LogStreamSearchedCompletely to be of type *bool, got %T instead", value) + return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) } - sv.SearchedCompletely = ptr.Bool(jtv) + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.TriggeredTimestamp = ptr.Int64(i64) } default: @@ -18455,7 +23476,7 @@ func awsAwsjson11_deserializeDocumentSearchedLogStream(v **types.SearchedLogStre return nil } -func awsAwsjson11_deserializeDocumentSearchedLogStreams(v *[]types.SearchedLogStream, value interface{}) error { +func awsAwsjson11_deserializeDocumentTriggerHistoryRecordList(v *[]types.TriggerHistoryRecord, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -18468,17 +23489,17 @@ func awsAwsjson11_deserializeDocumentSearchedLogStreams(v *[]types.SearchedLogSt return fmt.Errorf("unexpected JSON type %v", value) } - var cv []types.SearchedLogStream + var cv []types.TriggerHistoryRecord if *v == nil { - cv = []types.SearchedLogStream{} + cv = []types.TriggerHistoryRecord{} } else { cv = *v } for _, value := range shape { - var col types.SearchedLogStream + var col types.TriggerHistoryRecord destAddr := &col - if err := awsAwsjson11_deserializeDocumentSearchedLogStream(&destAddr, value); err != nil { + if err := awsAwsjson11_deserializeDocumentTriggerHistoryRecord(&destAddr, value); err != nil { return err } col = *destAddr @@ -18489,7 +23510,7 @@ func awsAwsjson11_deserializeDocumentSearchedLogStreams(v *[]types.SearchedLogSt return nil } -func awsAwsjson11_deserializeDocumentServiceQuotaExceededException(v **types.ServiceQuotaExceededException, value interface{}) error { +func awsAwsjson11_deserializeDocumentTrimString(v **types.TrimString, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -18502,22 +23523,18 @@ func awsAwsjson11_deserializeDocumentServiceQuotaExceededException(v **types.Ser return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.ServiceQuotaExceededException + var sv *types.TrimString if *v == nil { - sv = &types.ServiceQuotaExceededException{} + sv = &types.TrimString{} } else { sv = *v } for key, value := range shape { switch key { - case "message", "Message": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected Message to be of type string, got %T instead", value) - } - sv.Message = ptr.String(jtv) + case "withKeys": + if err := awsAwsjson11_deserializeDocumentTrimStringWithKeys(&sv.WithKeys, value); err != nil { + return err } default: @@ -18529,7 +23546,7 @@ func awsAwsjson11_deserializeDocumentServiceQuotaExceededException(v **types.Ser return nil } -func awsAwsjson11_deserializeDocumentServiceUnavailableException(v **types.ServiceUnavailableException, value interface{}) error { +func awsAwsjson11_deserializeDocumentTrimStringWithKeys(v *[]string, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -18537,39 +23554,35 @@ func awsAwsjson11_deserializeDocumentServiceUnavailableException(v **types.Servi return nil } - shape, ok := value.(map[string]interface{}) + shape, ok := value.([]interface{}) if !ok { return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.ServiceUnavailableException + var cv []string if *v == nil { - sv = &types.ServiceUnavailableException{} + cv = []string{} } else { - sv = *v + cv = *v } - for key, value := range shape { - switch key { - case "message", "Message": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected Message to be of type string, got %T instead", value) - } - sv.Message = ptr.String(jtv) + for _, value := range shape { + var col string + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected WithKey to be of type string, got %T instead", value) } - - default: - _, _ = key, value - + col = jtv } + cv = append(cv, col) + } - *v = sv + *v = cv return nil } -func awsAwsjson11_deserializeDocumentSplitString(v **types.SplitString, value interface{}) error { +func awsAwsjson11_deserializeDocumentTypeConverter(v **types.TypeConverter, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -18582,9 +23595,9 @@ func awsAwsjson11_deserializeDocumentSplitString(v **types.SplitString, value in return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.SplitString + var sv *types.TypeConverter if *v == nil { - sv = &types.SplitString{} + sv = &types.TypeConverter{} } else { sv = *v } @@ -18592,7 +23605,7 @@ func awsAwsjson11_deserializeDocumentSplitString(v **types.SplitString, value in for key, value := range shape { switch key { case "entries": - if err := awsAwsjson11_deserializeDocumentSplitStringEntries(&sv.Entries, value); err != nil { + if err := awsAwsjson11_deserializeDocumentTypeConverterEntries(&sv.Entries, value); err != nil { return err } @@ -18605,7 +23618,7 @@ func awsAwsjson11_deserializeDocumentSplitString(v **types.SplitString, value in return nil } -func awsAwsjson11_deserializeDocumentSplitStringEntries(v *[]types.SplitStringEntry, value interface{}) error { +func awsAwsjson11_deserializeDocumentTypeConverterEntries(v *[]types.TypeConverterEntry, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -18618,17 +23631,17 @@ func awsAwsjson11_deserializeDocumentSplitStringEntries(v *[]types.SplitStringEn return fmt.Errorf("unexpected JSON type %v", value) } - var cv []types.SplitStringEntry + var cv []types.TypeConverterEntry if *v == nil { - cv = []types.SplitStringEntry{} + cv = []types.TypeConverterEntry{} } else { cv = *v } for _, value := range shape { - var col types.SplitStringEntry + var col types.TypeConverterEntry destAddr := &col - if err := awsAwsjson11_deserializeDocumentSplitStringEntry(&destAddr, value); err != nil { + if err := awsAwsjson11_deserializeDocumentTypeConverterEntry(&destAddr, value); err != nil { return err } col = *destAddr @@ -18639,7 +23652,7 @@ func awsAwsjson11_deserializeDocumentSplitStringEntries(v *[]types.SplitStringEn return nil } -func awsAwsjson11_deserializeDocumentSplitStringEntry(v **types.SplitStringEntry, value interface{}) error { +func awsAwsjson11_deserializeDocumentTypeConverterEntry(v **types.TypeConverterEntry, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -18652,31 +23665,31 @@ func awsAwsjson11_deserializeDocumentSplitStringEntry(v **types.SplitStringEntry return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.SplitStringEntry + var sv *types.TypeConverterEntry if *v == nil { - sv = &types.SplitStringEntry{} + sv = &types.TypeConverterEntry{} } else { sv = *v } for key, value := range shape { switch key { - case "delimiter": + case "key": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected Delimiter to be of type string, got %T instead", value) + return fmt.Errorf("expected Key to be of type string, got %T instead", value) } - sv.Delimiter = ptr.String(jtv) + sv.Key = ptr.String(jtv) } - case "source": + case "type": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected Source to be of type string, got %T instead", value) + return fmt.Errorf("expected Type to be of type string, got %T instead", value) } - sv.Source = ptr.String(jtv) + sv.Type = types.Type(jtv) } default: @@ -18688,7 +23701,7 @@ func awsAwsjson11_deserializeDocumentSplitStringEntry(v **types.SplitStringEntry return nil } -func awsAwsjson11_deserializeDocumentSubscriptionFilter(v **types.SubscriptionFilter, value interface{}) error { +func awsAwsjson11_deserializeDocumentUnrecognizedClientException(v **types.UnrecognizedClientException, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -18701,89 +23714,58 @@ func awsAwsjson11_deserializeDocumentSubscriptionFilter(v **types.SubscriptionFi return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.SubscriptionFilter + var sv *types.UnrecognizedClientException if *v == nil { - sv = &types.SubscriptionFilter{} + sv = &types.UnrecognizedClientException{} } else { sv = *v } for key, value := range shape { switch key { - case "applyOnTransformedLogs": - if value != nil { - jtv, ok := value.(bool) - if !ok { - return fmt.Errorf("expected ApplyOnTransformedLogs to be of type *bool, got %T instead", value) - } - sv.ApplyOnTransformedLogs = jtv - } - - case "creationTime": - if value != nil { - jtv, ok := value.(json.Number) - if !ok { - return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) - } - i64, err := jtv.Int64() - if err != nil { - return err - } - sv.CreationTime = ptr.Int64(i64) - } - - case "destinationArn": + case "message", "Message": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected DestinationArn to be of type string, got %T instead", value) + return fmt.Errorf("expected Message to be of type string, got %T instead", value) } - sv.DestinationArn = ptr.String(jtv) + sv.Message = ptr.String(jtv) } - case "distribution": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected Distribution to be of type string, got %T instead", value) - } - sv.Distribution = types.Distribution(jtv) - } + default: + _, _ = key, value - case "filterName": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected FilterName to be of type string, got %T instead", value) - } - sv.FilterName = ptr.String(jtv) - } + } + } + *v = sv + return nil +} - case "filterPattern": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected FilterPattern to be of type string, got %T instead", value) - } - sv.FilterPattern = ptr.String(jtv) - } +func awsAwsjson11_deserializeDocumentUpperCaseString(v **types.UpperCaseString, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } - case "logGroupName": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected LogGroupName to be of type string, got %T instead", value) - } - sv.LogGroupName = ptr.String(jtv) - } + shape, ok := value.(map[string]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } - case "roleArn": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected RoleArn to be of type string, got %T instead", value) - } - sv.RoleArn = ptr.String(jtv) + var sv *types.UpperCaseString + if *v == nil { + sv = &types.UpperCaseString{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "withKeys": + if err := awsAwsjson11_deserializeDocumentUpperCaseStringWithKeys(&sv.WithKeys, value); err != nil { + return err } default: @@ -18795,7 +23777,7 @@ func awsAwsjson11_deserializeDocumentSubscriptionFilter(v **types.SubscriptionFi return nil } -func awsAwsjson11_deserializeDocumentSubscriptionFilters(v *[]types.SubscriptionFilter, value interface{}) error { +func awsAwsjson11_deserializeDocumentUpperCaseStringWithKeys(v *[]string, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -18808,20 +23790,22 @@ func awsAwsjson11_deserializeDocumentSubscriptionFilters(v *[]types.Subscription return fmt.Errorf("unexpected JSON type %v", value) } - var cv []types.SubscriptionFilter + var cv []string if *v == nil { - cv = []types.SubscriptionFilter{} + cv = []string{} } else { cv = *v } for _, value := range shape { - var col types.SubscriptionFilter - destAddr := &col - if err := awsAwsjson11_deserializeDocumentSubscriptionFilter(&destAddr, value); err != nil { - return err + var col string + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected WithKey to be of type string, got %T instead", value) + } + col = jtv } - col = *destAddr cv = append(cv, col) } @@ -18829,7 +23813,7 @@ func awsAwsjson11_deserializeDocumentSubscriptionFilters(v *[]types.Subscription return nil } -func awsAwsjson11_deserializeDocumentSubstituteString(v **types.SubstituteString, value interface{}) error { +func awsAwsjson11_deserializeDocumentValidationException(v **types.ValidationException, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -18842,18 +23826,22 @@ func awsAwsjson11_deserializeDocumentSubstituteString(v **types.SubstituteString return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.SubstituteString + var sv *types.ValidationException if *v == nil { - sv = &types.SubstituteString{} + sv = &types.ValidationException{} } else { sv = *v } for key, value := range shape { switch key { - case "entries": - if err := awsAwsjson11_deserializeDocumentSubstituteStringEntries(&sv.Entries, value); err != nil { - return err + case "message", "Message": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected Message to be of type string, got %T instead", value) + } + sv.Message = ptr.String(jtv) } default: @@ -18865,7 +23853,7 @@ func awsAwsjson11_deserializeDocumentSubstituteString(v **types.SubstituteString return nil } -func awsAwsjson11_deserializeDocumentSubstituteStringEntries(v *[]types.SubstituteStringEntry, value interface{}) error { +func awsAwsjson11_deserializeOpDocumentAssociateSourceToS3TableIntegrationOutput(v **AssociateSourceToS3TableIntegrationOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -18873,33 +23861,39 @@ func awsAwsjson11_deserializeDocumentSubstituteStringEntries(v *[]types.Substitu return nil } - shape, ok := value.([]interface{}) + shape, ok := value.(map[string]interface{}) if !ok { return fmt.Errorf("unexpected JSON type %v", value) } - var cv []types.SubstituteStringEntry + var sv *AssociateSourceToS3TableIntegrationOutput if *v == nil { - cv = []types.SubstituteStringEntry{} + sv = &AssociateSourceToS3TableIntegrationOutput{} } else { - cv = *v + sv = *v } - for _, value := range shape { - var col types.SubstituteStringEntry - destAddr := &col - if err := awsAwsjson11_deserializeDocumentSubstituteStringEntry(&destAddr, value); err != nil { - return err - } - col = *destAddr - cv = append(cv, col) + for key, value := range shape { + switch key { + case "identifier": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected S3TableIntegrationSourceIdentifier to be of type string, got %T instead", value) + } + sv.Identifier = ptr.String(jtv) + } + + default: + _, _ = key, value + } } - *v = cv + *v = sv return nil } -func awsAwsjson11_deserializeDocumentSubstituteStringEntry(v **types.SubstituteStringEntry, value interface{}) error { +func awsAwsjson11_deserializeOpDocumentCancelImportTaskOutput(v **CancelImportTaskOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -18912,40 +23906,62 @@ func awsAwsjson11_deserializeDocumentSubstituteStringEntry(v **types.SubstituteS return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.SubstituteStringEntry + var sv *CancelImportTaskOutput if *v == nil { - sv = &types.SubstituteStringEntry{} + sv = &CancelImportTaskOutput{} } else { sv = *v } for key, value := range shape { switch key { - case "from": + case "creationTime": if value != nil { - jtv, ok := value.(string) + jtv, ok := value.(json.Number) if !ok { - return fmt.Errorf("expected FromKey to be of type string, got %T instead", value) + return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) } - sv.From = ptr.String(jtv) + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.CreationTime = ptr.Int64(i64) } - case "source": + case "importId": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected Source to be of type string, got %T instead", value) + return fmt.Errorf("expected ImportId to be of type string, got %T instead", value) } - sv.Source = ptr.String(jtv) + sv.ImportId = ptr.String(jtv) } - case "to": + case "importStatistics": + if err := awsAwsjson11_deserializeDocumentImportStatistics(&sv.ImportStatistics, value); err != nil { + return err + } + + case "importStatus": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected ToKey to be of type string, got %T instead", value) + return fmt.Errorf("expected ImportStatus to be of type string, got %T instead", value) } - sv.To = ptr.String(jtv) + sv.ImportStatus = types.ImportStatus(jtv) + } + + case "lastUpdatedTime": + if value != nil { + jtv, ok := value.(json.Number) + if !ok { + return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) + } + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.LastUpdatedTime = ptr.Int64(i64) } default: @@ -18957,7 +23973,7 @@ func awsAwsjson11_deserializeDocumentSubstituteStringEntry(v **types.SubstituteS return nil } -func awsAwsjson11_deserializeDocumentTags(v *map[string]string, value interface{}) error { +func awsAwsjson11_deserializeOpDocumentCreateDeliveryOutput(v **CreateDeliveryOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -18970,30 +23986,30 @@ func awsAwsjson11_deserializeDocumentTags(v *map[string]string, value interface{ return fmt.Errorf("unexpected JSON type %v", value) } - var mv map[string]string + var sv *CreateDeliveryOutput if *v == nil { - mv = map[string]string{} + sv = &CreateDeliveryOutput{} } else { - mv = *v + sv = *v } for key, value := range shape { - var parsedVal string - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected TagValue to be of type string, got %T instead", value) + switch key { + case "delivery": + if err := awsAwsjson11_deserializeDocumentDelivery(&sv.Delivery, value); err != nil { + return err } - parsedVal = jtv - } - mv[key] = parsedVal + default: + _, _ = key, value + + } } - *v = mv + *v = sv return nil } -func awsAwsjson11_deserializeDocumentThrottlingException(v **types.ThrottlingException, value interface{}) error { +func awsAwsjson11_deserializeOpDocumentCreateExportTaskOutput(v **CreateExportTaskOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -19006,22 +24022,22 @@ func awsAwsjson11_deserializeDocumentThrottlingException(v **types.ThrottlingExc return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.ThrottlingException + var sv *CreateExportTaskOutput if *v == nil { - sv = &types.ThrottlingException{} + sv = &CreateExportTaskOutput{} } else { sv = *v } for key, value := range shape { switch key { - case "message", "Message": + case "taskId": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected Message to be of type string, got %T instead", value) + return fmt.Errorf("expected ExportTaskId to be of type string, got %T instead", value) } - sv.Message = ptr.String(jtv) + sv.TaskId = ptr.String(jtv) } default: @@ -19033,7 +24049,7 @@ func awsAwsjson11_deserializeDocumentThrottlingException(v **types.ThrottlingExc return nil } -func awsAwsjson11_deserializeDocumentTooManyTagsException(v **types.TooManyTagsException, value interface{}) error { +func awsAwsjson11_deserializeOpDocumentCreateImportTaskOutput(v **CreateImportTaskOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -19046,31 +24062,44 @@ func awsAwsjson11_deserializeDocumentTooManyTagsException(v **types.TooManyTagsE return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.TooManyTagsException + var sv *CreateImportTaskOutput if *v == nil { - sv = &types.TooManyTagsException{} + sv = &CreateImportTaskOutput{} } else { sv = *v } for key, value := range shape { switch key { - case "message", "Message": + case "creationTime": + if value != nil { + jtv, ok := value.(json.Number) + if !ok { + return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) + } + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.CreationTime = ptr.Int64(i64) + } + + case "importDestinationArn": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected Message to be of type string, got %T instead", value) + return fmt.Errorf("expected Arn to be of type string, got %T instead", value) } - sv.Message = ptr.String(jtv) + sv.ImportDestinationArn = ptr.String(jtv) } - case "resourceName": + case "importId": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected AmazonResourceName to be of type string, got %T instead", value) + return fmt.Errorf("expected ImportId to be of type string, got %T instead", value) } - sv.ResourceName = ptr.String(jtv) + sv.ImportId = ptr.String(jtv) } default: @@ -19082,7 +24111,7 @@ func awsAwsjson11_deserializeDocumentTooManyTagsException(v **types.TooManyTagsE return nil } -func awsAwsjson11_deserializeDocumentTransformedLogRecord(v **types.TransformedLogRecord, value interface{}) error { +func awsAwsjson11_deserializeOpDocumentCreateLogAnomalyDetectorOutput(v **CreateLogAnomalyDetectorOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -19095,44 +24124,22 @@ func awsAwsjson11_deserializeDocumentTransformedLogRecord(v **types.TransformedL return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.TransformedLogRecord + var sv *CreateLogAnomalyDetectorOutput if *v == nil { - sv = &types.TransformedLogRecord{} + sv = &CreateLogAnomalyDetectorOutput{} } else { sv = *v } for key, value := range shape { switch key { - case "eventMessage": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected EventMessage to be of type string, got %T instead", value) - } - sv.EventMessage = ptr.String(jtv) - } - - case "eventNumber": - if value != nil { - jtv, ok := value.(json.Number) - if !ok { - return fmt.Errorf("expected EventNumber to be json.Number, got %T instead", value) - } - i64, err := jtv.Int64() - if err != nil { - return err - } - sv.EventNumber = i64 - } - - case "transformedEventMessage": + case "anomalyDetectorArn": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected TransformedEventMessage to be of type string, got %T instead", value) + return fmt.Errorf("expected AnomalyDetectorArn to be of type string, got %T instead", value) } - sv.TransformedEventMessage = ptr.String(jtv) + sv.AnomalyDetectorArn = ptr.String(jtv) } default: @@ -19144,41 +24151,7 @@ func awsAwsjson11_deserializeDocumentTransformedLogRecord(v **types.TransformedL return nil } -func awsAwsjson11_deserializeDocumentTransformedLogs(v *[]types.TransformedLogRecord, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.([]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } - - var cv []types.TransformedLogRecord - if *v == nil { - cv = []types.TransformedLogRecord{} - } else { - cv = *v - } - - for _, value := range shape { - var col types.TransformedLogRecord - destAddr := &col - if err := awsAwsjson11_deserializeDocumentTransformedLogRecord(&destAddr, value); err != nil { - return err - } - col = *destAddr - cv = append(cv, col) - - } - *v = cv - return nil -} - -func awsAwsjson11_deserializeDocumentTrimString(v **types.TrimString, value interface{}) error { +func awsAwsjson11_deserializeOpDocumentCreateScheduledQueryOutput(v **CreateScheduledQueryOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -19191,18 +24164,31 @@ func awsAwsjson11_deserializeDocumentTrimString(v **types.TrimString, value inte return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.TrimString + var sv *CreateScheduledQueryOutput if *v == nil { - sv = &types.TrimString{} + sv = &CreateScheduledQueryOutput{} } else { sv = *v } for key, value := range shape { switch key { - case "withKeys": - if err := awsAwsjson11_deserializeDocumentTrimStringWithKeys(&sv.WithKeys, value); err != nil { - return err + case "scheduledQueryArn": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected Arn to be of type string, got %T instead", value) + } + sv.ScheduledQueryArn = ptr.String(jtv) + } + + case "state": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected ScheduledQueryState to be of type string, got %T instead", value) + } + sv.State = types.ScheduledQueryState(jtv) } default: @@ -19214,7 +24200,7 @@ func awsAwsjson11_deserializeDocumentTrimString(v **types.TrimString, value inte return nil } -func awsAwsjson11_deserializeDocumentTrimStringWithKeys(v *[]string, value interface{}) error { +func awsAwsjson11_deserializeOpDocumentDeleteIndexPolicyOutput(v **DeleteIndexPolicyOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -19222,35 +24208,30 @@ func awsAwsjson11_deserializeDocumentTrimStringWithKeys(v *[]string, value inter return nil } - shape, ok := value.([]interface{}) + shape, ok := value.(map[string]interface{}) if !ok { return fmt.Errorf("unexpected JSON type %v", value) } - var cv []string + var sv *DeleteIndexPolicyOutput if *v == nil { - cv = []string{} + sv = &DeleteIndexPolicyOutput{} } else { - cv = *v + sv = *v } - for _, value := range shape { - var col string - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected WithKey to be of type string, got %T instead", value) - } - col = jtv - } - cv = append(cv, col) + for key, value := range shape { + switch key { + default: + _, _ = key, value + } } - *v = cv + *v = sv return nil } -func awsAwsjson11_deserializeDocumentTypeConverter(v **types.TypeConverter, value interface{}) error { +func awsAwsjson11_deserializeOpDocumentDeleteIntegrationOutput(v **DeleteIntegrationOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -19263,20 +24244,15 @@ func awsAwsjson11_deserializeDocumentTypeConverter(v **types.TypeConverter, valu return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.TypeConverter + var sv *DeleteIntegrationOutput if *v == nil { - sv = &types.TypeConverter{} + sv = &DeleteIntegrationOutput{} } else { sv = *v } for key, value := range shape { switch key { - case "entries": - if err := awsAwsjson11_deserializeDocumentTypeConverterEntries(&sv.Entries, value); err != nil { - return err - } - default: _, _ = key, value @@ -19286,7 +24262,7 @@ func awsAwsjson11_deserializeDocumentTypeConverter(v **types.TypeConverter, valu return nil } -func awsAwsjson11_deserializeDocumentTypeConverterEntries(v *[]types.TypeConverterEntry, value interface{}) error { +func awsAwsjson11_deserializeOpDocumentDeleteQueryDefinitionOutput(v **DeleteQueryDefinitionOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -19294,33 +24270,39 @@ func awsAwsjson11_deserializeDocumentTypeConverterEntries(v *[]types.TypeConvert return nil } - shape, ok := value.([]interface{}) + shape, ok := value.(map[string]interface{}) if !ok { return fmt.Errorf("unexpected JSON type %v", value) } - var cv []types.TypeConverterEntry + var sv *DeleteQueryDefinitionOutput if *v == nil { - cv = []types.TypeConverterEntry{} + sv = &DeleteQueryDefinitionOutput{} } else { - cv = *v + sv = *v } - for _, value := range shape { - var col types.TypeConverterEntry - destAddr := &col - if err := awsAwsjson11_deserializeDocumentTypeConverterEntry(&destAddr, value); err != nil { - return err - } - col = *destAddr - cv = append(cv, col) + for key, value := range shape { + switch key { + case "success": + if value != nil { + jtv, ok := value.(bool) + if !ok { + return fmt.Errorf("expected Success to be of type *bool, got %T instead", value) + } + sv.Success = jtv + } + + default: + _, _ = key, value + } } - *v = cv + *v = sv return nil } -func awsAwsjson11_deserializeDocumentTypeConverterEntry(v **types.TypeConverterEntry, value interface{}) error { +func awsAwsjson11_deserializeOpDocumentDeleteScheduledQueryOutput(v **DeleteScheduledQueryOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -19333,33 +24315,15 @@ func awsAwsjson11_deserializeDocumentTypeConverterEntry(v **types.TypeConverterE return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.TypeConverterEntry + var sv *DeleteScheduledQueryOutput if *v == nil { - sv = &types.TypeConverterEntry{} + sv = &DeleteScheduledQueryOutput{} } else { sv = *v } for key, value := range shape { switch key { - case "key": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected Key to be of type string, got %T instead", value) - } - sv.Key = ptr.String(jtv) - } - - case "type": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected Type to be of type string, got %T instead", value) - } - sv.Type = types.Type(jtv) - } - default: _, _ = key, value @@ -19369,7 +24333,7 @@ func awsAwsjson11_deserializeDocumentTypeConverterEntry(v **types.TypeConverterE return nil } -func awsAwsjson11_deserializeDocumentUnrecognizedClientException(v **types.UnrecognizedClientException, value interface{}) error { +func awsAwsjson11_deserializeOpDocumentDescribeAccountPoliciesOutput(v **DescribeAccountPoliciesOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -19382,22 +24346,27 @@ func awsAwsjson11_deserializeDocumentUnrecognizedClientException(v **types.Unrec return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.UnrecognizedClientException + var sv *DescribeAccountPoliciesOutput if *v == nil { - sv = &types.UnrecognizedClientException{} + sv = &DescribeAccountPoliciesOutput{} } else { sv = *v } for key, value := range shape { switch key { - case "message", "Message": + case "accountPolicies": + if err := awsAwsjson11_deserializeDocumentAccountPolicies(&sv.AccountPolicies, value); err != nil { + return err + } + + case "nextToken": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected Message to be of type string, got %T instead", value) + return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) } - sv.Message = ptr.String(jtv) + sv.NextToken = ptr.String(jtv) } default: @@ -19409,7 +24378,7 @@ func awsAwsjson11_deserializeDocumentUnrecognizedClientException(v **types.Unrec return nil } -func awsAwsjson11_deserializeDocumentUpperCaseString(v **types.UpperCaseString, value interface{}) error { +func awsAwsjson11_deserializeOpDocumentDescribeConfigurationTemplatesOutput(v **DescribeConfigurationTemplatesOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -19422,20 +24391,29 @@ func awsAwsjson11_deserializeDocumentUpperCaseString(v **types.UpperCaseString, return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.UpperCaseString + var sv *DescribeConfigurationTemplatesOutput if *v == nil { - sv = &types.UpperCaseString{} + sv = &DescribeConfigurationTemplatesOutput{} } else { sv = *v } for key, value := range shape { switch key { - case "withKeys": - if err := awsAwsjson11_deserializeDocumentUpperCaseStringWithKeys(&sv.WithKeys, value); err != nil { + case "configurationTemplates": + if err := awsAwsjson11_deserializeDocumentConfigurationTemplates(&sv.ConfigurationTemplates, value); err != nil { return err } + case "nextToken": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) + } + sv.NextToken = ptr.String(jtv) + } + default: _, _ = key, value @@ -19445,7 +24423,7 @@ func awsAwsjson11_deserializeDocumentUpperCaseString(v **types.UpperCaseString, return nil } -func awsAwsjson11_deserializeDocumentUpperCaseStringWithKeys(v *[]string, value interface{}) error { +func awsAwsjson11_deserializeOpDocumentDescribeDeliveriesOutput(v **DescribeDeliveriesOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -19453,35 +24431,44 @@ func awsAwsjson11_deserializeDocumentUpperCaseStringWithKeys(v *[]string, value return nil } - shape, ok := value.([]interface{}) + shape, ok := value.(map[string]interface{}) if !ok { return fmt.Errorf("unexpected JSON type %v", value) } - var cv []string + var sv *DescribeDeliveriesOutput if *v == nil { - cv = []string{} + sv = &DescribeDeliveriesOutput{} } else { - cv = *v + sv = *v } - for _, value := range shape { - var col string - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected WithKey to be of type string, got %T instead", value) + for key, value := range shape { + switch key { + case "deliveries": + if err := awsAwsjson11_deserializeDocumentDeliveries(&sv.Deliveries, value); err != nil { + return err } - col = jtv - } - cv = append(cv, col) + case "nextToken": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) + } + sv.NextToken = ptr.String(jtv) + } + + default: + _, _ = key, value + + } } - *v = cv + *v = sv return nil } -func awsAwsjson11_deserializeDocumentValidationException(v **types.ValidationException, value interface{}) error { +func awsAwsjson11_deserializeOpDocumentDescribeDeliveryDestinationsOutput(v **DescribeDeliveryDestinationsOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -19494,22 +24481,27 @@ func awsAwsjson11_deserializeDocumentValidationException(v **types.ValidationExc return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.ValidationException + var sv *DescribeDeliveryDestinationsOutput if *v == nil { - sv = &types.ValidationException{} + sv = &DescribeDeliveryDestinationsOutput{} } else { sv = *v } for key, value := range shape { switch key { - case "message", "Message": + case "deliveryDestinations": + if err := awsAwsjson11_deserializeDocumentDeliveryDestinations(&sv.DeliveryDestinations, value); err != nil { + return err + } + + case "nextToken": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected Message to be of type string, got %T instead", value) + return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) } - sv.Message = ptr.String(jtv) + sv.NextToken = ptr.String(jtv) } default: @@ -19521,7 +24513,7 @@ func awsAwsjson11_deserializeDocumentValidationException(v **types.ValidationExc return nil } -func awsAwsjson11_deserializeOpDocumentCreateDeliveryOutput(v **CreateDeliveryOutput, value interface{}) error { +func awsAwsjson11_deserializeOpDocumentDescribeDeliverySourcesOutput(v **DescribeDeliverySourcesOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -19534,20 +24526,29 @@ func awsAwsjson11_deserializeOpDocumentCreateDeliveryOutput(v **CreateDeliveryOu return fmt.Errorf("unexpected JSON type %v", value) } - var sv *CreateDeliveryOutput + var sv *DescribeDeliverySourcesOutput if *v == nil { - sv = &CreateDeliveryOutput{} + sv = &DescribeDeliverySourcesOutput{} } else { sv = *v } for key, value := range shape { switch key { - case "delivery": - if err := awsAwsjson11_deserializeDocumentDelivery(&sv.Delivery, value); err != nil { + case "deliverySources": + if err := awsAwsjson11_deserializeDocumentDeliverySources(&sv.DeliverySources, value); err != nil { return err } + case "nextToken": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) + } + sv.NextToken = ptr.String(jtv) + } + default: _, _ = key, value @@ -19557,7 +24558,7 @@ func awsAwsjson11_deserializeOpDocumentCreateDeliveryOutput(v **CreateDeliveryOu return nil } -func awsAwsjson11_deserializeOpDocumentCreateExportTaskOutput(v **CreateExportTaskOutput, value interface{}) error { +func awsAwsjson11_deserializeOpDocumentDescribeDestinationsOutput(v **DescribeDestinationsOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -19570,22 +24571,27 @@ func awsAwsjson11_deserializeOpDocumentCreateExportTaskOutput(v **CreateExportTa return fmt.Errorf("unexpected JSON type %v", value) } - var sv *CreateExportTaskOutput + var sv *DescribeDestinationsOutput if *v == nil { - sv = &CreateExportTaskOutput{} + sv = &DescribeDestinationsOutput{} } else { sv = *v } for key, value := range shape { switch key { - case "taskId": + case "destinations": + if err := awsAwsjson11_deserializeDocumentDestinations(&sv.Destinations, value); err != nil { + return err + } + + case "nextToken": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected ExportTaskId to be of type string, got %T instead", value) + return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) } - sv.TaskId = ptr.String(jtv) + sv.NextToken = ptr.String(jtv) } default: @@ -19597,7 +24603,7 @@ func awsAwsjson11_deserializeOpDocumentCreateExportTaskOutput(v **CreateExportTa return nil } -func awsAwsjson11_deserializeOpDocumentCreateLogAnomalyDetectorOutput(v **CreateLogAnomalyDetectorOutput, value interface{}) error { +func awsAwsjson11_deserializeOpDocumentDescribeExportTasksOutput(v **DescribeExportTasksOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -19610,22 +24616,27 @@ func awsAwsjson11_deserializeOpDocumentCreateLogAnomalyDetectorOutput(v **Create return fmt.Errorf("unexpected JSON type %v", value) } - var sv *CreateLogAnomalyDetectorOutput + var sv *DescribeExportTasksOutput if *v == nil { - sv = &CreateLogAnomalyDetectorOutput{} + sv = &DescribeExportTasksOutput{} } else { sv = *v } for key, value := range shape { switch key { - case "anomalyDetectorArn": + case "exportTasks": + if err := awsAwsjson11_deserializeDocumentExportTasks(&sv.ExportTasks, value); err != nil { + return err + } + + case "nextToken": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected AnomalyDetectorArn to be of type string, got %T instead", value) + return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) } - sv.AnomalyDetectorArn = ptr.String(jtv) + sv.NextToken = ptr.String(jtv) } default: @@ -19637,7 +24648,7 @@ func awsAwsjson11_deserializeOpDocumentCreateLogAnomalyDetectorOutput(v **Create return nil } -func awsAwsjson11_deserializeOpDocumentDeleteIndexPolicyOutput(v **DeleteIndexPolicyOutput, value interface{}) error { +func awsAwsjson11_deserializeOpDocumentDescribeFieldIndexesOutput(v **DescribeFieldIndexesOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -19650,15 +24661,29 @@ func awsAwsjson11_deserializeOpDocumentDeleteIndexPolicyOutput(v **DeleteIndexPo return fmt.Errorf("unexpected JSON type %v", value) } - var sv *DeleteIndexPolicyOutput + var sv *DescribeFieldIndexesOutput if *v == nil { - sv = &DeleteIndexPolicyOutput{} + sv = &DescribeFieldIndexesOutput{} } else { sv = *v } for key, value := range shape { switch key { + case "fieldIndexes": + if err := awsAwsjson11_deserializeDocumentFieldIndexes(&sv.FieldIndexes, value); err != nil { + return err + } + + case "nextToken": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) + } + sv.NextToken = ptr.String(jtv) + } + default: _, _ = key, value @@ -19668,7 +24693,7 @@ func awsAwsjson11_deserializeOpDocumentDeleteIndexPolicyOutput(v **DeleteIndexPo return nil } -func awsAwsjson11_deserializeOpDocumentDeleteIntegrationOutput(v **DeleteIntegrationOutput, value interface{}) error { +func awsAwsjson11_deserializeOpDocumentDescribeImportTaskBatchesOutput(v **DescribeImportTaskBatchesOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -19681,15 +24706,47 @@ func awsAwsjson11_deserializeOpDocumentDeleteIntegrationOutput(v **DeleteIntegra return fmt.Errorf("unexpected JSON type %v", value) } - var sv *DeleteIntegrationOutput + var sv *DescribeImportTaskBatchesOutput if *v == nil { - sv = &DeleteIntegrationOutput{} + sv = &DescribeImportTaskBatchesOutput{} } else { sv = *v } for key, value := range shape { switch key { + case "importBatches": + if err := awsAwsjson11_deserializeDocumentImportBatchList(&sv.ImportBatches, value); err != nil { + return err + } + + case "importId": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected ImportId to be of type string, got %T instead", value) + } + sv.ImportId = ptr.String(jtv) + } + + case "importSourceArn": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected Arn to be of type string, got %T instead", value) + } + sv.ImportSourceArn = ptr.String(jtv) + } + + case "nextToken": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) + } + sv.NextToken = ptr.String(jtv) + } + default: _, _ = key, value @@ -19699,7 +24756,7 @@ func awsAwsjson11_deserializeOpDocumentDeleteIntegrationOutput(v **DeleteIntegra return nil } -func awsAwsjson11_deserializeOpDocumentDeleteQueryDefinitionOutput(v **DeleteQueryDefinitionOutput, value interface{}) error { +func awsAwsjson11_deserializeOpDocumentDescribeImportTasksOutput(v **DescribeImportTasksOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -19712,22 +24769,27 @@ func awsAwsjson11_deserializeOpDocumentDeleteQueryDefinitionOutput(v **DeleteQue return fmt.Errorf("unexpected JSON type %v", value) } - var sv *DeleteQueryDefinitionOutput + var sv *DescribeImportTasksOutput if *v == nil { - sv = &DeleteQueryDefinitionOutput{} + sv = &DescribeImportTasksOutput{} } else { sv = *v } for key, value := range shape { switch key { - case "success": + case "imports": + if err := awsAwsjson11_deserializeDocumentImportList(&sv.Imports, value); err != nil { + return err + } + + case "nextToken": if value != nil { - jtv, ok := value.(bool) + jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected Success to be of type *bool, got %T instead", value) + return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) } - sv.Success = jtv + sv.NextToken = ptr.String(jtv) } default: @@ -19739,7 +24801,7 @@ func awsAwsjson11_deserializeOpDocumentDeleteQueryDefinitionOutput(v **DeleteQue return nil } -func awsAwsjson11_deserializeOpDocumentDescribeAccountPoliciesOutput(v **DescribeAccountPoliciesOutput, value interface{}) error { +func awsAwsjson11_deserializeOpDocumentDescribeIndexPoliciesOutput(v **DescribeIndexPoliciesOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -19752,17 +24814,17 @@ func awsAwsjson11_deserializeOpDocumentDescribeAccountPoliciesOutput(v **Describ return fmt.Errorf("unexpected JSON type %v", value) } - var sv *DescribeAccountPoliciesOutput + var sv *DescribeIndexPoliciesOutput if *v == nil { - sv = &DescribeAccountPoliciesOutput{} + sv = &DescribeIndexPoliciesOutput{} } else { sv = *v } for key, value := range shape { switch key { - case "accountPolicies": - if err := awsAwsjson11_deserializeDocumentAccountPolicies(&sv.AccountPolicies, value); err != nil { + case "indexPolicies": + if err := awsAwsjson11_deserializeDocumentIndexPolicies(&sv.IndexPolicies, value); err != nil { return err } @@ -19784,7 +24846,7 @@ func awsAwsjson11_deserializeOpDocumentDescribeAccountPoliciesOutput(v **Describ return nil } -func awsAwsjson11_deserializeOpDocumentDescribeConfigurationTemplatesOutput(v **DescribeConfigurationTemplatesOutput, value interface{}) error { +func awsAwsjson11_deserializeOpDocumentDescribeLogGroupsOutput(v **DescribeLogGroupsOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -19797,17 +24859,17 @@ func awsAwsjson11_deserializeOpDocumentDescribeConfigurationTemplatesOutput(v ** return fmt.Errorf("unexpected JSON type %v", value) } - var sv *DescribeConfigurationTemplatesOutput + var sv *DescribeLogGroupsOutput if *v == nil { - sv = &DescribeConfigurationTemplatesOutput{} + sv = &DescribeLogGroupsOutput{} } else { sv = *v } for key, value := range shape { switch key { - case "configurationTemplates": - if err := awsAwsjson11_deserializeDocumentConfigurationTemplates(&sv.ConfigurationTemplates, value); err != nil { + case "logGroups": + if err := awsAwsjson11_deserializeDocumentLogGroups(&sv.LogGroups, value); err != nil { return err } @@ -19829,7 +24891,7 @@ func awsAwsjson11_deserializeOpDocumentDescribeConfigurationTemplatesOutput(v ** return nil } -func awsAwsjson11_deserializeOpDocumentDescribeDeliveriesOutput(v **DescribeDeliveriesOutput, value interface{}) error { +func awsAwsjson11_deserializeOpDocumentDescribeLogStreamsOutput(v **DescribeLogStreamsOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -19842,17 +24904,17 @@ func awsAwsjson11_deserializeOpDocumentDescribeDeliveriesOutput(v **DescribeDeli return fmt.Errorf("unexpected JSON type %v", value) } - var sv *DescribeDeliveriesOutput + var sv *DescribeLogStreamsOutput if *v == nil { - sv = &DescribeDeliveriesOutput{} + sv = &DescribeLogStreamsOutput{} } else { sv = *v } for key, value := range shape { switch key { - case "deliveries": - if err := awsAwsjson11_deserializeDocumentDeliveries(&sv.Deliveries, value); err != nil { + case "logStreams": + if err := awsAwsjson11_deserializeDocumentLogStreams(&sv.LogStreams, value); err != nil { return err } @@ -19874,7 +24936,7 @@ func awsAwsjson11_deserializeOpDocumentDescribeDeliveriesOutput(v **DescribeDeli return nil } -func awsAwsjson11_deserializeOpDocumentDescribeDeliveryDestinationsOutput(v **DescribeDeliveryDestinationsOutput, value interface{}) error { +func awsAwsjson11_deserializeOpDocumentDescribeMetricFiltersOutput(v **DescribeMetricFiltersOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -19887,17 +24949,17 @@ func awsAwsjson11_deserializeOpDocumentDescribeDeliveryDestinationsOutput(v **De return fmt.Errorf("unexpected JSON type %v", value) } - var sv *DescribeDeliveryDestinationsOutput + var sv *DescribeMetricFiltersOutput if *v == nil { - sv = &DescribeDeliveryDestinationsOutput{} + sv = &DescribeMetricFiltersOutput{} } else { sv = *v } for key, value := range shape { switch key { - case "deliveryDestinations": - if err := awsAwsjson11_deserializeDocumentDeliveryDestinations(&sv.DeliveryDestinations, value); err != nil { + case "metricFilters": + if err := awsAwsjson11_deserializeDocumentMetricFilters(&sv.MetricFilters, value); err != nil { return err } @@ -19919,7 +24981,7 @@ func awsAwsjson11_deserializeOpDocumentDescribeDeliveryDestinationsOutput(v **De return nil } -func awsAwsjson11_deserializeOpDocumentDescribeDeliverySourcesOutput(v **DescribeDeliverySourcesOutput, value interface{}) error { +func awsAwsjson11_deserializeOpDocumentDescribeQueriesOutput(v **DescribeQueriesOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -19932,20 +24994,15 @@ func awsAwsjson11_deserializeOpDocumentDescribeDeliverySourcesOutput(v **Describ return fmt.Errorf("unexpected JSON type %v", value) } - var sv *DescribeDeliverySourcesOutput + var sv *DescribeQueriesOutput if *v == nil { - sv = &DescribeDeliverySourcesOutput{} + sv = &DescribeQueriesOutput{} } else { sv = *v } for key, value := range shape { switch key { - case "deliverySources": - if err := awsAwsjson11_deserializeDocumentDeliverySources(&sv.DeliverySources, value); err != nil { - return err - } - case "nextToken": if value != nil { jtv, ok := value.(string) @@ -19955,6 +25012,11 @@ func awsAwsjson11_deserializeOpDocumentDescribeDeliverySourcesOutput(v **Describ sv.NextToken = ptr.String(jtv) } + case "queries": + if err := awsAwsjson11_deserializeDocumentQueryInfoList(&sv.Queries, value); err != nil { + return err + } + default: _, _ = key, value @@ -19964,7 +25026,7 @@ func awsAwsjson11_deserializeOpDocumentDescribeDeliverySourcesOutput(v **Describ return nil } -func awsAwsjson11_deserializeOpDocumentDescribeDestinationsOutput(v **DescribeDestinationsOutput, value interface{}) error { +func awsAwsjson11_deserializeOpDocumentDescribeQueryDefinitionsOutput(v **DescribeQueryDefinitionsOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -19977,20 +25039,15 @@ func awsAwsjson11_deserializeOpDocumentDescribeDestinationsOutput(v **DescribeDe return fmt.Errorf("unexpected JSON type %v", value) } - var sv *DescribeDestinationsOutput + var sv *DescribeQueryDefinitionsOutput if *v == nil { - sv = &DescribeDestinationsOutput{} + sv = &DescribeQueryDefinitionsOutput{} } else { sv = *v } for key, value := range shape { switch key { - case "destinations": - if err := awsAwsjson11_deserializeDocumentDestinations(&sv.Destinations, value); err != nil { - return err - } - case "nextToken": if value != nil { jtv, ok := value.(string) @@ -20000,6 +25057,11 @@ func awsAwsjson11_deserializeOpDocumentDescribeDestinationsOutput(v **DescribeDe sv.NextToken = ptr.String(jtv) } + case "queryDefinitions": + if err := awsAwsjson11_deserializeDocumentQueryDefinitionList(&sv.QueryDefinitions, value); err != nil { + return err + } + default: _, _ = key, value @@ -20009,7 +25071,7 @@ func awsAwsjson11_deserializeOpDocumentDescribeDestinationsOutput(v **DescribeDe return nil } -func awsAwsjson11_deserializeOpDocumentDescribeExportTasksOutput(v **DescribeExportTasksOutput, value interface{}) error { +func awsAwsjson11_deserializeOpDocumentDescribeResourcePoliciesOutput(v **DescribeResourcePoliciesOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -20022,20 +25084,15 @@ func awsAwsjson11_deserializeOpDocumentDescribeExportTasksOutput(v **DescribeExp return fmt.Errorf("unexpected JSON type %v", value) } - var sv *DescribeExportTasksOutput + var sv *DescribeResourcePoliciesOutput if *v == nil { - sv = &DescribeExportTasksOutput{} + sv = &DescribeResourcePoliciesOutput{} } else { sv = *v } for key, value := range shape { switch key { - case "exportTasks": - if err := awsAwsjson11_deserializeDocumentExportTasks(&sv.ExportTasks, value); err != nil { - return err - } - case "nextToken": if value != nil { jtv, ok := value.(string) @@ -20045,6 +25102,11 @@ func awsAwsjson11_deserializeOpDocumentDescribeExportTasksOutput(v **DescribeExp sv.NextToken = ptr.String(jtv) } + case "resourcePolicies": + if err := awsAwsjson11_deserializeDocumentResourcePolicies(&sv.ResourcePolicies, value); err != nil { + return err + } + default: _, _ = key, value @@ -20054,7 +25116,7 @@ func awsAwsjson11_deserializeOpDocumentDescribeExportTasksOutput(v **DescribeExp return nil } -func awsAwsjson11_deserializeOpDocumentDescribeFieldIndexesOutput(v **DescribeFieldIndexesOutput, value interface{}) error { +func awsAwsjson11_deserializeOpDocumentDescribeSubscriptionFiltersOutput(v **DescribeSubscriptionFiltersOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -20067,20 +25129,15 @@ func awsAwsjson11_deserializeOpDocumentDescribeFieldIndexesOutput(v **DescribeFi return fmt.Errorf("unexpected JSON type %v", value) } - var sv *DescribeFieldIndexesOutput + var sv *DescribeSubscriptionFiltersOutput if *v == nil { - sv = &DescribeFieldIndexesOutput{} + sv = &DescribeSubscriptionFiltersOutput{} } else { sv = *v } for key, value := range shape { switch key { - case "fieldIndexes": - if err := awsAwsjson11_deserializeDocumentFieldIndexes(&sv.FieldIndexes, value); err != nil { - return err - } - case "nextToken": if value != nil { jtv, ok := value.(string) @@ -20090,6 +25147,11 @@ func awsAwsjson11_deserializeOpDocumentDescribeFieldIndexesOutput(v **DescribeFi sv.NextToken = ptr.String(jtv) } + case "subscriptionFilters": + if err := awsAwsjson11_deserializeDocumentSubscriptionFilters(&sv.SubscriptionFilters, value); err != nil { + return err + } + default: _, _ = key, value @@ -20099,7 +25161,7 @@ func awsAwsjson11_deserializeOpDocumentDescribeFieldIndexesOutput(v **DescribeFi return nil } -func awsAwsjson11_deserializeOpDocumentDescribeIndexPoliciesOutput(v **DescribeIndexPoliciesOutput, value interface{}) error { +func awsAwsjson11_deserializeOpDocumentDisassociateSourceFromS3TableIntegrationOutput(v **DisassociateSourceFromS3TableIntegrationOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -20112,27 +25174,22 @@ func awsAwsjson11_deserializeOpDocumentDescribeIndexPoliciesOutput(v **DescribeI return fmt.Errorf("unexpected JSON type %v", value) } - var sv *DescribeIndexPoliciesOutput + var sv *DisassociateSourceFromS3TableIntegrationOutput if *v == nil { - sv = &DescribeIndexPoliciesOutput{} + sv = &DisassociateSourceFromS3TableIntegrationOutput{} } else { sv = *v } for key, value := range shape { switch key { - case "indexPolicies": - if err := awsAwsjson11_deserializeDocumentIndexPolicies(&sv.IndexPolicies, value); err != nil { - return err - } - - case "nextToken": + case "identifier": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) + return fmt.Errorf("expected S3TableIntegrationSourceIdentifier to be of type string, got %T instead", value) } - sv.NextToken = ptr.String(jtv) + sv.Identifier = ptr.String(jtv) } default: @@ -20144,7 +25201,7 @@ func awsAwsjson11_deserializeOpDocumentDescribeIndexPoliciesOutput(v **DescribeI return nil } -func awsAwsjson11_deserializeOpDocumentDescribeLogGroupsOutput(v **DescribeLogGroupsOutput, value interface{}) error { +func awsAwsjson11_deserializeOpDocumentFilterLogEventsOutput(v **FilterLogEventsOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -20157,17 +25214,17 @@ func awsAwsjson11_deserializeOpDocumentDescribeLogGroupsOutput(v **DescribeLogGr return fmt.Errorf("unexpected JSON type %v", value) } - var sv *DescribeLogGroupsOutput + var sv *FilterLogEventsOutput if *v == nil { - sv = &DescribeLogGroupsOutput{} + sv = &FilterLogEventsOutput{} } else { sv = *v } for key, value := range shape { switch key { - case "logGroups": - if err := awsAwsjson11_deserializeDocumentLogGroups(&sv.LogGroups, value); err != nil { + case "events": + if err := awsAwsjson11_deserializeDocumentFilteredLogEvents(&sv.Events, value); err != nil { return err } @@ -20180,6 +25237,11 @@ func awsAwsjson11_deserializeOpDocumentDescribeLogGroupsOutput(v **DescribeLogGr sv.NextToken = ptr.String(jtv) } + case "searchedLogStreams": + if err := awsAwsjson11_deserializeDocumentSearchedLogStreams(&sv.SearchedLogStreams, value); err != nil { + return err + } + default: _, _ = key, value @@ -20189,7 +25251,7 @@ func awsAwsjson11_deserializeOpDocumentDescribeLogGroupsOutput(v **DescribeLogGr return nil } -func awsAwsjson11_deserializeOpDocumentDescribeLogStreamsOutput(v **DescribeLogStreamsOutput, value interface{}) error { +func awsAwsjson11_deserializeOpDocumentGetDataProtectionPolicyOutput(v **GetDataProtectionPolicyOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -20202,27 +25264,44 @@ func awsAwsjson11_deserializeOpDocumentDescribeLogStreamsOutput(v **DescribeLogS return fmt.Errorf("unexpected JSON type %v", value) } - var sv *DescribeLogStreamsOutput + var sv *GetDataProtectionPolicyOutput if *v == nil { - sv = &DescribeLogStreamsOutput{} + sv = &GetDataProtectionPolicyOutput{} } else { sv = *v } for key, value := range shape { switch key { - case "logStreams": - if err := awsAwsjson11_deserializeDocumentLogStreams(&sv.LogStreams, value); err != nil { - return err + case "lastUpdatedTime": + if value != nil { + jtv, ok := value.(json.Number) + if !ok { + return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) + } + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.LastUpdatedTime = ptr.Int64(i64) } - case "nextToken": + case "logGroupIdentifier": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) + return fmt.Errorf("expected LogGroupIdentifier to be of type string, got %T instead", value) } - sv.NextToken = ptr.String(jtv) + sv.LogGroupIdentifier = ptr.String(jtv) + } + + case "policyDocument": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected DataProtectionPolicyDocument to be of type string, got %T instead", value) + } + sv.PolicyDocument = ptr.String(jtv) } default: @@ -20234,7 +25313,7 @@ func awsAwsjson11_deserializeOpDocumentDescribeLogStreamsOutput(v **DescribeLogS return nil } -func awsAwsjson11_deserializeOpDocumentDescribeMetricFiltersOutput(v **DescribeMetricFiltersOutput, value interface{}) error { +func awsAwsjson11_deserializeOpDocumentGetDeliveryDestinationOutput(v **GetDeliveryDestinationOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -20247,29 +25326,20 @@ func awsAwsjson11_deserializeOpDocumentDescribeMetricFiltersOutput(v **DescribeM return fmt.Errorf("unexpected JSON type %v", value) } - var sv *DescribeMetricFiltersOutput + var sv *GetDeliveryDestinationOutput if *v == nil { - sv = &DescribeMetricFiltersOutput{} + sv = &GetDeliveryDestinationOutput{} } else { sv = *v } for key, value := range shape { switch key { - case "metricFilters": - if err := awsAwsjson11_deserializeDocumentMetricFilters(&sv.MetricFilters, value); err != nil { + case "deliveryDestination": + if err := awsAwsjson11_deserializeDocumentDeliveryDestination(&sv.DeliveryDestination, value); err != nil { return err } - case "nextToken": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) - } - sv.NextToken = ptr.String(jtv) - } - default: _, _ = key, value @@ -20279,7 +25349,7 @@ func awsAwsjson11_deserializeOpDocumentDescribeMetricFiltersOutput(v **DescribeM return nil } -func awsAwsjson11_deserializeOpDocumentDescribeQueriesOutput(v **DescribeQueriesOutput, value interface{}) error { +func awsAwsjson11_deserializeOpDocumentGetDeliveryDestinationPolicyOutput(v **GetDeliveryDestinationPolicyOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -20292,26 +25362,17 @@ func awsAwsjson11_deserializeOpDocumentDescribeQueriesOutput(v **DescribeQueries return fmt.Errorf("unexpected JSON type %v", value) } - var sv *DescribeQueriesOutput + var sv *GetDeliveryDestinationPolicyOutput if *v == nil { - sv = &DescribeQueriesOutput{} + sv = &GetDeliveryDestinationPolicyOutput{} } else { sv = *v } for key, value := range shape { switch key { - case "nextToken": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) - } - sv.NextToken = ptr.String(jtv) - } - - case "queries": - if err := awsAwsjson11_deserializeDocumentQueryInfoList(&sv.Queries, value); err != nil { + case "policy": + if err := awsAwsjson11_deserializeDocumentPolicy(&sv.Policy, value); err != nil { return err } @@ -20324,7 +25385,7 @@ func awsAwsjson11_deserializeOpDocumentDescribeQueriesOutput(v **DescribeQueries return nil } -func awsAwsjson11_deserializeOpDocumentDescribeQueryDefinitionsOutput(v **DescribeQueryDefinitionsOutput, value interface{}) error { +func awsAwsjson11_deserializeOpDocumentGetDeliveryOutput(v **GetDeliveryOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -20337,26 +25398,17 @@ func awsAwsjson11_deserializeOpDocumentDescribeQueryDefinitionsOutput(v **Descri return fmt.Errorf("unexpected JSON type %v", value) } - var sv *DescribeQueryDefinitionsOutput + var sv *GetDeliveryOutput if *v == nil { - sv = &DescribeQueryDefinitionsOutput{} + sv = &GetDeliveryOutput{} } else { sv = *v } for key, value := range shape { switch key { - case "nextToken": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) - } - sv.NextToken = ptr.String(jtv) - } - - case "queryDefinitions": - if err := awsAwsjson11_deserializeDocumentQueryDefinitionList(&sv.QueryDefinitions, value); err != nil { + case "delivery": + if err := awsAwsjson11_deserializeDocumentDelivery(&sv.Delivery, value); err != nil { return err } @@ -20369,7 +25421,7 @@ func awsAwsjson11_deserializeOpDocumentDescribeQueryDefinitionsOutput(v **Descri return nil } -func awsAwsjson11_deserializeOpDocumentDescribeResourcePoliciesOutput(v **DescribeResourcePoliciesOutput, value interface{}) error { +func awsAwsjson11_deserializeOpDocumentGetDeliverySourceOutput(v **GetDeliverySourceOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -20382,26 +25434,17 @@ func awsAwsjson11_deserializeOpDocumentDescribeResourcePoliciesOutput(v **Descri return fmt.Errorf("unexpected JSON type %v", value) } - var sv *DescribeResourcePoliciesOutput + var sv *GetDeliverySourceOutput if *v == nil { - sv = &DescribeResourcePoliciesOutput{} + sv = &GetDeliverySourceOutput{} } else { sv = *v } for key, value := range shape { switch key { - case "nextToken": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) - } - sv.NextToken = ptr.String(jtv) - } - - case "resourcePolicies": - if err := awsAwsjson11_deserializeDocumentResourcePolicies(&sv.ResourcePolicies, value); err != nil { + case "deliverySource": + if err := awsAwsjson11_deserializeDocumentDeliverySource(&sv.DeliverySource, value); err != nil { return err } @@ -20414,7 +25457,7 @@ func awsAwsjson11_deserializeOpDocumentDescribeResourcePoliciesOutput(v **Descri return nil } -func awsAwsjson11_deserializeOpDocumentDescribeSubscriptionFiltersOutput(v **DescribeSubscriptionFiltersOutput, value interface{}) error { +func awsAwsjson11_deserializeOpDocumentGetIntegrationOutput(v **GetIntegrationOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -20427,27 +25470,45 @@ func awsAwsjson11_deserializeOpDocumentDescribeSubscriptionFiltersOutput(v **Des return fmt.Errorf("unexpected JSON type %v", value) } - var sv *DescribeSubscriptionFiltersOutput + var sv *GetIntegrationOutput if *v == nil { - sv = &DescribeSubscriptionFiltersOutput{} + sv = &GetIntegrationOutput{} } else { sv = *v } for key, value := range shape { switch key { - case "nextToken": + case "integrationDetails": + if err := awsAwsjson11_deserializeDocumentIntegrationDetails(&sv.IntegrationDetails, value); err != nil { + return err + } + + case "integrationName": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected IntegrationName to be of type string, got %T instead", value) + } + sv.IntegrationName = ptr.String(jtv) + } + + case "integrationStatus": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected IntegrationStatus to be of type string, got %T instead", value) + } + sv.IntegrationStatus = types.IntegrationStatus(jtv) + } + + case "integrationType": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) + return fmt.Errorf("expected IntegrationType to be of type string, got %T instead", value) } - sv.NextToken = ptr.String(jtv) - } - - case "subscriptionFilters": - if err := awsAwsjson11_deserializeDocumentSubscriptionFilters(&sv.SubscriptionFilters, value); err != nil { - return err + sv.IntegrationType = types.IntegrationType(jtv) } default: @@ -20459,7 +25520,7 @@ func awsAwsjson11_deserializeOpDocumentDescribeSubscriptionFiltersOutput(v **Des return nil } -func awsAwsjson11_deserializeOpDocumentFilterLogEventsOutput(v **FilterLogEventsOutput, value interface{}) error { +func awsAwsjson11_deserializeOpDocumentGetLogAnomalyDetectorOutput(v **GetLogAnomalyDetectorOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -20472,31 +25533,101 @@ func awsAwsjson11_deserializeOpDocumentFilterLogEventsOutput(v **FilterLogEvents return fmt.Errorf("unexpected JSON type %v", value) } - var sv *FilterLogEventsOutput + var sv *GetLogAnomalyDetectorOutput if *v == nil { - sv = &FilterLogEventsOutput{} + sv = &GetLogAnomalyDetectorOutput{} } else { sv = *v } for key, value := range shape { switch key { - case "events": - if err := awsAwsjson11_deserializeDocumentFilteredLogEvents(&sv.Events, value); err != nil { - return err + case "anomalyDetectorStatus": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected AnomalyDetectorStatus to be of type string, got %T instead", value) + } + sv.AnomalyDetectorStatus = types.AnomalyDetectorStatus(jtv) } - case "nextToken": + case "anomalyVisibilityTime": + if value != nil { + jtv, ok := value.(json.Number) + if !ok { + return fmt.Errorf("expected AnomalyVisibilityTime to be json.Number, got %T instead", value) + } + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.AnomalyVisibilityTime = ptr.Int64(i64) + } + + case "creationTimeStamp": + if value != nil { + jtv, ok := value.(json.Number) + if !ok { + return fmt.Errorf("expected EpochMillis to be json.Number, got %T instead", value) + } + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.CreationTimeStamp = i64 + } + + case "detectorName": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) + return fmt.Errorf("expected DetectorName to be of type string, got %T instead", value) } - sv.NextToken = ptr.String(jtv) + sv.DetectorName = ptr.String(jtv) } - case "searchedLogStreams": - if err := awsAwsjson11_deserializeDocumentSearchedLogStreams(&sv.SearchedLogStreams, value); err != nil { + case "evaluationFrequency": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected EvaluationFrequency to be of type string, got %T instead", value) + } + sv.EvaluationFrequency = types.EvaluationFrequency(jtv) + } + + case "filterPattern": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected FilterPattern to be of type string, got %T instead", value) + } + sv.FilterPattern = ptr.String(jtv) + } + + case "kmsKeyId": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected KmsKeyId to be of type string, got %T instead", value) + } + sv.KmsKeyId = ptr.String(jtv) + } + + case "lastModifiedTimeStamp": + if value != nil { + jtv, ok := value.(json.Number) + if !ok { + return fmt.Errorf("expected EpochMillis to be json.Number, got %T instead", value) + } + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.LastModifiedTimeStamp = i64 + } + + case "logGroupArnList": + if err := awsAwsjson11_deserializeDocumentLogGroupArnList(&sv.LogGroupArnList, value); err != nil { return err } @@ -20509,7 +25640,7 @@ func awsAwsjson11_deserializeOpDocumentFilterLogEventsOutput(v **FilterLogEvents return nil } -func awsAwsjson11_deserializeOpDocumentGetDataProtectionPolicyOutput(v **GetDataProtectionPolicyOutput, value interface{}) error { +func awsAwsjson11_deserializeOpDocumentGetLogEventsOutput(v **GetLogEventsOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -20522,44 +25653,36 @@ func awsAwsjson11_deserializeOpDocumentGetDataProtectionPolicyOutput(v **GetData return fmt.Errorf("unexpected JSON type %v", value) } - var sv *GetDataProtectionPolicyOutput + var sv *GetLogEventsOutput if *v == nil { - sv = &GetDataProtectionPolicyOutput{} + sv = &GetLogEventsOutput{} } else { sv = *v } for key, value := range shape { switch key { - case "lastUpdatedTime": - if value != nil { - jtv, ok := value.(json.Number) - if !ok { - return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) - } - i64, err := jtv.Int64() - if err != nil { - return err - } - sv.LastUpdatedTime = ptr.Int64(i64) + case "events": + if err := awsAwsjson11_deserializeDocumentOutputLogEvents(&sv.Events, value); err != nil { + return err } - case "logGroupIdentifier": + case "nextBackwardToken": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected LogGroupIdentifier to be of type string, got %T instead", value) + return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) } - sv.LogGroupIdentifier = ptr.String(jtv) + sv.NextBackwardToken = ptr.String(jtv) } - case "policyDocument": + case "nextForwardToken": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected DataProtectionPolicyDocument to be of type string, got %T instead", value) + return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) } - sv.PolicyDocument = ptr.String(jtv) + sv.NextForwardToken = ptr.String(jtv) } default: @@ -20571,7 +25694,7 @@ func awsAwsjson11_deserializeOpDocumentGetDataProtectionPolicyOutput(v **GetData return nil } -func awsAwsjson11_deserializeOpDocumentGetDeliveryDestinationOutput(v **GetDeliveryDestinationOutput, value interface{}) error { +func awsAwsjson11_deserializeOpDocumentGetLogFieldsOutput(v **GetLogFieldsOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -20584,17 +25707,17 @@ func awsAwsjson11_deserializeOpDocumentGetDeliveryDestinationOutput(v **GetDeliv return fmt.Errorf("unexpected JSON type %v", value) } - var sv *GetDeliveryDestinationOutput + var sv *GetLogFieldsOutput if *v == nil { - sv = &GetDeliveryDestinationOutput{} + sv = &GetLogFieldsOutput{} } else { sv = *v } for key, value := range shape { switch key { - case "deliveryDestination": - if err := awsAwsjson11_deserializeDocumentDeliveryDestination(&sv.DeliveryDestination, value); err != nil { + case "logFields": + if err := awsAwsjson11_deserializeDocumentLogFieldsList(&sv.LogFields, value); err != nil { return err } @@ -20607,7 +25730,7 @@ func awsAwsjson11_deserializeOpDocumentGetDeliveryDestinationOutput(v **GetDeliv return nil } -func awsAwsjson11_deserializeOpDocumentGetDeliveryDestinationPolicyOutput(v **GetDeliveryDestinationPolicyOutput, value interface{}) error { +func awsAwsjson11_deserializeOpDocumentGetLogGroupFieldsOutput(v **GetLogGroupFieldsOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -20620,17 +25743,17 @@ func awsAwsjson11_deserializeOpDocumentGetDeliveryDestinationPolicyOutput(v **Ge return fmt.Errorf("unexpected JSON type %v", value) } - var sv *GetDeliveryDestinationPolicyOutput + var sv *GetLogGroupFieldsOutput if *v == nil { - sv = &GetDeliveryDestinationPolicyOutput{} + sv = &GetLogGroupFieldsOutput{} } else { sv = *v } for key, value := range shape { switch key { - case "policy": - if err := awsAwsjson11_deserializeDocumentPolicy(&sv.Policy, value); err != nil { + case "logGroupFields": + if err := awsAwsjson11_deserializeDocumentLogGroupFieldList(&sv.LogGroupFields, value); err != nil { return err } @@ -20643,7 +25766,7 @@ func awsAwsjson11_deserializeOpDocumentGetDeliveryDestinationPolicyOutput(v **Ge return nil } -func awsAwsjson11_deserializeOpDocumentGetDeliveryOutput(v **GetDeliveryOutput, value interface{}) error { +func awsAwsjson11_deserializeOpDocumentGetLogRecordOutput(v **GetLogRecordOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -20656,17 +25779,17 @@ func awsAwsjson11_deserializeOpDocumentGetDeliveryOutput(v **GetDeliveryOutput, return fmt.Errorf("unexpected JSON type %v", value) } - var sv *GetDeliveryOutput + var sv *GetLogRecordOutput if *v == nil { - sv = &GetDeliveryOutput{} + sv = &GetLogRecordOutput{} } else { sv = *v } for key, value := range shape { switch key { - case "delivery": - if err := awsAwsjson11_deserializeDocumentDelivery(&sv.Delivery, value); err != nil { + case "logRecord": + if err := awsAwsjson11_deserializeDocumentLogRecord(&sv.LogRecord, value); err != nil { return err } @@ -20679,7 +25802,7 @@ func awsAwsjson11_deserializeOpDocumentGetDeliveryOutput(v **GetDeliveryOutput, return nil } -func awsAwsjson11_deserializeOpDocumentGetDeliverySourceOutput(v **GetDeliverySourceOutput, value interface{}) error { +func awsAwsjson11_deserializeOpDocumentGetQueryResultsOutput(v **GetQueryResultsOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -20692,20 +25815,52 @@ func awsAwsjson11_deserializeOpDocumentGetDeliverySourceOutput(v **GetDeliverySo return fmt.Errorf("unexpected JSON type %v", value) } - var sv *GetDeliverySourceOutput + var sv *GetQueryResultsOutput if *v == nil { - sv = &GetDeliverySourceOutput{} + sv = &GetQueryResultsOutput{} } else { sv = *v } for key, value := range shape { switch key { - case "deliverySource": - if err := awsAwsjson11_deserializeDocumentDeliverySource(&sv.DeliverySource, value); err != nil { + case "encryptionKey": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected EncryptionKey to be of type string, got %T instead", value) + } + sv.EncryptionKey = ptr.String(jtv) + } + + case "queryLanguage": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected QueryLanguage to be of type string, got %T instead", value) + } + sv.QueryLanguage = types.QueryLanguage(jtv) + } + + case "results": + if err := awsAwsjson11_deserializeDocumentQueryResults(&sv.Results, value); err != nil { + return err + } + + case "statistics": + if err := awsAwsjson11_deserializeDocumentQueryStatistics(&sv.Statistics, value); err != nil { return err } + case "status": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected QueryStatus to be of type string, got %T instead", value) + } + sv.Status = types.QueryStatus(jtv) + } + default: _, _ = key, value @@ -20715,7 +25870,7 @@ func awsAwsjson11_deserializeOpDocumentGetDeliverySourceOutput(v **GetDeliverySo return nil } -func awsAwsjson11_deserializeOpDocumentGetIntegrationOutput(v **GetIntegrationOutput, value interface{}) error { +func awsAwsjson11_deserializeOpDocumentGetScheduledQueryHistoryOutput(v **GetScheduledQueryHistoryOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -20728,45 +25883,45 @@ func awsAwsjson11_deserializeOpDocumentGetIntegrationOutput(v **GetIntegrationOu return fmt.Errorf("unexpected JSON type %v", value) } - var sv *GetIntegrationOutput + var sv *GetScheduledQueryHistoryOutput if *v == nil { - sv = &GetIntegrationOutput{} + sv = &GetScheduledQueryHistoryOutput{} } else { sv = *v } for key, value := range shape { switch key { - case "integrationDetails": - if err := awsAwsjson11_deserializeDocumentIntegrationDetails(&sv.IntegrationDetails, value); err != nil { - return err - } - - case "integrationName": + case "name": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected IntegrationName to be of type string, got %T instead", value) + return fmt.Errorf("expected ScheduledQueryName to be of type string, got %T instead", value) } - sv.IntegrationName = ptr.String(jtv) + sv.Name = ptr.String(jtv) } - case "integrationStatus": + case "nextToken": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected IntegrationStatus to be of type string, got %T instead", value) + return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) } - sv.IntegrationStatus = types.IntegrationStatus(jtv) + sv.NextToken = ptr.String(jtv) } - case "integrationType": + case "scheduledQueryArn": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected IntegrationType to be of type string, got %T instead", value) + return fmt.Errorf("expected Arn to be of type string, got %T instead", value) } - sv.IntegrationType = types.IntegrationType(jtv) + sv.ScheduledQueryArn = ptr.String(jtv) + } + + case "triggerHistory": + if err := awsAwsjson11_deserializeDocumentTriggerHistoryRecordList(&sv.TriggerHistory, value); err != nil { + return err } default: @@ -20778,7 +25933,7 @@ func awsAwsjson11_deserializeOpDocumentGetIntegrationOutput(v **GetIntegrationOu return nil } -func awsAwsjson11_deserializeOpDocumentGetLogAnomalyDetectorOutput(v **GetLogAnomalyDetectorOutput, value interface{}) error { +func awsAwsjson11_deserializeOpDocumentGetScheduledQueryOutput(v **GetScheduledQueryOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -20791,102 +25946,191 @@ func awsAwsjson11_deserializeOpDocumentGetLogAnomalyDetectorOutput(v **GetLogAno return fmt.Errorf("unexpected JSON type %v", value) } - var sv *GetLogAnomalyDetectorOutput - if *v == nil { - sv = &GetLogAnomalyDetectorOutput{} - } else { - sv = *v - } + var sv *GetScheduledQueryOutput + if *v == nil { + sv = &GetScheduledQueryOutput{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "creationTime": + if value != nil { + jtv, ok := value.(json.Number) + if !ok { + return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) + } + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.CreationTime = ptr.Int64(i64) + } + + case "description": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected ScheduledQueryDescription to be of type string, got %T instead", value) + } + sv.Description = ptr.String(jtv) + } + + case "destinationConfiguration": + if err := awsAwsjson11_deserializeDocumentDestinationConfiguration(&sv.DestinationConfiguration, value); err != nil { + return err + } - for key, value := range shape { - switch key { - case "anomalyDetectorStatus": + case "executionRoleArn": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected AnomalyDetectorStatus to be of type string, got %T instead", value) + return fmt.Errorf("expected RoleArn to be of type string, got %T instead", value) } - sv.AnomalyDetectorStatus = types.AnomalyDetectorStatus(jtv) + sv.ExecutionRoleArn = ptr.String(jtv) } - case "anomalyVisibilityTime": + case "lastExecutionStatus": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected ExecutionStatus to be of type string, got %T instead", value) + } + sv.LastExecutionStatus = types.ExecutionStatus(jtv) + } + + case "lastTriggeredTime": if value != nil { jtv, ok := value.(json.Number) if !ok { - return fmt.Errorf("expected AnomalyVisibilityTime to be json.Number, got %T instead", value) + return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) } i64, err := jtv.Int64() if err != nil { return err } - sv.AnomalyVisibilityTime = ptr.Int64(i64) + sv.LastTriggeredTime = ptr.Int64(i64) } - case "creationTimeStamp": + case "lastUpdatedTime": if value != nil { jtv, ok := value.(json.Number) if !ok { - return fmt.Errorf("expected EpochMillis to be json.Number, got %T instead", value) + return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) } i64, err := jtv.Int64() if err != nil { return err } - sv.CreationTimeStamp = i64 + sv.LastUpdatedTime = ptr.Int64(i64) } - case "detectorName": + case "logGroupIdentifiers": + if err := awsAwsjson11_deserializeDocumentScheduledQueryLogGroupIdentifiers(&sv.LogGroupIdentifiers, value); err != nil { + return err + } + + case "name": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected DetectorName to be of type string, got %T instead", value) + return fmt.Errorf("expected ScheduledQueryName to be of type string, got %T instead", value) } - sv.DetectorName = ptr.String(jtv) + sv.Name = ptr.String(jtv) } - case "evaluationFrequency": + case "queryLanguage": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected EvaluationFrequency to be of type string, got %T instead", value) + return fmt.Errorf("expected QueryLanguage to be of type string, got %T instead", value) } - sv.EvaluationFrequency = types.EvaluationFrequency(jtv) + sv.QueryLanguage = types.QueryLanguage(jtv) } - case "filterPattern": + case "queryString": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected FilterPattern to be of type string, got %T instead", value) + return fmt.Errorf("expected QueryString to be of type string, got %T instead", value) } - sv.FilterPattern = ptr.String(jtv) + sv.QueryString = ptr.String(jtv) } - case "kmsKeyId": + case "scheduledQueryArn": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected KmsKeyId to be of type string, got %T instead", value) + return fmt.Errorf("expected Arn to be of type string, got %T instead", value) } - sv.KmsKeyId = ptr.String(jtv) + sv.ScheduledQueryArn = ptr.String(jtv) } - case "lastModifiedTimeStamp": + case "scheduleEndTime": if value != nil { jtv, ok := value.(json.Number) if !ok { - return fmt.Errorf("expected EpochMillis to be json.Number, got %T instead", value) + return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) } i64, err := jtv.Int64() if err != nil { return err } - sv.LastModifiedTimeStamp = i64 + sv.ScheduleEndTime = ptr.Int64(i64) } - case "logGroupArnList": - if err := awsAwsjson11_deserializeDocumentLogGroupArnList(&sv.LogGroupArnList, value); err != nil { - return err + case "scheduleExpression": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected ScheduleExpression to be of type string, got %T instead", value) + } + sv.ScheduleExpression = ptr.String(jtv) + } + + case "scheduleStartTime": + if value != nil { + jtv, ok := value.(json.Number) + if !ok { + return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) + } + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.ScheduleStartTime = ptr.Int64(i64) + } + + case "startTimeOffset": + if value != nil { + jtv, ok := value.(json.Number) + if !ok { + return fmt.Errorf("expected StartTimeOffset to be json.Number, got %T instead", value) + } + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.StartTimeOffset = ptr.Int64(i64) + } + + case "state": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected ScheduledQueryState to be of type string, got %T instead", value) + } + sv.State = types.ScheduledQueryState(jtv) + } + + case "timezone": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected ScheduleTimezone to be of type string, got %T instead", value) + } + sv.Timezone = ptr.String(jtv) } default: @@ -20898,7 +26142,7 @@ func awsAwsjson11_deserializeOpDocumentGetLogAnomalyDetectorOutput(v **GetLogAno return nil } -func awsAwsjson11_deserializeOpDocumentGetLogEventsOutput(v **GetLogEventsOutput, value interface{}) error { +func awsAwsjson11_deserializeOpDocumentGetTransformerOutput(v **GetTransformerOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -20911,36 +26155,53 @@ func awsAwsjson11_deserializeOpDocumentGetLogEventsOutput(v **GetLogEventsOutput return fmt.Errorf("unexpected JSON type %v", value) } - var sv *GetLogEventsOutput + var sv *GetTransformerOutput if *v == nil { - sv = &GetLogEventsOutput{} + sv = &GetTransformerOutput{} } else { sv = *v } for key, value := range shape { switch key { - case "events": - if err := awsAwsjson11_deserializeDocumentOutputLogEvents(&sv.Events, value); err != nil { - return err + case "creationTime": + if value != nil { + jtv, ok := value.(json.Number) + if !ok { + return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) + } + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.CreationTime = ptr.Int64(i64) } - case "nextBackwardToken": + case "lastModifiedTime": if value != nil { - jtv, ok := value.(string) + jtv, ok := value.(json.Number) if !ok { - return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) + return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) } - sv.NextBackwardToken = ptr.String(jtv) + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.LastModifiedTime = ptr.Int64(i64) } - case "nextForwardToken": + case "logGroupIdentifier": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) + return fmt.Errorf("expected LogGroupIdentifier to be of type string, got %T instead", value) } - sv.NextForwardToken = ptr.String(jtv) + sv.LogGroupIdentifier = ptr.String(jtv) + } + + case "transformerConfig": + if err := awsAwsjson11_deserializeDocumentProcessors(&sv.TransformerConfig, value); err != nil { + return err } default: @@ -20952,7 +26213,7 @@ func awsAwsjson11_deserializeOpDocumentGetLogEventsOutput(v **GetLogEventsOutput return nil } -func awsAwsjson11_deserializeOpDocumentGetLogGroupFieldsOutput(v **GetLogGroupFieldsOutput, value interface{}) error { +func awsAwsjson11_deserializeOpDocumentListAggregateLogGroupSummariesOutput(v **ListAggregateLogGroupSummariesOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -20965,20 +26226,29 @@ func awsAwsjson11_deserializeOpDocumentGetLogGroupFieldsOutput(v **GetLogGroupFi return fmt.Errorf("unexpected JSON type %v", value) } - var sv *GetLogGroupFieldsOutput + var sv *ListAggregateLogGroupSummariesOutput if *v == nil { - sv = &GetLogGroupFieldsOutput{} + sv = &ListAggregateLogGroupSummariesOutput{} } else { sv = *v } for key, value := range shape { switch key { - case "logGroupFields": - if err := awsAwsjson11_deserializeDocumentLogGroupFieldList(&sv.LogGroupFields, value); err != nil { + case "aggregateLogGroupSummaries": + if err := awsAwsjson11_deserializeDocumentAggregateLogGroupSummaries(&sv.AggregateLogGroupSummaries, value); err != nil { return err } + case "nextToken": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) + } + sv.NextToken = ptr.String(jtv) + } + default: _, _ = key, value @@ -20988,7 +26258,7 @@ func awsAwsjson11_deserializeOpDocumentGetLogGroupFieldsOutput(v **GetLogGroupFi return nil } -func awsAwsjson11_deserializeOpDocumentGetLogRecordOutput(v **GetLogRecordOutput, value interface{}) error { +func awsAwsjson11_deserializeOpDocumentListAnomaliesOutput(v **ListAnomaliesOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -21001,20 +26271,29 @@ func awsAwsjson11_deserializeOpDocumentGetLogRecordOutput(v **GetLogRecordOutput return fmt.Errorf("unexpected JSON type %v", value) } - var sv *GetLogRecordOutput + var sv *ListAnomaliesOutput if *v == nil { - sv = &GetLogRecordOutput{} + sv = &ListAnomaliesOutput{} } else { sv = *v } for key, value := range shape { switch key { - case "logRecord": - if err := awsAwsjson11_deserializeDocumentLogRecord(&sv.LogRecord, value); err != nil { + case "anomalies": + if err := awsAwsjson11_deserializeDocumentAnomalies(&sv.Anomalies, value); err != nil { return err } + case "nextToken": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) + } + sv.NextToken = ptr.String(jtv) + } + default: _, _ = key, value @@ -21024,7 +26303,7 @@ func awsAwsjson11_deserializeOpDocumentGetLogRecordOutput(v **GetLogRecordOutput return nil } -func awsAwsjson11_deserializeOpDocumentGetQueryResultsOutput(v **GetQueryResultsOutput, value interface{}) error { +func awsAwsjson11_deserializeOpDocumentListIntegrationsOutput(v **ListIntegrationsOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -21037,52 +26316,20 @@ func awsAwsjson11_deserializeOpDocumentGetQueryResultsOutput(v **GetQueryResults return fmt.Errorf("unexpected JSON type %v", value) } - var sv *GetQueryResultsOutput + var sv *ListIntegrationsOutput if *v == nil { - sv = &GetQueryResultsOutput{} + sv = &ListIntegrationsOutput{} } else { sv = *v } for key, value := range shape { switch key { - case "encryptionKey": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected EncryptionKey to be of type string, got %T instead", value) - } - sv.EncryptionKey = ptr.String(jtv) - } - - case "queryLanguage": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected QueryLanguage to be of type string, got %T instead", value) - } - sv.QueryLanguage = types.QueryLanguage(jtv) - } - - case "results": - if err := awsAwsjson11_deserializeDocumentQueryResults(&sv.Results, value); err != nil { - return err - } - - case "statistics": - if err := awsAwsjson11_deserializeDocumentQueryStatistics(&sv.Statistics, value); err != nil { + case "integrationSummaries": + if err := awsAwsjson11_deserializeDocumentIntegrationSummaries(&sv.IntegrationSummaries, value); err != nil { return err } - case "status": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected QueryStatus to be of type string, got %T instead", value) - } - sv.Status = types.QueryStatus(jtv) - } - default: _, _ = key, value @@ -21092,7 +26339,7 @@ func awsAwsjson11_deserializeOpDocumentGetQueryResultsOutput(v **GetQueryResults return nil } -func awsAwsjson11_deserializeOpDocumentGetTransformerOutput(v **GetTransformerOutput, value interface{}) error { +func awsAwsjson11_deserializeOpDocumentListLogAnomalyDetectorsOutput(v **ListLogAnomalyDetectorsOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -21102,56 +26349,30 @@ func awsAwsjson11_deserializeOpDocumentGetTransformerOutput(v **GetTransformerOu shape, ok := value.(map[string]interface{}) if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } - - var sv *GetTransformerOutput - if *v == nil { - sv = &GetTransformerOutput{} - } else { - sv = *v - } - - for key, value := range shape { - switch key { - case "creationTime": - if value != nil { - jtv, ok := value.(json.Number) - if !ok { - return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) - } - i64, err := jtv.Int64() - if err != nil { - return err - } - sv.CreationTime = ptr.Int64(i64) - } - - case "lastModifiedTime": - if value != nil { - jtv, ok := value.(json.Number) - if !ok { - return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) - } - i64, err := jtv.Int64() - if err != nil { - return err - } - sv.LastModifiedTime = ptr.Int64(i64) + return fmt.Errorf("unexpected JSON type %v", value) + } + + var sv *ListLogAnomalyDetectorsOutput + if *v == nil { + sv = &ListLogAnomalyDetectorsOutput{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "anomalyDetectors": + if err := awsAwsjson11_deserializeDocumentAnomalyDetectors(&sv.AnomalyDetectors, value); err != nil { + return err } - case "logGroupIdentifier": + case "nextToken": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected LogGroupIdentifier to be of type string, got %T instead", value) + return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) } - sv.LogGroupIdentifier = ptr.String(jtv) - } - - case "transformerConfig": - if err := awsAwsjson11_deserializeDocumentProcessors(&sv.TransformerConfig, value); err != nil { - return err + sv.NextToken = ptr.String(jtv) } default: @@ -21163,7 +26384,7 @@ func awsAwsjson11_deserializeOpDocumentGetTransformerOutput(v **GetTransformerOu return nil } -func awsAwsjson11_deserializeOpDocumentListAnomaliesOutput(v **ListAnomaliesOutput, value interface{}) error { +func awsAwsjson11_deserializeOpDocumentListLogGroupsForQueryOutput(v **ListLogGroupsForQueryOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -21176,17 +26397,17 @@ func awsAwsjson11_deserializeOpDocumentListAnomaliesOutput(v **ListAnomaliesOutp return fmt.Errorf("unexpected JSON type %v", value) } - var sv *ListAnomaliesOutput + var sv *ListLogGroupsForQueryOutput if *v == nil { - sv = &ListAnomaliesOutput{} + sv = &ListLogGroupsForQueryOutput{} } else { sv = *v } for key, value := range shape { switch key { - case "anomalies": - if err := awsAwsjson11_deserializeDocumentAnomalies(&sv.Anomalies, value); err != nil { + case "logGroupIdentifiers": + if err := awsAwsjson11_deserializeDocumentLogGroupIdentifiers(&sv.LogGroupIdentifiers, value); err != nil { return err } @@ -21208,7 +26429,7 @@ func awsAwsjson11_deserializeOpDocumentListAnomaliesOutput(v **ListAnomaliesOutp return nil } -func awsAwsjson11_deserializeOpDocumentListIntegrationsOutput(v **ListIntegrationsOutput, value interface{}) error { +func awsAwsjson11_deserializeOpDocumentListLogGroupsOutput(v **ListLogGroupsOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -21221,20 +26442,29 @@ func awsAwsjson11_deserializeOpDocumentListIntegrationsOutput(v **ListIntegratio return fmt.Errorf("unexpected JSON type %v", value) } - var sv *ListIntegrationsOutput + var sv *ListLogGroupsOutput if *v == nil { - sv = &ListIntegrationsOutput{} + sv = &ListLogGroupsOutput{} } else { sv = *v } for key, value := range shape { switch key { - case "integrationSummaries": - if err := awsAwsjson11_deserializeDocumentIntegrationSummaries(&sv.IntegrationSummaries, value); err != nil { + case "logGroups": + if err := awsAwsjson11_deserializeDocumentLogGroupSummaries(&sv.LogGroups, value); err != nil { return err } + case "nextToken": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) + } + sv.NextToken = ptr.String(jtv) + } + default: _, _ = key, value @@ -21244,7 +26474,7 @@ func awsAwsjson11_deserializeOpDocumentListIntegrationsOutput(v **ListIntegratio return nil } -func awsAwsjson11_deserializeOpDocumentListLogAnomalyDetectorsOutput(v **ListLogAnomalyDetectorsOutput, value interface{}) error { +func awsAwsjson11_deserializeOpDocumentListScheduledQueriesOutput(v **ListScheduledQueriesOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -21257,20 +26487,15 @@ func awsAwsjson11_deserializeOpDocumentListLogAnomalyDetectorsOutput(v **ListLog return fmt.Errorf("unexpected JSON type %v", value) } - var sv *ListLogAnomalyDetectorsOutput + var sv *ListScheduledQueriesOutput if *v == nil { - sv = &ListLogAnomalyDetectorsOutput{} + sv = &ListScheduledQueriesOutput{} } else { sv = *v } for key, value := range shape { switch key { - case "anomalyDetectors": - if err := awsAwsjson11_deserializeDocumentAnomalyDetectors(&sv.AnomalyDetectors, value); err != nil { - return err - } - case "nextToken": if value != nil { jtv, ok := value.(string) @@ -21280,6 +26505,11 @@ func awsAwsjson11_deserializeOpDocumentListLogAnomalyDetectorsOutput(v **ListLog sv.NextToken = ptr.String(jtv) } + case "scheduledQueries": + if err := awsAwsjson11_deserializeDocumentScheduledQuerySummaryList(&sv.ScheduledQueries, value); err != nil { + return err + } + default: _, _ = key, value @@ -21289,7 +26519,7 @@ func awsAwsjson11_deserializeOpDocumentListLogAnomalyDetectorsOutput(v **ListLog return nil } -func awsAwsjson11_deserializeOpDocumentListLogGroupsForQueryOutput(v **ListLogGroupsForQueryOutput, value interface{}) error { +func awsAwsjson11_deserializeOpDocumentListSourcesForS3TableIntegrationOutput(v **ListSourcesForS3TableIntegrationOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -21302,20 +26532,15 @@ func awsAwsjson11_deserializeOpDocumentListLogGroupsForQueryOutput(v **ListLogGr return fmt.Errorf("unexpected JSON type %v", value) } - var sv *ListLogGroupsForQueryOutput + var sv *ListSourcesForS3TableIntegrationOutput if *v == nil { - sv = &ListLogGroupsForQueryOutput{} + sv = &ListSourcesForS3TableIntegrationOutput{} } else { sv = *v } for key, value := range shape { switch key { - case "logGroupIdentifiers": - if err := awsAwsjson11_deserializeDocumentLogGroupIdentifiers(&sv.LogGroupIdentifiers, value); err != nil { - return err - } - case "nextToken": if value != nil { jtv, ok := value.(string) @@ -21325,6 +26550,11 @@ func awsAwsjson11_deserializeOpDocumentListLogGroupsForQueryOutput(v **ListLogGr sv.NextToken = ptr.String(jtv) } + case "sources": + if err := awsAwsjson11_deserializeDocumentS3TableIntegrationSources(&sv.Sources, value); err != nil { + return err + } + default: _, _ = key, value @@ -21850,6 +27080,15 @@ func awsAwsjson11_deserializeOpDocumentPutResourcePolicyOutput(v **PutResourcePo return err } + case "revisionId": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected ExpectedRevisionId to be of type string, got %T instead", value) + } + sv.RevisionId = ptr.String(jtv) + } + default: _, _ = key, value @@ -22042,6 +27281,215 @@ func awsAwsjson11_deserializeOpDocumentUpdateDeliveryConfigurationOutput(v **Upd return nil } +func awsAwsjson11_deserializeOpDocumentUpdateScheduledQueryOutput(v **UpdateScheduledQueryOutput, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.(map[string]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var sv *UpdateScheduledQueryOutput + if *v == nil { + sv = &UpdateScheduledQueryOutput{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "creationTime": + if value != nil { + jtv, ok := value.(json.Number) + if !ok { + return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) + } + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.CreationTime = ptr.Int64(i64) + } + + case "description": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected ScheduledQueryDescription to be of type string, got %T instead", value) + } + sv.Description = ptr.String(jtv) + } + + case "destinationConfiguration": + if err := awsAwsjson11_deserializeDocumentDestinationConfiguration(&sv.DestinationConfiguration, value); err != nil { + return err + } + + case "executionRoleArn": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected RoleArn to be of type string, got %T instead", value) + } + sv.ExecutionRoleArn = ptr.String(jtv) + } + + case "lastExecutionStatus": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected ExecutionStatus to be of type string, got %T instead", value) + } + sv.LastExecutionStatus = types.ExecutionStatus(jtv) + } + + case "lastTriggeredTime": + if value != nil { + jtv, ok := value.(json.Number) + if !ok { + return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) + } + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.LastTriggeredTime = ptr.Int64(i64) + } + + case "lastUpdatedTime": + if value != nil { + jtv, ok := value.(json.Number) + if !ok { + return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) + } + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.LastUpdatedTime = ptr.Int64(i64) + } + + case "logGroupIdentifiers": + if err := awsAwsjson11_deserializeDocumentScheduledQueryLogGroupIdentifiers(&sv.LogGroupIdentifiers, value); err != nil { + return err + } + + case "name": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected ScheduledQueryName to be of type string, got %T instead", value) + } + sv.Name = ptr.String(jtv) + } + + case "queryLanguage": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected QueryLanguage to be of type string, got %T instead", value) + } + sv.QueryLanguage = types.QueryLanguage(jtv) + } + + case "queryString": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected QueryString to be of type string, got %T instead", value) + } + sv.QueryString = ptr.String(jtv) + } + + case "scheduledQueryArn": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected Arn to be of type string, got %T instead", value) + } + sv.ScheduledQueryArn = ptr.String(jtv) + } + + case "scheduleEndTime": + if value != nil { + jtv, ok := value.(json.Number) + if !ok { + return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) + } + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.ScheduleEndTime = ptr.Int64(i64) + } + + case "scheduleExpression": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected ScheduleExpression to be of type string, got %T instead", value) + } + sv.ScheduleExpression = ptr.String(jtv) + } + + case "scheduleStartTime": + if value != nil { + jtv, ok := value.(json.Number) + if !ok { + return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) + } + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.ScheduleStartTime = ptr.Int64(i64) + } + + case "startTimeOffset": + if value != nil { + jtv, ok := value.(json.Number) + if !ok { + return fmt.Errorf("expected StartTimeOffset to be json.Number, got %T instead", value) + } + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.StartTimeOffset = ptr.Int64(i64) + } + + case "state": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected ScheduledQueryState to be of type string, got %T instead", value) + } + sv.State = types.ScheduledQueryState(jtv) + } + + case "timezone": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected ScheduleTimezone to be of type string, got %T instead", value) + } + sv.Timezone = ptr.String(jtv) + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + type protocolErrorInfo struct { Type string `json:"__type"` Message string diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/endpoints.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/endpoints.go index ef1e720d283..4e3861bbd98 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/endpoints.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/endpoints.go @@ -14,6 +14,7 @@ import ( internalendpoints "github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/internal/endpoints" smithyauth "github.com/aws/smithy-go/auth" smithyendpoints "github.com/aws/smithy-go/endpoints" + "github.com/aws/smithy-go/endpoints/private/rulesfn" "github.com/aws/smithy-go/middleware" "github.com/aws/smithy-go/ptr" "github.com/aws/smithy-go/tracing" @@ -217,11 +218,15 @@ func resolveBaseEndpoint(cfg aws.Config, o *Options) { } } -func bindRegion(region string) *string { +func bindRegion(region string) (*string, error) { if region == "" { - return nil + return nil, nil + } + if !rulesfn.IsValidHostLabel(region, true) { + return nil, fmt.Errorf("invalid input region %s", region) } - return aws.String(endpoints.MapFIPSRegion(region)) + + return aws.String(endpoints.MapFIPSRegion(region)), nil } // EndpointParameters provides the parameters that influence how endpoints are @@ -328,7 +333,9 @@ func (r *resolver) ResolveEndpoint( return endpoint, fmt.Errorf("endpoint parameters are not valid, %w", err) } _UseDualStack := *params.UseDualStack + _ = _UseDualStack _UseFIPS := *params.UseFIPS + _ = _UseFIPS if exprVal := params.Endpoint; exprVal != nil { _Endpoint := *exprVal @@ -484,10 +491,15 @@ type endpointParamsBinder interface { bindEndpointParams(*EndpointParameters) } -func bindEndpointParams(ctx context.Context, input interface{}, options Options) *EndpointParameters { +func bindEndpointParams(ctx context.Context, input interface{}, options Options) (*EndpointParameters, error) { params := &EndpointParameters{} - params.Region = bindRegion(options.Region) + region, err := bindRegion(options.Region) + if err != nil { + return nil, err + } + params.Region = region + params.UseDualStack = aws.Bool(options.EndpointOptions.UseDualStackEndpoint == aws.DualStackEndpointStateEnabled) params.UseFIPS = aws.Bool(options.EndpointOptions.UseFIPSEndpoint == aws.FIPSEndpointStateEnabled) params.Endpoint = options.BaseEndpoint @@ -496,7 +508,7 @@ func bindEndpointParams(ctx context.Context, input interface{}, options Options) b.bindEndpointParams(params) } - return params + return params, nil } type resolveEndpointV2Middleware struct { @@ -526,7 +538,10 @@ func (m *resolveEndpointV2Middleware) HandleFinalize(ctx context.Context, in mid return out, metadata, fmt.Errorf("expected endpoint resolver to not be nil") } - params := bindEndpointParams(ctx, getOperationInput(ctx), m.options) + params, err := bindEndpointParams(ctx, getOperationInput(ctx), m.options) + if err != nil { + return out, metadata, fmt.Errorf("failed to bind endpoint params, %w", err) + } endpt, err := timeOperationMetric(ctx, "client.call.resolve_endpoint_duration", func() (smithyendpoints.Endpoint, error) { return m.options.EndpointResolverV2.ResolveEndpoint(ctx, *params) diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/eventstream.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/eventstream.go index 3e723215e6a..66b4729631f 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/eventstream.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/eventstream.go @@ -18,6 +18,16 @@ import ( "sync" ) +// GetLogObjectResponseStreamReader provides the interface for reading events from +// a stream. +// +// The writer's Close method must allow multiple concurrent calls. +type GetLogObjectResponseStreamReader interface { + Events() <-chan types.GetLogObjectResponseStream + Close() error + Err() error +} + // StartLiveTailResponseStreamReader provides the interface for reading events // from a stream. // @@ -205,6 +215,278 @@ func (r *startLiveTailResponseStreamReader) Closed() <-chan struct{} { return r.done } +type getLogObjectResponseStreamReadEvent interface { + isGetLogObjectResponseStreamReadEvent() +} + +type getLogObjectResponseStreamReadEventMessage struct { + Value types.GetLogObjectResponseStream +} + +func (*getLogObjectResponseStreamReadEventMessage) isGetLogObjectResponseStreamReadEvent() {} + +type getLogObjectResponseStreamReadEventInitialResponse struct { + Value interface{} +} + +func (*getLogObjectResponseStreamReadEventInitialResponse) isGetLogObjectResponseStreamReadEvent() {} + +type getLogObjectResponseStreamReader struct { + stream chan types.GetLogObjectResponseStream + decoder *eventstream.Decoder + eventStream io.ReadCloser + err *smithysync.OnceErr + payloadBuf []byte + done chan struct{} + closeOnce sync.Once + initialResponseDeserializer func(*eventstream.Message) (interface{}, error) + initialResponse chan interface{} +} + +func newGetLogObjectResponseStreamReader(readCloser io.ReadCloser, decoder *eventstream.Decoder, ird func(*eventstream.Message) (interface{}, error)) *getLogObjectResponseStreamReader { + w := &getLogObjectResponseStreamReader{ + stream: make(chan types.GetLogObjectResponseStream), + decoder: decoder, + eventStream: readCloser, + err: smithysync.NewOnceErr(), + done: make(chan struct{}), + payloadBuf: make([]byte, 10*1024), + initialResponseDeserializer: ird, + initialResponse: make(chan interface{}, 1), + } + + go w.readEventStream() + + return w +} + +func (r *getLogObjectResponseStreamReader) Events() <-chan types.GetLogObjectResponseStream { + return r.stream +} + +func (r *getLogObjectResponseStreamReader) readEventStream() { + defer r.Close() + defer close(r.stream) + + defer close(r.initialResponse) + + for { + r.payloadBuf = r.payloadBuf[0:0] + decodedMessage, err := r.decoder.Decode(r.eventStream, r.payloadBuf) + if err != nil { + if err == io.EOF { + return + } + select { + case <-r.done: + return + default: + r.err.SetError(err) + return + } + } + + event, err := r.deserializeEventMessage(&decodedMessage) + if err != nil { + r.err.SetError(err) + return + } + + switch ev := event.(type) { + case *getLogObjectResponseStreamReadEventInitialResponse: + select { + case r.initialResponse <- ev.Value: + case <-r.done: + return + default: + } + case *getLogObjectResponseStreamReadEventMessage: + select { + case r.stream <- ev.Value: + case <-r.done: + return + } + default: + r.err.SetError(fmt.Errorf("unexpected event wrapper: %T", event)) + return + } + + } +} + +func (r *getLogObjectResponseStreamReader) deserializeEventMessage(msg *eventstream.Message) (getLogObjectResponseStreamReadEvent, error) { + messageType := msg.Headers.Get(eventstreamapi.MessageTypeHeader) + if messageType == nil { + return nil, fmt.Errorf("%s event header not present", eventstreamapi.MessageTypeHeader) + } + + switch messageType.String() { + case eventstreamapi.EventMessageType: + eventType := msg.Headers.Get(eventstreamapi.EventTypeHeader) + if eventType == nil { + return nil, fmt.Errorf("%s event header not present", eventstreamapi.EventTypeHeader) + } + + if eventType.String() == "initial-response" { + v, err := r.initialResponseDeserializer(msg) + if err != nil { + return nil, err + } + return &getLogObjectResponseStreamReadEventInitialResponse{Value: v}, nil + } + + var v types.GetLogObjectResponseStream + if err := awsAwsjson11_deserializeEventStreamGetLogObjectResponseStream(&v, msg); err != nil { + return nil, err + } + return &getLogObjectResponseStreamReadEventMessage{Value: v}, nil + + case eventstreamapi.ExceptionMessageType: + return nil, awsAwsjson11_deserializeEventStreamExceptionGetLogObjectResponseStream(msg) + + case eventstreamapi.ErrorMessageType: + errorCode := "UnknownError" + errorMessage := errorCode + if header := msg.Headers.Get(eventstreamapi.ErrorCodeHeader); header != nil { + errorCode = header.String() + } + if header := msg.Headers.Get(eventstreamapi.ErrorMessageHeader); header != nil { + errorMessage = header.String() + } + return nil, &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, + } + + default: + mc := msg.Clone() + return nil, &UnknownEventMessageError{ + Type: messageType.String(), + Message: &mc, + } + + } +} + +func (r *getLogObjectResponseStreamReader) ErrorSet() <-chan struct{} { + return r.err.ErrorSet() +} + +func (r *getLogObjectResponseStreamReader) Close() error { + r.closeOnce.Do(r.safeClose) + return r.Err() +} + +func (r *getLogObjectResponseStreamReader) safeClose() { + close(r.done) + r.eventStream.Close() + +} + +func (r *getLogObjectResponseStreamReader) Err() error { + return r.err.Err() +} + +func (r *getLogObjectResponseStreamReader) Closed() <-chan struct{} { + return r.done +} + +type awsAwsjson11_deserializeOpEventStreamGetLogObject struct { + LogEventStreamWrites bool + LogEventStreamReads bool +} + +func (*awsAwsjson11_deserializeOpEventStreamGetLogObject) ID() string { + return "OperationEventStreamDeserializer" +} + +func (m *awsAwsjson11_deserializeOpEventStreamGetLogObject) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( + out middleware.DeserializeOutput, metadata middleware.Metadata, err error, +) { + defer func() { + if err == nil { + return + } + m.closeResponseBody(out) + }() + + logger := middleware.GetLogger(ctx) + + request, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, fmt.Errorf("unknown transport type: %T", in.Request) + } + _ = request + + out, metadata, err = next.HandleDeserialize(ctx, in) + if err != nil { + return out, metadata, err + } + + deserializeOutput, ok := out.RawResponse.(*smithyhttp.Response) + if !ok { + return out, metadata, fmt.Errorf("unknown transport type: %T", out.RawResponse) + } + _ = deserializeOutput + + output, ok := out.Result.(*GetLogObjectOutput) + if out.Result != nil && !ok { + return out, metadata, fmt.Errorf("unexpected output result type: %T", out.Result) + } else if out.Result == nil { + output = &GetLogObjectOutput{} + out.Result = output + } + + eventReader := newGetLogObjectResponseStreamReader( + deserializeOutput.Body, + eventstream.NewDecoder(func(options *eventstream.DecoderOptions) { + options.Logger = logger + options.LogMessages = m.LogEventStreamReads + + }), + awsAwsjson11_deserializeEventMessageResponseGetLogObjectOutput, + ) + defer func() { + if err == nil { + return + } + _ = eventReader.Close() + }() + + ir := <-eventReader.initialResponse + irv, ok := ir.(*GetLogObjectOutput) + if !ok { + return out, metadata, fmt.Errorf("unexpected output result type: %T", ir) + } + *output = *irv + + output.eventStream = NewGetLogObjectEventStream(func(stream *GetLogObjectEventStream) { + stream.Reader = eventReader + }) + + go output.eventStream.waitStreamClose() + + return out, metadata, nil +} + +func (*awsAwsjson11_deserializeOpEventStreamGetLogObject) closeResponseBody(out middleware.DeserializeOutput) { + if resp, ok := out.RawResponse.(*smithyhttp.Response); ok && resp != nil && resp.Body != nil { + _, _ = io.Copy(ioutil.Discard, resp.Body) + _ = resp.Body.Close() + } +} + +func addEventStreamGetLogObjectMiddleware(stack *middleware.Stack, options Options) error { + if err := stack.Deserialize.Insert(&awsAwsjson11_deserializeOpEventStreamGetLogObject{ + LogEventStreamWrites: options.ClientLogMode.IsRequestEventMessage(), + LogEventStreamReads: options.ClientLogMode.IsResponseEventMessage(), + }, "OperationDeserializer", middleware.Before); err != nil { + return err + } + return nil + +} + type awsAwsjson11_deserializeOpEventStreamStartLiveTail struct { LogEventStreamWrites bool LogEventStreamReads bool @@ -315,6 +597,10 @@ func (e *UnknownEventMessageError) Error() string { func setSafeEventStreamClientLogMode(o *Options, operation string) { switch operation { + case "GetLogObject": + toggleEventStreamClientLogMode(o, false, true) + return + case "StartLiveTail": toggleEventStreamClientLogMode(o, false, true) return diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/generated.json b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/generated.json index 9818c5717db..fa186b8960b 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/generated.json +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/generated.json @@ -10,12 +10,16 @@ "api_client.go", "api_client_test.go", "api_op_AssociateKmsKey.go", + "api_op_AssociateSourceToS3TableIntegration.go", "api_op_CancelExportTask.go", + "api_op_CancelImportTask.go", "api_op_CreateDelivery.go", "api_op_CreateExportTask.go", + "api_op_CreateImportTask.go", "api_op_CreateLogAnomalyDetector.go", "api_op_CreateLogGroup.go", "api_op_CreateLogStream.go", + "api_op_CreateScheduledQuery.go", "api_op_DeleteAccountPolicy.go", "api_op_DeleteDataProtectionPolicy.go", "api_op_DeleteDelivery.go", @@ -32,6 +36,7 @@ "api_op_DeleteQueryDefinition.go", "api_op_DeleteResourcePolicy.go", "api_op_DeleteRetentionPolicy.go", + "api_op_DeleteScheduledQuery.go", "api_op_DeleteSubscriptionFilter.go", "api_op_DeleteTransformer.go", "api_op_DescribeAccountPolicies.go", @@ -42,6 +47,8 @@ "api_op_DescribeDestinations.go", "api_op_DescribeExportTasks.go", "api_op_DescribeFieldIndexes.go", + "api_op_DescribeImportTaskBatches.go", + "api_op_DescribeImportTasks.go", "api_op_DescribeIndexPolicies.go", "api_op_DescribeLogGroups.go", "api_op_DescribeLogStreams.go", @@ -51,6 +58,7 @@ "api_op_DescribeResourcePolicies.go", "api_op_DescribeSubscriptionFilters.go", "api_op_DisassociateKmsKey.go", + "api_op_DisassociateSourceFromS3TableIntegration.go", "api_op_FilterLogEvents.go", "api_op_GetDataProtectionPolicy.go", "api_op_GetDelivery.go", @@ -60,17 +68,26 @@ "api_op_GetIntegration.go", "api_op_GetLogAnomalyDetector.go", "api_op_GetLogEvents.go", + "api_op_GetLogFields.go", "api_op_GetLogGroupFields.go", + "api_op_GetLogObject.go", "api_op_GetLogRecord.go", "api_op_GetQueryResults.go", + "api_op_GetScheduledQuery.go", + "api_op_GetScheduledQueryHistory.go", "api_op_GetTransformer.go", + "api_op_ListAggregateLogGroupSummaries.go", "api_op_ListAnomalies.go", "api_op_ListIntegrations.go", "api_op_ListLogAnomalyDetectors.go", + "api_op_ListLogGroups.go", "api_op_ListLogGroupsForQuery.go", + "api_op_ListScheduledQueries.go", + "api_op_ListSourcesForS3TableIntegration.go", "api_op_ListTagsForResource.go", "api_op_ListTagsLogGroup.go", "api_op_PutAccountPolicy.go", + "api_op_PutBearerTokenAuthentication.go", "api_op_PutDataProtectionPolicy.go", "api_op_PutDeliveryDestination.go", "api_op_PutDeliveryDestinationPolicy.go", @@ -80,6 +97,7 @@ "api_op_PutIndexPolicy.go", "api_op_PutIntegration.go", "api_op_PutLogEvents.go", + "api_op_PutLogGroupDeletionProtection.go", "api_op_PutMetricFilter.go", "api_op_PutQueryDefinition.go", "api_op_PutResourcePolicy.go", @@ -98,6 +116,7 @@ "api_op_UpdateAnomaly.go", "api_op_UpdateDeliveryConfiguration.go", "api_op_UpdateLogAnomalyDetector.go", + "api_op_UpdateScheduledQuery.go", "auth.go", "deserializers.go", "doc.go", @@ -109,7 +128,6 @@ "internal/endpoints/endpoints.go", "internal/endpoints/endpoints_test.go", "options.go", - "protocol_test.go", "serializers.go", "snapshot_test.go", "sra_operation_order_test.go", @@ -119,7 +137,7 @@ "types/types_exported_test.go", "validators.go" ], - "go": "1.22", + "go": "1.24", "module": "github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs", "unstable": false } diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/go_module_metadata.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/go_module_metadata.go index 99d26f1ab0f..ccf557ff0a5 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/go_module_metadata.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/go_module_metadata.go @@ -3,4 +3,4 @@ package cloudwatchlogs // goModuleVersion is the tagged release for this module -const goModuleVersion = "1.47.3" +const goModuleVersion = "1.65.0" diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/internal/endpoints/endpoints.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/internal/endpoints/endpoints.go index b682de2a74e..611159cdf0e 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/internal/endpoints/endpoints.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/internal/endpoints/endpoints.go @@ -159,6 +159,9 @@ var defaultPartitions = endpoints.Partitions{ }: { Hostname: "logs.ap-east-1.api.aws", }, + endpoints.EndpointKey{ + Region: "ap-east-2", + }: endpoints.Endpoint{}, endpoints.EndpointKey{ Region: "ap-northeast-1", }: endpoints.Endpoint{}, @@ -243,6 +246,9 @@ var defaultPartitions = endpoints.Partitions{ endpoints.EndpointKey{ Region: "ap-southeast-5", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "ap-southeast-6", + }: endpoints.Endpoint{}, endpoints.EndpointKey{ Region: "ap-southeast-7", }: endpoints.Endpoint{}, @@ -561,6 +567,13 @@ var defaultPartitions = endpoints.Partitions{ { ID: "aws-eusc", Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{ + { + Variant: endpoints.DualStackVariant, + }: { + Hostname: "logs.{region}.api.amazonwebservices.eu", + Protocols: []string{"https"}, + SignatureVersions: []string{"v4"}, + }, { Variant: endpoints.FIPSVariant, }: { @@ -568,6 +581,13 @@ var defaultPartitions = endpoints.Partitions{ Protocols: []string{"https"}, SignatureVersions: []string{"v4"}, }, + { + Variant: endpoints.FIPSVariant | endpoints.DualStackVariant, + }: { + Hostname: "logs-fips.{region}.api.amazonwebservices.eu", + Protocols: []string{"https"}, + SignatureVersions: []string{"v4"}, + }, { Variant: 0, }: { @@ -578,6 +598,11 @@ var defaultPartitions = endpoints.Partitions{ }, RegionRegex: partitionRegexp.AwsEusc, IsRegionalized: true, + Endpoints: endpoints.Endpoints{ + endpoints.EndpointKey{ + Region: "eusc-de-east-1", + }: endpoints.Endpoint{}, + }, }, { ID: "aws-iso", @@ -632,6 +657,9 @@ var defaultPartitions = endpoints.Partitions{ endpoints.EndpointKey{ Region: "us-isob-east-1", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "us-isob-west-1", + }: endpoints.Endpoint{}, }, }, { diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/options.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/options.go index 79ede12486c..325abe180cf 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/options.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/options.go @@ -58,8 +58,7 @@ type Options struct { // the client option BaseEndpoint instead. EndpointResolver EndpointResolver - // Resolves the endpoint used for a particular service operation. This should be - // used over the deprecated EndpointResolver. + // Resolves the endpoint used for a particular service operation. EndpointResolverV2 EndpointResolverV2 // Signature Version 4 (SigV4) Signer @@ -123,12 +122,18 @@ type Options struct { // implementation if nil. HTTPClient HTTPClient + // Client registry of operation interceptors. + Interceptors smithyhttp.InterceptorRegistry + // The auth scheme resolver which determines how to authenticate for each // operation. AuthSchemeResolver AuthSchemeResolver // The list of auth schemes supported by the client. AuthSchemes []smithyhttp.AuthScheme + + // Priority list of preferred auth scheme names (e.g. sigv4a). + AuthSchemePreference []string } // Copy creates a clone where the APIOptions list is deep copied. @@ -136,6 +141,7 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + to.Interceptors = o.Interceptors.Copy() return to } diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/serializers.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/serializers.go index ead09b61c02..92c63d8676c 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/serializers.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/serializers.go @@ -78,6 +78,67 @@ func (m *awsAwsjson11_serializeOpAssociateKmsKey) HandleSerialize(ctx context.Co return next.HandleSerialize(ctx, in) } +type awsAwsjson11_serializeOpAssociateSourceToS3TableIntegration struct { +} + +func (*awsAwsjson11_serializeOpAssociateSourceToS3TableIntegration) ID() string { + return "OperationSerializer" +} + +func (m *awsAwsjson11_serializeOpAssociateSourceToS3TableIntegration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + _, span := tracing.StartSpan(ctx, "OperationSerializer") + endTimer := startMetricTimer(ctx, "client.call.serialization_duration") + defer endTimer() + defer span.End() + request, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} + } + + input, ok := in.Parameters.(*AssociateSourceToS3TableIntegrationInput) + _ = input + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} + } + + operationPath := "/" + if len(request.Request.URL.Path) == 0 { + request.Request.URL.Path = operationPath + } else { + request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath) + if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' { + request.Request.URL.Path += "/" + } + } + request.Request.Method = "POST" + httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) + if err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") + httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.AssociateSourceToS3TableIntegration") + + jsonEncoder := smithyjson.NewEncoder() + if err := awsAwsjson11_serializeOpDocumentAssociateSourceToS3TableIntegrationInput(input, jsonEncoder.Value); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + in.Request = request + + endTimer() + span.End() + return next.HandleSerialize(ctx, in) +} + type awsAwsjson11_serializeOpCancelExportTask struct { } @@ -139,6 +200,67 @@ func (m *awsAwsjson11_serializeOpCancelExportTask) HandleSerialize(ctx context.C return next.HandleSerialize(ctx, in) } +type awsAwsjson11_serializeOpCancelImportTask struct { +} + +func (*awsAwsjson11_serializeOpCancelImportTask) ID() string { + return "OperationSerializer" +} + +func (m *awsAwsjson11_serializeOpCancelImportTask) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + _, span := tracing.StartSpan(ctx, "OperationSerializer") + endTimer := startMetricTimer(ctx, "client.call.serialization_duration") + defer endTimer() + defer span.End() + request, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} + } + + input, ok := in.Parameters.(*CancelImportTaskInput) + _ = input + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} + } + + operationPath := "/" + if len(request.Request.URL.Path) == 0 { + request.Request.URL.Path = operationPath + } else { + request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath) + if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' { + request.Request.URL.Path += "/" + } + } + request.Request.Method = "POST" + httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) + if err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") + httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.CancelImportTask") + + jsonEncoder := smithyjson.NewEncoder() + if err := awsAwsjson11_serializeOpDocumentCancelImportTaskInput(input, jsonEncoder.Value); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + in.Request = request + + endTimer() + span.End() + return next.HandleSerialize(ctx, in) +} + type awsAwsjson11_serializeOpCreateDelivery struct { } @@ -261,6 +383,67 @@ func (m *awsAwsjson11_serializeOpCreateExportTask) HandleSerialize(ctx context.C return next.HandleSerialize(ctx, in) } +type awsAwsjson11_serializeOpCreateImportTask struct { +} + +func (*awsAwsjson11_serializeOpCreateImportTask) ID() string { + return "OperationSerializer" +} + +func (m *awsAwsjson11_serializeOpCreateImportTask) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + _, span := tracing.StartSpan(ctx, "OperationSerializer") + endTimer := startMetricTimer(ctx, "client.call.serialization_duration") + defer endTimer() + defer span.End() + request, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} + } + + input, ok := in.Parameters.(*CreateImportTaskInput) + _ = input + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} + } + + operationPath := "/" + if len(request.Request.URL.Path) == 0 { + request.Request.URL.Path = operationPath + } else { + request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath) + if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' { + request.Request.URL.Path += "/" + } + } + request.Request.Method = "POST" + httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) + if err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") + httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.CreateImportTask") + + jsonEncoder := smithyjson.NewEncoder() + if err := awsAwsjson11_serializeOpDocumentCreateImportTaskInput(input, jsonEncoder.Value); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + in.Request = request + + endTimer() + span.End() + return next.HandleSerialize(ctx, in) +} + type awsAwsjson11_serializeOpCreateLogAnomalyDetector struct { } @@ -444,6 +627,67 @@ func (m *awsAwsjson11_serializeOpCreateLogStream) HandleSerialize(ctx context.Co return next.HandleSerialize(ctx, in) } +type awsAwsjson11_serializeOpCreateScheduledQuery struct { +} + +func (*awsAwsjson11_serializeOpCreateScheduledQuery) ID() string { + return "OperationSerializer" +} + +func (m *awsAwsjson11_serializeOpCreateScheduledQuery) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + _, span := tracing.StartSpan(ctx, "OperationSerializer") + endTimer := startMetricTimer(ctx, "client.call.serialization_duration") + defer endTimer() + defer span.End() + request, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} + } + + input, ok := in.Parameters.(*CreateScheduledQueryInput) + _ = input + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} + } + + operationPath := "/" + if len(request.Request.URL.Path) == 0 { + request.Request.URL.Path = operationPath + } else { + request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath) + if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' { + request.Request.URL.Path += "/" + } + } + request.Request.Method = "POST" + httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) + if err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") + httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.CreateScheduledQuery") + + jsonEncoder := smithyjson.NewEncoder() + if err := awsAwsjson11_serializeOpDocumentCreateScheduledQueryInput(input, jsonEncoder.Value); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + in.Request = request + + endTimer() + span.End() + return next.HandleSerialize(ctx, in) +} + type awsAwsjson11_serializeOpDeleteAccountPolicy struct { } @@ -1420,14 +1664,14 @@ func (m *awsAwsjson11_serializeOpDeleteRetentionPolicy) HandleSerialize(ctx cont return next.HandleSerialize(ctx, in) } -type awsAwsjson11_serializeOpDeleteSubscriptionFilter struct { +type awsAwsjson11_serializeOpDeleteScheduledQuery struct { } -func (*awsAwsjson11_serializeOpDeleteSubscriptionFilter) ID() string { +func (*awsAwsjson11_serializeOpDeleteScheduledQuery) ID() string { return "OperationSerializer" } -func (m *awsAwsjson11_serializeOpDeleteSubscriptionFilter) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsAwsjson11_serializeOpDeleteScheduledQuery) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -1439,7 +1683,7 @@ func (m *awsAwsjson11_serializeOpDeleteSubscriptionFilter) HandleSerialize(ctx c return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DeleteSubscriptionFilterInput) + input, ok := in.Parameters.(*DeleteScheduledQueryInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -1460,10 +1704,10 @@ func (m *awsAwsjson11_serializeOpDeleteSubscriptionFilter) HandleSerialize(ctx c return out, metadata, &smithy.SerializationError{Err: err} } httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") - httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.DeleteSubscriptionFilter") + httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.DeleteScheduledQuery") jsonEncoder := smithyjson.NewEncoder() - if err := awsAwsjson11_serializeOpDocumentDeleteSubscriptionFilterInput(input, jsonEncoder.Value); err != nil { + if err := awsAwsjson11_serializeOpDocumentDeleteScheduledQueryInput(input, jsonEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -1481,14 +1725,14 @@ func (m *awsAwsjson11_serializeOpDeleteSubscriptionFilter) HandleSerialize(ctx c return next.HandleSerialize(ctx, in) } -type awsAwsjson11_serializeOpDeleteTransformer struct { +type awsAwsjson11_serializeOpDeleteSubscriptionFilter struct { } -func (*awsAwsjson11_serializeOpDeleteTransformer) ID() string { +func (*awsAwsjson11_serializeOpDeleteSubscriptionFilter) ID() string { return "OperationSerializer" } -func (m *awsAwsjson11_serializeOpDeleteTransformer) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsAwsjson11_serializeOpDeleteSubscriptionFilter) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -1500,7 +1744,7 @@ func (m *awsAwsjson11_serializeOpDeleteTransformer) HandleSerialize(ctx context. return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DeleteTransformerInput) + input, ok := in.Parameters.(*DeleteSubscriptionFilterInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -1521,10 +1765,10 @@ func (m *awsAwsjson11_serializeOpDeleteTransformer) HandleSerialize(ctx context. return out, metadata, &smithy.SerializationError{Err: err} } httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") - httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.DeleteTransformer") + httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.DeleteSubscriptionFilter") jsonEncoder := smithyjson.NewEncoder() - if err := awsAwsjson11_serializeOpDocumentDeleteTransformerInput(input, jsonEncoder.Value); err != nil { + if err := awsAwsjson11_serializeOpDocumentDeleteSubscriptionFilterInput(input, jsonEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -1542,14 +1786,14 @@ func (m *awsAwsjson11_serializeOpDeleteTransformer) HandleSerialize(ctx context. return next.HandleSerialize(ctx, in) } -type awsAwsjson11_serializeOpDescribeAccountPolicies struct { +type awsAwsjson11_serializeOpDeleteTransformer struct { } -func (*awsAwsjson11_serializeOpDescribeAccountPolicies) ID() string { +func (*awsAwsjson11_serializeOpDeleteTransformer) ID() string { return "OperationSerializer" } -func (m *awsAwsjson11_serializeOpDescribeAccountPolicies) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsAwsjson11_serializeOpDeleteTransformer) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -1561,7 +1805,7 @@ func (m *awsAwsjson11_serializeOpDescribeAccountPolicies) HandleSerialize(ctx co return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeAccountPoliciesInput) + input, ok := in.Parameters.(*DeleteTransformerInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -1582,10 +1826,10 @@ func (m *awsAwsjson11_serializeOpDescribeAccountPolicies) HandleSerialize(ctx co return out, metadata, &smithy.SerializationError{Err: err} } httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") - httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.DescribeAccountPolicies") + httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.DeleteTransformer") jsonEncoder := smithyjson.NewEncoder() - if err := awsAwsjson11_serializeOpDocumentDescribeAccountPoliciesInput(input, jsonEncoder.Value); err != nil { + if err := awsAwsjson11_serializeOpDocumentDeleteTransformerInput(input, jsonEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -1603,14 +1847,75 @@ func (m *awsAwsjson11_serializeOpDescribeAccountPolicies) HandleSerialize(ctx co return next.HandleSerialize(ctx, in) } -type awsAwsjson11_serializeOpDescribeConfigurationTemplates struct { +type awsAwsjson11_serializeOpDescribeAccountPolicies struct { } -func (*awsAwsjson11_serializeOpDescribeConfigurationTemplates) ID() string { +func (*awsAwsjson11_serializeOpDescribeAccountPolicies) ID() string { return "OperationSerializer" } -func (m *awsAwsjson11_serializeOpDescribeConfigurationTemplates) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsAwsjson11_serializeOpDescribeAccountPolicies) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + _, span := tracing.StartSpan(ctx, "OperationSerializer") + endTimer := startMetricTimer(ctx, "client.call.serialization_duration") + defer endTimer() + defer span.End() + request, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} + } + + input, ok := in.Parameters.(*DescribeAccountPoliciesInput) + _ = input + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} + } + + operationPath := "/" + if len(request.Request.URL.Path) == 0 { + request.Request.URL.Path = operationPath + } else { + request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath) + if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' { + request.Request.URL.Path += "/" + } + } + request.Request.Method = "POST" + httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) + if err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") + httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.DescribeAccountPolicies") + + jsonEncoder := smithyjson.NewEncoder() + if err := awsAwsjson11_serializeOpDocumentDescribeAccountPoliciesInput(input, jsonEncoder.Value); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + in.Request = request + + endTimer() + span.End() + return next.HandleSerialize(ctx, in) +} + +type awsAwsjson11_serializeOpDescribeConfigurationTemplates struct { +} + +func (*awsAwsjson11_serializeOpDescribeConfigurationTemplates) ID() string { + return "OperationSerializer" +} + +func (m *awsAwsjson11_serializeOpDescribeConfigurationTemplates) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -2030,6 +2335,128 @@ func (m *awsAwsjson11_serializeOpDescribeFieldIndexes) HandleSerialize(ctx conte return next.HandleSerialize(ctx, in) } +type awsAwsjson11_serializeOpDescribeImportTaskBatches struct { +} + +func (*awsAwsjson11_serializeOpDescribeImportTaskBatches) ID() string { + return "OperationSerializer" +} + +func (m *awsAwsjson11_serializeOpDescribeImportTaskBatches) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + _, span := tracing.StartSpan(ctx, "OperationSerializer") + endTimer := startMetricTimer(ctx, "client.call.serialization_duration") + defer endTimer() + defer span.End() + request, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} + } + + input, ok := in.Parameters.(*DescribeImportTaskBatchesInput) + _ = input + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} + } + + operationPath := "/" + if len(request.Request.URL.Path) == 0 { + request.Request.URL.Path = operationPath + } else { + request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath) + if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' { + request.Request.URL.Path += "/" + } + } + request.Request.Method = "POST" + httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) + if err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") + httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.DescribeImportTaskBatches") + + jsonEncoder := smithyjson.NewEncoder() + if err := awsAwsjson11_serializeOpDocumentDescribeImportTaskBatchesInput(input, jsonEncoder.Value); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + in.Request = request + + endTimer() + span.End() + return next.HandleSerialize(ctx, in) +} + +type awsAwsjson11_serializeOpDescribeImportTasks struct { +} + +func (*awsAwsjson11_serializeOpDescribeImportTasks) ID() string { + return "OperationSerializer" +} + +func (m *awsAwsjson11_serializeOpDescribeImportTasks) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + _, span := tracing.StartSpan(ctx, "OperationSerializer") + endTimer := startMetricTimer(ctx, "client.call.serialization_duration") + defer endTimer() + defer span.End() + request, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} + } + + input, ok := in.Parameters.(*DescribeImportTasksInput) + _ = input + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} + } + + operationPath := "/" + if len(request.Request.URL.Path) == 0 { + request.Request.URL.Path = operationPath + } else { + request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath) + if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' { + request.Request.URL.Path += "/" + } + } + request.Request.Method = "POST" + httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) + if err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") + httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.DescribeImportTasks") + + jsonEncoder := smithyjson.NewEncoder() + if err := awsAwsjson11_serializeOpDocumentDescribeImportTasksInput(input, jsonEncoder.Value); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + in.Request = request + + endTimer() + span.End() + return next.HandleSerialize(ctx, in) +} + type awsAwsjson11_serializeOpDescribeIndexPolicies struct { } @@ -2579,6 +3006,67 @@ func (m *awsAwsjson11_serializeOpDisassociateKmsKey) HandleSerialize(ctx context return next.HandleSerialize(ctx, in) } +type awsAwsjson11_serializeOpDisassociateSourceFromS3TableIntegration struct { +} + +func (*awsAwsjson11_serializeOpDisassociateSourceFromS3TableIntegration) ID() string { + return "OperationSerializer" +} + +func (m *awsAwsjson11_serializeOpDisassociateSourceFromS3TableIntegration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + _, span := tracing.StartSpan(ctx, "OperationSerializer") + endTimer := startMetricTimer(ctx, "client.call.serialization_duration") + defer endTimer() + defer span.End() + request, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} + } + + input, ok := in.Parameters.(*DisassociateSourceFromS3TableIntegrationInput) + _ = input + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} + } + + operationPath := "/" + if len(request.Request.URL.Path) == 0 { + request.Request.URL.Path = operationPath + } else { + request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath) + if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' { + request.Request.URL.Path += "/" + } + } + request.Request.Method = "POST" + httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) + if err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") + httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.DisassociateSourceFromS3TableIntegration") + + jsonEncoder := smithyjson.NewEncoder() + if err := awsAwsjson11_serializeOpDocumentDisassociateSourceFromS3TableIntegrationInput(input, jsonEncoder.Value); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + in.Request = request + + endTimer() + span.End() + return next.HandleSerialize(ctx, in) +} + type awsAwsjson11_serializeOpFilterLogEvents struct { } @@ -3128,14 +3616,14 @@ func (m *awsAwsjson11_serializeOpGetLogEvents) HandleSerialize(ctx context.Conte return next.HandleSerialize(ctx, in) } -type awsAwsjson11_serializeOpGetLogGroupFields struct { +type awsAwsjson11_serializeOpGetLogFields struct { } -func (*awsAwsjson11_serializeOpGetLogGroupFields) ID() string { +func (*awsAwsjson11_serializeOpGetLogFields) ID() string { return "OperationSerializer" } -func (m *awsAwsjson11_serializeOpGetLogGroupFields) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsAwsjson11_serializeOpGetLogFields) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -3147,7 +3635,7 @@ func (m *awsAwsjson11_serializeOpGetLogGroupFields) HandleSerialize(ctx context. return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetLogGroupFieldsInput) + input, ok := in.Parameters.(*GetLogFieldsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -3168,10 +3656,10 @@ func (m *awsAwsjson11_serializeOpGetLogGroupFields) HandleSerialize(ctx context. return out, metadata, &smithy.SerializationError{Err: err} } httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") - httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.GetLogGroupFields") + httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.GetLogFields") jsonEncoder := smithyjson.NewEncoder() - if err := awsAwsjson11_serializeOpDocumentGetLogGroupFieldsInput(input, jsonEncoder.Value); err != nil { + if err := awsAwsjson11_serializeOpDocumentGetLogFieldsInput(input, jsonEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -3189,14 +3677,14 @@ func (m *awsAwsjson11_serializeOpGetLogGroupFields) HandleSerialize(ctx context. return next.HandleSerialize(ctx, in) } -type awsAwsjson11_serializeOpGetLogRecord struct { +type awsAwsjson11_serializeOpGetLogGroupFields struct { } -func (*awsAwsjson11_serializeOpGetLogRecord) ID() string { +func (*awsAwsjson11_serializeOpGetLogGroupFields) ID() string { return "OperationSerializer" } -func (m *awsAwsjson11_serializeOpGetLogRecord) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsAwsjson11_serializeOpGetLogGroupFields) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -3208,7 +3696,7 @@ func (m *awsAwsjson11_serializeOpGetLogRecord) HandleSerialize(ctx context.Conte return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetLogRecordInput) + input, ok := in.Parameters.(*GetLogGroupFieldsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -3229,10 +3717,10 @@ func (m *awsAwsjson11_serializeOpGetLogRecord) HandleSerialize(ctx context.Conte return out, metadata, &smithy.SerializationError{Err: err} } httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") - httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.GetLogRecord") + httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.GetLogGroupFields") jsonEncoder := smithyjson.NewEncoder() - if err := awsAwsjson11_serializeOpDocumentGetLogRecordInput(input, jsonEncoder.Value); err != nil { + if err := awsAwsjson11_serializeOpDocumentGetLogGroupFieldsInput(input, jsonEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -3250,14 +3738,14 @@ func (m *awsAwsjson11_serializeOpGetLogRecord) HandleSerialize(ctx context.Conte return next.HandleSerialize(ctx, in) } -type awsAwsjson11_serializeOpGetQueryResults struct { +type awsAwsjson11_serializeOpGetLogObject struct { } -func (*awsAwsjson11_serializeOpGetQueryResults) ID() string { +func (*awsAwsjson11_serializeOpGetLogObject) ID() string { return "OperationSerializer" } -func (m *awsAwsjson11_serializeOpGetQueryResults) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsAwsjson11_serializeOpGetLogObject) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -3269,7 +3757,7 @@ func (m *awsAwsjson11_serializeOpGetQueryResults) HandleSerialize(ctx context.Co return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetQueryResultsInput) + input, ok := in.Parameters.(*GetLogObjectInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -3290,10 +3778,10 @@ func (m *awsAwsjson11_serializeOpGetQueryResults) HandleSerialize(ctx context.Co return out, metadata, &smithy.SerializationError{Err: err} } httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") - httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.GetQueryResults") + httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.GetLogObject") jsonEncoder := smithyjson.NewEncoder() - if err := awsAwsjson11_serializeOpDocumentGetQueryResultsInput(input, jsonEncoder.Value); err != nil { + if err := awsAwsjson11_serializeOpDocumentGetLogObjectInput(input, jsonEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -3311,14 +3799,14 @@ func (m *awsAwsjson11_serializeOpGetQueryResults) HandleSerialize(ctx context.Co return next.HandleSerialize(ctx, in) } -type awsAwsjson11_serializeOpGetTransformer struct { +type awsAwsjson11_serializeOpGetLogRecord struct { } -func (*awsAwsjson11_serializeOpGetTransformer) ID() string { +func (*awsAwsjson11_serializeOpGetLogRecord) ID() string { return "OperationSerializer" } -func (m *awsAwsjson11_serializeOpGetTransformer) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsAwsjson11_serializeOpGetLogRecord) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -3330,7 +3818,7 @@ func (m *awsAwsjson11_serializeOpGetTransformer) HandleSerialize(ctx context.Con return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetTransformerInput) + input, ok := in.Parameters.(*GetLogRecordInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -3351,10 +3839,10 @@ func (m *awsAwsjson11_serializeOpGetTransformer) HandleSerialize(ctx context.Con return out, metadata, &smithy.SerializationError{Err: err} } httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") - httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.GetTransformer") + httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.GetLogRecord") jsonEncoder := smithyjson.NewEncoder() - if err := awsAwsjson11_serializeOpDocumentGetTransformerInput(input, jsonEncoder.Value); err != nil { + if err := awsAwsjson11_serializeOpDocumentGetLogRecordInput(input, jsonEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -3372,14 +3860,14 @@ func (m *awsAwsjson11_serializeOpGetTransformer) HandleSerialize(ctx context.Con return next.HandleSerialize(ctx, in) } -type awsAwsjson11_serializeOpListAnomalies struct { +type awsAwsjson11_serializeOpGetQueryResults struct { } -func (*awsAwsjson11_serializeOpListAnomalies) ID() string { +func (*awsAwsjson11_serializeOpGetQueryResults) ID() string { return "OperationSerializer" } -func (m *awsAwsjson11_serializeOpListAnomalies) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsAwsjson11_serializeOpGetQueryResults) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -3391,7 +3879,7 @@ func (m *awsAwsjson11_serializeOpListAnomalies) HandleSerialize(ctx context.Cont return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ListAnomaliesInput) + input, ok := in.Parameters.(*GetQueryResultsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -3412,10 +3900,10 @@ func (m *awsAwsjson11_serializeOpListAnomalies) HandleSerialize(ctx context.Cont return out, metadata, &smithy.SerializationError{Err: err} } httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") - httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.ListAnomalies") + httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.GetQueryResults") jsonEncoder := smithyjson.NewEncoder() - if err := awsAwsjson11_serializeOpDocumentListAnomaliesInput(input, jsonEncoder.Value); err != nil { + if err := awsAwsjson11_serializeOpDocumentGetQueryResultsInput(input, jsonEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -3433,14 +3921,14 @@ func (m *awsAwsjson11_serializeOpListAnomalies) HandleSerialize(ctx context.Cont return next.HandleSerialize(ctx, in) } -type awsAwsjson11_serializeOpListIntegrations struct { +type awsAwsjson11_serializeOpGetScheduledQuery struct { } -func (*awsAwsjson11_serializeOpListIntegrations) ID() string { +func (*awsAwsjson11_serializeOpGetScheduledQuery) ID() string { return "OperationSerializer" } -func (m *awsAwsjson11_serializeOpListIntegrations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsAwsjson11_serializeOpGetScheduledQuery) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -3452,7 +3940,7 @@ func (m *awsAwsjson11_serializeOpListIntegrations) HandleSerialize(ctx context.C return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ListIntegrationsInput) + input, ok := in.Parameters.(*GetScheduledQueryInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -3473,10 +3961,10 @@ func (m *awsAwsjson11_serializeOpListIntegrations) HandleSerialize(ctx context.C return out, metadata, &smithy.SerializationError{Err: err} } httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") - httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.ListIntegrations") + httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.GetScheduledQuery") jsonEncoder := smithyjson.NewEncoder() - if err := awsAwsjson11_serializeOpDocumentListIntegrationsInput(input, jsonEncoder.Value); err != nil { + if err := awsAwsjson11_serializeOpDocumentGetScheduledQueryInput(input, jsonEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -3494,14 +3982,14 @@ func (m *awsAwsjson11_serializeOpListIntegrations) HandleSerialize(ctx context.C return next.HandleSerialize(ctx, in) } -type awsAwsjson11_serializeOpListLogAnomalyDetectors struct { +type awsAwsjson11_serializeOpGetScheduledQueryHistory struct { } -func (*awsAwsjson11_serializeOpListLogAnomalyDetectors) ID() string { +func (*awsAwsjson11_serializeOpGetScheduledQueryHistory) ID() string { return "OperationSerializer" } -func (m *awsAwsjson11_serializeOpListLogAnomalyDetectors) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsAwsjson11_serializeOpGetScheduledQueryHistory) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -3513,7 +4001,7 @@ func (m *awsAwsjson11_serializeOpListLogAnomalyDetectors) HandleSerialize(ctx co return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ListLogAnomalyDetectorsInput) + input, ok := in.Parameters.(*GetScheduledQueryHistoryInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -3534,10 +4022,10 @@ func (m *awsAwsjson11_serializeOpListLogAnomalyDetectors) HandleSerialize(ctx co return out, metadata, &smithy.SerializationError{Err: err} } httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") - httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.ListLogAnomalyDetectors") + httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.GetScheduledQueryHistory") jsonEncoder := smithyjson.NewEncoder() - if err := awsAwsjson11_serializeOpDocumentListLogAnomalyDetectorsInput(input, jsonEncoder.Value); err != nil { + if err := awsAwsjson11_serializeOpDocumentGetScheduledQueryHistoryInput(input, jsonEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -3555,14 +4043,14 @@ func (m *awsAwsjson11_serializeOpListLogAnomalyDetectors) HandleSerialize(ctx co return next.HandleSerialize(ctx, in) } -type awsAwsjson11_serializeOpListLogGroupsForQuery struct { +type awsAwsjson11_serializeOpGetTransformer struct { } -func (*awsAwsjson11_serializeOpListLogGroupsForQuery) ID() string { +func (*awsAwsjson11_serializeOpGetTransformer) ID() string { return "OperationSerializer" } -func (m *awsAwsjson11_serializeOpListLogGroupsForQuery) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsAwsjson11_serializeOpGetTransformer) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -3574,7 +4062,7 @@ func (m *awsAwsjson11_serializeOpListLogGroupsForQuery) HandleSerialize(ctx cont return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ListLogGroupsForQueryInput) + input, ok := in.Parameters.(*GetTransformerInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -3595,10 +4083,10 @@ func (m *awsAwsjson11_serializeOpListLogGroupsForQuery) HandleSerialize(ctx cont return out, metadata, &smithy.SerializationError{Err: err} } httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") - httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.ListLogGroupsForQuery") + httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.GetTransformer") jsonEncoder := smithyjson.NewEncoder() - if err := awsAwsjson11_serializeOpDocumentListLogGroupsForQueryInput(input, jsonEncoder.Value); err != nil { + if err := awsAwsjson11_serializeOpDocumentGetTransformerInput(input, jsonEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -3616,14 +4104,14 @@ func (m *awsAwsjson11_serializeOpListLogGroupsForQuery) HandleSerialize(ctx cont return next.HandleSerialize(ctx, in) } -type awsAwsjson11_serializeOpListTagsForResource struct { +type awsAwsjson11_serializeOpListAggregateLogGroupSummaries struct { } -func (*awsAwsjson11_serializeOpListTagsForResource) ID() string { +func (*awsAwsjson11_serializeOpListAggregateLogGroupSummaries) ID() string { return "OperationSerializer" } -func (m *awsAwsjson11_serializeOpListTagsForResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsAwsjson11_serializeOpListAggregateLogGroupSummaries) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -3635,7 +4123,7 @@ func (m *awsAwsjson11_serializeOpListTagsForResource) HandleSerialize(ctx contex return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ListTagsForResourceInput) + input, ok := in.Parameters.(*ListAggregateLogGroupSummariesInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -3656,10 +4144,10 @@ func (m *awsAwsjson11_serializeOpListTagsForResource) HandleSerialize(ctx contex return out, metadata, &smithy.SerializationError{Err: err} } httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") - httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.ListTagsForResource") + httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.ListAggregateLogGroupSummaries") jsonEncoder := smithyjson.NewEncoder() - if err := awsAwsjson11_serializeOpDocumentListTagsForResourceInput(input, jsonEncoder.Value); err != nil { + if err := awsAwsjson11_serializeOpDocumentListAggregateLogGroupSummariesInput(input, jsonEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -3677,14 +4165,14 @@ func (m *awsAwsjson11_serializeOpListTagsForResource) HandleSerialize(ctx contex return next.HandleSerialize(ctx, in) } -type awsAwsjson11_serializeOpListTagsLogGroup struct { +type awsAwsjson11_serializeOpListAnomalies struct { } -func (*awsAwsjson11_serializeOpListTagsLogGroup) ID() string { +func (*awsAwsjson11_serializeOpListAnomalies) ID() string { return "OperationSerializer" } -func (m *awsAwsjson11_serializeOpListTagsLogGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsAwsjson11_serializeOpListAnomalies) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -3696,7 +4184,7 @@ func (m *awsAwsjson11_serializeOpListTagsLogGroup) HandleSerialize(ctx context.C return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ListTagsLogGroupInput) + input, ok := in.Parameters.(*ListAnomaliesInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -3717,10 +4205,10 @@ func (m *awsAwsjson11_serializeOpListTagsLogGroup) HandleSerialize(ctx context.C return out, metadata, &smithy.SerializationError{Err: err} } httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") - httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.ListTagsLogGroup") + httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.ListAnomalies") jsonEncoder := smithyjson.NewEncoder() - if err := awsAwsjson11_serializeOpDocumentListTagsLogGroupInput(input, jsonEncoder.Value); err != nil { + if err := awsAwsjson11_serializeOpDocumentListAnomaliesInput(input, jsonEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -3738,14 +4226,14 @@ func (m *awsAwsjson11_serializeOpListTagsLogGroup) HandleSerialize(ctx context.C return next.HandleSerialize(ctx, in) } -type awsAwsjson11_serializeOpPutAccountPolicy struct { +type awsAwsjson11_serializeOpListIntegrations struct { } -func (*awsAwsjson11_serializeOpPutAccountPolicy) ID() string { +func (*awsAwsjson11_serializeOpListIntegrations) ID() string { return "OperationSerializer" } -func (m *awsAwsjson11_serializeOpPutAccountPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsAwsjson11_serializeOpListIntegrations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -3757,7 +4245,7 @@ func (m *awsAwsjson11_serializeOpPutAccountPolicy) HandleSerialize(ctx context.C return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*PutAccountPolicyInput) + input, ok := in.Parameters.(*ListIntegrationsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -3778,10 +4266,10 @@ func (m *awsAwsjson11_serializeOpPutAccountPolicy) HandleSerialize(ctx context.C return out, metadata, &smithy.SerializationError{Err: err} } httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") - httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.PutAccountPolicy") + httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.ListIntegrations") jsonEncoder := smithyjson.NewEncoder() - if err := awsAwsjson11_serializeOpDocumentPutAccountPolicyInput(input, jsonEncoder.Value); err != nil { + if err := awsAwsjson11_serializeOpDocumentListIntegrationsInput(input, jsonEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -3799,14 +4287,14 @@ func (m *awsAwsjson11_serializeOpPutAccountPolicy) HandleSerialize(ctx context.C return next.HandleSerialize(ctx, in) } -type awsAwsjson11_serializeOpPutDataProtectionPolicy struct { +type awsAwsjson11_serializeOpListLogAnomalyDetectors struct { } -func (*awsAwsjson11_serializeOpPutDataProtectionPolicy) ID() string { +func (*awsAwsjson11_serializeOpListLogAnomalyDetectors) ID() string { return "OperationSerializer" } -func (m *awsAwsjson11_serializeOpPutDataProtectionPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsAwsjson11_serializeOpListLogAnomalyDetectors) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -3818,7 +4306,7 @@ func (m *awsAwsjson11_serializeOpPutDataProtectionPolicy) HandleSerialize(ctx co return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*PutDataProtectionPolicyInput) + input, ok := in.Parameters.(*ListLogAnomalyDetectorsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -3839,10 +4327,10 @@ func (m *awsAwsjson11_serializeOpPutDataProtectionPolicy) HandleSerialize(ctx co return out, metadata, &smithy.SerializationError{Err: err} } httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") - httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.PutDataProtectionPolicy") + httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.ListLogAnomalyDetectors") jsonEncoder := smithyjson.NewEncoder() - if err := awsAwsjson11_serializeOpDocumentPutDataProtectionPolicyInput(input, jsonEncoder.Value); err != nil { + if err := awsAwsjson11_serializeOpDocumentListLogAnomalyDetectorsInput(input, jsonEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -3860,14 +4348,14 @@ func (m *awsAwsjson11_serializeOpPutDataProtectionPolicy) HandleSerialize(ctx co return next.HandleSerialize(ctx, in) } -type awsAwsjson11_serializeOpPutDeliveryDestination struct { +type awsAwsjson11_serializeOpListLogGroups struct { } -func (*awsAwsjson11_serializeOpPutDeliveryDestination) ID() string { +func (*awsAwsjson11_serializeOpListLogGroups) ID() string { return "OperationSerializer" } -func (m *awsAwsjson11_serializeOpPutDeliveryDestination) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsAwsjson11_serializeOpListLogGroups) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -3879,7 +4367,7 @@ func (m *awsAwsjson11_serializeOpPutDeliveryDestination) HandleSerialize(ctx con return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*PutDeliveryDestinationInput) + input, ok := in.Parameters.(*ListLogGroupsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -3900,10 +4388,10 @@ func (m *awsAwsjson11_serializeOpPutDeliveryDestination) HandleSerialize(ctx con return out, metadata, &smithy.SerializationError{Err: err} } httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") - httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.PutDeliveryDestination") + httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.ListLogGroups") jsonEncoder := smithyjson.NewEncoder() - if err := awsAwsjson11_serializeOpDocumentPutDeliveryDestinationInput(input, jsonEncoder.Value); err != nil { + if err := awsAwsjson11_serializeOpDocumentListLogGroupsInput(input, jsonEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -3921,14 +4409,14 @@ func (m *awsAwsjson11_serializeOpPutDeliveryDestination) HandleSerialize(ctx con return next.HandleSerialize(ctx, in) } -type awsAwsjson11_serializeOpPutDeliveryDestinationPolicy struct { +type awsAwsjson11_serializeOpListLogGroupsForQuery struct { } -func (*awsAwsjson11_serializeOpPutDeliveryDestinationPolicy) ID() string { +func (*awsAwsjson11_serializeOpListLogGroupsForQuery) ID() string { return "OperationSerializer" } -func (m *awsAwsjson11_serializeOpPutDeliveryDestinationPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsAwsjson11_serializeOpListLogGroupsForQuery) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -3940,7 +4428,7 @@ func (m *awsAwsjson11_serializeOpPutDeliveryDestinationPolicy) HandleSerialize(c return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*PutDeliveryDestinationPolicyInput) + input, ok := in.Parameters.(*ListLogGroupsForQueryInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -3961,10 +4449,10 @@ func (m *awsAwsjson11_serializeOpPutDeliveryDestinationPolicy) HandleSerialize(c return out, metadata, &smithy.SerializationError{Err: err} } httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") - httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.PutDeliveryDestinationPolicy") + httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.ListLogGroupsForQuery") jsonEncoder := smithyjson.NewEncoder() - if err := awsAwsjson11_serializeOpDocumentPutDeliveryDestinationPolicyInput(input, jsonEncoder.Value); err != nil { + if err := awsAwsjson11_serializeOpDocumentListLogGroupsForQueryInput(input, jsonEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -3982,14 +4470,14 @@ func (m *awsAwsjson11_serializeOpPutDeliveryDestinationPolicy) HandleSerialize(c return next.HandleSerialize(ctx, in) } -type awsAwsjson11_serializeOpPutDeliverySource struct { +type awsAwsjson11_serializeOpListScheduledQueries struct { } -func (*awsAwsjson11_serializeOpPutDeliverySource) ID() string { +func (*awsAwsjson11_serializeOpListScheduledQueries) ID() string { return "OperationSerializer" } -func (m *awsAwsjson11_serializeOpPutDeliverySource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsAwsjson11_serializeOpListScheduledQueries) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -4001,7 +4489,7 @@ func (m *awsAwsjson11_serializeOpPutDeliverySource) HandleSerialize(ctx context. return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*PutDeliverySourceInput) + input, ok := in.Parameters.(*ListScheduledQueriesInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -4022,10 +4510,10 @@ func (m *awsAwsjson11_serializeOpPutDeliverySource) HandleSerialize(ctx context. return out, metadata, &smithy.SerializationError{Err: err} } httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") - httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.PutDeliverySource") + httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.ListScheduledQueries") jsonEncoder := smithyjson.NewEncoder() - if err := awsAwsjson11_serializeOpDocumentPutDeliverySourceInput(input, jsonEncoder.Value); err != nil { + if err := awsAwsjson11_serializeOpDocumentListScheduledQueriesInput(input, jsonEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -4043,14 +4531,14 @@ func (m *awsAwsjson11_serializeOpPutDeliverySource) HandleSerialize(ctx context. return next.HandleSerialize(ctx, in) } -type awsAwsjson11_serializeOpPutDestination struct { +type awsAwsjson11_serializeOpListSourcesForS3TableIntegration struct { } -func (*awsAwsjson11_serializeOpPutDestination) ID() string { +func (*awsAwsjson11_serializeOpListSourcesForS3TableIntegration) ID() string { return "OperationSerializer" } -func (m *awsAwsjson11_serializeOpPutDestination) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsAwsjson11_serializeOpListSourcesForS3TableIntegration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -4062,7 +4550,7 @@ func (m *awsAwsjson11_serializeOpPutDestination) HandleSerialize(ctx context.Con return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*PutDestinationInput) + input, ok := in.Parameters.(*ListSourcesForS3TableIntegrationInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -4083,10 +4571,10 @@ func (m *awsAwsjson11_serializeOpPutDestination) HandleSerialize(ctx context.Con return out, metadata, &smithy.SerializationError{Err: err} } httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") - httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.PutDestination") + httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.ListSourcesForS3TableIntegration") jsonEncoder := smithyjson.NewEncoder() - if err := awsAwsjson11_serializeOpDocumentPutDestinationInput(input, jsonEncoder.Value); err != nil { + if err := awsAwsjson11_serializeOpDocumentListSourcesForS3TableIntegrationInput(input, jsonEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -4104,14 +4592,14 @@ func (m *awsAwsjson11_serializeOpPutDestination) HandleSerialize(ctx context.Con return next.HandleSerialize(ctx, in) } -type awsAwsjson11_serializeOpPutDestinationPolicy struct { +type awsAwsjson11_serializeOpListTagsForResource struct { } -func (*awsAwsjson11_serializeOpPutDestinationPolicy) ID() string { +func (*awsAwsjson11_serializeOpListTagsForResource) ID() string { return "OperationSerializer" } -func (m *awsAwsjson11_serializeOpPutDestinationPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsAwsjson11_serializeOpListTagsForResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -4123,7 +4611,7 @@ func (m *awsAwsjson11_serializeOpPutDestinationPolicy) HandleSerialize(ctx conte return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*PutDestinationPolicyInput) + input, ok := in.Parameters.(*ListTagsForResourceInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -4144,10 +4632,10 @@ func (m *awsAwsjson11_serializeOpPutDestinationPolicy) HandleSerialize(ctx conte return out, metadata, &smithy.SerializationError{Err: err} } httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") - httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.PutDestinationPolicy") + httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.ListTagsForResource") jsonEncoder := smithyjson.NewEncoder() - if err := awsAwsjson11_serializeOpDocumentPutDestinationPolicyInput(input, jsonEncoder.Value); err != nil { + if err := awsAwsjson11_serializeOpDocumentListTagsForResourceInput(input, jsonEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -4165,14 +4653,14 @@ func (m *awsAwsjson11_serializeOpPutDestinationPolicy) HandleSerialize(ctx conte return next.HandleSerialize(ctx, in) } -type awsAwsjson11_serializeOpPutIndexPolicy struct { +type awsAwsjson11_serializeOpListTagsLogGroup struct { } -func (*awsAwsjson11_serializeOpPutIndexPolicy) ID() string { +func (*awsAwsjson11_serializeOpListTagsLogGroup) ID() string { return "OperationSerializer" } -func (m *awsAwsjson11_serializeOpPutIndexPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsAwsjson11_serializeOpListTagsLogGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -4184,7 +4672,7 @@ func (m *awsAwsjson11_serializeOpPutIndexPolicy) HandleSerialize(ctx context.Con return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*PutIndexPolicyInput) + input, ok := in.Parameters.(*ListTagsLogGroupInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -4205,10 +4693,10 @@ func (m *awsAwsjson11_serializeOpPutIndexPolicy) HandleSerialize(ctx context.Con return out, metadata, &smithy.SerializationError{Err: err} } httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") - httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.PutIndexPolicy") + httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.ListTagsLogGroup") jsonEncoder := smithyjson.NewEncoder() - if err := awsAwsjson11_serializeOpDocumentPutIndexPolicyInput(input, jsonEncoder.Value); err != nil { + if err := awsAwsjson11_serializeOpDocumentListTagsLogGroupInput(input, jsonEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -4226,14 +4714,14 @@ func (m *awsAwsjson11_serializeOpPutIndexPolicy) HandleSerialize(ctx context.Con return next.HandleSerialize(ctx, in) } -type awsAwsjson11_serializeOpPutIntegration struct { +type awsAwsjson11_serializeOpPutAccountPolicy struct { } -func (*awsAwsjson11_serializeOpPutIntegration) ID() string { +func (*awsAwsjson11_serializeOpPutAccountPolicy) ID() string { return "OperationSerializer" } -func (m *awsAwsjson11_serializeOpPutIntegration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsAwsjson11_serializeOpPutAccountPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -4245,7 +4733,7 @@ func (m *awsAwsjson11_serializeOpPutIntegration) HandleSerialize(ctx context.Con return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*PutIntegrationInput) + input, ok := in.Parameters.(*PutAccountPolicyInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -4266,10 +4754,10 @@ func (m *awsAwsjson11_serializeOpPutIntegration) HandleSerialize(ctx context.Con return out, metadata, &smithy.SerializationError{Err: err} } httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") - httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.PutIntegration") + httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.PutAccountPolicy") jsonEncoder := smithyjson.NewEncoder() - if err := awsAwsjson11_serializeOpDocumentPutIntegrationInput(input, jsonEncoder.Value); err != nil { + if err := awsAwsjson11_serializeOpDocumentPutAccountPolicyInput(input, jsonEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -4287,14 +4775,14 @@ func (m *awsAwsjson11_serializeOpPutIntegration) HandleSerialize(ctx context.Con return next.HandleSerialize(ctx, in) } -type awsAwsjson11_serializeOpPutLogEvents struct { +type awsAwsjson11_serializeOpPutBearerTokenAuthentication struct { } -func (*awsAwsjson11_serializeOpPutLogEvents) ID() string { +func (*awsAwsjson11_serializeOpPutBearerTokenAuthentication) ID() string { return "OperationSerializer" } -func (m *awsAwsjson11_serializeOpPutLogEvents) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsAwsjson11_serializeOpPutBearerTokenAuthentication) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -4306,7 +4794,7 @@ func (m *awsAwsjson11_serializeOpPutLogEvents) HandleSerialize(ctx context.Conte return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*PutLogEventsInput) + input, ok := in.Parameters.(*PutBearerTokenAuthenticationInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -4327,10 +4815,10 @@ func (m *awsAwsjson11_serializeOpPutLogEvents) HandleSerialize(ctx context.Conte return out, metadata, &smithy.SerializationError{Err: err} } httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") - httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.PutLogEvents") + httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.PutBearerTokenAuthentication") jsonEncoder := smithyjson.NewEncoder() - if err := awsAwsjson11_serializeOpDocumentPutLogEventsInput(input, jsonEncoder.Value); err != nil { + if err := awsAwsjson11_serializeOpDocumentPutBearerTokenAuthenticationInput(input, jsonEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -4348,14 +4836,14 @@ func (m *awsAwsjson11_serializeOpPutLogEvents) HandleSerialize(ctx context.Conte return next.HandleSerialize(ctx, in) } -type awsAwsjson11_serializeOpPutMetricFilter struct { +type awsAwsjson11_serializeOpPutDataProtectionPolicy struct { } -func (*awsAwsjson11_serializeOpPutMetricFilter) ID() string { +func (*awsAwsjson11_serializeOpPutDataProtectionPolicy) ID() string { return "OperationSerializer" } -func (m *awsAwsjson11_serializeOpPutMetricFilter) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsAwsjson11_serializeOpPutDataProtectionPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -4367,7 +4855,7 @@ func (m *awsAwsjson11_serializeOpPutMetricFilter) HandleSerialize(ctx context.Co return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*PutMetricFilterInput) + input, ok := in.Parameters.(*PutDataProtectionPolicyInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -4388,10 +4876,10 @@ func (m *awsAwsjson11_serializeOpPutMetricFilter) HandleSerialize(ctx context.Co return out, metadata, &smithy.SerializationError{Err: err} } httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") - httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.PutMetricFilter") + httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.PutDataProtectionPolicy") jsonEncoder := smithyjson.NewEncoder() - if err := awsAwsjson11_serializeOpDocumentPutMetricFilterInput(input, jsonEncoder.Value); err != nil { + if err := awsAwsjson11_serializeOpDocumentPutDataProtectionPolicyInput(input, jsonEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -4409,14 +4897,14 @@ func (m *awsAwsjson11_serializeOpPutMetricFilter) HandleSerialize(ctx context.Co return next.HandleSerialize(ctx, in) } -type awsAwsjson11_serializeOpPutQueryDefinition struct { +type awsAwsjson11_serializeOpPutDeliveryDestination struct { } -func (*awsAwsjson11_serializeOpPutQueryDefinition) ID() string { +func (*awsAwsjson11_serializeOpPutDeliveryDestination) ID() string { return "OperationSerializer" } -func (m *awsAwsjson11_serializeOpPutQueryDefinition) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsAwsjson11_serializeOpPutDeliveryDestination) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -4428,7 +4916,7 @@ func (m *awsAwsjson11_serializeOpPutQueryDefinition) HandleSerialize(ctx context return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*PutQueryDefinitionInput) + input, ok := in.Parameters.(*PutDeliveryDestinationInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -4449,10 +4937,10 @@ func (m *awsAwsjson11_serializeOpPutQueryDefinition) HandleSerialize(ctx context return out, metadata, &smithy.SerializationError{Err: err} } httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") - httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.PutQueryDefinition") + httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.PutDeliveryDestination") jsonEncoder := smithyjson.NewEncoder() - if err := awsAwsjson11_serializeOpDocumentPutQueryDefinitionInput(input, jsonEncoder.Value); err != nil { + if err := awsAwsjson11_serializeOpDocumentPutDeliveryDestinationInput(input, jsonEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -4470,14 +4958,14 @@ func (m *awsAwsjson11_serializeOpPutQueryDefinition) HandleSerialize(ctx context return next.HandleSerialize(ctx, in) } -type awsAwsjson11_serializeOpPutResourcePolicy struct { +type awsAwsjson11_serializeOpPutDeliveryDestinationPolicy struct { } -func (*awsAwsjson11_serializeOpPutResourcePolicy) ID() string { +func (*awsAwsjson11_serializeOpPutDeliveryDestinationPolicy) ID() string { return "OperationSerializer" } -func (m *awsAwsjson11_serializeOpPutResourcePolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsAwsjson11_serializeOpPutDeliveryDestinationPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -4489,7 +4977,7 @@ func (m *awsAwsjson11_serializeOpPutResourcePolicy) HandleSerialize(ctx context. return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*PutResourcePolicyInput) + input, ok := in.Parameters.(*PutDeliveryDestinationPolicyInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -4510,10 +4998,10 @@ func (m *awsAwsjson11_serializeOpPutResourcePolicy) HandleSerialize(ctx context. return out, metadata, &smithy.SerializationError{Err: err} } httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") - httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.PutResourcePolicy") + httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.PutDeliveryDestinationPolicy") jsonEncoder := smithyjson.NewEncoder() - if err := awsAwsjson11_serializeOpDocumentPutResourcePolicyInput(input, jsonEncoder.Value); err != nil { + if err := awsAwsjson11_serializeOpDocumentPutDeliveryDestinationPolicyInput(input, jsonEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -4531,14 +5019,14 @@ func (m *awsAwsjson11_serializeOpPutResourcePolicy) HandleSerialize(ctx context. return next.HandleSerialize(ctx, in) } -type awsAwsjson11_serializeOpPutRetentionPolicy struct { +type awsAwsjson11_serializeOpPutDeliverySource struct { } -func (*awsAwsjson11_serializeOpPutRetentionPolicy) ID() string { +func (*awsAwsjson11_serializeOpPutDeliverySource) ID() string { return "OperationSerializer" } -func (m *awsAwsjson11_serializeOpPutRetentionPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsAwsjson11_serializeOpPutDeliverySource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -4550,7 +5038,7 @@ func (m *awsAwsjson11_serializeOpPutRetentionPolicy) HandleSerialize(ctx context return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*PutRetentionPolicyInput) + input, ok := in.Parameters.(*PutDeliverySourceInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -4571,10 +5059,10 @@ func (m *awsAwsjson11_serializeOpPutRetentionPolicy) HandleSerialize(ctx context return out, metadata, &smithy.SerializationError{Err: err} } httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") - httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.PutRetentionPolicy") + httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.PutDeliverySource") jsonEncoder := smithyjson.NewEncoder() - if err := awsAwsjson11_serializeOpDocumentPutRetentionPolicyInput(input, jsonEncoder.Value); err != nil { + if err := awsAwsjson11_serializeOpDocumentPutDeliverySourceInput(input, jsonEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -4592,14 +5080,14 @@ func (m *awsAwsjson11_serializeOpPutRetentionPolicy) HandleSerialize(ctx context return next.HandleSerialize(ctx, in) } -type awsAwsjson11_serializeOpPutSubscriptionFilter struct { +type awsAwsjson11_serializeOpPutDestination struct { } -func (*awsAwsjson11_serializeOpPutSubscriptionFilter) ID() string { +func (*awsAwsjson11_serializeOpPutDestination) ID() string { return "OperationSerializer" } -func (m *awsAwsjson11_serializeOpPutSubscriptionFilter) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsAwsjson11_serializeOpPutDestination) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -4611,7 +5099,7 @@ func (m *awsAwsjson11_serializeOpPutSubscriptionFilter) HandleSerialize(ctx cont return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*PutSubscriptionFilterInput) + input, ok := in.Parameters.(*PutDestinationInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -4632,10 +5120,10 @@ func (m *awsAwsjson11_serializeOpPutSubscriptionFilter) HandleSerialize(ctx cont return out, metadata, &smithy.SerializationError{Err: err} } httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") - httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.PutSubscriptionFilter") + httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.PutDestination") jsonEncoder := smithyjson.NewEncoder() - if err := awsAwsjson11_serializeOpDocumentPutSubscriptionFilterInput(input, jsonEncoder.Value); err != nil { + if err := awsAwsjson11_serializeOpDocumentPutDestinationInput(input, jsonEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -4653,14 +5141,14 @@ func (m *awsAwsjson11_serializeOpPutSubscriptionFilter) HandleSerialize(ctx cont return next.HandleSerialize(ctx, in) } -type awsAwsjson11_serializeOpPutTransformer struct { +type awsAwsjson11_serializeOpPutDestinationPolicy struct { } -func (*awsAwsjson11_serializeOpPutTransformer) ID() string { +func (*awsAwsjson11_serializeOpPutDestinationPolicy) ID() string { return "OperationSerializer" } -func (m *awsAwsjson11_serializeOpPutTransformer) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsAwsjson11_serializeOpPutDestinationPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -4672,7 +5160,7 @@ func (m *awsAwsjson11_serializeOpPutTransformer) HandleSerialize(ctx context.Con return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*PutTransformerInput) + input, ok := in.Parameters.(*PutDestinationPolicyInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -4693,10 +5181,10 @@ func (m *awsAwsjson11_serializeOpPutTransformer) HandleSerialize(ctx context.Con return out, metadata, &smithy.SerializationError{Err: err} } httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") - httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.PutTransformer") + httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.PutDestinationPolicy") jsonEncoder := smithyjson.NewEncoder() - if err := awsAwsjson11_serializeOpDocumentPutTransformerInput(input, jsonEncoder.Value); err != nil { + if err := awsAwsjson11_serializeOpDocumentPutDestinationPolicyInput(input, jsonEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -4714,14 +5202,14 @@ func (m *awsAwsjson11_serializeOpPutTransformer) HandleSerialize(ctx context.Con return next.HandleSerialize(ctx, in) } -type awsAwsjson11_serializeOpStartLiveTail struct { +type awsAwsjson11_serializeOpPutIndexPolicy struct { } -func (*awsAwsjson11_serializeOpStartLiveTail) ID() string { +func (*awsAwsjson11_serializeOpPutIndexPolicy) ID() string { return "OperationSerializer" } -func (m *awsAwsjson11_serializeOpStartLiveTail) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsAwsjson11_serializeOpPutIndexPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -4733,7 +5221,7 @@ func (m *awsAwsjson11_serializeOpStartLiveTail) HandleSerialize(ctx context.Cont return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*StartLiveTailInput) + input, ok := in.Parameters.(*PutIndexPolicyInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -4754,10 +5242,10 @@ func (m *awsAwsjson11_serializeOpStartLiveTail) HandleSerialize(ctx context.Cont return out, metadata, &smithy.SerializationError{Err: err} } httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") - httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.StartLiveTail") + httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.PutIndexPolicy") jsonEncoder := smithyjson.NewEncoder() - if err := awsAwsjson11_serializeOpDocumentStartLiveTailInput(input, jsonEncoder.Value); err != nil { + if err := awsAwsjson11_serializeOpDocumentPutIndexPolicyInput(input, jsonEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -4775,14 +5263,14 @@ func (m *awsAwsjson11_serializeOpStartLiveTail) HandleSerialize(ctx context.Cont return next.HandleSerialize(ctx, in) } -type awsAwsjson11_serializeOpStartQuery struct { +type awsAwsjson11_serializeOpPutIntegration struct { } -func (*awsAwsjson11_serializeOpStartQuery) ID() string { +func (*awsAwsjson11_serializeOpPutIntegration) ID() string { return "OperationSerializer" } -func (m *awsAwsjson11_serializeOpStartQuery) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsAwsjson11_serializeOpPutIntegration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -4794,7 +5282,7 @@ func (m *awsAwsjson11_serializeOpStartQuery) HandleSerialize(ctx context.Context return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*StartQueryInput) + input, ok := in.Parameters.(*PutIntegrationInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -4815,10 +5303,10 @@ func (m *awsAwsjson11_serializeOpStartQuery) HandleSerialize(ctx context.Context return out, metadata, &smithy.SerializationError{Err: err} } httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") - httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.StartQuery") + httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.PutIntegration") jsonEncoder := smithyjson.NewEncoder() - if err := awsAwsjson11_serializeOpDocumentStartQueryInput(input, jsonEncoder.Value); err != nil { + if err := awsAwsjson11_serializeOpDocumentPutIntegrationInput(input, jsonEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -4836,10 +5324,620 @@ func (m *awsAwsjson11_serializeOpStartQuery) HandleSerialize(ctx context.Context return next.HandleSerialize(ctx, in) } -type awsAwsjson11_serializeOpStopQuery struct { +type awsAwsjson11_serializeOpPutLogEvents struct { } -func (*awsAwsjson11_serializeOpStopQuery) ID() string { +func (*awsAwsjson11_serializeOpPutLogEvents) ID() string { + return "OperationSerializer" +} + +func (m *awsAwsjson11_serializeOpPutLogEvents) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + _, span := tracing.StartSpan(ctx, "OperationSerializer") + endTimer := startMetricTimer(ctx, "client.call.serialization_duration") + defer endTimer() + defer span.End() + request, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} + } + + input, ok := in.Parameters.(*PutLogEventsInput) + _ = input + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} + } + + operationPath := "/" + if len(request.Request.URL.Path) == 0 { + request.Request.URL.Path = operationPath + } else { + request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath) + if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' { + request.Request.URL.Path += "/" + } + } + request.Request.Method = "POST" + httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) + if err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") + httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.PutLogEvents") + + jsonEncoder := smithyjson.NewEncoder() + if err := awsAwsjson11_serializeOpDocumentPutLogEventsInput(input, jsonEncoder.Value); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + in.Request = request + + endTimer() + span.End() + return next.HandleSerialize(ctx, in) +} + +type awsAwsjson11_serializeOpPutLogGroupDeletionProtection struct { +} + +func (*awsAwsjson11_serializeOpPutLogGroupDeletionProtection) ID() string { + return "OperationSerializer" +} + +func (m *awsAwsjson11_serializeOpPutLogGroupDeletionProtection) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + _, span := tracing.StartSpan(ctx, "OperationSerializer") + endTimer := startMetricTimer(ctx, "client.call.serialization_duration") + defer endTimer() + defer span.End() + request, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} + } + + input, ok := in.Parameters.(*PutLogGroupDeletionProtectionInput) + _ = input + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} + } + + operationPath := "/" + if len(request.Request.URL.Path) == 0 { + request.Request.URL.Path = operationPath + } else { + request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath) + if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' { + request.Request.URL.Path += "/" + } + } + request.Request.Method = "POST" + httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) + if err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") + httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.PutLogGroupDeletionProtection") + + jsonEncoder := smithyjson.NewEncoder() + if err := awsAwsjson11_serializeOpDocumentPutLogGroupDeletionProtectionInput(input, jsonEncoder.Value); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + in.Request = request + + endTimer() + span.End() + return next.HandleSerialize(ctx, in) +} + +type awsAwsjson11_serializeOpPutMetricFilter struct { +} + +func (*awsAwsjson11_serializeOpPutMetricFilter) ID() string { + return "OperationSerializer" +} + +func (m *awsAwsjson11_serializeOpPutMetricFilter) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + _, span := tracing.StartSpan(ctx, "OperationSerializer") + endTimer := startMetricTimer(ctx, "client.call.serialization_duration") + defer endTimer() + defer span.End() + request, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} + } + + input, ok := in.Parameters.(*PutMetricFilterInput) + _ = input + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} + } + + operationPath := "/" + if len(request.Request.URL.Path) == 0 { + request.Request.URL.Path = operationPath + } else { + request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath) + if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' { + request.Request.URL.Path += "/" + } + } + request.Request.Method = "POST" + httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) + if err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") + httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.PutMetricFilter") + + jsonEncoder := smithyjson.NewEncoder() + if err := awsAwsjson11_serializeOpDocumentPutMetricFilterInput(input, jsonEncoder.Value); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + in.Request = request + + endTimer() + span.End() + return next.HandleSerialize(ctx, in) +} + +type awsAwsjson11_serializeOpPutQueryDefinition struct { +} + +func (*awsAwsjson11_serializeOpPutQueryDefinition) ID() string { + return "OperationSerializer" +} + +func (m *awsAwsjson11_serializeOpPutQueryDefinition) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + _, span := tracing.StartSpan(ctx, "OperationSerializer") + endTimer := startMetricTimer(ctx, "client.call.serialization_duration") + defer endTimer() + defer span.End() + request, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} + } + + input, ok := in.Parameters.(*PutQueryDefinitionInput) + _ = input + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} + } + + operationPath := "/" + if len(request.Request.URL.Path) == 0 { + request.Request.URL.Path = operationPath + } else { + request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath) + if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' { + request.Request.URL.Path += "/" + } + } + request.Request.Method = "POST" + httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) + if err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") + httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.PutQueryDefinition") + + jsonEncoder := smithyjson.NewEncoder() + if err := awsAwsjson11_serializeOpDocumentPutQueryDefinitionInput(input, jsonEncoder.Value); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + in.Request = request + + endTimer() + span.End() + return next.HandleSerialize(ctx, in) +} + +type awsAwsjson11_serializeOpPutResourcePolicy struct { +} + +func (*awsAwsjson11_serializeOpPutResourcePolicy) ID() string { + return "OperationSerializer" +} + +func (m *awsAwsjson11_serializeOpPutResourcePolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + _, span := tracing.StartSpan(ctx, "OperationSerializer") + endTimer := startMetricTimer(ctx, "client.call.serialization_duration") + defer endTimer() + defer span.End() + request, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} + } + + input, ok := in.Parameters.(*PutResourcePolicyInput) + _ = input + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} + } + + operationPath := "/" + if len(request.Request.URL.Path) == 0 { + request.Request.URL.Path = operationPath + } else { + request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath) + if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' { + request.Request.URL.Path += "/" + } + } + request.Request.Method = "POST" + httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) + if err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") + httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.PutResourcePolicy") + + jsonEncoder := smithyjson.NewEncoder() + if err := awsAwsjson11_serializeOpDocumentPutResourcePolicyInput(input, jsonEncoder.Value); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + in.Request = request + + endTimer() + span.End() + return next.HandleSerialize(ctx, in) +} + +type awsAwsjson11_serializeOpPutRetentionPolicy struct { +} + +func (*awsAwsjson11_serializeOpPutRetentionPolicy) ID() string { + return "OperationSerializer" +} + +func (m *awsAwsjson11_serializeOpPutRetentionPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + _, span := tracing.StartSpan(ctx, "OperationSerializer") + endTimer := startMetricTimer(ctx, "client.call.serialization_duration") + defer endTimer() + defer span.End() + request, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} + } + + input, ok := in.Parameters.(*PutRetentionPolicyInput) + _ = input + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} + } + + operationPath := "/" + if len(request.Request.URL.Path) == 0 { + request.Request.URL.Path = operationPath + } else { + request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath) + if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' { + request.Request.URL.Path += "/" + } + } + request.Request.Method = "POST" + httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) + if err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") + httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.PutRetentionPolicy") + + jsonEncoder := smithyjson.NewEncoder() + if err := awsAwsjson11_serializeOpDocumentPutRetentionPolicyInput(input, jsonEncoder.Value); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + in.Request = request + + endTimer() + span.End() + return next.HandleSerialize(ctx, in) +} + +type awsAwsjson11_serializeOpPutSubscriptionFilter struct { +} + +func (*awsAwsjson11_serializeOpPutSubscriptionFilter) ID() string { + return "OperationSerializer" +} + +func (m *awsAwsjson11_serializeOpPutSubscriptionFilter) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + _, span := tracing.StartSpan(ctx, "OperationSerializer") + endTimer := startMetricTimer(ctx, "client.call.serialization_duration") + defer endTimer() + defer span.End() + request, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} + } + + input, ok := in.Parameters.(*PutSubscriptionFilterInput) + _ = input + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} + } + + operationPath := "/" + if len(request.Request.URL.Path) == 0 { + request.Request.URL.Path = operationPath + } else { + request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath) + if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' { + request.Request.URL.Path += "/" + } + } + request.Request.Method = "POST" + httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) + if err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") + httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.PutSubscriptionFilter") + + jsonEncoder := smithyjson.NewEncoder() + if err := awsAwsjson11_serializeOpDocumentPutSubscriptionFilterInput(input, jsonEncoder.Value); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + in.Request = request + + endTimer() + span.End() + return next.HandleSerialize(ctx, in) +} + +type awsAwsjson11_serializeOpPutTransformer struct { +} + +func (*awsAwsjson11_serializeOpPutTransformer) ID() string { + return "OperationSerializer" +} + +func (m *awsAwsjson11_serializeOpPutTransformer) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + _, span := tracing.StartSpan(ctx, "OperationSerializer") + endTimer := startMetricTimer(ctx, "client.call.serialization_duration") + defer endTimer() + defer span.End() + request, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} + } + + input, ok := in.Parameters.(*PutTransformerInput) + _ = input + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} + } + + operationPath := "/" + if len(request.Request.URL.Path) == 0 { + request.Request.URL.Path = operationPath + } else { + request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath) + if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' { + request.Request.URL.Path += "/" + } + } + request.Request.Method = "POST" + httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) + if err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") + httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.PutTransformer") + + jsonEncoder := smithyjson.NewEncoder() + if err := awsAwsjson11_serializeOpDocumentPutTransformerInput(input, jsonEncoder.Value); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + in.Request = request + + endTimer() + span.End() + return next.HandleSerialize(ctx, in) +} + +type awsAwsjson11_serializeOpStartLiveTail struct { +} + +func (*awsAwsjson11_serializeOpStartLiveTail) ID() string { + return "OperationSerializer" +} + +func (m *awsAwsjson11_serializeOpStartLiveTail) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + _, span := tracing.StartSpan(ctx, "OperationSerializer") + endTimer := startMetricTimer(ctx, "client.call.serialization_duration") + defer endTimer() + defer span.End() + request, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} + } + + input, ok := in.Parameters.(*StartLiveTailInput) + _ = input + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} + } + + operationPath := "/" + if len(request.Request.URL.Path) == 0 { + request.Request.URL.Path = operationPath + } else { + request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath) + if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' { + request.Request.URL.Path += "/" + } + } + request.Request.Method = "POST" + httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) + if err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") + httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.StartLiveTail") + + jsonEncoder := smithyjson.NewEncoder() + if err := awsAwsjson11_serializeOpDocumentStartLiveTailInput(input, jsonEncoder.Value); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + in.Request = request + + endTimer() + span.End() + return next.HandleSerialize(ctx, in) +} + +type awsAwsjson11_serializeOpStartQuery struct { +} + +func (*awsAwsjson11_serializeOpStartQuery) ID() string { + return "OperationSerializer" +} + +func (m *awsAwsjson11_serializeOpStartQuery) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + _, span := tracing.StartSpan(ctx, "OperationSerializer") + endTimer := startMetricTimer(ctx, "client.call.serialization_duration") + defer endTimer() + defer span.End() + request, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} + } + + input, ok := in.Parameters.(*StartQueryInput) + _ = input + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} + } + + operationPath := "/" + if len(request.Request.URL.Path) == 0 { + request.Request.URL.Path = operationPath + } else { + request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath) + if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' { + request.Request.URL.Path += "/" + } + } + request.Request.Method = "POST" + httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) + if err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") + httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.StartQuery") + + jsonEncoder := smithyjson.NewEncoder() + if err := awsAwsjson11_serializeOpDocumentStartQueryInput(input, jsonEncoder.Value); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + in.Request = request + + endTimer() + span.End() + return next.HandleSerialize(ctx, in) +} + +type awsAwsjson11_serializeOpStopQuery struct { +} + +func (*awsAwsjson11_serializeOpStopQuery) ID() string { return "OperationSerializer" } @@ -5263,14 +6361,75 @@ func (m *awsAwsjson11_serializeOpUntagResource) HandleSerialize(ctx context.Cont return next.HandleSerialize(ctx, in) } -type awsAwsjson11_serializeOpUpdateAnomaly struct { +type awsAwsjson11_serializeOpUpdateAnomaly struct { +} + +func (*awsAwsjson11_serializeOpUpdateAnomaly) ID() string { + return "OperationSerializer" +} + +func (m *awsAwsjson11_serializeOpUpdateAnomaly) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + _, span := tracing.StartSpan(ctx, "OperationSerializer") + endTimer := startMetricTimer(ctx, "client.call.serialization_duration") + defer endTimer() + defer span.End() + request, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} + } + + input, ok := in.Parameters.(*UpdateAnomalyInput) + _ = input + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} + } + + operationPath := "/" + if len(request.Request.URL.Path) == 0 { + request.Request.URL.Path = operationPath + } else { + request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath) + if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' { + request.Request.URL.Path += "/" + } + } + request.Request.Method = "POST" + httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) + if err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") + httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.UpdateAnomaly") + + jsonEncoder := smithyjson.NewEncoder() + if err := awsAwsjson11_serializeOpDocumentUpdateAnomalyInput(input, jsonEncoder.Value); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + in.Request = request + + endTimer() + span.End() + return next.HandleSerialize(ctx, in) +} + +type awsAwsjson11_serializeOpUpdateDeliveryConfiguration struct { } -func (*awsAwsjson11_serializeOpUpdateAnomaly) ID() string { +func (*awsAwsjson11_serializeOpUpdateDeliveryConfiguration) ID() string { return "OperationSerializer" } -func (m *awsAwsjson11_serializeOpUpdateAnomaly) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsAwsjson11_serializeOpUpdateDeliveryConfiguration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -5282,7 +6441,7 @@ func (m *awsAwsjson11_serializeOpUpdateAnomaly) HandleSerialize(ctx context.Cont return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*UpdateAnomalyInput) + input, ok := in.Parameters.(*UpdateDeliveryConfigurationInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -5303,10 +6462,10 @@ func (m *awsAwsjson11_serializeOpUpdateAnomaly) HandleSerialize(ctx context.Cont return out, metadata, &smithy.SerializationError{Err: err} } httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") - httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.UpdateAnomaly") + httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.UpdateDeliveryConfiguration") jsonEncoder := smithyjson.NewEncoder() - if err := awsAwsjson11_serializeOpDocumentUpdateAnomalyInput(input, jsonEncoder.Value); err != nil { + if err := awsAwsjson11_serializeOpDocumentUpdateDeliveryConfigurationInput(input, jsonEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -5324,14 +6483,14 @@ func (m *awsAwsjson11_serializeOpUpdateAnomaly) HandleSerialize(ctx context.Cont return next.HandleSerialize(ctx, in) } -type awsAwsjson11_serializeOpUpdateDeliveryConfiguration struct { +type awsAwsjson11_serializeOpUpdateLogAnomalyDetector struct { } -func (*awsAwsjson11_serializeOpUpdateDeliveryConfiguration) ID() string { +func (*awsAwsjson11_serializeOpUpdateLogAnomalyDetector) ID() string { return "OperationSerializer" } -func (m *awsAwsjson11_serializeOpUpdateDeliveryConfiguration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsAwsjson11_serializeOpUpdateLogAnomalyDetector) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -5343,7 +6502,7 @@ func (m *awsAwsjson11_serializeOpUpdateDeliveryConfiguration) HandleSerialize(ct return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*UpdateDeliveryConfigurationInput) + input, ok := in.Parameters.(*UpdateLogAnomalyDetectorInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -5364,10 +6523,10 @@ func (m *awsAwsjson11_serializeOpUpdateDeliveryConfiguration) HandleSerialize(ct return out, metadata, &smithy.SerializationError{Err: err} } httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") - httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.UpdateDeliveryConfiguration") + httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.UpdateLogAnomalyDetector") jsonEncoder := smithyjson.NewEncoder() - if err := awsAwsjson11_serializeOpDocumentUpdateDeliveryConfigurationInput(input, jsonEncoder.Value); err != nil { + if err := awsAwsjson11_serializeOpDocumentUpdateLogAnomalyDetectorInput(input, jsonEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -5385,14 +6544,14 @@ func (m *awsAwsjson11_serializeOpUpdateDeliveryConfiguration) HandleSerialize(ct return next.HandleSerialize(ctx, in) } -type awsAwsjson11_serializeOpUpdateLogAnomalyDetector struct { +type awsAwsjson11_serializeOpUpdateScheduledQuery struct { } -func (*awsAwsjson11_serializeOpUpdateLogAnomalyDetector) ID() string { +func (*awsAwsjson11_serializeOpUpdateScheduledQuery) ID() string { return "OperationSerializer" } -func (m *awsAwsjson11_serializeOpUpdateLogAnomalyDetector) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsAwsjson11_serializeOpUpdateScheduledQuery) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -5404,7 +6563,7 @@ func (m *awsAwsjson11_serializeOpUpdateLogAnomalyDetector) HandleSerialize(ctx c return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*UpdateLogAnomalyDetectorInput) + input, ok := in.Parameters.(*UpdateScheduledQueryInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -5425,10 +6584,10 @@ func (m *awsAwsjson11_serializeOpUpdateLogAnomalyDetector) HandleSerialize(ctx c return out, metadata, &smithy.SerializationError{Err: err} } httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") - httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.UpdateLogAnomalyDetector") + httpBindingEncoder.SetHeader("X-Amz-Target").String("Logs_20140328.UpdateScheduledQuery") jsonEncoder := smithyjson.NewEncoder() - if err := awsAwsjson11_serializeOpDocumentUpdateLogAnomalyDetectorInput(input, jsonEncoder.Value); err != nil { + if err := awsAwsjson11_serializeOpDocumentUpdateScheduledQueryInput(input, jsonEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -5605,6 +6764,53 @@ func awsAwsjson11_serializeDocumentDashboardViewerPrincipals(v []string, value s return nil } +func awsAwsjson11_serializeDocumentDataSource(v *types.DataSource, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.Name != nil { + ok := object.Key("name") + ok.String(*v.Name) + } + + if v.Type != nil { + ok := object.Key("type") + ok.String(*v.Type) + } + + return nil +} + +func awsAwsjson11_serializeDocumentDataSourceFilter(v *types.DataSourceFilter, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.Name != nil { + ok := object.Key("name") + ok.String(*v.Name) + } + + if v.Type != nil { + ok := object.Key("type") + ok.String(*v.Type) + } + + return nil +} + +func awsAwsjson11_serializeDocumentDataSourceFilters(v []types.DataSourceFilter, value smithyjson.Value) error { + array := value.Array() + defer array.Close() + + for i := range v { + av := array.Value() + if err := awsAwsjson11_serializeDocumentDataSourceFilter(&v[i], av); err != nil { + return err + } + } + return nil +} + func awsAwsjson11_serializeDocumentDateTimeConverter(v *types.DateTimeConverter, value smithyjson.Value) error { object := value.Object() defer object.Close() @@ -5719,6 +6925,31 @@ func awsAwsjson11_serializeDocumentDescribeIndexPoliciesLogGroupIdentifiers(v [] return nil } +func awsAwsjson11_serializeDocumentDescribeLogGroupsLogGroupIdentifiers(v []string, value smithyjson.Value) error { + array := value.Array() + defer array.Close() + + for i := range v { + av := array.Value() + av.String(v[i]) + } + return nil +} + +func awsAwsjson11_serializeDocumentDestinationConfiguration(v *types.DestinationConfiguration, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.S3Configuration != nil { + ok := object.Key("s3Configuration") + if err := awsAwsjson11_serializeDocumentS3Configuration(v.S3Configuration, ok); err != nil { + return err + } + } + + return nil +} + func awsAwsjson11_serializeDocumentDimensions(v map[string]string, value smithyjson.Value) error { object := value.Object() defer object.Close() @@ -5730,6 +6961,17 @@ func awsAwsjson11_serializeDocumentDimensions(v map[string]string, value smithyj return nil } +func awsAwsjson11_serializeDocumentEmitSystemFields(v []string, value smithyjson.Value) error { + array := value.Array() + defer array.Close() + + for i := range v { + av := array.Value() + av.String(v[i]) + } + return nil +} + func awsAwsjson11_serializeDocumentEntity(v *types.Entity, value smithyjson.Value) error { object := value.Object() defer object.Close() @@ -5773,6 +7015,28 @@ func awsAwsjson11_serializeDocumentEntityKeyAttributes(v map[string]string, valu return nil } +func awsAwsjson11_serializeDocumentExecutionStatusList(v []types.ExecutionStatus, value smithyjson.Value) error { + array := value.Array() + defer array.Close() + + for i := range v { + av := array.Value() + av.String(string(v[i])) + } + return nil +} + +func awsAwsjson11_serializeDocumentFieldIndexNames(v []string, value smithyjson.Value) error { + array := value.Array() + defer array.Close() + + for i := range v { + av := array.Value() + av.String(v[i]) + } + return nil +} + func awsAwsjson11_serializeDocumentGrok(v *types.Grok, value smithyjson.Value) error { object := value.Object() defer object.Close() @@ -5790,6 +7054,34 @@ func awsAwsjson11_serializeDocumentGrok(v *types.Grok, value smithyjson.Value) e return nil } +func awsAwsjson11_serializeDocumentImportFilter(v *types.ImportFilter, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.EndEventTime != nil { + ok := object.Key("endEventTime") + ok.Long(*v.EndEventTime) + } + + if v.StartEventTime != nil { + ok := object.Key("startEventTime") + ok.Long(*v.StartEventTime) + } + + return nil +} + +func awsAwsjson11_serializeDocumentImportStatusList(v []types.ImportStatus, value smithyjson.Value) error { + array := value.Array() + defer array.Close() + + for i := range v { + av := array.Value() + av.String(string(v[i])) + } + return nil +} + func awsAwsjson11_serializeDocumentInputLogEvent(v *types.InputLogEvent, value smithyjson.Value) error { object := value.Object() defer object.Close() @@ -6191,6 +7483,33 @@ func awsAwsjson11_serializeDocumentParseRoute53(v *types.ParseRoute53, value smi return nil } +func awsAwsjson11_serializeDocumentParseToOCSF(v *types.ParseToOCSF, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if len(v.EventSource) > 0 { + ok := object.Key("eventSource") + ok.String(string(v.EventSource)) + } + + if v.MappingVersion != nil { + ok := object.Key("mappingVersion") + ok.String(*v.MappingVersion) + } + + if len(v.OcsfVersion) > 0 { + ok := object.Key("ocsfVersion") + ok.String(string(v.OcsfVersion)) + } + + if v.Source != nil { + ok := object.Key("source") + ok.String(*v.Source) + } + + return nil +} + func awsAwsjson11_serializeDocumentParseVPC(v *types.ParseVPC, value smithyjson.Value) error { object := value.Object() defer object.Close() @@ -6317,6 +7636,13 @@ func awsAwsjson11_serializeDocumentProcessor(v *types.Processor, value smithyjso } } + if v.ParseToOCSF != nil { + ok := object.Key("parseToOCSF") + if err := awsAwsjson11_serializeDocumentParseToOCSF(v.ParseToOCSF, ok); err != nil { + return err + } + } + if v.ParseVPC != nil { ok := object.Key("parseVPC") if err := awsAwsjson11_serializeDocumentParseVPC(v.ParseVPC, ok); err != nil { @@ -6389,6 +7715,41 @@ func awsAwsjson11_serializeDocumentProcessors(v []types.Processor, value smithyj return nil } +func awsAwsjson11_serializeDocumentQueryParameter(v *types.QueryParameter, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.DefaultValue != nil { + ok := object.Key("defaultValue") + ok.String(*v.DefaultValue) + } + + if v.Description != nil { + ok := object.Key("description") + ok.String(*v.Description) + } + + if v.Name != nil { + ok := object.Key("name") + ok.String(*v.Name) + } + + return nil +} + +func awsAwsjson11_serializeDocumentQueryParameterList(v []types.QueryParameter, value smithyjson.Value) error { + array := value.Array() + defer array.Close() + + for i := range v { + av := array.Value() + if err := awsAwsjson11_serializeDocumentQueryParameter(&v[i], av); err != nil { + return err + } + } + return nil +} + func awsAwsjson11_serializeDocumentRecordFields(v []string, value smithyjson.Value) error { array := value.Array() defer array.Close() @@ -6478,6 +7839,33 @@ func awsAwsjson11_serializeDocumentResourceTypes(v []string, value smithyjson.Va return nil } +func awsAwsjson11_serializeDocumentS3Configuration(v *types.S3Configuration, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.DestinationIdentifier != nil { + ok := object.Key("destinationIdentifier") + ok.String(*v.DestinationIdentifier) + } + + if v.KmsKeyId != nil { + ok := object.Key("kmsKeyId") + ok.String(*v.KmsKeyId) + } + + if v.OwnerAccountId != nil { + ok := object.Key("ownerAccountId") + ok.String(*v.OwnerAccountId) + } + + if v.RoleArn != nil { + ok := object.Key("roleArn") + ok.String(*v.RoleArn) + } + + return nil +} + func awsAwsjson11_serializeDocumentS3DeliveryConfiguration(v *types.S3DeliveryConfiguration, value smithyjson.Value) error { object := value.Object() defer object.Close() @@ -6495,6 +7883,17 @@ func awsAwsjson11_serializeDocumentS3DeliveryConfiguration(v *types.S3DeliveryCo return nil } +func awsAwsjson11_serializeDocumentScheduledQueryLogGroupIdentifiers(v []string, value smithyjson.Value) error { + array := value.Array() + defer array.Close() + + for i := range v { + av := array.Value() + av.String(v[i]) + } + return nil +} + func awsAwsjson11_serializeDocumentSplitString(v *types.SplitString, value smithyjson.Value) error { object := value.Object() defer object.Close() @@ -6776,6 +8175,25 @@ func awsAwsjson11_serializeOpDocumentAssociateKmsKeyInput(v *AssociateKmsKeyInpu return nil } +func awsAwsjson11_serializeOpDocumentAssociateSourceToS3TableIntegrationInput(v *AssociateSourceToS3TableIntegrationInput, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.DataSource != nil { + ok := object.Key("dataSource") + if err := awsAwsjson11_serializeDocumentDataSource(v.DataSource, ok); err != nil { + return err + } + } + + if v.IntegrationArn != nil { + ok := object.Key("integrationArn") + ok.String(*v.IntegrationArn) + } + + return nil +} + func awsAwsjson11_serializeOpDocumentCancelExportTaskInput(v *CancelExportTaskInput, value smithyjson.Value) error { object := value.Object() defer object.Close() @@ -6788,6 +8206,18 @@ func awsAwsjson11_serializeOpDocumentCancelExportTaskInput(v *CancelExportTaskIn return nil } +func awsAwsjson11_serializeOpDocumentCancelImportTaskInput(v *CancelImportTaskInput, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.ImportId != nil { + ok := object.Key("importId") + ok.String(*v.ImportId) + } + + return nil +} + func awsAwsjson11_serializeOpDocumentCreateDeliveryInput(v *CreateDeliveryInput, value smithyjson.Value) error { object := value.Object() defer object.Close() @@ -6860,14 +8290,38 @@ func awsAwsjson11_serializeOpDocumentCreateExportTaskInput(v *CreateExportTaskIn ok.String(*v.LogStreamNamePrefix) } - if v.TaskName != nil { - ok := object.Key("taskName") - ok.String(*v.TaskName) + if v.TaskName != nil { + ok := object.Key("taskName") + ok.String(*v.TaskName) + } + + if v.To != nil { + ok := object.Key("to") + ok.Long(*v.To) + } + + return nil +} + +func awsAwsjson11_serializeOpDocumentCreateImportTaskInput(v *CreateImportTaskInput, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.ImportFilter != nil { + ok := object.Key("importFilter") + if err := awsAwsjson11_serializeDocumentImportFilter(v.ImportFilter, ok); err != nil { + return err + } + } + + if v.ImportRoleArn != nil { + ok := object.Key("importRoleArn") + ok.String(*v.ImportRoleArn) } - if v.To != nil { - ok := object.Key("to") - ok.Long(*v.To) + if v.ImportSourceArn != nil { + ok := object.Key("importSourceArn") + ok.String(*v.ImportSourceArn) } return nil @@ -6923,6 +8377,11 @@ func awsAwsjson11_serializeOpDocumentCreateLogGroupInput(v *CreateLogGroupInput, object := value.Object() defer object.Close() + if v.DeletionProtectionEnabled != nil { + ok := object.Key("deletionProtectionEnabled") + ok.Boolean(*v.DeletionProtectionEnabled) + } + if v.KmsKeyId != nil { ok := object.Key("kmsKeyId") ok.String(*v.KmsKeyId) @@ -6965,6 +8424,89 @@ func awsAwsjson11_serializeOpDocumentCreateLogStreamInput(v *CreateLogStreamInpu return nil } +func awsAwsjson11_serializeOpDocumentCreateScheduledQueryInput(v *CreateScheduledQueryInput, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.Description != nil { + ok := object.Key("description") + ok.String(*v.Description) + } + + if v.DestinationConfiguration != nil { + ok := object.Key("destinationConfiguration") + if err := awsAwsjson11_serializeDocumentDestinationConfiguration(v.DestinationConfiguration, ok); err != nil { + return err + } + } + + if v.ExecutionRoleArn != nil { + ok := object.Key("executionRoleArn") + ok.String(*v.ExecutionRoleArn) + } + + if v.LogGroupIdentifiers != nil { + ok := object.Key("logGroupIdentifiers") + if err := awsAwsjson11_serializeDocumentScheduledQueryLogGroupIdentifiers(v.LogGroupIdentifiers, ok); err != nil { + return err + } + } + + if v.Name != nil { + ok := object.Key("name") + ok.String(*v.Name) + } + + if len(v.QueryLanguage) > 0 { + ok := object.Key("queryLanguage") + ok.String(string(v.QueryLanguage)) + } + + if v.QueryString != nil { + ok := object.Key("queryString") + ok.String(*v.QueryString) + } + + if v.ScheduleEndTime != nil { + ok := object.Key("scheduleEndTime") + ok.Long(*v.ScheduleEndTime) + } + + if v.ScheduleExpression != nil { + ok := object.Key("scheduleExpression") + ok.String(*v.ScheduleExpression) + } + + if v.ScheduleStartTime != nil { + ok := object.Key("scheduleStartTime") + ok.Long(*v.ScheduleStartTime) + } + + if v.StartTimeOffset != nil { + ok := object.Key("startTimeOffset") + ok.Long(*v.StartTimeOffset) + } + + if len(v.State) > 0 { + ok := object.Key("state") + ok.String(string(v.State)) + } + + if v.Tags != nil { + ok := object.Key("tags") + if err := awsAwsjson11_serializeDocumentTags(v.Tags, ok); err != nil { + return err + } + } + + if v.Timezone != nil { + ok := object.Key("timezone") + ok.String(*v.Timezone) + } + + return nil +} + func awsAwsjson11_serializeOpDocumentDeleteAccountPolicyInput(v *DeleteAccountPolicyInput, value smithyjson.Value) error { object := value.Object() defer object.Close() @@ -7157,11 +8699,21 @@ func awsAwsjson11_serializeOpDocumentDeleteResourcePolicyInput(v *DeleteResource object := value.Object() defer object.Close() + if v.ExpectedRevisionId != nil { + ok := object.Key("expectedRevisionId") + ok.String(*v.ExpectedRevisionId) + } + if v.PolicyName != nil { ok := object.Key("policyName") ok.String(*v.PolicyName) } + if v.ResourceArn != nil { + ok := object.Key("resourceArn") + ok.String(*v.ResourceArn) + } + return nil } @@ -7177,6 +8729,18 @@ func awsAwsjson11_serializeOpDocumentDeleteRetentionPolicyInput(v *DeleteRetenti return nil } +func awsAwsjson11_serializeOpDocumentDeleteScheduledQueryInput(v *DeleteScheduledQueryInput, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.Identifier != nil { + ok := object.Key("identifier") + ok.String(*v.Identifier) + } + + return nil +} + func awsAwsjson11_serializeOpDocumentDeleteSubscriptionFilterInput(v *DeleteSubscriptionFilterInput, value smithyjson.Value) error { object := value.Object() defer object.Close() @@ -7397,6 +8961,67 @@ func awsAwsjson11_serializeOpDocumentDescribeFieldIndexesInput(v *DescribeFieldI return nil } +func awsAwsjson11_serializeOpDocumentDescribeImportTaskBatchesInput(v *DescribeImportTaskBatchesInput, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.BatchImportStatus != nil { + ok := object.Key("batchImportStatus") + if err := awsAwsjson11_serializeDocumentImportStatusList(v.BatchImportStatus, ok); err != nil { + return err + } + } + + if v.ImportId != nil { + ok := object.Key("importId") + ok.String(*v.ImportId) + } + + if v.Limit != nil { + ok := object.Key("limit") + ok.Integer(*v.Limit) + } + + if v.NextToken != nil { + ok := object.Key("nextToken") + ok.String(*v.NextToken) + } + + return nil +} + +func awsAwsjson11_serializeOpDocumentDescribeImportTasksInput(v *DescribeImportTasksInput, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.ImportId != nil { + ok := object.Key("importId") + ok.String(*v.ImportId) + } + + if v.ImportSourceArn != nil { + ok := object.Key("importSourceArn") + ok.String(*v.ImportSourceArn) + } + + if len(v.ImportStatus) > 0 { + ok := object.Key("importStatus") + ok.String(string(v.ImportStatus)) + } + + if v.Limit != nil { + ok := object.Key("limit") + ok.Integer(*v.Limit) + } + + if v.NextToken != nil { + ok := object.Key("nextToken") + ok.String(*v.NextToken) + } + + return nil +} + func awsAwsjson11_serializeOpDocumentDescribeIndexPoliciesInput(v *DescribeIndexPoliciesInput, value smithyjson.Value) error { object := value.Object() defer object.Close() @@ -7442,6 +9067,13 @@ func awsAwsjson11_serializeOpDocumentDescribeLogGroupsInput(v *DescribeLogGroups ok.String(string(v.LogGroupClass)) } + if v.LogGroupIdentifiers != nil { + ok := object.Key("logGroupIdentifiers") + if err := awsAwsjson11_serializeDocumentDescribeLogGroupsLogGroupIdentifiers(v.LogGroupIdentifiers, ok); err != nil { + return err + } + } + if v.LogGroupNamePattern != nil { ok := object.Key("logGroupNamePattern") ok.String(*v.LogGroupNamePattern) @@ -7612,6 +9244,16 @@ func awsAwsjson11_serializeOpDocumentDescribeResourcePoliciesInput(v *DescribeRe ok.String(*v.NextToken) } + if len(v.PolicyScope) > 0 { + ok := object.Key("policyScope") + ok.String(string(v.PolicyScope)) + } + + if v.ResourceArn != nil { + ok := object.Key("resourceArn") + ok.String(*v.ResourceArn) + } + return nil } @@ -7659,6 +9301,18 @@ func awsAwsjson11_serializeOpDocumentDisassociateKmsKeyInput(v *DisassociateKmsK return nil } +func awsAwsjson11_serializeOpDocumentDisassociateSourceFromS3TableIntegrationInput(v *DisassociateSourceFromS3TableIntegrationInput, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.Identifier != nil { + ok := object.Key("identifier") + ok.String(*v.Identifier) + } + + return nil +} + func awsAwsjson11_serializeOpDocumentFilterLogEventsInput(v *FilterLogEventsInput, value smithyjson.Value) error { object := value.Object() defer object.Close() @@ -7841,25 +9495,161 @@ func awsAwsjson11_serializeOpDocumentGetLogEventsInput(v *GetLogEventsInput, val ok.String(*v.NextToken) } - if v.StartFromHead != nil { - ok := object.Key("startFromHead") - ok.Boolean(*v.StartFromHead) - } - + if v.StartFromHead != nil { + ok := object.Key("startFromHead") + ok.Boolean(*v.StartFromHead) + } + + if v.StartTime != nil { + ok := object.Key("startTime") + ok.Long(*v.StartTime) + } + + if v.Unmask { + ok := object.Key("unmask") + ok.Boolean(v.Unmask) + } + + return nil +} + +func awsAwsjson11_serializeOpDocumentGetLogFieldsInput(v *GetLogFieldsInput, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.DataSourceName != nil { + ok := object.Key("dataSourceName") + ok.String(*v.DataSourceName) + } + + if v.DataSourceType != nil { + ok := object.Key("dataSourceType") + ok.String(*v.DataSourceType) + } + + return nil +} + +func awsAwsjson11_serializeOpDocumentGetLogGroupFieldsInput(v *GetLogGroupFieldsInput, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.LogGroupIdentifier != nil { + ok := object.Key("logGroupIdentifier") + ok.String(*v.LogGroupIdentifier) + } + + if v.LogGroupName != nil { + ok := object.Key("logGroupName") + ok.String(*v.LogGroupName) + } + + if v.Time != nil { + ok := object.Key("time") + ok.Long(*v.Time) + } + + return nil +} + +func awsAwsjson11_serializeOpDocumentGetLogObjectInput(v *GetLogObjectInput, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.LogObjectPointer != nil { + ok := object.Key("logObjectPointer") + ok.String(*v.LogObjectPointer) + } + + if v.Unmask { + ok := object.Key("unmask") + ok.Boolean(v.Unmask) + } + + return nil +} + +func awsAwsjson11_serializeOpDocumentGetLogRecordInput(v *GetLogRecordInput, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.LogRecordPointer != nil { + ok := object.Key("logRecordPointer") + ok.String(*v.LogRecordPointer) + } + + if v.Unmask { + ok := object.Key("unmask") + ok.Boolean(v.Unmask) + } + + return nil +} + +func awsAwsjson11_serializeOpDocumentGetQueryResultsInput(v *GetQueryResultsInput, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.QueryId != nil { + ok := object.Key("queryId") + ok.String(*v.QueryId) + } + + return nil +} + +func awsAwsjson11_serializeOpDocumentGetScheduledQueryHistoryInput(v *GetScheduledQueryHistoryInput, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.EndTime != nil { + ok := object.Key("endTime") + ok.Long(*v.EndTime) + } + + if v.ExecutionStatuses != nil { + ok := object.Key("executionStatuses") + if err := awsAwsjson11_serializeDocumentExecutionStatusList(v.ExecutionStatuses, ok); err != nil { + return err + } + } + + if v.Identifier != nil { + ok := object.Key("identifier") + ok.String(*v.Identifier) + } + + if v.MaxResults != nil { + ok := object.Key("maxResults") + ok.Integer(*v.MaxResults) + } + + if v.NextToken != nil { + ok := object.Key("nextToken") + ok.String(*v.NextToken) + } + if v.StartTime != nil { ok := object.Key("startTime") ok.Long(*v.StartTime) } - if v.Unmask { - ok := object.Key("unmask") - ok.Boolean(v.Unmask) + return nil +} + +func awsAwsjson11_serializeOpDocumentGetScheduledQueryInput(v *GetScheduledQueryInput, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.Identifier != nil { + ok := object.Key("identifier") + ok.String(*v.Identifier) } return nil } -func awsAwsjson11_serializeOpDocumentGetLogGroupFieldsInput(v *GetLogGroupFieldsInput, value smithyjson.Value) error { +func awsAwsjson11_serializeOpDocumentGetTransformerInput(v *GetTransformerInput, value smithyjson.Value) error { object := value.Object() defer object.Close() @@ -7868,55 +9658,55 @@ func awsAwsjson11_serializeOpDocumentGetLogGroupFieldsInput(v *GetLogGroupFields ok.String(*v.LogGroupIdentifier) } - if v.LogGroupName != nil { - ok := object.Key("logGroupName") - ok.String(*v.LogGroupName) - } - - if v.Time != nil { - ok := object.Key("time") - ok.Long(*v.Time) - } - return nil } -func awsAwsjson11_serializeOpDocumentGetLogRecordInput(v *GetLogRecordInput, value smithyjson.Value) error { +func awsAwsjson11_serializeOpDocumentListAggregateLogGroupSummariesInput(v *ListAggregateLogGroupSummariesInput, value smithyjson.Value) error { object := value.Object() defer object.Close() - if v.LogRecordPointer != nil { - ok := object.Key("logRecordPointer") - ok.String(*v.LogRecordPointer) + if v.AccountIdentifiers != nil { + ok := object.Key("accountIdentifiers") + if err := awsAwsjson11_serializeDocumentAccountIds(v.AccountIdentifiers, ok); err != nil { + return err + } } - if v.Unmask { - ok := object.Key("unmask") - ok.Boolean(v.Unmask) + if v.DataSources != nil { + ok := object.Key("dataSources") + if err := awsAwsjson11_serializeDocumentDataSourceFilters(v.DataSources, ok); err != nil { + return err + } } - return nil -} + if len(v.GroupBy) > 0 { + ok := object.Key("groupBy") + ok.String(string(v.GroupBy)) + } -func awsAwsjson11_serializeOpDocumentGetQueryResultsInput(v *GetQueryResultsInput, value smithyjson.Value) error { - object := value.Object() - defer object.Close() + if v.IncludeLinkedAccounts != nil { + ok := object.Key("includeLinkedAccounts") + ok.Boolean(*v.IncludeLinkedAccounts) + } - if v.QueryId != nil { - ok := object.Key("queryId") - ok.String(*v.QueryId) + if v.Limit != nil { + ok := object.Key("limit") + ok.Integer(*v.Limit) } - return nil -} + if len(v.LogGroupClass) > 0 { + ok := object.Key("logGroupClass") + ok.String(string(v.LogGroupClass)) + } -func awsAwsjson11_serializeOpDocumentGetTransformerInput(v *GetTransformerInput, value smithyjson.Value) error { - object := value.Object() - defer object.Close() + if v.LogGroupNamePattern != nil { + ok := object.Key("logGroupNamePattern") + ok.String(*v.LogGroupNamePattern) + } - if v.LogGroupIdentifier != nil { - ok := object.Key("logGroupIdentifier") - ok.String(*v.LogGroupIdentifier) + if v.NextToken != nil { + ok := object.Key("nextToken") + ok.String(*v.NextToken) } return nil @@ -8015,6 +9805,103 @@ func awsAwsjson11_serializeOpDocumentListLogGroupsForQueryInput(v *ListLogGroups return nil } +func awsAwsjson11_serializeOpDocumentListLogGroupsInput(v *ListLogGroupsInput, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.AccountIdentifiers != nil { + ok := object.Key("accountIdentifiers") + if err := awsAwsjson11_serializeDocumentAccountIds(v.AccountIdentifiers, ok); err != nil { + return err + } + } + + if v.DataSources != nil { + ok := object.Key("dataSources") + if err := awsAwsjson11_serializeDocumentDataSourceFilters(v.DataSources, ok); err != nil { + return err + } + } + + if v.FieldIndexNames != nil { + ok := object.Key("fieldIndexNames") + if err := awsAwsjson11_serializeDocumentFieldIndexNames(v.FieldIndexNames, ok); err != nil { + return err + } + } + + if v.IncludeLinkedAccounts != nil { + ok := object.Key("includeLinkedAccounts") + ok.Boolean(*v.IncludeLinkedAccounts) + } + + if v.Limit != nil { + ok := object.Key("limit") + ok.Integer(*v.Limit) + } + + if len(v.LogGroupClass) > 0 { + ok := object.Key("logGroupClass") + ok.String(string(v.LogGroupClass)) + } + + if v.LogGroupNamePattern != nil { + ok := object.Key("logGroupNamePattern") + ok.String(*v.LogGroupNamePattern) + } + + if v.NextToken != nil { + ok := object.Key("nextToken") + ok.String(*v.NextToken) + } + + return nil +} + +func awsAwsjson11_serializeOpDocumentListScheduledQueriesInput(v *ListScheduledQueriesInput, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.MaxResults != nil { + ok := object.Key("maxResults") + ok.Integer(*v.MaxResults) + } + + if v.NextToken != nil { + ok := object.Key("nextToken") + ok.String(*v.NextToken) + } + + if len(v.State) > 0 { + ok := object.Key("state") + ok.String(string(v.State)) + } + + return nil +} + +func awsAwsjson11_serializeOpDocumentListSourcesForS3TableIntegrationInput(v *ListSourcesForS3TableIntegrationInput, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.IntegrationArn != nil { + ok := object.Key("integrationArn") + ok.String(*v.IntegrationArn) + } + + if v.MaxResults != nil { + ok := object.Key("maxResults") + ok.Integer(*v.MaxResults) + } + + if v.NextToken != nil { + ok := object.Key("nextToken") + ok.String(*v.NextToken) + } + + return nil +} + func awsAwsjson11_serializeOpDocumentListTagsForResourceInput(v *ListTagsForResourceInput, value smithyjson.Value) error { object := value.Object() defer object.Close() @@ -8071,6 +9958,23 @@ func awsAwsjson11_serializeOpDocumentPutAccountPolicyInput(v *PutAccountPolicyIn return nil } +func awsAwsjson11_serializeOpDocumentPutBearerTokenAuthenticationInput(v *PutBearerTokenAuthenticationInput, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.BearerTokenAuthenticationEnabled != nil { + ok := object.Key("bearerTokenAuthenticationEnabled") + ok.Boolean(*v.BearerTokenAuthenticationEnabled) + } + + if v.LogGroupIdentifier != nil { + ok := object.Key("logGroupIdentifier") + ok.String(*v.LogGroupIdentifier) + } + + return nil +} + func awsAwsjson11_serializeOpDocumentPutDataProtectionPolicyInput(v *PutDataProtectionPolicyInput, value smithyjson.Value) error { object := value.Object() defer object.Close() @@ -8099,6 +10003,11 @@ func awsAwsjson11_serializeOpDocumentPutDeliveryDestinationInput(v *PutDeliveryD } } + if len(v.DeliveryDestinationType) > 0 { + ok := object.Key("deliveryDestinationType") + ok.String(string(v.DeliveryDestinationType)) + } + if v.Name != nil { ok := object.Key("name") ok.String(*v.Name) @@ -8293,6 +10202,23 @@ func awsAwsjson11_serializeOpDocumentPutLogEventsInput(v *PutLogEventsInput, val return nil } +func awsAwsjson11_serializeOpDocumentPutLogGroupDeletionProtectionInput(v *PutLogGroupDeletionProtectionInput, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.DeletionProtectionEnabled != nil { + ok := object.Key("deletionProtectionEnabled") + ok.Boolean(*v.DeletionProtectionEnabled) + } + + if v.LogGroupIdentifier != nil { + ok := object.Key("logGroupIdentifier") + ok.String(*v.LogGroupIdentifier) + } + + return nil +} + func awsAwsjson11_serializeOpDocumentPutMetricFilterInput(v *PutMetricFilterInput, value smithyjson.Value) error { object := value.Object() defer object.Close() @@ -8302,6 +10228,18 @@ func awsAwsjson11_serializeOpDocumentPutMetricFilterInput(v *PutMetricFilterInpu ok.Boolean(v.ApplyOnTransformedLogs) } + if v.EmitSystemFieldDimensions != nil { + ok := object.Key("emitSystemFieldDimensions") + if err := awsAwsjson11_serializeDocumentEmitSystemFields(v.EmitSystemFieldDimensions, ok); err != nil { + return err + } + } + + if v.FieldSelectionCriteria != nil { + ok := object.Key("fieldSelectionCriteria") + ok.String(*v.FieldSelectionCriteria) + } + if v.FilterName != nil { ok := object.Key("filterName") ok.String(*v.FilterName) @@ -8348,6 +10286,13 @@ func awsAwsjson11_serializeOpDocumentPutQueryDefinitionInput(v *PutQueryDefiniti ok.String(*v.Name) } + if v.Parameters != nil { + ok := object.Key("parameters") + if err := awsAwsjson11_serializeDocumentQueryParameterList(v.Parameters, ok); err != nil { + return err + } + } + if v.QueryDefinitionId != nil { ok := object.Key("queryDefinitionId") ok.String(*v.QueryDefinitionId) @@ -8370,6 +10315,11 @@ func awsAwsjson11_serializeOpDocumentPutResourcePolicyInput(v *PutResourcePolicy object := value.Object() defer object.Close() + if v.ExpectedRevisionId != nil { + ok := object.Key("expectedRevisionId") + ok.String(*v.ExpectedRevisionId) + } + if v.PolicyDocument != nil { ok := object.Key("policyDocument") ok.String(*v.PolicyDocument) @@ -8380,6 +10330,11 @@ func awsAwsjson11_serializeOpDocumentPutResourcePolicyInput(v *PutResourcePolicy ok.String(*v.PolicyName) } + if v.ResourceArn != nil { + ok := object.Key("resourceArn") + ok.String(*v.ResourceArn) + } + return nil } @@ -8419,6 +10374,18 @@ func awsAwsjson11_serializeOpDocumentPutSubscriptionFilterInput(v *PutSubscripti ok.String(string(v.Distribution)) } + if v.EmitSystemFields != nil { + ok := object.Key("emitSystemFields") + if err := awsAwsjson11_serializeDocumentEmitSystemFields(v.EmitSystemFields, ok); err != nil { + return err + } + } + + if v.FieldSelectionCriteria != nil { + ok := object.Key("fieldSelectionCriteria") + ok.String(*v.FieldSelectionCriteria) + } + if v.FilterName != nil { ok := object.Key("filterName") ok.String(*v.FilterName) @@ -8774,3 +10741,79 @@ func awsAwsjson11_serializeOpDocumentUpdateLogAnomalyDetectorInput(v *UpdateLogA return nil } + +func awsAwsjson11_serializeOpDocumentUpdateScheduledQueryInput(v *UpdateScheduledQueryInput, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.Description != nil { + ok := object.Key("description") + ok.String(*v.Description) + } + + if v.DestinationConfiguration != nil { + ok := object.Key("destinationConfiguration") + if err := awsAwsjson11_serializeDocumentDestinationConfiguration(v.DestinationConfiguration, ok); err != nil { + return err + } + } + + if v.ExecutionRoleArn != nil { + ok := object.Key("executionRoleArn") + ok.String(*v.ExecutionRoleArn) + } + + if v.Identifier != nil { + ok := object.Key("identifier") + ok.String(*v.Identifier) + } + + if v.LogGroupIdentifiers != nil { + ok := object.Key("logGroupIdentifiers") + if err := awsAwsjson11_serializeDocumentScheduledQueryLogGroupIdentifiers(v.LogGroupIdentifiers, ok); err != nil { + return err + } + } + + if len(v.QueryLanguage) > 0 { + ok := object.Key("queryLanguage") + ok.String(string(v.QueryLanguage)) + } + + if v.QueryString != nil { + ok := object.Key("queryString") + ok.String(*v.QueryString) + } + + if v.ScheduleEndTime != nil { + ok := object.Key("scheduleEndTime") + ok.Long(*v.ScheduleEndTime) + } + + if v.ScheduleExpression != nil { + ok := object.Key("scheduleExpression") + ok.String(*v.ScheduleExpression) + } + + if v.ScheduleStartTime != nil { + ok := object.Key("scheduleStartTime") + ok.Long(*v.ScheduleStartTime) + } + + if v.StartTimeOffset != nil { + ok := object.Key("startTimeOffset") + ok.Long(*v.StartTimeOffset) + } + + if len(v.State) > 0 { + ok := object.Key("state") + ok.String(string(v.State)) + } + + if v.Timezone != nil { + ok := object.Key("timezone") + ok.String(*v.Timezone) + } + + return nil +} diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/types/enums.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/types/enums.go index 526e0511ce1..a5316f300b4 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/types/enums.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/types/enums.go @@ -2,6 +2,29 @@ package types +type ActionStatus string + +// Enum values for ActionStatus +const ( + ActionStatusInProgress ActionStatus = "IN_PROGRESS" + ActionStatusClientError ActionStatus = "CLIENT_ERROR" + ActionStatusFailed ActionStatus = "FAILED" + ActionStatusComplete ActionStatus = "COMPLETE" +) + +// Values returns all known values for ActionStatus. Note that this can be +// expanded in the future, and so it is only as up to date as the client. +// +// The ordering of this slice is not guaranteed to be stable across updates. +func (ActionStatus) Values() []ActionStatus { + return []ActionStatus{ + "IN_PROGRESS", + "CLIENT_ERROR", + "FAILED", + "COMPLETE", + } +} + type AnomalyDetectorStatus string // Enum values for AnomalyDetectorStatus @@ -56,9 +79,10 @@ type DeliveryDestinationType string // Enum values for DeliveryDestinationType const ( - DeliveryDestinationTypeS3 DeliveryDestinationType = "S3" - DeliveryDestinationTypeCwl DeliveryDestinationType = "CWL" - DeliveryDestinationTypeFh DeliveryDestinationType = "FH" + DeliveryDestinationTypeS3 DeliveryDestinationType = "S3" + DeliveryDestinationTypeCwl DeliveryDestinationType = "CWL" + DeliveryDestinationTypeFh DeliveryDestinationType = "FH" + DeliveryDestinationTypeXray DeliveryDestinationType = "XRAY" ) // Values returns all known values for DeliveryDestinationType. Note that this can @@ -70,6 +94,7 @@ func (DeliveryDestinationType) Values() []DeliveryDestinationType { "S3", "CWL", "FH", + "XRAY", } } @@ -148,6 +173,56 @@ func (EvaluationFrequency) Values() []EvaluationFrequency { } } +type EventSource string + +// Enum values for EventSource +const ( + EventSourceCloudTrail EventSource = "CloudTrail" + EventSourceRoute53Resolver EventSource = "Route53Resolver" + EventSourceVpcFlow EventSource = "VPCFlow" + EventSourceEksAudit EventSource = "EKSAudit" + EventSourceAwswaf EventSource = "AWSWAF" +) + +// Values returns all known values for EventSource. Note that this can be expanded +// in the future, and so it is only as up to date as the client. +// +// The ordering of this slice is not guaranteed to be stable across updates. +func (EventSource) Values() []EventSource { + return []EventSource{ + "CloudTrail", + "Route53Resolver", + "VPCFlow", + "EKSAudit", + "AWSWAF", + } +} + +type ExecutionStatus string + +// Enum values for ExecutionStatus +const ( + ExecutionStatusRunning ExecutionStatus = "Running" + ExecutionStatusInvalidQuery ExecutionStatus = "InvalidQuery" + ExecutionStatusComplete ExecutionStatus = "Complete" + ExecutionStatusFailed ExecutionStatus = "Failed" + ExecutionStatusTimeout ExecutionStatus = "Timeout" +) + +// Values returns all known values for ExecutionStatus. Note that this can be +// expanded in the future, and so it is only as up to date as the client. +// +// The ordering of this slice is not guaranteed to be stable across updates. +func (ExecutionStatus) Values() []ExecutionStatus { + return []ExecutionStatus{ + "Running", + "InvalidQuery", + "Complete", + "Failed", + "Timeout", + } +} + type ExportTaskStatusCode string // Enum values for ExportTaskStatusCode @@ -194,6 +269,29 @@ func (FlattenedElement) Values() []FlattenedElement { } } +type ImportStatus string + +// Enum values for ImportStatus +const ( + ImportStatusInProgress ImportStatus = "IN_PROGRESS" + ImportStatusCancelled ImportStatus = "CANCELLED" + ImportStatusCompleted ImportStatus = "COMPLETED" + ImportStatusFailed ImportStatus = "FAILED" +) + +// Values returns all known values for ImportStatus. Note that this can be +// expanded in the future, and so it is only as up to date as the client. +// +// The ordering of this slice is not guaranteed to be stable across updates. +func (ImportStatus) Values() []ImportStatus { + return []ImportStatus{ + "IN_PROGRESS", + "CANCELLED", + "COMPLETED", + "FAILED", + } +} + type IndexSource string // Enum values for IndexSource @@ -213,6 +311,25 @@ func (IndexSource) Values() []IndexSource { } } +type IndexType string + +// Enum values for IndexType +const ( + IndexTypeFacet IndexType = "FACET" + IndexTypeFieldIndex IndexType = "FIELD_INDEX" +) + +// Values returns all known values for IndexType. Note that this can be expanded +// in the future, and so it is only as up to date as the client. +// +// The ordering of this slice is not guaranteed to be stable across updates. +func (IndexType) Values() []IndexType { + return []IndexType{ + "FACET", + "FIELD_INDEX", + } +} + type InheritedProperty string // Enum values for InheritedProperty @@ -268,12 +385,33 @@ func (IntegrationType) Values() []IntegrationType { } } +type ListAggregateLogGroupSummariesGroupBy string + +// Enum values for ListAggregateLogGroupSummariesGroupBy +const ( + ListAggregateLogGroupSummariesGroupByDataSourceNameTypeAndFormat ListAggregateLogGroupSummariesGroupBy = "DATA_SOURCE_NAME_TYPE_AND_FORMAT" + ListAggregateLogGroupSummariesGroupByDataSourceNameAndType ListAggregateLogGroupSummariesGroupBy = "DATA_SOURCE_NAME_AND_TYPE" +) + +// Values returns all known values for ListAggregateLogGroupSummariesGroupBy. Note +// that this can be expanded in the future, and so it is only as up to date as the +// client. +// +// The ordering of this slice is not guaranteed to be stable across updates. +func (ListAggregateLogGroupSummariesGroupBy) Values() []ListAggregateLogGroupSummariesGroupBy { + return []ListAggregateLogGroupSummariesGroupBy{ + "DATA_SOURCE_NAME_TYPE_AND_FORMAT", + "DATA_SOURCE_NAME_AND_TYPE", + } +} + type LogGroupClass string // Enum values for LogGroupClass const ( LogGroupClassStandard LogGroupClass = "STANDARD" LogGroupClassInfrequentAccess LogGroupClass = "INFREQUENT_ACCESS" + LogGroupClassDelivery LogGroupClass = "DELIVERY" ) // Values returns all known values for LogGroupClass. Note that this can be @@ -284,6 +422,26 @@ func (LogGroupClass) Values() []LogGroupClass { return []LogGroupClass{ "STANDARD", "INFREQUENT_ACCESS", + "DELIVERY", + } +} + +type OCSFVersion string + +// Enum values for OCSFVersion +const ( + OCSFVersionV11 OCSFVersion = "V1.1" + OCSFVersionV15 OCSFVersion = "V1.5" +) + +// Values returns all known values for OCSFVersion. Note that this can be expanded +// in the future, and so it is only as up to date as the client. +// +// The ordering of this slice is not guaranteed to be stable across updates. +func (OCSFVersion) Values() []OCSFVersion { + return []OCSFVersion{ + "V1.1", + "V1.5", } } @@ -353,6 +511,25 @@ func (OutputFormat) Values() []OutputFormat { } } +type PolicyScope string + +// Enum values for PolicyScope +const ( + PolicyScopeAccount PolicyScope = "ACCOUNT" + PolicyScopeResource PolicyScope = "RESOURCE" +) + +// Values returns all known values for PolicyScope. Note that this can be expanded +// in the future, and so it is only as up to date as the client. +// +// The ordering of this slice is not guaranteed to be stable across updates. +func (PolicyScope) Values() []PolicyScope { + return []PolicyScope{ + "ACCOUNT", + "RESOURCE", + } +} + type PolicyType string // Enum values for PolicyType @@ -361,6 +538,7 @@ const ( PolicyTypeSubscriptionFilterPolicy PolicyType = "SUBSCRIPTION_FILTER_POLICY" PolicyTypeFieldIndexPolicy PolicyType = "FIELD_INDEX_POLICY" PolicyTypeTransformerPolicy PolicyType = "TRANSFORMER_POLICY" + PolicyTypeMetricExtractionPolicy PolicyType = "METRIC_EXTRACTION_POLICY" ) // Values returns all known values for PolicyType. Note that this can be expanded @@ -373,6 +551,7 @@ func (PolicyType) Values() []PolicyType { "SUBSCRIPTION_FILTER_POLICY", "FIELD_INDEX_POLICY", "TRANSFORMER_POLICY", + "METRIC_EXTRACTION_POLICY", } } @@ -426,6 +605,67 @@ func (QueryStatus) Values() []QueryStatus { } } +type S3TableIntegrationSourceStatus string + +// Enum values for S3TableIntegrationSourceStatus +const ( + S3TableIntegrationSourceStatusActive S3TableIntegrationSourceStatus = "ACTIVE" + S3TableIntegrationSourceStatusUnhealthy S3TableIntegrationSourceStatus = "UNHEALTHY" + S3TableIntegrationSourceStatusFailed S3TableIntegrationSourceStatus = "FAILED" + S3TableIntegrationSourceStatusDataSourceDeleteInProgress S3TableIntegrationSourceStatus = "DATA_SOURCE_DELETE_IN_PROGRESS" +) + +// Values returns all known values for S3TableIntegrationSourceStatus. Note that +// this can be expanded in the future, and so it is only as up to date as the +// client. +// +// The ordering of this slice is not guaranteed to be stable across updates. +func (S3TableIntegrationSourceStatus) Values() []S3TableIntegrationSourceStatus { + return []S3TableIntegrationSourceStatus{ + "ACTIVE", + "UNHEALTHY", + "FAILED", + "DATA_SOURCE_DELETE_IN_PROGRESS", + } +} + +type ScheduledQueryDestinationType string + +// Enum values for ScheduledQueryDestinationType +const ( + ScheduledQueryDestinationTypeS3 ScheduledQueryDestinationType = "S3" +) + +// Values returns all known values for ScheduledQueryDestinationType. Note that +// this can be expanded in the future, and so it is only as up to date as the +// client. +// +// The ordering of this slice is not guaranteed to be stable across updates. +func (ScheduledQueryDestinationType) Values() []ScheduledQueryDestinationType { + return []ScheduledQueryDestinationType{ + "S3", + } +} + +type ScheduledQueryState string + +// Enum values for ScheduledQueryState +const ( + ScheduledQueryStateEnabled ScheduledQueryState = "ENABLED" + ScheduledQueryStateDisabled ScheduledQueryState = "DISABLED" +) + +// Values returns all known values for ScheduledQueryState. Note that this can be +// expanded in the future, and so it is only as up to date as the client. +// +// The ordering of this slice is not guaranteed to be stable across updates. +func (ScheduledQueryState) Values() []ScheduledQueryState { + return []ScheduledQueryState{ + "ENABLED", + "DISABLED", + } +} + type Scope string // Enum values for Scope diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/types/errors.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/types/errors.go index d1a4b0cd50e..f9f9dbcec4b 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/types/errors.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/types/errors.go @@ -91,6 +91,62 @@ func (e *DataAlreadyAcceptedException) ErrorCode() string { } func (e *DataAlreadyAcceptedException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient } +// An internal server error occurred while processing the request. This exception +// is returned when the service encounters an unexpected condition that prevents it +// from fulfilling the request. +type InternalServerException struct { + Message *string + + ErrorCodeOverride *string + + noSmithyDocumentSerde +} + +func (e *InternalServerException) Error() string { + return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage()) +} +func (e *InternalServerException) ErrorMessage() string { + if e.Message == nil { + return "" + } + return *e.Message +} +func (e *InternalServerException) ErrorCode() string { + if e == nil || e.ErrorCodeOverride == nil { + return "InternalServerException" + } + return *e.ErrorCodeOverride +} +func (e *InternalServerException) ErrorFault() smithy.ErrorFault { return smithy.FaultServer } + +// An internal error occurred during the streaming of log data. This exception is +// thrown when there's an issue with the internal streaming mechanism used by the +// GetLogObject operation. +type InternalStreamingException struct { + Message *string + + ErrorCodeOverride *string + + noSmithyDocumentSerde +} + +func (e *InternalStreamingException) Error() string { + return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage()) +} +func (e *InternalStreamingException) ErrorMessage() string { + if e.Message == nil { + return "" + } + return *e.Message +} +func (e *InternalStreamingException) ErrorCode() string { + if e == nil || e.ErrorCodeOverride == nil { + return "InternalStreamingException" + } + return *e.ErrorCodeOverride +} +func (e *InternalStreamingException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient } + // The operation is not valid on the specified resource. type InvalidOperationException struct { Message *string diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/types/types.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/types/types.go index ce3be7d3aaa..34195dbefbf 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/types/types.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/types/types.go @@ -74,6 +74,24 @@ type AddKeys struct { noSmithyDocumentSerde } +// Contains an aggregate summary of log groups grouped by data source +// characteristics, including the count of log groups and their grouping +// identifiers. +type AggregateLogGroupSummary struct { + + // An array of key-value pairs that identify the data source characteristics used + // to group the log groups. + // + // The size and content of this array depends on the groupBy parameter specified + // in the request. + GroupingIdentifiers []GroupingIdentifier + + // The number of log groups in this aggregate summary group. + LogGroupCount *int32 + + noSmithyDocumentSerde +} + // This structure represents one anomaly that has been found by a logs anomaly // detector. // @@ -394,6 +412,36 @@ type CSV struct { noSmithyDocumentSerde } +// Represents a data source that categorizes logs by originating service and log +// type, providing service-based organization complementing traditional log groups. +type DataSource struct { + + // The name of the data source. + // + // This member is required. + Name *string + + // The type of the data source. + Type *string + + noSmithyDocumentSerde +} + +// Filter criteria for data sources, used to specify which data sources to include +// in operations based on name and type. +type DataSourceFilter struct { + + // The name pattern to filter data sources by. + // + // This member is required. + Name *string + + // The type pattern to filter data sources by. + Type *string + + noSmithyDocumentSerde +} + // This processor converts a datetime string into a format that you specify. // // For more information about this processor including examples, see [datetimeConverter] in the @@ -474,7 +522,7 @@ type Delivery struct { DeliveryDestinationArn *string // Displays whether the delivery destination associated with this delivery is - // CloudWatch Logs, Amazon S3, or Firehose. + // CloudWatch Logs, Amazon S3, Firehose, or X-Ray. DeliveryDestinationType DeliveryDestinationType // The name of the delivery source that is associated with this delivery. @@ -503,7 +551,7 @@ type Delivery struct { // This structure contains information about one delivery destination in your // account. A delivery destination is an Amazon Web Services resource that // represents an Amazon Web Services service that logs can be sent to. CloudWatch -// Logs, Amazon S3, are supported as Firehose delivery destinations. +// Logs, Amazon S3, Firehose, and X-Ray are supported as delivery destinations. // // To configure logs delivery between a supported Amazon Web Services service and // a destination, you must do the following: @@ -539,8 +587,8 @@ type DeliveryDestination struct { // receive the logs. DeliveryDestinationConfiguration *DeliveryDestinationConfiguration - // Displays whether this delivery destination is CloudWatch Logs, Amazon S3, or - // Firehose. + // Displays whether this delivery destination is CloudWatch Logs, Amazon S3, + // Firehose, or X-Ray. DeliveryDestinationType DeliveryDestinationType // The name of this delivery destination. @@ -655,6 +703,18 @@ type Destination struct { noSmithyDocumentSerde } +// Configuration for where to deliver scheduled query results. Specifies the +// destination type and associated settings for result delivery. +type DestinationConfiguration struct { + + // Configuration for delivering query results to Amazon S3. + // + // This member is required. + S3Configuration *S3Configuration + + noSmithyDocumentSerde +} + // The entity associated with the log events in a PutLogEvents call. type Entity struct { @@ -767,6 +827,24 @@ type FieldIndex struct { // log group, the ARN of that log group is displayed here. LogGroupIdentifier *string + // The type of index. Specify FACET for facet-based indexing or FIELD_INDEX for + // field-based indexing. This determines how the field is indexed and can be + // queried. + Type IndexType + + noSmithyDocumentSerde +} + +// A structure containing the extracted fields from a log event. These fields are +// extracted based on the log format and can be used for structured querying and +// analysis. +type FieldsData struct { + + // The actual log data content returned in the streaming response. This contains + // the fields and values of the log event in a structured format that can be parsed + // and processed by the client. + Data []byte + noSmithyDocumentSerde } @@ -793,19 +871,40 @@ type FilteredLogEvent struct { noSmithyDocumentSerde } +// A stream of structured log data returned by the GetLogObject operation. This +// stream contains log events with their associated metadata and extracted fields. +// +// The following types satisfy this interface: +// +// GetLogObjectResponseStreamMemberFields +type GetLogObjectResponseStream interface { + isGetLogObjectResponseStream() +} + +// A structure containing the extracted fields from a log event. These fields are +// extracted based on the log format and can be used for structured querying and +// analysis. +type GetLogObjectResponseStreamMemberFields struct { + Value FieldsData + + noSmithyDocumentSerde +} + +func (*GetLogObjectResponseStreamMemberFields) isGetLogObjectResponseStream() {} + // This processor uses pattern matching to parse and structure unstructured data. // This processor can also extract fields from log messages. // // For more information about this processor including examples, see [grok] in the // CloudWatch Logs User Guide. // -// [grok]: https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CloudWatch-Logs-Transformation.html#CloudWatch-Logs-Transformation-Grok +// [grok]: https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CloudWatch-Logs-Transformation-Configurable.html#CloudWatch-Logs-Transformation-Grok type Grok struct { // The grok pattern to match against the log event. For a list of supported grok // patterns, see [Supported grok patterns]. // - // [Supported grok patterns]: https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CloudWatch-Logs-Transformation.html#Grok-Patterns + // [Supported grok patterns]: https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CloudWatch-Logs-Transformation-Configurable.html#CloudWatch-Logs-Transformation-Grok // // This member is required. Match *string @@ -817,6 +916,103 @@ type Grok struct { noSmithyDocumentSerde } +// A key-value pair that identifies how log groups are grouped in aggregate +// summaries. +type GroupingIdentifier struct { + + // The key that identifies the grouping characteristic. The format of the key uses + // dot notation. Examples are, dataSource.Name , dataSource.Type , and + // dataSource.Format . + Key *string + + // The value associated with the grouping characteristic. Examples are amazon_vpc , + // flow , and OCSF . + Value *string + + noSmithyDocumentSerde +} + +// An import job to move data from CloudTrail Event Data Store to CloudWatch. +type Import struct { + + // The timestamp when the import task was created, expressed as the number of + // milliseconds after Jan 1, 1970 00:00:00 UTC. + CreationTime *int64 + + // Error message related to any failed imports + ErrorMessage *string + + // The ARN of the managed CloudWatch Logs log group where the events are being + // imported to. + ImportDestinationArn *string + + // The filter criteria used for this import task. + ImportFilter *ImportFilter + + // The unique identifier of the import task. + ImportId *string + + // The ARN of the CloudTrail Lake Event Data Store being imported from. + ImportSourceArn *string + + // Statistics about the import progress + ImportStatistics *ImportStatistics + + // The current status of the import task. Valid values are IN_PROGRESS, CANCELLED, + // COMPLETED and FAILED. + ImportStatus ImportStatus + + // The timestamp when the import task was last updated, expressed as the number of + // milliseconds after Jan 1, 1970 00:00:00 UTC. + LastUpdatedTime *int64 + + noSmithyDocumentSerde +} + +// A collection of events being imported to CloudWatch +type ImportBatch struct { + + // The unique identifier of the import batch. + // + // This member is required. + BatchId *string + + // The current status of the import batch. Valid values are IN_PROGRESS, + // CANCELLED, COMPLETED and FAILED. + // + // This member is required. + Status ImportStatus + + // The error message if the batch failed to import. Only present when status is + // FAILED. + ErrorMessage *string + + noSmithyDocumentSerde +} + +// The filter criteria used for import tasks +type ImportFilter struct { + + // The end of the time range for events to import, expressed as the number of + // milliseconds after Jan 1, 1970 00:00:00 UTC. + EndEventTime *int64 + + // The start of the time range for events to import, expressed as the number of + // milliseconds after Jan 1, 1970 00:00:00 UTC. + StartEventTime *int64 + + noSmithyDocumentSerde +} + +// Statistics about the import progress +type ImportStatistics struct { + + // The total number of bytes that have been imported to the managed log group. + BytesImported *int64 + + noSmithyDocumentSerde +} + // This structure contains information about one field index policy in this // account. type IndexPolicy struct { @@ -845,7 +1041,7 @@ type IndexPolicy struct { // application or resource being monitored. type InputLogEvent struct { - // The raw event message. Each log event can be no larger than 256 KB. + // The raw event message. Each log event can be no larger than 1 MB. // // This member is required. Message *string @@ -909,7 +1105,7 @@ type IntegrationSummary struct { // For more information about this processor including examples, see [listToMap] in the // CloudWatch Logs User Guide. // -// [listToMap]: https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CloudWatch-Logs-Transformation.html#CloudWatch-Logs-Transformation-listToMap +// [listToMap]: https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CloudWatch-Logs-Transformation-Processors.html#CloudWatch-Logs-Transformation-listToMap type ListToMap struct { // The key of the field to be extracted as keys in the generated map @@ -1051,6 +1247,35 @@ type LogEvent struct { noSmithyDocumentSerde } +// Represents a log field with its name and data type information for a specific +// data source. +type LogFieldsListItem struct { + + // The name of the log field. + LogFieldName *string + + // The data type information for the log field. + LogFieldType *LogFieldType + + noSmithyDocumentSerde +} + +// Defines the data type structure for a log field, including the type, element +// information, and nested fields for complex types. +type LogFieldType struct { + + // For array or collection types, specifies the element type information. + Element *LogFieldType + + // For complex types, contains the nested field definitions. + Fields []LogFieldsListItem + + // The data type of the log field. + Type *string + + noSmithyDocumentSerde +} + // Represents a log group. type LogGroup struct { @@ -1067,6 +1292,11 @@ type LogGroup struct { // [ListTagsForResource]: https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_ListTagsForResource.html Arn *string + // Indicates whether bearer token authentication is enabled for this log group. + // When enabled, bearer token authentication is allowed on operations until it is + // explicitly disabled. + BearerTokenAuthenticationEnabled *bool + // The creation time of the log group, expressed as the number of milliseconds // after Jan 1, 1970 00:00:00 UTC. CreationTime *int64 @@ -1077,6 +1307,11 @@ type LogGroup struct { // [PutDataProtectionPolicy]: https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_PutDataProtectionPolicy.html DataProtectionStatus DataProtectionStatus + // Indicates whether deletion protection is enabled for this log group. When + // enabled, deletion protection blocks all deletion operations until it is + // explicitly disabled. + DeletionProtectionEnabled *bool + // Displays all the properties that this log group has inherited from // account-level settings. InheritedProperties []InheritedProperty @@ -1100,14 +1335,20 @@ type LogGroup struct { // [ListTagsForResource]: https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_ListTagsForResource.html LogGroupArn *string - // This specifies the log group class for this log group. There are two classes: + // This specifies the log group class for this log group. There are three classes: // // - The Standard log class supports all CloudWatch Logs features. // // - The Infrequent Access log class supports a subset of CloudWatch Logs // features and incurs lower costs. // - // For details about the features supported by each class, see [Log classes] + // - Use the Delivery log class only for delivering Lambda logs to store in + // Amazon S3 or Amazon Data Firehose. Log events in log groups in the Delivery + // class are kept in CloudWatch Logs for only one day. This log class doesn't offer + // rich CloudWatch Logs capabilities such as CloudWatch Logs Insights queries. + // + // For details about the features supported by the Standard and Infrequent Access + // classes, see [Log classes] // // [Log classes]: https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CloudWatch_Logs_Log_Classes.html LogGroupClass LogGroupClass @@ -1146,6 +1387,24 @@ type LogGroupField struct { noSmithyDocumentSerde } +// This structure contains information about one log group in your account. +type LogGroupSummary struct { + + // The Amazon Resource Name (ARN) of the log group. + LogGroupArn *string + + // The log group class for this log group. For details about the features + // supported by each log group class, see [Log classes] + // + // [Log classes]: https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CloudWatch_Logs_Log_Classes.html + LogGroupClass LogGroupClass + + // The name of the log group. + LogGroupName *string + + noSmithyDocumentSerde +} + // Represents a log stream, which is a sequence of log events from a single // emitter of logs. type LogStream struct { @@ -1232,6 +1491,16 @@ type MetricFilter struct { // after Jan 1, 1970 00:00:00 UTC . CreationTime *int64 + // The list of system fields that are emitted as additional dimensions in the + // generated metrics. Returns the emitSystemFieldDimensions value if it was + // specified when the metric filter was created. + EmitSystemFieldDimensions []string + + // The filter expression that specifies which log events are processed by this + // metric filter based on system fields. Returns the fieldSelectionCriteria value + // if it was specified when the metric filter was created. + FieldSelectionCriteria *string + // The name of the metric filter. FilterName *string @@ -1790,6 +2059,36 @@ type ParseRoute53 struct { noSmithyDocumentSerde } +// This processor converts logs into [Open Cybersecurity Schema Framework (OCSF)] events. +// +// For more information about this processor including examples, see [parseToOCSF] in the +// CloudWatch Logs User Guide. +// +// [parseToOCSF]: https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CloudWatch-Logs-Transformation.html#CloudWatch-Logs-Transformation-parseToOCSF +// [Open Cybersecurity Schema Framework (OCSF)]: https://ocsf.io +type ParseToOCSF struct { + + // Specify the service or process that produces the log events that will be + // converted with this processor. + // + // This member is required. + EventSource EventSource + + // Specify which version of the OCSF schema to use for the transformed log events. + // + // This member is required. + OcsfVersion OCSFVersion + + // The version of the OCSF mapping to use for parsing log data. + MappingVersion *string + + // The path to the field in the log event that you want to parse. If you omit this + // value, the whole log message is parsed. + Source *string + + noSmithyDocumentSerde +} + // Use this processor to parse Amazon VPC vended logs, extract fields, and and // convert them into a JSON format. This processor always processes the entire log // event message. @@ -1957,6 +2256,9 @@ type Processor struct { // [parseRoute53]: https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CloudWatch-Logs-Transformation.html#CloudWatch-Logs-Transformation-parseRoute53 ParseRoute53 *ParseRoute53 + // Use this parameter to convert logs into Open Cybersecurity Schema (OCSF) format. + ParseToOCSF *ParseToOCSF + // Use this parameter to include the [parseVPC] processor in your transformer. // // If you use this processor, it must be the first processor in your transformer. @@ -2042,6 +2344,10 @@ type QueryDefinition struct { // The name of the query definition. Name *string + // If this query definition contains a list of query parameters that define + // placeholder variables for the query string, that list appears here. + Parameters []QueryParameter + // The unique ID of the query definition. QueryDefinitionId *string @@ -2088,6 +2394,30 @@ type QueryInfo struct { noSmithyDocumentSerde } +// This structure defines a query parameter for a saved CloudWatch Logs Insights +// query definition. Query parameters are supported only for Logs Insights QL +// queries. They are placeholder variables that you can reference in a query string +// using the {{parameterName}} syntax. Each parameter can include a default value +// and a description. +type QueryParameter struct { + + // The name of the query parameter. A query parameter name must start with a + // letter or underscore, and contain only letters, digits, and underscores. + // + // This member is required. + Name *string + + // The default value to use for this query parameter if no value is supplied at + // execution time. + DefaultValue *string + + // A description of the query parameter that explains its purpose or expected + // values. + Description *string + + noSmithyDocumentSerde +} + // Contains the number of log events scanned by the query, the number of log // events that matched the query criteria, and the total number of bytes in the log // events that were scanned. @@ -2252,6 +2582,17 @@ type ResourcePolicy struct { // The name of the resource policy. PolicyName *string + // Specifies scope of the resource policy. Valid values are ACCOUNT or RESOURCE. + PolicyScope PolicyScope + + // The ARN of the CloudWatch Logs resource to which the resource policy is + // attached. Only populated for resource-scoped policies. + ResourceArn *string + + // The revision ID of the resource policy. Only populated for resource-scoped + // policies. + RevisionId *string + noSmithyDocumentSerde } @@ -2273,6 +2614,32 @@ type ResultField struct { noSmithyDocumentSerde } +// Configuration for Amazon S3 destination where scheduled query results are +// delivered. +type S3Configuration struct { + + // The Amazon S3 URI where query results are delivered. Must be a valid S3 URI + // format. + // + // This member is required. + DestinationIdentifier *string + + // The ARN of the IAM role that grants permissions to write query results to the + // specified Amazon S3 destination. + // + // This member is required. + RoleArn *string + + // The Amazon Resource Name (ARN) of the KMS encryption key. Must belong to the + // same AWS Region as the destination Amazon S3 bucket. + KmsKeyId *string + + // The AWS accountId for the bucket owning account. + OwnerAccountId *string + + noSmithyDocumentSerde +} + // This structure contains delivery configurations that apply only when the // delivery destination resource is an S3 bucket. type S3DeliveryConfiguration struct { @@ -2293,6 +2660,87 @@ type S3DeliveryConfiguration struct { noSmithyDocumentSerde } +// Represents a data source association with an S3 Table Integration, including +// its status and metadata. +type S3TableIntegrationSource struct { + + // The timestamp when the data source association was created. + CreatedTimeStamp *int64 + + // The data source associated with the S3 Table Integration. + DataSource *DataSource + + // The unique identifier for this data source association. + Identifier *string + + // The current status of the data source association. + Status S3TableIntegrationSourceStatus + + // Additional information about the status of the data source association. + StatusReason *string + + noSmithyDocumentSerde +} + +// Information about a destination where scheduled query results are processed, +// including processing status and any error messages. +type ScheduledQueryDestination struct { + + // The identifier for the destination where results are delivered. + DestinationIdentifier *string + + // The type of destination for query results. + DestinationType ScheduledQueryDestinationType + + // Error message if destination processing failed. + ErrorMessage *string + + // The identifier of the processed result at the destination. + ProcessedIdentifier *string + + // The processing status of the destination delivery. + Status ActionStatus + + noSmithyDocumentSerde +} + +// Summary information about a scheduled query, including basic configuration and +// execution status. +type ScheduledQuerySummary struct { + + // The timestamp when the scheduled query was created. + CreationTime *int64 + + // Configuration for where query results are delivered. + DestinationConfiguration *DestinationConfiguration + + // The status of the most recent execution. + LastExecutionStatus ExecutionStatus + + // The timestamp when the scheduled query was last executed. + LastTriggeredTime *int64 + + // The timestamp when the scheduled query was last updated. + LastUpdatedTime *int64 + + // The name of the scheduled query. + Name *string + + // The cron expression that defines when the scheduled query runs. + ScheduleExpression *string + + // The ARN of the scheduled query. + ScheduledQueryArn *string + + // The current state of the scheduled query. + State ScheduledQueryState + + // The timezone used for evaluating the schedule expression. + Timezone *string + + noSmithyDocumentSerde +} + // Represents the search status of a log stream. type SearchedLogStream struct { @@ -2395,6 +2843,16 @@ type SubscriptionFilter struct { // random or grouped by log stream. Distribution Distribution + // The list of system fields that are included in the log events sent to the + // subscription destination. Returns the emitSystemFields value if it was + // specified when the subscription filter was created. + EmitSystemFields []string + + // The filter expression that specifies which log events are processed by this + // subscription filter based on system fields. Returns the fieldSelectionCriteria + // value if it was specified when the subscription filter was created. + FieldSelectionCriteria *string + // The name of the subscription filter. FilterName *string @@ -2489,6 +2947,28 @@ type TransformedLogRecord struct { noSmithyDocumentSerde } +// A record of a scheduled query execution, including execution status, timestamp, +// and destination processing results. +type TriggerHistoryRecord struct { + + // Information about destination processing for this query execution. + Destinations []ScheduledQueryDestination + + // Error message if the query execution failed. + ErrorMessage *string + + // The execution status of the scheduled query run. + ExecutionStatus ExecutionStatus + + // The unique identifier for this query execution. + QueryId *string + + // The timestamp when the scheduled query execution was triggered. + TriggeredTimestamp *int64 + + noSmithyDocumentSerde +} + // Use this processor to remove leading and trailing whitespace. // // For more information about this processor including examples, see [trimString] in the @@ -2571,6 +3051,7 @@ type UnknownUnionMember struct { noSmithyDocumentSerde } +func (*UnknownUnionMember) isGetLogObjectResponseStream() {} func (*UnknownUnionMember) isIntegrationDetails() {} func (*UnknownUnionMember) isResourceConfig() {} func (*UnknownUnionMember) isStartLiveTailResponseStream() {} diff --git a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/validators.go b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/validators.go index a524c4842b2..569d28bd50f 100644 --- a/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/validators.go +++ b/agent/vendor/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/validators.go @@ -30,6 +30,26 @@ func (m *validateOpAssociateKmsKey) HandleInitialize(ctx context.Context, in mid return next.HandleInitialize(ctx, in) } +type validateOpAssociateSourceToS3TableIntegration struct { +} + +func (*validateOpAssociateSourceToS3TableIntegration) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpAssociateSourceToS3TableIntegration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*AssociateSourceToS3TableIntegrationInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpAssociateSourceToS3TableIntegrationInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + type validateOpCancelExportTask struct { } @@ -50,6 +70,26 @@ func (m *validateOpCancelExportTask) HandleInitialize(ctx context.Context, in mi return next.HandleInitialize(ctx, in) } +type validateOpCancelImportTask struct { +} + +func (*validateOpCancelImportTask) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpCancelImportTask) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*CancelImportTaskInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpCancelImportTaskInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + type validateOpCreateDelivery struct { } @@ -90,6 +130,26 @@ func (m *validateOpCreateExportTask) HandleInitialize(ctx context.Context, in mi return next.HandleInitialize(ctx, in) } +type validateOpCreateImportTask struct { +} + +func (*validateOpCreateImportTask) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpCreateImportTask) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*CreateImportTaskInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpCreateImportTaskInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + type validateOpCreateLogAnomalyDetector struct { } @@ -150,6 +210,26 @@ func (m *validateOpCreateLogStream) HandleInitialize(ctx context.Context, in mid return next.HandleInitialize(ctx, in) } +type validateOpCreateScheduledQuery struct { +} + +func (*validateOpCreateScheduledQuery) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpCreateScheduledQuery) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*CreateScheduledQueryInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpCreateScheduledQueryInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + type validateOpDeleteAccountPolicy struct { } @@ -450,6 +530,26 @@ func (m *validateOpDeleteRetentionPolicy) HandleInitialize(ctx context.Context, return next.HandleInitialize(ctx, in) } +type validateOpDeleteScheduledQuery struct { +} + +func (*validateOpDeleteScheduledQuery) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpDeleteScheduledQuery) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*DeleteScheduledQueryInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpDeleteScheduledQueryInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + type validateOpDeleteSubscriptionFilter struct { } @@ -530,6 +630,26 @@ func (m *validateOpDescribeFieldIndexes) HandleInitialize(ctx context.Context, i return next.HandleInitialize(ctx, in) } +type validateOpDescribeImportTaskBatches struct { +} + +func (*validateOpDescribeImportTaskBatches) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpDescribeImportTaskBatches) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*DescribeImportTaskBatchesInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpDescribeImportTaskBatchesInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + type validateOpDescribeIndexPolicies struct { } @@ -570,6 +690,26 @@ func (m *validateOpDescribeSubscriptionFilters) HandleInitialize(ctx context.Con return next.HandleInitialize(ctx, in) } +type validateOpDisassociateSourceFromS3TableIntegration struct { +} + +func (*validateOpDisassociateSourceFromS3TableIntegration) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpDisassociateSourceFromS3TableIntegration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*DisassociateSourceFromS3TableIntegrationInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpDisassociateSourceFromS3TableIntegrationInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + type validateOpGetDataProtectionPolicy struct { } @@ -730,6 +870,46 @@ func (m *validateOpGetLogEvents) HandleInitialize(ctx context.Context, in middle return next.HandleInitialize(ctx, in) } +type validateOpGetLogFields struct { +} + +func (*validateOpGetLogFields) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpGetLogFields) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*GetLogFieldsInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpGetLogFieldsInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + +type validateOpGetLogObject struct { +} + +func (*validateOpGetLogObject) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpGetLogObject) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*GetLogObjectInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpGetLogObjectInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + type validateOpGetLogRecord struct { } @@ -770,6 +950,46 @@ func (m *validateOpGetQueryResults) HandleInitialize(ctx context.Context, in mid return next.HandleInitialize(ctx, in) } +type validateOpGetScheduledQueryHistory struct { +} + +func (*validateOpGetScheduledQueryHistory) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpGetScheduledQueryHistory) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*GetScheduledQueryHistoryInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpGetScheduledQueryHistoryInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + +type validateOpGetScheduledQuery struct { +} + +func (*validateOpGetScheduledQuery) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpGetScheduledQuery) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*GetScheduledQueryInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpGetScheduledQueryInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + type validateOpGetTransformer struct { } @@ -790,6 +1010,26 @@ func (m *validateOpGetTransformer) HandleInitialize(ctx context.Context, in midd return next.HandleInitialize(ctx, in) } +type validateOpListAggregateLogGroupSummaries struct { +} + +func (*validateOpListAggregateLogGroupSummaries) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpListAggregateLogGroupSummaries) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*ListAggregateLogGroupSummariesInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpListAggregateLogGroupSummariesInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + type validateOpListLogGroupsForQuery struct { } @@ -810,6 +1050,46 @@ func (m *validateOpListLogGroupsForQuery) HandleInitialize(ctx context.Context, return next.HandleInitialize(ctx, in) } +type validateOpListLogGroups struct { +} + +func (*validateOpListLogGroups) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpListLogGroups) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*ListLogGroupsInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpListLogGroupsInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + +type validateOpListSourcesForS3TableIntegration struct { +} + +func (*validateOpListSourcesForS3TableIntegration) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpListSourcesForS3TableIntegration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*ListSourcesForS3TableIntegrationInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpListSourcesForS3TableIntegrationInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + type validateOpListTagsForResource struct { } @@ -870,6 +1150,26 @@ func (m *validateOpPutAccountPolicy) HandleInitialize(ctx context.Context, in mi return next.HandleInitialize(ctx, in) } +type validateOpPutBearerTokenAuthentication struct { +} + +func (*validateOpPutBearerTokenAuthentication) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpPutBearerTokenAuthentication) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*PutBearerTokenAuthenticationInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpPutBearerTokenAuthenticationInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + type validateOpPutDataProtectionPolicy struct { } @@ -1050,6 +1350,26 @@ func (m *validateOpPutLogEvents) HandleInitialize(ctx context.Context, in middle return next.HandleInitialize(ctx, in) } +type validateOpPutLogGroupDeletionProtection struct { +} + +func (*validateOpPutLogGroupDeletionProtection) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpPutLogGroupDeletionProtection) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*PutLogGroupDeletionProtectionInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpPutLogGroupDeletionProtectionInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + type validateOpPutMetricFilter struct { } @@ -1390,14 +1710,42 @@ func (m *validateOpUpdateLogAnomalyDetector) HandleInitialize(ctx context.Contex return next.HandleInitialize(ctx, in) } +type validateOpUpdateScheduledQuery struct { +} + +func (*validateOpUpdateScheduledQuery) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpUpdateScheduledQuery) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*UpdateScheduledQueryInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpUpdateScheduledQueryInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + func addOpAssociateKmsKeyValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpAssociateKmsKey{}, middleware.After) } +func addOpAssociateSourceToS3TableIntegrationValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpAssociateSourceToS3TableIntegration{}, middleware.After) +} + func addOpCancelExportTaskValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpCancelExportTask{}, middleware.After) } +func addOpCancelImportTaskValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpCancelImportTask{}, middleware.After) +} + func addOpCreateDeliveryValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpCreateDelivery{}, middleware.After) } @@ -1406,6 +1754,10 @@ func addOpCreateExportTaskValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpCreateExportTask{}, middleware.After) } +func addOpCreateImportTaskValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpCreateImportTask{}, middleware.After) +} + func addOpCreateLogAnomalyDetectorValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpCreateLogAnomalyDetector{}, middleware.After) } @@ -1418,6 +1770,10 @@ func addOpCreateLogStreamValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpCreateLogStream{}, middleware.After) } +func addOpCreateScheduledQueryValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpCreateScheduledQuery{}, middleware.After) +} + func addOpDeleteAccountPolicyValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpDeleteAccountPolicy{}, middleware.After) } @@ -1478,6 +1834,10 @@ func addOpDeleteRetentionPolicyValidationMiddleware(stack *middleware.Stack) err return stack.Initialize.Add(&validateOpDeleteRetentionPolicy{}, middleware.After) } +func addOpDeleteScheduledQueryValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpDeleteScheduledQuery{}, middleware.After) +} + func addOpDeleteSubscriptionFilterValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpDeleteSubscriptionFilter{}, middleware.After) } @@ -1494,6 +1854,10 @@ func addOpDescribeFieldIndexesValidationMiddleware(stack *middleware.Stack) erro return stack.Initialize.Add(&validateOpDescribeFieldIndexes{}, middleware.After) } +func addOpDescribeImportTaskBatchesValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpDescribeImportTaskBatches{}, middleware.After) +} + func addOpDescribeIndexPoliciesValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpDescribeIndexPolicies{}, middleware.After) } @@ -1502,6 +1866,10 @@ func addOpDescribeSubscriptionFiltersValidationMiddleware(stack *middleware.Stac return stack.Initialize.Add(&validateOpDescribeSubscriptionFilters{}, middleware.After) } +func addOpDisassociateSourceFromS3TableIntegrationValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpDisassociateSourceFromS3TableIntegration{}, middleware.After) +} + func addOpGetDataProtectionPolicyValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpGetDataProtectionPolicy{}, middleware.After) } @@ -1534,6 +1902,14 @@ func addOpGetLogEventsValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpGetLogEvents{}, middleware.After) } +func addOpGetLogFieldsValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpGetLogFields{}, middleware.After) +} + +func addOpGetLogObjectValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpGetLogObject{}, middleware.After) +} + func addOpGetLogRecordValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpGetLogRecord{}, middleware.After) } @@ -1542,14 +1918,34 @@ func addOpGetQueryResultsValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpGetQueryResults{}, middleware.After) } +func addOpGetScheduledQueryHistoryValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpGetScheduledQueryHistory{}, middleware.After) +} + +func addOpGetScheduledQueryValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpGetScheduledQuery{}, middleware.After) +} + func addOpGetTransformerValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpGetTransformer{}, middleware.After) } +func addOpListAggregateLogGroupSummariesValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpListAggregateLogGroupSummaries{}, middleware.After) +} + func addOpListLogGroupsForQueryValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpListLogGroupsForQuery{}, middleware.After) } +func addOpListLogGroupsValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpListLogGroups{}, middleware.After) +} + +func addOpListSourcesForS3TableIntegrationValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpListSourcesForS3TableIntegration{}, middleware.After) +} + func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After) } @@ -1562,6 +1958,10 @@ func addOpPutAccountPolicyValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpPutAccountPolicy{}, middleware.After) } +func addOpPutBearerTokenAuthenticationValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpPutBearerTokenAuthentication{}, middleware.After) +} + func addOpPutDataProtectionPolicyValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpPutDataProtectionPolicy{}, middleware.After) } @@ -1598,6 +1998,10 @@ func addOpPutLogEventsValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpPutLogEvents{}, middleware.After) } +func addOpPutLogGroupDeletionProtectionValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpPutLogGroupDeletionProtection{}, middleware.After) +} + func addOpPutMetricFilterValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpPutMetricFilter{}, middleware.After) } @@ -1666,6 +2070,10 @@ func addOpUpdateLogAnomalyDetectorValidationMiddleware(stack *middleware.Stack) return stack.Initialize.Add(&validateOpUpdateLogAnomalyDetector{}, middleware.After) } +func addOpUpdateScheduledQueryValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpUpdateScheduledQuery{}, middleware.After) +} + func validateAddKeyEntries(v []types.AddKeyEntry) error { if v == nil { return nil @@ -1774,6 +2182,53 @@ func validateCopyValueEntry(v *types.CopyValueEntry) error { } } +func validateDataSource(v *types.DataSource) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "DataSource"} + if v.Name == nil { + invalidParams.Add(smithy.NewErrParamRequired("Name")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + +func validateDataSourceFilter(v *types.DataSourceFilter) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "DataSourceFilter"} + if v.Name == nil { + invalidParams.Add(smithy.NewErrParamRequired("Name")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + +func validateDataSourceFilters(v []types.DataSourceFilter) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "DataSourceFilters"} + for i := range v { + if err := validateDataSourceFilter(&v[i]); err != nil { + invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) + } + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateDateTimeConverter(v *types.DateTimeConverter) error { if v == nil { return nil @@ -1825,6 +2280,25 @@ func validateDeliveryDestinationConfiguration(v *types.DeliveryDestinationConfig } } +func validateDestinationConfiguration(v *types.DestinationConfiguration) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "DestinationConfiguration"} + if v.S3Configuration == nil { + invalidParams.Add(smithy.NewErrParamRequired("S3Configuration")) + } else if v.S3Configuration != nil { + if err := validateS3Configuration(v.S3Configuration); err != nil { + invalidParams.AddNested("S3Configuration", err.(smithy.InvalidParamsError)) + } + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateGrok(v *types.Grok) error { if v == nil { return nil @@ -2021,6 +2495,24 @@ func validateOpenSearchResourceConfig(v *types.OpenSearchResourceConfig) error { } } +func validateParseToOCSF(v *types.ParseToOCSF) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "ParseToOCSF"} + if len(v.EventSource) == 0 { + invalidParams.Add(smithy.NewErrParamRequired("EventSource")) + } + if len(v.OcsfVersion) == 0 { + invalidParams.Add(smithy.NewErrParamRequired("OcsfVersion")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateProcessor(v *types.Processor) error { if v == nil { return nil @@ -2066,6 +2558,11 @@ func validateProcessor(v *types.Processor) error { invalidParams.AddNested("MoveKeys", err.(smithy.InvalidParamsError)) } } + if v.ParseToOCSF != nil { + if err := validateParseToOCSF(v.ParseToOCSF); err != nil { + invalidParams.AddNested("ParseToOCSF", err.(smithy.InvalidParamsError)) + } + } if v.RenameKeys != nil { if err := validateRenameKeys(v.RenameKeys); err != nil { invalidParams.AddNested("RenameKeys", err.(smithy.InvalidParamsError)) @@ -2103,13 +2600,45 @@ func validateProcessor(v *types.Processor) error { } } -func validateProcessors(v []types.Processor) error { +func validateProcessors(v []types.Processor) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "Processors"} + for i := range v { + if err := validateProcessor(&v[i]); err != nil { + invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) + } + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + +func validateQueryParameter(v *types.QueryParameter) error { if v == nil { return nil } - invalidParams := smithy.InvalidParamsError{Context: "Processors"} + invalidParams := smithy.InvalidParamsError{Context: "QueryParameter"} + if v.Name == nil { + invalidParams.Add(smithy.NewErrParamRequired("Name")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + +func validateQueryParameterList(v []types.QueryParameter) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "QueryParameterList"} for i := range v { - if err := validateProcessor(&v[i]); err != nil { + if err := validateQueryParameter(&v[i]); err != nil { invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) } } @@ -2193,6 +2722,24 @@ func validateResourceConfig(v types.ResourceConfig) error { } } +func validateS3Configuration(v *types.S3Configuration) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "S3Configuration"} + if v.DestinationIdentifier == nil { + invalidParams.Add(smithy.NewErrParamRequired("DestinationIdentifier")) + } + if v.RoleArn == nil { + invalidParams.Add(smithy.NewErrParamRequired("RoleArn")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateSplitString(v *types.SplitString) error { if v == nil { return nil @@ -2403,6 +2950,28 @@ func validateOpAssociateKmsKeyInput(v *AssociateKmsKeyInput) error { } } +func validateOpAssociateSourceToS3TableIntegrationInput(v *AssociateSourceToS3TableIntegrationInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "AssociateSourceToS3TableIntegrationInput"} + if v.IntegrationArn == nil { + invalidParams.Add(smithy.NewErrParamRequired("IntegrationArn")) + } + if v.DataSource == nil { + invalidParams.Add(smithy.NewErrParamRequired("DataSource")) + } else if v.DataSource != nil { + if err := validateDataSource(v.DataSource); err != nil { + invalidParams.AddNested("DataSource", err.(smithy.InvalidParamsError)) + } + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateOpCancelExportTaskInput(v *CancelExportTaskInput) error { if v == nil { return nil @@ -2418,6 +2987,21 @@ func validateOpCancelExportTaskInput(v *CancelExportTaskInput) error { } } +func validateOpCancelImportTaskInput(v *CancelImportTaskInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "CancelImportTaskInput"} + if v.ImportId == nil { + invalidParams.Add(smithy.NewErrParamRequired("ImportId")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateOpCreateDeliveryInput(v *CreateDeliveryInput) error { if v == nil { return nil @@ -2460,6 +3044,24 @@ func validateOpCreateExportTaskInput(v *CreateExportTaskInput) error { } } +func validateOpCreateImportTaskInput(v *CreateImportTaskInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "CreateImportTaskInput"} + if v.ImportSourceArn == nil { + invalidParams.Add(smithy.NewErrParamRequired("ImportSourceArn")) + } + if v.ImportRoleArn == nil { + invalidParams.Add(smithy.NewErrParamRequired("ImportRoleArn")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateOpCreateLogAnomalyDetectorInput(v *CreateLogAnomalyDetectorInput) error { if v == nil { return nil @@ -2508,6 +3110,38 @@ func validateOpCreateLogStreamInput(v *CreateLogStreamInput) error { } } +func validateOpCreateScheduledQueryInput(v *CreateScheduledQueryInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "CreateScheduledQueryInput"} + if v.Name == nil { + invalidParams.Add(smithy.NewErrParamRequired("Name")) + } + if len(v.QueryLanguage) == 0 { + invalidParams.Add(smithy.NewErrParamRequired("QueryLanguage")) + } + if v.QueryString == nil { + invalidParams.Add(smithy.NewErrParamRequired("QueryString")) + } + if v.ScheduleExpression == nil { + invalidParams.Add(smithy.NewErrParamRequired("ScheduleExpression")) + } + if v.DestinationConfiguration != nil { + if err := validateDestinationConfiguration(v.DestinationConfiguration); err != nil { + invalidParams.AddNested("DestinationConfiguration", err.(smithy.InvalidParamsError)) + } + } + if v.ExecutionRoleArn == nil { + invalidParams.Add(smithy.NewErrParamRequired("ExecutionRoleArn")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateOpDeleteAccountPolicyInput(v *DeleteAccountPolicyInput) error { if v == nil { return nil @@ -2742,6 +3376,21 @@ func validateOpDeleteRetentionPolicyInput(v *DeleteRetentionPolicyInput) error { } } +func validateOpDeleteScheduledQueryInput(v *DeleteScheduledQueryInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "DeleteScheduledQueryInput"} + if v.Identifier == nil { + invalidParams.Add(smithy.NewErrParamRequired("Identifier")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateOpDeleteSubscriptionFilterInput(v *DeleteSubscriptionFilterInput) error { if v == nil { return nil @@ -2805,6 +3454,21 @@ func validateOpDescribeFieldIndexesInput(v *DescribeFieldIndexesInput) error { } } +func validateOpDescribeImportTaskBatchesInput(v *DescribeImportTaskBatchesInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "DescribeImportTaskBatchesInput"} + if v.ImportId == nil { + invalidParams.Add(smithy.NewErrParamRequired("ImportId")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateOpDescribeIndexPoliciesInput(v *DescribeIndexPoliciesInput) error { if v == nil { return nil @@ -2835,6 +3499,21 @@ func validateOpDescribeSubscriptionFiltersInput(v *DescribeSubscriptionFiltersIn } } +func validateOpDisassociateSourceFromS3TableIntegrationInput(v *DisassociateSourceFromS3TableIntegrationInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "DisassociateSourceFromS3TableIntegrationInput"} + if v.Identifier == nil { + invalidParams.Add(smithy.NewErrParamRequired("Identifier")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateOpGetDataProtectionPolicyInput(v *GetDataProtectionPolicyInput) error { if v == nil { return nil @@ -2955,6 +3634,39 @@ func validateOpGetLogEventsInput(v *GetLogEventsInput) error { } } +func validateOpGetLogFieldsInput(v *GetLogFieldsInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "GetLogFieldsInput"} + if v.DataSourceName == nil { + invalidParams.Add(smithy.NewErrParamRequired("DataSourceName")) + } + if v.DataSourceType == nil { + invalidParams.Add(smithy.NewErrParamRequired("DataSourceType")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + +func validateOpGetLogObjectInput(v *GetLogObjectInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "GetLogObjectInput"} + if v.LogObjectPointer == nil { + invalidParams.Add(smithy.NewErrParamRequired("LogObjectPointer")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateOpGetLogRecordInput(v *GetLogRecordInput) error { if v == nil { return nil @@ -2985,6 +3697,42 @@ func validateOpGetQueryResultsInput(v *GetQueryResultsInput) error { } } +func validateOpGetScheduledQueryHistoryInput(v *GetScheduledQueryHistoryInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "GetScheduledQueryHistoryInput"} + if v.Identifier == nil { + invalidParams.Add(smithy.NewErrParamRequired("Identifier")) + } + if v.StartTime == nil { + invalidParams.Add(smithy.NewErrParamRequired("StartTime")) + } + if v.EndTime == nil { + invalidParams.Add(smithy.NewErrParamRequired("EndTime")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + +func validateOpGetScheduledQueryInput(v *GetScheduledQueryInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "GetScheduledQueryInput"} + if v.Identifier == nil { + invalidParams.Add(smithy.NewErrParamRequired("Identifier")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateOpGetTransformerInput(v *GetTransformerInput) error { if v == nil { return nil @@ -3000,6 +3748,26 @@ func validateOpGetTransformerInput(v *GetTransformerInput) error { } } +func validateOpListAggregateLogGroupSummariesInput(v *ListAggregateLogGroupSummariesInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "ListAggregateLogGroupSummariesInput"} + if v.DataSources != nil { + if err := validateDataSourceFilters(v.DataSources); err != nil { + invalidParams.AddNested("DataSources", err.(smithy.InvalidParamsError)) + } + } + if len(v.GroupBy) == 0 { + invalidParams.Add(smithy.NewErrParamRequired("GroupBy")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateOpListLogGroupsForQueryInput(v *ListLogGroupsForQueryInput) error { if v == nil { return nil @@ -3015,6 +3783,38 @@ func validateOpListLogGroupsForQueryInput(v *ListLogGroupsForQueryInput) error { } } +func validateOpListLogGroupsInput(v *ListLogGroupsInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "ListLogGroupsInput"} + if v.DataSources != nil { + if err := validateDataSourceFilters(v.DataSources); err != nil { + invalidParams.AddNested("DataSources", err.(smithy.InvalidParamsError)) + } + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + +func validateOpListSourcesForS3TableIntegrationInput(v *ListSourcesForS3TableIntegrationInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "ListSourcesForS3TableIntegrationInput"} + if v.IntegrationArn == nil { + invalidParams.Add(smithy.NewErrParamRequired("IntegrationArn")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error { if v == nil { return nil @@ -3066,6 +3866,24 @@ func validateOpPutAccountPolicyInput(v *PutAccountPolicyInput) error { } } +func validateOpPutBearerTokenAuthenticationInput(v *PutBearerTokenAuthenticationInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "PutBearerTokenAuthenticationInput"} + if v.LogGroupIdentifier == nil { + invalidParams.Add(smithy.NewErrParamRequired("LogGroupIdentifier")) + } + if v.BearerTokenAuthenticationEnabled == nil { + invalidParams.Add(smithy.NewErrParamRequired("BearerTokenAuthenticationEnabled")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateOpPutDataProtectionPolicyInput(v *PutDataProtectionPolicyInput) error { if v == nil { return nil @@ -3092,9 +3910,7 @@ func validateOpPutDeliveryDestinationInput(v *PutDeliveryDestinationInput) error if v.Name == nil { invalidParams.Add(smithy.NewErrParamRequired("Name")) } - if v.DeliveryDestinationConfiguration == nil { - invalidParams.Add(smithy.NewErrParamRequired("DeliveryDestinationConfiguration")) - } else if v.DeliveryDestinationConfiguration != nil { + if v.DeliveryDestinationConfiguration != nil { if err := validateDeliveryDestinationConfiguration(v.DeliveryDestinationConfiguration); err != nil { invalidParams.AddNested("DeliveryDestinationConfiguration", err.(smithy.InvalidParamsError)) } @@ -3252,6 +4068,24 @@ func validateOpPutLogEventsInput(v *PutLogEventsInput) error { } } +func validateOpPutLogGroupDeletionProtectionInput(v *PutLogGroupDeletionProtectionInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "PutLogGroupDeletionProtectionInput"} + if v.LogGroupIdentifier == nil { + invalidParams.Add(smithy.NewErrParamRequired("LogGroupIdentifier")) + } + if v.DeletionProtectionEnabled == nil { + invalidParams.Add(smithy.NewErrParamRequired("DeletionProtectionEnabled")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateOpPutMetricFilterInput(v *PutMetricFilterInput) error { if v == nil { return nil @@ -3291,6 +4125,11 @@ func validateOpPutQueryDefinitionInput(v *PutQueryDefinitionInput) error { if v.QueryString == nil { invalidParams.Add(smithy.NewErrParamRequired("QueryString")) } + if v.Parameters != nil { + if err := validateQueryParameterList(v.Parameters); err != nil { + invalidParams.AddNested("Parameters", err.(smithy.InvalidParamsError)) + } + } if invalidParams.Len() > 0 { return invalidParams } else { @@ -3572,3 +4411,35 @@ func validateOpUpdateLogAnomalyDetectorInput(v *UpdateLogAnomalyDetectorInput) e return nil } } + +func validateOpUpdateScheduledQueryInput(v *UpdateScheduledQueryInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "UpdateScheduledQueryInput"} + if v.Identifier == nil { + invalidParams.Add(smithy.NewErrParamRequired("Identifier")) + } + if len(v.QueryLanguage) == 0 { + invalidParams.Add(smithy.NewErrParamRequired("QueryLanguage")) + } + if v.QueryString == nil { + invalidParams.Add(smithy.NewErrParamRequired("QueryString")) + } + if v.ScheduleExpression == nil { + invalidParams.Add(smithy.NewErrParamRequired("ScheduleExpression")) + } + if v.DestinationConfiguration != nil { + if err := validateDestinationConfiguration(v.DestinationConfiguration); err != nil { + invalidParams.AddNested("DestinationConfiguration", err.(smithy.InvalidParamsError)) + } + } + if v.ExecutionRoleArn == nil { + invalidParams.Add(smithy.NewErrParamRequired("ExecutionRoleArn")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} diff --git a/agent/vendor/modules.txt b/agent/vendor/modules.txt index 36bf6707e8c..27cbbd0e500 100644 --- a/agent/vendor/modules.txt +++ b/agent/vendor/modules.txt @@ -188,8 +188,8 @@ github.com/aws/aws-sdk-go-v2/internal/ini github.com/aws/aws-sdk-go-v2/internal/v4a github.com/aws/aws-sdk-go-v2/internal/v4a/internal/crypto github.com/aws/aws-sdk-go-v2/internal/v4a/internal/v4 -# github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs v1.47.3 -## explicit; go 1.22 +# github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs v1.65.0 +## explicit; go 1.24 github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/internal/endpoints github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/types