1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
|
// Code generated by smithy-go-codegen DO NOT EDIT.
package forecast
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/forecast/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// What-if analysis is a scenario modeling technique where you make a hypothetical
// change to a time series and compare the forecasts generated by these changes
// against the baseline, unchanged time series. It is important to remember that
// the purpose of a what-if analysis is to understand how a forecast can change
// given different modifications to the baseline time series. For example, imagine
// you are a clothing retailer who is considering an end of season sale to clear
// space for new styles. After creating a baseline forecast, you can use a what-if
// analysis to investigate how different sales tactics might affect your goals. You
// could create a scenario where everything is given a 25% markdown, and another
// where everything is given a fixed dollar markdown. You could create a scenario
// where the sale lasts for one week and another where the sale lasts for one
// month. With a what-if analysis, you can compare many different scenarios against
// each other. Note that a what-if analysis is meant to display what the
// forecasting model has learned and how it will behave in the scenarios that you
// are evaluating. Do not blindly use the results of the what-if analysis to make
// business decisions. For instance, forecasts might not be accurate for novel
// scenarios where there is no reference available to determine whether a forecast
// is good. The TimeSeriesSelector object defines the items that you want in the
// what-if analysis.
func (c *Client) CreateWhatIfAnalysis(ctx context.Context, params *CreateWhatIfAnalysisInput, optFns ...func(*Options)) (*CreateWhatIfAnalysisOutput, error) {
if params == nil {
params = &CreateWhatIfAnalysisInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateWhatIfAnalysis", params, optFns, c.addOperationCreateWhatIfAnalysisMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateWhatIfAnalysisOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateWhatIfAnalysisInput struct {
// The Amazon Resource Name (ARN) of the baseline forecast.
//
// This member is required.
ForecastArn *string
// The name of the what-if analysis. Each name must be unique.
//
// This member is required.
WhatIfAnalysisName *string
// A list of tags (https://docs.aws.amazon.com/forecast/latest/dg/tagging-forecast-resources.html)
// to apply to the what if forecast.
Tags []types.Tag
// Defines the set of time series that are used in the what-if analysis with a
// TimeSeriesIdentifiers object. What-if analyses are performed only for the time
// series in this object. The TimeSeriesIdentifiers object needs the following
// information:
// - DataSource
// - Format
// - Schema
TimeSeriesSelector *types.TimeSeriesSelector
noSmithyDocumentSerde
}
type CreateWhatIfAnalysisOutput struct {
// The Amazon Resource Name (ARN) of the what-if analysis.
WhatIfAnalysisArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateWhatIfAnalysisMiddlewares(stack *middleware.Stack, options Options) (err error) {
if err := stack.Serialize.Add(&setOperationInputMiddleware{}, middleware.After); err != nil {
return err
}
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateWhatIfAnalysis{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateWhatIfAnalysis{}, middleware.After)
if err != nil {
return err
}
if err := addProtocolFinalizerMiddlewares(stack, options, "CreateWhatIfAnalysis"); 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 = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); 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 = addOpCreateWhatIfAnalysisValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateWhatIfAnalysis(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.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
}
return nil
}
func newServiceMetadataMiddleware_opCreateWhatIfAnalysis(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
OperationName: "CreateWhatIfAnalysis",
}
}
|
