@aws-sdk/client-bcm-dashboards 3.901.0 → 3.906.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (2) hide show
  1. package/dist-cjs/index.js +1014 -1127
  2. package/package.json +5 -5
package/dist-cjs/index.js CHANGED
@@ -1,1165 +1,1052 @@
1
- "use strict";
2
- var __defProp = Object.defineProperty;
3
- var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
4
- var __getOwnPropNames = Object.getOwnPropertyNames;
5
- var __hasOwnProp = Object.prototype.hasOwnProperty;
6
- var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
7
- var __export = (target, all) => {
8
- for (var name in all)
9
- __defProp(target, name, { get: all[name], enumerable: true });
10
- };
11
- var __copyProps = (to, from, except, desc) => {
12
- if (from && typeof from === "object" || typeof from === "function") {
13
- for (let key of __getOwnPropNames(from))
14
- if (!__hasOwnProp.call(to, key) && key !== except)
15
- __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
16
- }
17
- return to;
18
- };
19
- var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
1
+ 'use strict';
20
2
 
21
- // src/index.ts
22
- var index_exports = {};
23
- __export(index_exports, {
24
- AccessDeniedException: () => AccessDeniedException,
25
- BCMDashboards: () => BCMDashboards,
26
- BCMDashboardsClient: () => BCMDashboardsClient,
27
- BCMDashboardsServiceException: () => BCMDashboardsServiceException,
28
- CreateDashboardCommand: () => CreateDashboardCommand,
29
- DashboardType: () => DashboardType,
30
- DateTimeType: () => DateTimeType,
31
- DeleteDashboardCommand: () => DeleteDashboardCommand,
32
- Dimension: () => Dimension,
33
- DisplayConfig: () => DisplayConfig,
34
- GetDashboardCommand: () => GetDashboardCommand,
35
- GetResourcePolicyCommand: () => GetResourcePolicyCommand,
36
- Granularity: () => Granularity,
37
- GroupDefinitionType: () => GroupDefinitionType,
38
- InternalServerException: () => InternalServerException,
39
- ListDashboardsCommand: () => ListDashboardsCommand,
40
- ListTagsForResourceCommand: () => ListTagsForResourceCommand,
41
- MatchOption: () => MatchOption,
42
- MetricName: () => MetricName,
43
- QueryParameters: () => QueryParameters,
44
- ResourceNotFoundException: () => ResourceNotFoundException,
45
- ServiceQuotaExceededException: () => ServiceQuotaExceededException,
46
- TagResourceCommand: () => TagResourceCommand,
47
- ThrottlingException: () => ThrottlingException,
48
- UntagResourceCommand: () => UntagResourceCommand,
49
- UpdateDashboardCommand: () => UpdateDashboardCommand,
50
- ValidationException: () => ValidationException,
51
- VisualType: () => VisualType,
52
- __Client: () => import_smithy_client.Client,
53
- paginateListDashboards: () => paginateListDashboards
54
- });
55
- module.exports = __toCommonJS(index_exports);
56
-
57
- // src/BCMDashboardsClient.ts
58
- var import_middleware_host_header = require("@aws-sdk/middleware-host-header");
59
- var import_middleware_logger = require("@aws-sdk/middleware-logger");
60
- var import_middleware_recursion_detection = require("@aws-sdk/middleware-recursion-detection");
61
- var import_middleware_user_agent = require("@aws-sdk/middleware-user-agent");
62
- var import_config_resolver = require("@smithy/config-resolver");
63
- var import_core = require("@smithy/core");
64
- var import_middleware_content_length = require("@smithy/middleware-content-length");
65
- var import_middleware_endpoint = require("@smithy/middleware-endpoint");
66
- var import_middleware_retry = require("@smithy/middleware-retry");
3
+ var middlewareHostHeader = require('@aws-sdk/middleware-host-header');
4
+ var middlewareLogger = require('@aws-sdk/middleware-logger');
5
+ var middlewareRecursionDetection = require('@aws-sdk/middleware-recursion-detection');
6
+ var middlewareUserAgent = require('@aws-sdk/middleware-user-agent');
7
+ var configResolver = require('@smithy/config-resolver');
8
+ var core = require('@smithy/core');
9
+ var middlewareContentLength = require('@smithy/middleware-content-length');
10
+ var middlewareEndpoint = require('@smithy/middleware-endpoint');
11
+ var middlewareRetry = require('@smithy/middleware-retry');
12
+ var smithyClient = require('@smithy/smithy-client');
13
+ var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
14
+ var runtimeConfig = require('./runtimeConfig');
15
+ var regionConfigResolver = require('@aws-sdk/region-config-resolver');
16
+ var protocolHttp = require('@smithy/protocol-http');
17
+ var middlewareSerde = require('@smithy/middleware-serde');
18
+ var core$1 = require('@aws-sdk/core');
67
19
 
68
- var import_httpAuthSchemeProvider = require("./auth/httpAuthSchemeProvider");
69
-
70
- // src/endpoint/EndpointParameters.ts
71
- var resolveClientEndpointParameters = /* @__PURE__ */ __name((options) => {
72
- return Object.assign(options, {
73
- useFipsEndpoint: options.useFipsEndpoint ?? false,
74
- defaultSigningName: "bcm-dashboards"
75
- });
76
- }, "resolveClientEndpointParameters");
77
- var commonParams = {
78
- UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
79
- Endpoint: { type: "builtInParams", name: "endpoint" },
80
- Region: { type: "builtInParams", name: "region" }
20
+ const resolveClientEndpointParameters = (options) => {
21
+ return Object.assign(options, {
22
+ useFipsEndpoint: options.useFipsEndpoint ?? false,
23
+ defaultSigningName: "bcm-dashboards",
24
+ });
25
+ };
26
+ const commonParams = {
27
+ UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
28
+ Endpoint: { type: "builtInParams", name: "endpoint" },
29
+ Region: { type: "builtInParams", name: "region" },
81
30
  };
82
31
 
83
- // src/BCMDashboardsClient.ts
84
- var import_runtimeConfig = require("././runtimeConfig");
32
+ const getHttpAuthExtensionConfiguration = (runtimeConfig) => {
33
+ const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
34
+ let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
35
+ let _credentials = runtimeConfig.credentials;
36
+ return {
37
+ setHttpAuthScheme(httpAuthScheme) {
38
+ const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
39
+ if (index === -1) {
40
+ _httpAuthSchemes.push(httpAuthScheme);
41
+ }
42
+ else {
43
+ _httpAuthSchemes.splice(index, 1, httpAuthScheme);
44
+ }
45
+ },
46
+ httpAuthSchemes() {
47
+ return _httpAuthSchemes;
48
+ },
49
+ setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
50
+ _httpAuthSchemeProvider = httpAuthSchemeProvider;
51
+ },
52
+ httpAuthSchemeProvider() {
53
+ return _httpAuthSchemeProvider;
54
+ },
55
+ setCredentials(credentials) {
56
+ _credentials = credentials;
57
+ },
58
+ credentials() {
59
+ return _credentials;
60
+ },
61
+ };
62
+ };
63
+ const resolveHttpAuthRuntimeConfig = (config) => {
64
+ return {
65
+ httpAuthSchemes: config.httpAuthSchemes(),
66
+ httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
67
+ credentials: config.credentials(),
68
+ };
69
+ };
85
70
 
86
- // src/runtimeExtensions.ts
87
- var import_region_config_resolver = require("@aws-sdk/region-config-resolver");
88
- var import_protocol_http = require("@smithy/protocol-http");
89
- var import_smithy_client = require("@smithy/smithy-client");
71
+ const resolveRuntimeExtensions = (runtimeConfig, extensions) => {
72
+ const extensionConfiguration = Object.assign(regionConfigResolver.getAwsRegionExtensionConfiguration(runtimeConfig), smithyClient.getDefaultExtensionConfiguration(runtimeConfig), protocolHttp.getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
73
+ extensions.forEach((extension) => extension.configure(extensionConfiguration));
74
+ return Object.assign(runtimeConfig, regionConfigResolver.resolveAwsRegionExtensionConfiguration(extensionConfiguration), smithyClient.resolveDefaultRuntimeConfig(extensionConfiguration), protocolHttp.resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
75
+ };
90
76
 
91
- // src/auth/httpAuthExtensionConfiguration.ts
92
- var getHttpAuthExtensionConfiguration = /* @__PURE__ */ __name((runtimeConfig) => {
93
- const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
94
- let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
95
- let _credentials = runtimeConfig.credentials;
96
- return {
97
- setHttpAuthScheme(httpAuthScheme) {
98
- const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
99
- if (index === -1) {
100
- _httpAuthSchemes.push(httpAuthScheme);
101
- } else {
102
- _httpAuthSchemes.splice(index, 1, httpAuthScheme);
103
- }
104
- },
105
- httpAuthSchemes() {
106
- return _httpAuthSchemes;
107
- },
108
- setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
109
- _httpAuthSchemeProvider = httpAuthSchemeProvider;
110
- },
111
- httpAuthSchemeProvider() {
112
- return _httpAuthSchemeProvider;
113
- },
114
- setCredentials(credentials) {
115
- _credentials = credentials;
116
- },
117
- credentials() {
118
- return _credentials;
77
+ class BCMDashboardsClient extends smithyClient.Client {
78
+ config;
79
+ constructor(...[configuration]) {
80
+ const _config_0 = runtimeConfig.getRuntimeConfig(configuration || {});
81
+ super(_config_0);
82
+ this.initConfig = _config_0;
83
+ const _config_1 = resolveClientEndpointParameters(_config_0);
84
+ const _config_2 = middlewareUserAgent.resolveUserAgentConfig(_config_1);
85
+ const _config_3 = middlewareRetry.resolveRetryConfig(_config_2);
86
+ const _config_4 = configResolver.resolveRegionConfig(_config_3);
87
+ const _config_5 = middlewareHostHeader.resolveHostHeaderConfig(_config_4);
88
+ const _config_6 = middlewareEndpoint.resolveEndpointConfig(_config_5);
89
+ const _config_7 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_6);
90
+ const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
91
+ this.config = _config_8;
92
+ this.middlewareStack.use(middlewareUserAgent.getUserAgentPlugin(this.config));
93
+ this.middlewareStack.use(middlewareRetry.getRetryPlugin(this.config));
94
+ this.middlewareStack.use(middlewareContentLength.getContentLengthPlugin(this.config));
95
+ this.middlewareStack.use(middlewareHostHeader.getHostHeaderPlugin(this.config));
96
+ this.middlewareStack.use(middlewareLogger.getLoggerPlugin(this.config));
97
+ this.middlewareStack.use(middlewareRecursionDetection.getRecursionDetectionPlugin(this.config));
98
+ this.middlewareStack.use(core.getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
99
+ httpAuthSchemeParametersProvider: httpAuthSchemeProvider.defaultBCMDashboardsHttpAuthSchemeParametersProvider,
100
+ identityProviderConfigProvider: async (config) => new core.DefaultIdentityProviderConfig({
101
+ "aws.auth#sigv4": config.credentials,
102
+ }),
103
+ }));
104
+ this.middlewareStack.use(core.getHttpSigningPlugin(this.config));
105
+ }
106
+ destroy() {
107
+ super.destroy();
119
108
  }
120
- };
121
- }, "getHttpAuthExtensionConfiguration");
122
- var resolveHttpAuthRuntimeConfig = /* @__PURE__ */ __name((config) => {
123
- return {
124
- httpAuthSchemes: config.httpAuthSchemes(),
125
- httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
126
- credentials: config.credentials()
127
- };
128
- }, "resolveHttpAuthRuntimeConfig");
109
+ }
129
110
 
130
- // src/runtimeExtensions.ts
131
- var resolveRuntimeExtensions = /* @__PURE__ */ __name((runtimeConfig, extensions) => {
132
- const extensionConfiguration = Object.assign(
133
- (0, import_region_config_resolver.getAwsRegionExtensionConfiguration)(runtimeConfig),
134
- (0, import_smithy_client.getDefaultExtensionConfiguration)(runtimeConfig),
135
- (0, import_protocol_http.getHttpHandlerExtensionConfiguration)(runtimeConfig),
136
- getHttpAuthExtensionConfiguration(runtimeConfig)
137
- );
138
- extensions.forEach((extension) => extension.configure(extensionConfiguration));
139
- return Object.assign(
140
- runtimeConfig,
141
- (0, import_region_config_resolver.resolveAwsRegionExtensionConfiguration)(extensionConfiguration),
142
- (0, import_smithy_client.resolveDefaultRuntimeConfig)(extensionConfiguration),
143
- (0, import_protocol_http.resolveHttpHandlerRuntimeConfig)(extensionConfiguration),
144
- resolveHttpAuthRuntimeConfig(extensionConfiguration)
145
- );
146
- }, "resolveRuntimeExtensions");
111
+ class BCMDashboardsServiceException extends smithyClient.ServiceException {
112
+ constructor(options) {
113
+ super(options);
114
+ Object.setPrototypeOf(this, BCMDashboardsServiceException.prototype);
115
+ }
116
+ }
147
117
 
148
- // src/BCMDashboardsClient.ts
149
- var BCMDashboardsClient = class extends import_smithy_client.Client {
150
- static {
151
- __name(this, "BCMDashboardsClient");
152
- }
153
- /**
154
- * The resolved configuration of BCMDashboardsClient class. This is resolved and normalized from the {@link BCMDashboardsClientConfig | constructor configuration interface}.
155
- */
156
- config;
157
- constructor(...[configuration]) {
158
- const _config_0 = (0, import_runtimeConfig.getRuntimeConfig)(configuration || {});
159
- super(_config_0);
160
- this.initConfig = _config_0;
161
- const _config_1 = resolveClientEndpointParameters(_config_0);
162
- const _config_2 = (0, import_middleware_user_agent.resolveUserAgentConfig)(_config_1);
163
- const _config_3 = (0, import_middleware_retry.resolveRetryConfig)(_config_2);
164
- const _config_4 = (0, import_config_resolver.resolveRegionConfig)(_config_3);
165
- const _config_5 = (0, import_middleware_host_header.resolveHostHeaderConfig)(_config_4);
166
- const _config_6 = (0, import_middleware_endpoint.resolveEndpointConfig)(_config_5);
167
- const _config_7 = (0, import_httpAuthSchemeProvider.resolveHttpAuthSchemeConfig)(_config_6);
168
- const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
169
- this.config = _config_8;
170
- this.middlewareStack.use((0, import_middleware_user_agent.getUserAgentPlugin)(this.config));
171
- this.middlewareStack.use((0, import_middleware_retry.getRetryPlugin)(this.config));
172
- this.middlewareStack.use((0, import_middleware_content_length.getContentLengthPlugin)(this.config));
173
- this.middlewareStack.use((0, import_middleware_host_header.getHostHeaderPlugin)(this.config));
174
- this.middlewareStack.use((0, import_middleware_logger.getLoggerPlugin)(this.config));
175
- this.middlewareStack.use((0, import_middleware_recursion_detection.getRecursionDetectionPlugin)(this.config));
176
- this.middlewareStack.use(
177
- (0, import_core.getHttpAuthSchemeEndpointRuleSetPlugin)(this.config, {
178
- httpAuthSchemeParametersProvider: import_httpAuthSchemeProvider.defaultBCMDashboardsHttpAuthSchemeParametersProvider,
179
- identityProviderConfigProvider: /* @__PURE__ */ __name(async (config) => new import_core.DefaultIdentityProviderConfig({
180
- "aws.auth#sigv4": config.credentials
181
- }), "identityProviderConfigProvider")
182
- })
183
- );
184
- this.middlewareStack.use((0, import_core.getHttpSigningPlugin)(this.config));
185
- }
186
- /**
187
- * Destroy underlying resources, like sockets. It's usually not necessary to do this.
188
- * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
189
- * Otherwise, sockets might stay open for quite a long time before the server terminates them.
190
- */
191
- destroy() {
192
- super.destroy();
193
- }
118
+ class AccessDeniedException extends BCMDashboardsServiceException {
119
+ name = "AccessDeniedException";
120
+ $fault = "client";
121
+ constructor(opts) {
122
+ super({
123
+ name: "AccessDeniedException",
124
+ $fault: "client",
125
+ ...opts,
126
+ });
127
+ Object.setPrototypeOf(this, AccessDeniedException.prototype);
128
+ }
129
+ }
130
+ const VisualType = {
131
+ BAR: "BAR",
132
+ LINE: "LINE",
133
+ STACK: "STACK",
194
134
  };
195
-
196
- // src/BCMDashboards.ts
197
-
198
-
199
- // src/commands/CreateDashboardCommand.ts
200
-
201
- var import_middleware_serde = require("@smithy/middleware-serde");
202
-
203
-
204
- // src/protocols/Aws_json1_0.ts
205
- var import_core2 = require("@aws-sdk/core");
206
-
207
-
208
-
209
- // src/models/BCMDashboardsServiceException.ts
210
-
211
- var BCMDashboardsServiceException = class _BCMDashboardsServiceException extends import_smithy_client.ServiceException {
212
- static {
213
- __name(this, "BCMDashboardsServiceException");
214
- }
215
- /**
216
- * @internal
217
- */
218
- constructor(options) {
219
- super(options);
220
- Object.setPrototypeOf(this, _BCMDashboardsServiceException.prototype);
221
- }
135
+ exports.DisplayConfig = void 0;
136
+ (function (DisplayConfig) {
137
+ DisplayConfig.visit = (value, visitor) => {
138
+ if (value.graph !== undefined)
139
+ return visitor.graph(value.graph);
140
+ if (value.table !== undefined)
141
+ return visitor.table(value.table);
142
+ return visitor._(value.$unknown[0], value.$unknown[1]);
143
+ };
144
+ })(exports.DisplayConfig || (exports.DisplayConfig = {}));
145
+ const MatchOption = {
146
+ ABSENT: "ABSENT",
147
+ CASE_INSENSITIVE: "CASE_INSENSITIVE",
148
+ CASE_SENSITIVE: "CASE_SENSITIVE",
149
+ CONTAINS: "CONTAINS",
150
+ ENDS_WITH: "ENDS_WITH",
151
+ EQUALS: "EQUALS",
152
+ GREATER_THAN_OR_EQUAL: "GREATER_THAN_OR_EQUAL",
153
+ STARTS_WITH: "STARTS_WITH",
154
+ };
155
+ const Dimension = {
156
+ AZ: "AZ",
157
+ BILLING_ENTITY: "BILLING_ENTITY",
158
+ CACHE_ENGINE: "CACHE_ENGINE",
159
+ COST_CATEGORY_NAME: "COST_CATEGORY_NAME",
160
+ DATABASE_ENGINE: "DATABASE_ENGINE",
161
+ DEPLOYMENT_OPTION: "DEPLOYMENT_OPTION",
162
+ INSTANCE_TYPE: "INSTANCE_TYPE",
163
+ INSTANCE_TYPE_FAMILY: "INSTANCE_TYPE_FAMILY",
164
+ LEGAL_ENTITY_NAME: "LEGAL_ENTITY_NAME",
165
+ LINKED_ACCOUNT: "LINKED_ACCOUNT",
166
+ OPERATING_SYSTEM: "OPERATING_SYSTEM",
167
+ OPERATION: "OPERATION",
168
+ PLATFORM: "PLATFORM",
169
+ PURCHASE_TYPE: "PURCHASE_TYPE",
170
+ RECORD_TYPE: "RECORD_TYPE",
171
+ REGION: "REGION",
172
+ RESERVATION_ID: "RESERVATION_ID",
173
+ RESOURCE_ID: "RESOURCE_ID",
174
+ SAVINGS_PLANS_TYPE: "SAVINGS_PLANS_TYPE",
175
+ SCOPE: "SCOPE",
176
+ SERVICE: "SERVICE",
177
+ SUBSCRIPTION_ID: "SUBSCRIPTION_ID",
178
+ TAG_KEY: "TAG_KEY",
179
+ TENANCY: "TENANCY",
180
+ USAGE_TYPE: "USAGE_TYPE",
181
+ USAGE_TYPE_GROUP: "USAGE_TYPE_GROUP",
182
+ };
183
+ const Granularity = {
184
+ DAILY: "DAILY",
185
+ HOURLY: "HOURLY",
186
+ MONTHLY: "MONTHLY",
187
+ };
188
+ const GroupDefinitionType = {
189
+ COST_CATEGORY: "COST_CATEGORY",
190
+ DIMENSION: "DIMENSION",
191
+ TAG: "TAG",
192
+ };
193
+ const MetricName = {
194
+ AmortizedCost: "AmortizedCost",
195
+ BlendedCost: "BlendedCost",
196
+ Cost: "Cost",
197
+ Hour: "Hour",
198
+ NetAmortizedCost: "NetAmortizedCost",
199
+ NetUnblendedCost: "NetUnblendedCost",
200
+ NormalizedUsageAmount: "NormalizedUsageAmount",
201
+ SpendCoveredBySavingsPlans: "SpendCoveredBySavingsPlans",
202
+ UnblendedCost: "UnblendedCost",
203
+ Unit: "Unit",
204
+ UsageQuantity: "UsageQuantity",
205
+ };
206
+ const DateTimeType = {
207
+ ABSOLUTE: "ABSOLUTE",
208
+ RELATIVE: "RELATIVE",
209
+ };
210
+ class InternalServerException extends BCMDashboardsServiceException {
211
+ name = "InternalServerException";
212
+ $fault = "server";
213
+ constructor(opts) {
214
+ super({
215
+ name: "InternalServerException",
216
+ $fault: "server",
217
+ ...opts,
218
+ });
219
+ Object.setPrototypeOf(this, InternalServerException.prototype);
220
+ }
221
+ }
222
+ class ServiceQuotaExceededException extends BCMDashboardsServiceException {
223
+ name = "ServiceQuotaExceededException";
224
+ $fault = "client";
225
+ constructor(opts) {
226
+ super({
227
+ name: "ServiceQuotaExceededException",
228
+ $fault: "client",
229
+ ...opts,
230
+ });
231
+ Object.setPrototypeOf(this, ServiceQuotaExceededException.prototype);
232
+ }
233
+ }
234
+ class ThrottlingException extends BCMDashboardsServiceException {
235
+ name = "ThrottlingException";
236
+ $fault = "client";
237
+ constructor(opts) {
238
+ super({
239
+ name: "ThrottlingException",
240
+ $fault: "client",
241
+ ...opts,
242
+ });
243
+ Object.setPrototypeOf(this, ThrottlingException.prototype);
244
+ }
245
+ }
246
+ class ValidationException extends BCMDashboardsServiceException {
247
+ name = "ValidationException";
248
+ $fault = "client";
249
+ constructor(opts) {
250
+ super({
251
+ name: "ValidationException",
252
+ $fault: "client",
253
+ ...opts,
254
+ });
255
+ Object.setPrototypeOf(this, ValidationException.prototype);
256
+ }
257
+ }
258
+ const DashboardType = {
259
+ CUSTOM: "CUSTOM",
222
260
  };
261
+ class ResourceNotFoundException extends BCMDashboardsServiceException {
262
+ name = "ResourceNotFoundException";
263
+ $fault = "client";
264
+ constructor(opts) {
265
+ super({
266
+ name: "ResourceNotFoundException",
267
+ $fault: "client",
268
+ ...opts,
269
+ });
270
+ Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
271
+ }
272
+ }
273
+ exports.QueryParameters = void 0;
274
+ (function (QueryParameters) {
275
+ QueryParameters.visit = (value, visitor) => {
276
+ if (value.costAndUsage !== undefined)
277
+ return visitor.costAndUsage(value.costAndUsage);
278
+ if (value.savingsPlansCoverage !== undefined)
279
+ return visitor.savingsPlansCoverage(value.savingsPlansCoverage);
280
+ if (value.savingsPlansUtilization !== undefined)
281
+ return visitor.savingsPlansUtilization(value.savingsPlansUtilization);
282
+ if (value.reservationCoverage !== undefined)
283
+ return visitor.reservationCoverage(value.reservationCoverage);
284
+ if (value.reservationUtilization !== undefined)
285
+ return visitor.reservationUtilization(value.reservationUtilization);
286
+ return visitor._(value.$unknown[0], value.$unknown[1]);
287
+ };
288
+ })(exports.QueryParameters || (exports.QueryParameters = {}));
223
289
 
224
- // src/models/models_0.ts
225
- var AccessDeniedException = class _AccessDeniedException extends BCMDashboardsServiceException {
226
- static {
227
- __name(this, "AccessDeniedException");
228
- }
229
- name = "AccessDeniedException";
230
- $fault = "client";
231
- /**
232
- * @internal
233
- */
234
- constructor(opts) {
235
- super({
236
- name: "AccessDeniedException",
237
- $fault: "client",
238
- ...opts
290
+ const se_CreateDashboardCommand = async (input, context) => {
291
+ const headers = sharedHeaders("CreateDashboard");
292
+ let body;
293
+ body = JSON.stringify(se_CreateDashboardRequest(input));
294
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
295
+ };
296
+ const se_DeleteDashboardCommand = async (input, context) => {
297
+ const headers = sharedHeaders("DeleteDashboard");
298
+ let body;
299
+ body = JSON.stringify(smithyClient._json(input));
300
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
301
+ };
302
+ const se_GetDashboardCommand = async (input, context) => {
303
+ const headers = sharedHeaders("GetDashboard");
304
+ let body;
305
+ body = JSON.stringify(smithyClient._json(input));
306
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
307
+ };
308
+ const se_GetResourcePolicyCommand = async (input, context) => {
309
+ const headers = sharedHeaders("GetResourcePolicy");
310
+ let body;
311
+ body = JSON.stringify(smithyClient._json(input));
312
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
313
+ };
314
+ const se_ListDashboardsCommand = async (input, context) => {
315
+ const headers = sharedHeaders("ListDashboards");
316
+ let body;
317
+ body = JSON.stringify(smithyClient._json(input));
318
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
319
+ };
320
+ const se_ListTagsForResourceCommand = async (input, context) => {
321
+ const headers = sharedHeaders("ListTagsForResource");
322
+ let body;
323
+ body = JSON.stringify(smithyClient._json(input));
324
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
325
+ };
326
+ const se_TagResourceCommand = async (input, context) => {
327
+ const headers = sharedHeaders("TagResource");
328
+ let body;
329
+ body = JSON.stringify(smithyClient._json(input));
330
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
331
+ };
332
+ const se_UntagResourceCommand = async (input, context) => {
333
+ const headers = sharedHeaders("UntagResource");
334
+ let body;
335
+ body = JSON.stringify(smithyClient._json(input));
336
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
337
+ };
338
+ const se_UpdateDashboardCommand = async (input, context) => {
339
+ const headers = sharedHeaders("UpdateDashboard");
340
+ let body;
341
+ body = JSON.stringify(se_UpdateDashboardRequest(input));
342
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
343
+ };
344
+ const de_CreateDashboardCommand = async (output, context) => {
345
+ if (output.statusCode >= 300) {
346
+ return de_CommandError(output, context);
347
+ }
348
+ const data = await core$1.parseJsonBody(output.body, context);
349
+ let contents = {};
350
+ contents = smithyClient._json(data);
351
+ const response = {
352
+ $metadata: deserializeMetadata(output),
353
+ ...contents,
354
+ };
355
+ return response;
356
+ };
357
+ const de_DeleteDashboardCommand = async (output, context) => {
358
+ if (output.statusCode >= 300) {
359
+ return de_CommandError(output, context);
360
+ }
361
+ const data = await core$1.parseJsonBody(output.body, context);
362
+ let contents = {};
363
+ contents = smithyClient._json(data);
364
+ const response = {
365
+ $metadata: deserializeMetadata(output),
366
+ ...contents,
367
+ };
368
+ return response;
369
+ };
370
+ const de_GetDashboardCommand = async (output, context) => {
371
+ if (output.statusCode >= 300) {
372
+ return de_CommandError(output, context);
373
+ }
374
+ const data = await core$1.parseJsonBody(output.body, context);
375
+ let contents = {};
376
+ contents = de_GetDashboardResponse(data);
377
+ const response = {
378
+ $metadata: deserializeMetadata(output),
379
+ ...contents,
380
+ };
381
+ return response;
382
+ };
383
+ const de_GetResourcePolicyCommand = async (output, context) => {
384
+ if (output.statusCode >= 300) {
385
+ return de_CommandError(output, context);
386
+ }
387
+ const data = await core$1.parseJsonBody(output.body, context);
388
+ let contents = {};
389
+ contents = smithyClient._json(data);
390
+ const response = {
391
+ $metadata: deserializeMetadata(output),
392
+ ...contents,
393
+ };
394
+ return response;
395
+ };
396
+ const de_ListDashboardsCommand = async (output, context) => {
397
+ if (output.statusCode >= 300) {
398
+ return de_CommandError(output, context);
399
+ }
400
+ const data = await core$1.parseJsonBody(output.body, context);
401
+ let contents = {};
402
+ contents = de_ListDashboardsResponse(data);
403
+ const response = {
404
+ $metadata: deserializeMetadata(output),
405
+ ...contents,
406
+ };
407
+ return response;
408
+ };
409
+ const de_ListTagsForResourceCommand = async (output, context) => {
410
+ if (output.statusCode >= 300) {
411
+ return de_CommandError(output, context);
412
+ }
413
+ const data = await core$1.parseJsonBody(output.body, context);
414
+ let contents = {};
415
+ contents = smithyClient._json(data);
416
+ const response = {
417
+ $metadata: deserializeMetadata(output),
418
+ ...contents,
419
+ };
420
+ return response;
421
+ };
422
+ const de_TagResourceCommand = async (output, context) => {
423
+ if (output.statusCode >= 300) {
424
+ return de_CommandError(output, context);
425
+ }
426
+ const data = await core$1.parseJsonBody(output.body, context);
427
+ let contents = {};
428
+ contents = smithyClient._json(data);
429
+ const response = {
430
+ $metadata: deserializeMetadata(output),
431
+ ...contents,
432
+ };
433
+ return response;
434
+ };
435
+ const de_UntagResourceCommand = async (output, context) => {
436
+ if (output.statusCode >= 300) {
437
+ return de_CommandError(output, context);
438
+ }
439
+ const data = await core$1.parseJsonBody(output.body, context);
440
+ let contents = {};
441
+ contents = smithyClient._json(data);
442
+ const response = {
443
+ $metadata: deserializeMetadata(output),
444
+ ...contents,
445
+ };
446
+ return response;
447
+ };
448
+ const de_UpdateDashboardCommand = async (output, context) => {
449
+ if (output.statusCode >= 300) {
450
+ return de_CommandError(output, context);
451
+ }
452
+ const data = await core$1.parseJsonBody(output.body, context);
453
+ let contents = {};
454
+ contents = smithyClient._json(data);
455
+ const response = {
456
+ $metadata: deserializeMetadata(output),
457
+ ...contents,
458
+ };
459
+ return response;
460
+ };
461
+ const de_CommandError = async (output, context) => {
462
+ const parsedOutput = {
463
+ ...output,
464
+ body: await core$1.parseJsonErrorBody(output.body, context),
465
+ };
466
+ const errorCode = core$1.loadRestJsonErrorCode(output, parsedOutput.body);
467
+ switch (errorCode) {
468
+ case "AccessDeniedException":
469
+ case "com.amazonaws.bcmdashboards#AccessDeniedException":
470
+ throw await de_AccessDeniedExceptionRes(parsedOutput);
471
+ case "InternalServerException":
472
+ case "com.amazonaws.bcmdashboards#InternalServerException":
473
+ throw await de_InternalServerExceptionRes(parsedOutput);
474
+ case "ServiceQuotaExceededException":
475
+ case "com.amazonaws.bcmdashboards#ServiceQuotaExceededException":
476
+ throw await de_ServiceQuotaExceededExceptionRes(parsedOutput);
477
+ case "ThrottlingException":
478
+ case "com.amazonaws.bcmdashboards#ThrottlingException":
479
+ throw await de_ThrottlingExceptionRes(parsedOutput);
480
+ case "ValidationException":
481
+ case "com.amazonaws.bcmdashboards#ValidationException":
482
+ throw await de_ValidationExceptionRes(parsedOutput);
483
+ case "ResourceNotFoundException":
484
+ case "com.amazonaws.bcmdashboards#ResourceNotFoundException":
485
+ throw await de_ResourceNotFoundExceptionRes(parsedOutput);
486
+ default:
487
+ const parsedBody = parsedOutput.body;
488
+ return throwDefaultError({
489
+ output,
490
+ parsedBody,
491
+ errorCode,
492
+ });
493
+ }
494
+ };
495
+ const de_AccessDeniedExceptionRes = async (parsedOutput, context) => {
496
+ const body = parsedOutput.body;
497
+ const deserialized = smithyClient._json(body);
498
+ const exception = new AccessDeniedException({
499
+ $metadata: deserializeMetadata(parsedOutput),
500
+ ...deserialized,
239
501
  });
240
- Object.setPrototypeOf(this, _AccessDeniedException.prototype);
241
- }
242
- };
243
- var VisualType = {
244
- BAR: "BAR",
245
- LINE: "LINE",
246
- STACK: "STACK"
247
- };
248
- var DisplayConfig;
249
- ((DisplayConfig3) => {
250
- DisplayConfig3.visit = /* @__PURE__ */ __name((value, visitor) => {
251
- if (value.graph !== void 0) return visitor.graph(value.graph);
252
- if (value.table !== void 0) return visitor.table(value.table);
253
- return visitor._(value.$unknown[0], value.$unknown[1]);
254
- }, "visit");
255
- })(DisplayConfig || (DisplayConfig = {}));
256
- var MatchOption = {
257
- ABSENT: "ABSENT",
258
- CASE_INSENSITIVE: "CASE_INSENSITIVE",
259
- CASE_SENSITIVE: "CASE_SENSITIVE",
260
- CONTAINS: "CONTAINS",
261
- ENDS_WITH: "ENDS_WITH",
262
- EQUALS: "EQUALS",
263
- GREATER_THAN_OR_EQUAL: "GREATER_THAN_OR_EQUAL",
264
- STARTS_WITH: "STARTS_WITH"
265
- };
266
- var Dimension = {
267
- AZ: "AZ",
268
- BILLING_ENTITY: "BILLING_ENTITY",
269
- CACHE_ENGINE: "CACHE_ENGINE",
270
- COST_CATEGORY_NAME: "COST_CATEGORY_NAME",
271
- DATABASE_ENGINE: "DATABASE_ENGINE",
272
- DEPLOYMENT_OPTION: "DEPLOYMENT_OPTION",
273
- INSTANCE_TYPE: "INSTANCE_TYPE",
274
- INSTANCE_TYPE_FAMILY: "INSTANCE_TYPE_FAMILY",
275
- LEGAL_ENTITY_NAME: "LEGAL_ENTITY_NAME",
276
- LINKED_ACCOUNT: "LINKED_ACCOUNT",
277
- OPERATING_SYSTEM: "OPERATING_SYSTEM",
278
- OPERATION: "OPERATION",
279
- PLATFORM: "PLATFORM",
280
- PURCHASE_TYPE: "PURCHASE_TYPE",
281
- RECORD_TYPE: "RECORD_TYPE",
282
- REGION: "REGION",
283
- RESERVATION_ID: "RESERVATION_ID",
284
- RESOURCE_ID: "RESOURCE_ID",
285
- SAVINGS_PLANS_TYPE: "SAVINGS_PLANS_TYPE",
286
- SCOPE: "SCOPE",
287
- SERVICE: "SERVICE",
288
- SUBSCRIPTION_ID: "SUBSCRIPTION_ID",
289
- TAG_KEY: "TAG_KEY",
290
- TENANCY: "TENANCY",
291
- USAGE_TYPE: "USAGE_TYPE",
292
- USAGE_TYPE_GROUP: "USAGE_TYPE_GROUP"
293
- };
294
- var Granularity = {
295
- DAILY: "DAILY",
296
- HOURLY: "HOURLY",
297
- MONTHLY: "MONTHLY"
298
- };
299
- var GroupDefinitionType = {
300
- COST_CATEGORY: "COST_CATEGORY",
301
- DIMENSION: "DIMENSION",
302
- TAG: "TAG"
303
- };
304
- var MetricName = {
305
- AmortizedCost: "AmortizedCost",
306
- BlendedCost: "BlendedCost",
307
- Cost: "Cost",
308
- Hour: "Hour",
309
- NetAmortizedCost: "NetAmortizedCost",
310
- NetUnblendedCost: "NetUnblendedCost",
311
- NormalizedUsageAmount: "NormalizedUsageAmount",
312
- SpendCoveredBySavingsPlans: "SpendCoveredBySavingsPlans",
313
- UnblendedCost: "UnblendedCost",
314
- Unit: "Unit",
315
- UsageQuantity: "UsageQuantity"
316
- };
317
- var DateTimeType = {
318
- ABSOLUTE: "ABSOLUTE",
319
- RELATIVE: "RELATIVE"
320
- };
321
- var InternalServerException = class _InternalServerException extends BCMDashboardsServiceException {
322
- static {
323
- __name(this, "InternalServerException");
324
- }
325
- name = "InternalServerException";
326
- $fault = "server";
327
- /**
328
- * @internal
329
- */
330
- constructor(opts) {
331
- super({
332
- name: "InternalServerException",
333
- $fault: "server",
334
- ...opts
502
+ return smithyClient.decorateServiceException(exception, body);
503
+ };
504
+ const de_InternalServerExceptionRes = async (parsedOutput, context) => {
505
+ const body = parsedOutput.body;
506
+ const deserialized = smithyClient._json(body);
507
+ const exception = new InternalServerException({
508
+ $metadata: deserializeMetadata(parsedOutput),
509
+ ...deserialized,
335
510
  });
336
- Object.setPrototypeOf(this, _InternalServerException.prototype);
337
- }
338
- };
339
- var ServiceQuotaExceededException = class _ServiceQuotaExceededException extends BCMDashboardsServiceException {
340
- static {
341
- __name(this, "ServiceQuotaExceededException");
342
- }
343
- name = "ServiceQuotaExceededException";
344
- $fault = "client";
345
- /**
346
- * @internal
347
- */
348
- constructor(opts) {
349
- super({
350
- name: "ServiceQuotaExceededException",
351
- $fault: "client",
352
- ...opts
511
+ return smithyClient.decorateServiceException(exception, body);
512
+ };
513
+ const de_ResourceNotFoundExceptionRes = async (parsedOutput, context) => {
514
+ const body = parsedOutput.body;
515
+ const deserialized = smithyClient._json(body);
516
+ const exception = new ResourceNotFoundException({
517
+ $metadata: deserializeMetadata(parsedOutput),
518
+ ...deserialized,
353
519
  });
354
- Object.setPrototypeOf(this, _ServiceQuotaExceededException.prototype);
355
- }
356
- };
357
- var ThrottlingException = class _ThrottlingException extends BCMDashboardsServiceException {
358
- static {
359
- __name(this, "ThrottlingException");
360
- }
361
- name = "ThrottlingException";
362
- $fault = "client";
363
- /**
364
- * @internal
365
- */
366
- constructor(opts) {
367
- super({
368
- name: "ThrottlingException",
369
- $fault: "client",
370
- ...opts
520
+ return smithyClient.decorateServiceException(exception, body);
521
+ };
522
+ const de_ServiceQuotaExceededExceptionRes = async (parsedOutput, context) => {
523
+ const body = parsedOutput.body;
524
+ const deserialized = smithyClient._json(body);
525
+ const exception = new ServiceQuotaExceededException({
526
+ $metadata: deserializeMetadata(parsedOutput),
527
+ ...deserialized,
371
528
  });
372
- Object.setPrototypeOf(this, _ThrottlingException.prototype);
373
- }
374
- };
375
- var ValidationException = class _ValidationException extends BCMDashboardsServiceException {
376
- static {
377
- __name(this, "ValidationException");
378
- }
379
- name = "ValidationException";
380
- $fault = "client";
381
- /**
382
- * @internal
383
- */
384
- constructor(opts) {
385
- super({
386
- name: "ValidationException",
387
- $fault: "client",
388
- ...opts
529
+ return smithyClient.decorateServiceException(exception, body);
530
+ };
531
+ const de_ThrottlingExceptionRes = async (parsedOutput, context) => {
532
+ const body = parsedOutput.body;
533
+ const deserialized = smithyClient._json(body);
534
+ const exception = new ThrottlingException({
535
+ $metadata: deserializeMetadata(parsedOutput),
536
+ ...deserialized,
389
537
  });
390
- Object.setPrototypeOf(this, _ValidationException.prototype);
391
- }
392
- };
393
- var DashboardType = {
394
- CUSTOM: "CUSTOM"
395
- };
396
- var ResourceNotFoundException = class _ResourceNotFoundException extends BCMDashboardsServiceException {
397
- static {
398
- __name(this, "ResourceNotFoundException");
399
- }
400
- name = "ResourceNotFoundException";
401
- $fault = "client";
402
- /**
403
- * @internal
404
- */
405
- constructor(opts) {
406
- super({
407
- name: "ResourceNotFoundException",
408
- $fault: "client",
409
- ...opts
538
+ return smithyClient.decorateServiceException(exception, body);
539
+ };
540
+ const de_ValidationExceptionRes = async (parsedOutput, context) => {
541
+ const body = parsedOutput.body;
542
+ const deserialized = smithyClient._json(body);
543
+ const exception = new ValidationException({
544
+ $metadata: deserializeMetadata(parsedOutput),
545
+ ...deserialized,
410
546
  });
411
- Object.setPrototypeOf(this, _ResourceNotFoundException.prototype);
412
- }
413
- };
414
- var QueryParameters;
415
- ((QueryParameters2) => {
416
- QueryParameters2.visit = /* @__PURE__ */ __name((value, visitor) => {
417
- if (value.costAndUsage !== void 0) return visitor.costAndUsage(value.costAndUsage);
418
- if (value.savingsPlansCoverage !== void 0) return visitor.savingsPlansCoverage(value.savingsPlansCoverage);
419
- if (value.savingsPlansUtilization !== void 0)
420
- return visitor.savingsPlansUtilization(value.savingsPlansUtilization);
421
- if (value.reservationCoverage !== void 0) return visitor.reservationCoverage(value.reservationCoverage);
422
- if (value.reservationUtilization !== void 0) return visitor.reservationUtilization(value.reservationUtilization);
423
- return visitor._(value.$unknown[0], value.$unknown[1]);
424
- }, "visit");
425
- })(QueryParameters || (QueryParameters = {}));
426
-
427
- // src/protocols/Aws_json1_0.ts
428
- var se_CreateDashboardCommand = /* @__PURE__ */ __name(async (input, context) => {
429
- const headers = sharedHeaders("CreateDashboard");
430
- let body;
431
- body = JSON.stringify(se_CreateDashboardRequest(input, context));
432
- return buildHttpRpcRequest(context, headers, "/", void 0, body);
433
- }, "se_CreateDashboardCommand");
434
- var se_DeleteDashboardCommand = /* @__PURE__ */ __name(async (input, context) => {
435
- const headers = sharedHeaders("DeleteDashboard");
436
- let body;
437
- body = JSON.stringify((0, import_smithy_client._json)(input));
438
- return buildHttpRpcRequest(context, headers, "/", void 0, body);
439
- }, "se_DeleteDashboardCommand");
440
- var se_GetDashboardCommand = /* @__PURE__ */ __name(async (input, context) => {
441
- const headers = sharedHeaders("GetDashboard");
442
- let body;
443
- body = JSON.stringify((0, import_smithy_client._json)(input));
444
- return buildHttpRpcRequest(context, headers, "/", void 0, body);
445
- }, "se_GetDashboardCommand");
446
- var se_GetResourcePolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
447
- const headers = sharedHeaders("GetResourcePolicy");
448
- let body;
449
- body = JSON.stringify((0, import_smithy_client._json)(input));
450
- return buildHttpRpcRequest(context, headers, "/", void 0, body);
451
- }, "se_GetResourcePolicyCommand");
452
- var se_ListDashboardsCommand = /* @__PURE__ */ __name(async (input, context) => {
453
- const headers = sharedHeaders("ListDashboards");
454
- let body;
455
- body = JSON.stringify((0, import_smithy_client._json)(input));
456
- return buildHttpRpcRequest(context, headers, "/", void 0, body);
457
- }, "se_ListDashboardsCommand");
458
- var se_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
459
- const headers = sharedHeaders("ListTagsForResource");
460
- let body;
461
- body = JSON.stringify((0, import_smithy_client._json)(input));
462
- return buildHttpRpcRequest(context, headers, "/", void 0, body);
463
- }, "se_ListTagsForResourceCommand");
464
- var se_TagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
465
- const headers = sharedHeaders("TagResource");
466
- let body;
467
- body = JSON.stringify((0, import_smithy_client._json)(input));
468
- return buildHttpRpcRequest(context, headers, "/", void 0, body);
469
- }, "se_TagResourceCommand");
470
- var se_UntagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
471
- const headers = sharedHeaders("UntagResource");
472
- let body;
473
- body = JSON.stringify((0, import_smithy_client._json)(input));
474
- return buildHttpRpcRequest(context, headers, "/", void 0, body);
475
- }, "se_UntagResourceCommand");
476
- var se_UpdateDashboardCommand = /* @__PURE__ */ __name(async (input, context) => {
477
- const headers = sharedHeaders("UpdateDashboard");
478
- let body;
479
- body = JSON.stringify(se_UpdateDashboardRequest(input, context));
480
- return buildHttpRpcRequest(context, headers, "/", void 0, body);
481
- }, "se_UpdateDashboardCommand");
482
- var de_CreateDashboardCommand = /* @__PURE__ */ __name(async (output, context) => {
483
- if (output.statusCode >= 300) {
484
- return de_CommandError(output, context);
485
- }
486
- const data = await (0, import_core2.parseJsonBody)(output.body, context);
487
- let contents = {};
488
- contents = (0, import_smithy_client._json)(data);
489
- const response = {
490
- $metadata: deserializeMetadata(output),
491
- ...contents
492
- };
493
- return response;
494
- }, "de_CreateDashboardCommand");
495
- var de_DeleteDashboardCommand = /* @__PURE__ */ __name(async (output, context) => {
496
- if (output.statusCode >= 300) {
497
- return de_CommandError(output, context);
498
- }
499
- const data = await (0, import_core2.parseJsonBody)(output.body, context);
500
- let contents = {};
501
- contents = (0, import_smithy_client._json)(data);
502
- const response = {
503
- $metadata: deserializeMetadata(output),
504
- ...contents
505
- };
506
- return response;
507
- }, "de_DeleteDashboardCommand");
508
- var de_GetDashboardCommand = /* @__PURE__ */ __name(async (output, context) => {
509
- if (output.statusCode >= 300) {
510
- return de_CommandError(output, context);
511
- }
512
- const data = await (0, import_core2.parseJsonBody)(output.body, context);
513
- let contents = {};
514
- contents = de_GetDashboardResponse(data, context);
515
- const response = {
516
- $metadata: deserializeMetadata(output),
517
- ...contents
518
- };
519
- return response;
520
- }, "de_GetDashboardCommand");
521
- var de_GetResourcePolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
522
- if (output.statusCode >= 300) {
523
- return de_CommandError(output, context);
524
- }
525
- const data = await (0, import_core2.parseJsonBody)(output.body, context);
526
- let contents = {};
527
- contents = (0, import_smithy_client._json)(data);
528
- const response = {
529
- $metadata: deserializeMetadata(output),
530
- ...contents
531
- };
532
- return response;
533
- }, "de_GetResourcePolicyCommand");
534
- var de_ListDashboardsCommand = /* @__PURE__ */ __name(async (output, context) => {
535
- if (output.statusCode >= 300) {
536
- return de_CommandError(output, context);
537
- }
538
- const data = await (0, import_core2.parseJsonBody)(output.body, context);
539
- let contents = {};
540
- contents = de_ListDashboardsResponse(data, context);
541
- const response = {
542
- $metadata: deserializeMetadata(output),
543
- ...contents
544
- };
545
- return response;
546
- }, "de_ListDashboardsCommand");
547
- var de_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
548
- if (output.statusCode >= 300) {
549
- return de_CommandError(output, context);
550
- }
551
- const data = await (0, import_core2.parseJsonBody)(output.body, context);
552
- let contents = {};
553
- contents = (0, import_smithy_client._json)(data);
554
- const response = {
555
- $metadata: deserializeMetadata(output),
556
- ...contents
557
- };
558
- return response;
559
- }, "de_ListTagsForResourceCommand");
560
- var de_TagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
561
- if (output.statusCode >= 300) {
562
- return de_CommandError(output, context);
563
- }
564
- const data = await (0, import_core2.parseJsonBody)(output.body, context);
565
- let contents = {};
566
- contents = (0, import_smithy_client._json)(data);
567
- const response = {
568
- $metadata: deserializeMetadata(output),
569
- ...contents
570
- };
571
- return response;
572
- }, "de_TagResourceCommand");
573
- var de_UntagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
574
- if (output.statusCode >= 300) {
575
- return de_CommandError(output, context);
576
- }
577
- const data = await (0, import_core2.parseJsonBody)(output.body, context);
578
- let contents = {};
579
- contents = (0, import_smithy_client._json)(data);
580
- const response = {
581
- $metadata: deserializeMetadata(output),
582
- ...contents
583
- };
584
- return response;
585
- }, "de_UntagResourceCommand");
586
- var de_UpdateDashboardCommand = /* @__PURE__ */ __name(async (output, context) => {
587
- if (output.statusCode >= 300) {
588
- return de_CommandError(output, context);
589
- }
590
- const data = await (0, import_core2.parseJsonBody)(output.body, context);
591
- let contents = {};
592
- contents = (0, import_smithy_client._json)(data);
593
- const response = {
594
- $metadata: deserializeMetadata(output),
595
- ...contents
596
- };
597
- return response;
598
- }, "de_UpdateDashboardCommand");
599
- var de_CommandError = /* @__PURE__ */ __name(async (output, context) => {
600
- const parsedOutput = {
601
- ...output,
602
- body: await (0, import_core2.parseJsonErrorBody)(output.body, context)
603
- };
604
- const errorCode = (0, import_core2.loadRestJsonErrorCode)(output, parsedOutput.body);
605
- switch (errorCode) {
606
- case "AccessDeniedException":
607
- case "com.amazonaws.bcmdashboards#AccessDeniedException":
608
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
609
- case "InternalServerException":
610
- case "com.amazonaws.bcmdashboards#InternalServerException":
611
- throw await de_InternalServerExceptionRes(parsedOutput, context);
612
- case "ServiceQuotaExceededException":
613
- case "com.amazonaws.bcmdashboards#ServiceQuotaExceededException":
614
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
615
- case "ThrottlingException":
616
- case "com.amazonaws.bcmdashboards#ThrottlingException":
617
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
618
- case "ValidationException":
619
- case "com.amazonaws.bcmdashboards#ValidationException":
620
- throw await de_ValidationExceptionRes(parsedOutput, context);
621
- case "ResourceNotFoundException":
622
- case "com.amazonaws.bcmdashboards#ResourceNotFoundException":
623
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
624
- default:
625
- const parsedBody = parsedOutput.body;
626
- return throwDefaultError({
627
- output,
628
- parsedBody,
629
- errorCode
630
- });
631
- }
632
- }, "de_CommandError");
633
- var de_AccessDeniedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
634
- const body = parsedOutput.body;
635
- const deserialized = (0, import_smithy_client._json)(body);
636
- const exception = new AccessDeniedException({
637
- $metadata: deserializeMetadata(parsedOutput),
638
- ...deserialized
639
- });
640
- return (0, import_smithy_client.decorateServiceException)(exception, body);
641
- }, "de_AccessDeniedExceptionRes");
642
- var de_InternalServerExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
643
- const body = parsedOutput.body;
644
- const deserialized = (0, import_smithy_client._json)(body);
645
- const exception = new InternalServerException({
646
- $metadata: deserializeMetadata(parsedOutput),
647
- ...deserialized
648
- });
649
- return (0, import_smithy_client.decorateServiceException)(exception, body);
650
- }, "de_InternalServerExceptionRes");
651
- var de_ResourceNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
652
- const body = parsedOutput.body;
653
- const deserialized = (0, import_smithy_client._json)(body);
654
- const exception = new ResourceNotFoundException({
655
- $metadata: deserializeMetadata(parsedOutput),
656
- ...deserialized
657
- });
658
- return (0, import_smithy_client.decorateServiceException)(exception, body);
659
- }, "de_ResourceNotFoundExceptionRes");
660
- var de_ServiceQuotaExceededExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
661
- const body = parsedOutput.body;
662
- const deserialized = (0, import_smithy_client._json)(body);
663
- const exception = new ServiceQuotaExceededException({
664
- $metadata: deserializeMetadata(parsedOutput),
665
- ...deserialized
666
- });
667
- return (0, import_smithy_client.decorateServiceException)(exception, body);
668
- }, "de_ServiceQuotaExceededExceptionRes");
669
- var de_ThrottlingExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
670
- const body = parsedOutput.body;
671
- const deserialized = (0, import_smithy_client._json)(body);
672
- const exception = new ThrottlingException({
673
- $metadata: deserializeMetadata(parsedOutput),
674
- ...deserialized
675
- });
676
- return (0, import_smithy_client.decorateServiceException)(exception, body);
677
- }, "de_ThrottlingExceptionRes");
678
- var de_ValidationExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
679
- const body = parsedOutput.body;
680
- const deserialized = (0, import_smithy_client._json)(body);
681
- const exception = new ValidationException({
682
- $metadata: deserializeMetadata(parsedOutput),
683
- ...deserialized
684
- });
685
- return (0, import_smithy_client.decorateServiceException)(exception, body);
686
- }, "de_ValidationExceptionRes");
687
- var se_CostAndUsageQuery = /* @__PURE__ */ __name((input, context) => {
688
- return (0, import_smithy_client.take)(input, {
689
- filter: /* @__PURE__ */ __name((_) => se_Expression(_, context), "filter"),
690
- granularity: [],
691
- groupBy: import_smithy_client._json,
692
- metrics: import_smithy_client._json,
693
- timeRange: import_smithy_client._json
694
- });
695
- }, "se_CostAndUsageQuery");
696
- var se_CreateDashboardRequest = /* @__PURE__ */ __name((input, context) => {
697
- return (0, import_smithy_client.take)(input, {
698
- description: [],
699
- name: [],
700
- resourceTags: import_smithy_client._json,
701
- widgets: /* @__PURE__ */ __name((_) => se_WidgetList(_, context), "widgets")
702
- });
703
- }, "se_CreateDashboardRequest");
704
- var se_Expression = /* @__PURE__ */ __name((input, context) => {
705
- return (0, import_smithy_client.take)(input, {
706
- and: /* @__PURE__ */ __name((_) => se_Expressions(_, context), "and"),
707
- costCategories: import_smithy_client._json,
708
- dimensions: import_smithy_client._json,
709
- not: /* @__PURE__ */ __name((_) => se_Expression(_, context), "not"),
710
- or: /* @__PURE__ */ __name((_) => se_Expressions(_, context), "or"),
711
- tags: import_smithy_client._json
712
- });
713
- }, "se_Expression");
714
- var se_Expressions = /* @__PURE__ */ __name((input, context) => {
715
- return input.filter((e) => e != null).map((entry) => {
716
- return se_Expression(entry, context);
717
- });
718
- }, "se_Expressions");
719
- var se_QueryParameters = /* @__PURE__ */ __name((input, context) => {
720
- return QueryParameters.visit(input, {
721
- costAndUsage: /* @__PURE__ */ __name((value) => ({ costAndUsage: se_CostAndUsageQuery(value, context) }), "costAndUsage"),
722
- reservationCoverage: /* @__PURE__ */ __name((value) => ({ reservationCoverage: se_ReservationCoverageQuery(value, context) }), "reservationCoverage"),
723
- reservationUtilization: /* @__PURE__ */ __name((value) => ({ reservationUtilization: se_ReservationUtilizationQuery(value, context) }), "reservationUtilization"),
724
- savingsPlansCoverage: /* @__PURE__ */ __name((value) => ({ savingsPlansCoverage: se_SavingsPlansCoverageQuery(value, context) }), "savingsPlansCoverage"),
725
- savingsPlansUtilization: /* @__PURE__ */ __name((value) => ({ savingsPlansUtilization: se_SavingsPlansUtilizationQuery(value, context) }), "savingsPlansUtilization"),
726
- _: /* @__PURE__ */ __name((name, value) => ({ [name]: value }), "_")
727
- });
728
- }, "se_QueryParameters");
729
- var se_ReservationCoverageQuery = /* @__PURE__ */ __name((input, context) => {
730
- return (0, import_smithy_client.take)(input, {
731
- filter: /* @__PURE__ */ __name((_) => se_Expression(_, context), "filter"),
732
- granularity: [],
733
- groupBy: import_smithy_client._json,
734
- metrics: import_smithy_client._json,
735
- timeRange: import_smithy_client._json
736
- });
737
- }, "se_ReservationCoverageQuery");
738
- var se_ReservationUtilizationQuery = /* @__PURE__ */ __name((input, context) => {
739
- return (0, import_smithy_client.take)(input, {
740
- filter: /* @__PURE__ */ __name((_) => se_Expression(_, context), "filter"),
741
- granularity: [],
742
- groupBy: import_smithy_client._json,
743
- timeRange: import_smithy_client._json
744
- });
745
- }, "se_ReservationUtilizationQuery");
746
- var se_SavingsPlansCoverageQuery = /* @__PURE__ */ __name((input, context) => {
747
- return (0, import_smithy_client.take)(input, {
748
- filter: /* @__PURE__ */ __name((_) => se_Expression(_, context), "filter"),
749
- granularity: [],
750
- groupBy: import_smithy_client._json,
751
- metrics: import_smithy_client._json,
752
- timeRange: import_smithy_client._json
753
- });
754
- }, "se_SavingsPlansCoverageQuery");
755
- var se_SavingsPlansUtilizationQuery = /* @__PURE__ */ __name((input, context) => {
756
- return (0, import_smithy_client.take)(input, {
757
- filter: /* @__PURE__ */ __name((_) => se_Expression(_, context), "filter"),
758
- granularity: [],
759
- timeRange: import_smithy_client._json
760
- });
761
- }, "se_SavingsPlansUtilizationQuery");
762
- var se_UpdateDashboardRequest = /* @__PURE__ */ __name((input, context) => {
763
- return (0, import_smithy_client.take)(input, {
764
- arn: [],
765
- description: [],
766
- name: [],
767
- widgets: /* @__PURE__ */ __name((_) => se_WidgetList(_, context), "widgets")
768
- });
769
- }, "se_UpdateDashboardRequest");
770
- var se_Widget = /* @__PURE__ */ __name((input, context) => {
771
- return (0, import_smithy_client.take)(input, {
772
- configs: /* @__PURE__ */ __name((_) => se_WidgetConfigList(_, context), "configs"),
773
- description: [],
774
- height: [],
775
- horizontalOffset: [],
776
- title: [],
777
- width: []
778
- });
779
- }, "se_Widget");
780
- var se_WidgetConfig = /* @__PURE__ */ __name((input, context) => {
781
- return (0, import_smithy_client.take)(input, {
782
- displayConfig: import_smithy_client._json,
783
- queryParameters: /* @__PURE__ */ __name((_) => se_QueryParameters(_, context), "queryParameters")
784
- });
785
- }, "se_WidgetConfig");
786
- var se_WidgetConfigList = /* @__PURE__ */ __name((input, context) => {
787
- return input.filter((e) => e != null).map((entry) => {
788
- return se_WidgetConfig(entry, context);
789
- });
790
- }, "se_WidgetConfigList");
791
- var se_WidgetList = /* @__PURE__ */ __name((input, context) => {
792
- return input.filter((e) => e != null).map((entry) => {
793
- return se_Widget(entry, context);
794
- });
795
- }, "se_WidgetList");
796
- var de_CostAndUsageQuery = /* @__PURE__ */ __name((output, context) => {
797
- return (0, import_smithy_client.take)(output, {
798
- filter: /* @__PURE__ */ __name((_) => de_Expression(_, context), "filter"),
799
- granularity: import_smithy_client.expectString,
800
- groupBy: import_smithy_client._json,
801
- metrics: import_smithy_client._json,
802
- timeRange: import_smithy_client._json
803
- });
804
- }, "de_CostAndUsageQuery");
805
- var de_DashboardReference = /* @__PURE__ */ __name((output, context) => {
806
- return (0, import_smithy_client.take)(output, {
807
- arn: import_smithy_client.expectString,
808
- createdAt: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "createdAt"),
809
- description: import_smithy_client.expectString,
810
- name: import_smithy_client.expectString,
811
- type: import_smithy_client.expectString,
812
- updatedAt: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "updatedAt")
813
- });
814
- }, "de_DashboardReference");
815
- var de_DashboardReferenceList = /* @__PURE__ */ __name((output, context) => {
816
- const retVal = (output || []).filter((e) => e != null).map((entry) => {
817
- return de_DashboardReference(entry, context);
818
- });
819
- return retVal;
820
- }, "de_DashboardReferenceList");
821
- var de_Expression = /* @__PURE__ */ __name((output, context) => {
822
- return (0, import_smithy_client.take)(output, {
823
- and: /* @__PURE__ */ __name((_) => de_Expressions(_, context), "and"),
824
- costCategories: import_smithy_client._json,
825
- dimensions: import_smithy_client._json,
826
- not: /* @__PURE__ */ __name((_) => de_Expression(_, context), "not"),
827
- or: /* @__PURE__ */ __name((_) => de_Expressions(_, context), "or"),
828
- tags: import_smithy_client._json
829
- });
830
- }, "de_Expression");
831
- var de_Expressions = /* @__PURE__ */ __name((output, context) => {
832
- const retVal = (output || []).filter((e) => e != null).map((entry) => {
833
- return de_Expression(entry, context);
834
- });
835
- return retVal;
836
- }, "de_Expressions");
837
- var de_GetDashboardResponse = /* @__PURE__ */ __name((output, context) => {
838
- return (0, import_smithy_client.take)(output, {
839
- arn: import_smithy_client.expectString,
840
- createdAt: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "createdAt"),
841
- description: import_smithy_client.expectString,
842
- name: import_smithy_client.expectString,
843
- type: import_smithy_client.expectString,
844
- updatedAt: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "updatedAt"),
845
- widgets: /* @__PURE__ */ __name((_) => de_WidgetList(_, context), "widgets")
846
- });
847
- }, "de_GetDashboardResponse");
848
- var de_ListDashboardsResponse = /* @__PURE__ */ __name((output, context) => {
849
- return (0, import_smithy_client.take)(output, {
850
- dashboards: /* @__PURE__ */ __name((_) => de_DashboardReferenceList(_, context), "dashboards"),
851
- nextToken: import_smithy_client.expectString
852
- });
853
- }, "de_ListDashboardsResponse");
854
- var de_QueryParameters = /* @__PURE__ */ __name((output, context) => {
855
- if (output.costAndUsage != null) {
856
- return {
857
- costAndUsage: de_CostAndUsageQuery(output.costAndUsage, context)
858
- };
859
- }
860
- if (output.reservationCoverage != null) {
861
- return {
862
- reservationCoverage: de_ReservationCoverageQuery(output.reservationCoverage, context)
863
- };
864
- }
865
- if (output.reservationUtilization != null) {
866
- return {
867
- reservationUtilization: de_ReservationUtilizationQuery(output.reservationUtilization, context)
868
- };
869
- }
870
- if (output.savingsPlansCoverage != null) {
871
- return {
872
- savingsPlansCoverage: de_SavingsPlansCoverageQuery(output.savingsPlansCoverage, context)
873
- };
874
- }
875
- if (output.savingsPlansUtilization != null) {
876
- return {
877
- savingsPlansUtilization: de_SavingsPlansUtilizationQuery(output.savingsPlansUtilization, context)
878
- };
879
- }
880
- return { $unknown: Object.entries(output)[0] };
881
- }, "de_QueryParameters");
882
- var de_ReservationCoverageQuery = /* @__PURE__ */ __name((output, context) => {
883
- return (0, import_smithy_client.take)(output, {
884
- filter: /* @__PURE__ */ __name((_) => de_Expression(_, context), "filter"),
885
- granularity: import_smithy_client.expectString,
886
- groupBy: import_smithy_client._json,
887
- metrics: import_smithy_client._json,
888
- timeRange: import_smithy_client._json
889
- });
890
- }, "de_ReservationCoverageQuery");
891
- var de_ReservationUtilizationQuery = /* @__PURE__ */ __name((output, context) => {
892
- return (0, import_smithy_client.take)(output, {
893
- filter: /* @__PURE__ */ __name((_) => de_Expression(_, context), "filter"),
894
- granularity: import_smithy_client.expectString,
895
- groupBy: import_smithy_client._json,
896
- timeRange: import_smithy_client._json
897
- });
898
- }, "de_ReservationUtilizationQuery");
899
- var de_SavingsPlansCoverageQuery = /* @__PURE__ */ __name((output, context) => {
900
- return (0, import_smithy_client.take)(output, {
901
- filter: /* @__PURE__ */ __name((_) => de_Expression(_, context), "filter"),
902
- granularity: import_smithy_client.expectString,
903
- groupBy: import_smithy_client._json,
904
- metrics: import_smithy_client._json,
905
- timeRange: import_smithy_client._json
906
- });
907
- }, "de_SavingsPlansCoverageQuery");
908
- var de_SavingsPlansUtilizationQuery = /* @__PURE__ */ __name((output, context) => {
909
- return (0, import_smithy_client.take)(output, {
910
- filter: /* @__PURE__ */ __name((_) => de_Expression(_, context), "filter"),
911
- granularity: import_smithy_client.expectString,
912
- timeRange: import_smithy_client._json
913
- });
914
- }, "de_SavingsPlansUtilizationQuery");
915
- var de_Widget = /* @__PURE__ */ __name((output, context) => {
916
- return (0, import_smithy_client.take)(output, {
917
- configs: /* @__PURE__ */ __name((_) => de_WidgetConfigList(_, context), "configs"),
918
- description: import_smithy_client.expectString,
919
- height: import_smithy_client.expectInt32,
920
- horizontalOffset: import_smithy_client.expectInt32,
921
- title: import_smithy_client.expectString,
922
- width: import_smithy_client.expectInt32
923
- });
924
- }, "de_Widget");
925
- var de_WidgetConfig = /* @__PURE__ */ __name((output, context) => {
926
- return (0, import_smithy_client.take)(output, {
927
- displayConfig: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)((0, import_core2.awsExpectUnion)(_)), "displayConfig"),
928
- queryParameters: /* @__PURE__ */ __name((_) => de_QueryParameters((0, import_core2.awsExpectUnion)(_), context), "queryParameters")
929
- });
930
- }, "de_WidgetConfig");
931
- var de_WidgetConfigList = /* @__PURE__ */ __name((output, context) => {
932
- const retVal = (output || []).filter((e) => e != null).map((entry) => {
933
- return de_WidgetConfig(entry, context);
934
- });
935
- return retVal;
936
- }, "de_WidgetConfigList");
937
- var de_WidgetList = /* @__PURE__ */ __name((output, context) => {
938
- const retVal = (output || []).filter((e) => e != null).map((entry) => {
939
- return de_Widget(entry, context);
940
- });
941
- return retVal;
942
- }, "de_WidgetList");
943
- var deserializeMetadata = /* @__PURE__ */ __name((output) => ({
944
- httpStatusCode: output.statusCode,
945
- requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
946
- extendedRequestId: output.headers["x-amz-id-2"],
947
- cfId: output.headers["x-amz-cf-id"]
948
- }), "deserializeMetadata");
949
- var throwDefaultError = (0, import_smithy_client.withBaseException)(BCMDashboardsServiceException);
950
- var buildHttpRpcRequest = /* @__PURE__ */ __name(async (context, headers, path, resolvedHostname, body) => {
951
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
952
- const contents = {
953
- protocol,
954
- hostname,
955
- port,
956
- method: "POST",
957
- path: basePath.endsWith("/") ? basePath.slice(0, -1) + path : basePath + path,
958
- headers
959
- };
960
- if (resolvedHostname !== void 0) {
961
- contents.hostname = resolvedHostname;
962
- }
963
- if (body !== void 0) {
964
- contents.body = body;
965
- }
966
- return new import_protocol_http.HttpRequest(contents);
967
- }, "buildHttpRpcRequest");
968
- function sharedHeaders(operation) {
969
- return {
970
- "content-type": "application/x-amz-json-1.0",
971
- "x-amz-target": `AWSBCMDashboardsService.${operation}`
972
- };
973
- }
974
- __name(sharedHeaders, "sharedHeaders");
975
-
976
- // src/commands/CreateDashboardCommand.ts
977
- var CreateDashboardCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
978
- return [
979
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
980
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
981
- ];
982
- }).s("AWSBCMDashboardsService", "CreateDashboard", {}).n("BCMDashboardsClient", "CreateDashboardCommand").f(void 0, void 0).ser(se_CreateDashboardCommand).de(de_CreateDashboardCommand).build() {
983
- static {
984
- __name(this, "CreateDashboardCommand");
985
- }
547
+ return smithyClient.decorateServiceException(exception, body);
986
548
  };
987
-
988
- // src/commands/DeleteDashboardCommand.ts
989
-
990
-
991
-
992
- var DeleteDashboardCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
993
- return [
994
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
995
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
996
- ];
997
- }).s("AWSBCMDashboardsService", "DeleteDashboard", {}).n("BCMDashboardsClient", "DeleteDashboardCommand").f(void 0, void 0).ser(se_DeleteDashboardCommand).de(de_DeleteDashboardCommand).build() {
998
- static {
999
- __name(this, "DeleteDashboardCommand");
1000
- }
549
+ const se_CostAndUsageQuery = (input, context) => {
550
+ return smithyClient.take(input, {
551
+ filter: (_) => se_Expression(_),
552
+ granularity: [],
553
+ groupBy: smithyClient._json,
554
+ metrics: smithyClient._json,
555
+ timeRange: smithyClient._json,
556
+ });
1001
557
  };
1002
-
1003
- // src/commands/GetDashboardCommand.ts
1004
-
1005
-
1006
-
1007
- var GetDashboardCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1008
- return [
1009
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1010
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1011
- ];
1012
- }).s("AWSBCMDashboardsService", "GetDashboard", {}).n("BCMDashboardsClient", "GetDashboardCommand").f(void 0, void 0).ser(se_GetDashboardCommand).de(de_GetDashboardCommand).build() {
1013
- static {
1014
- __name(this, "GetDashboardCommand");
1015
- }
558
+ const se_CreateDashboardRequest = (input, context) => {
559
+ return smithyClient.take(input, {
560
+ description: [],
561
+ name: [],
562
+ resourceTags: smithyClient._json,
563
+ widgets: (_) => se_WidgetList(_),
564
+ });
1016
565
  };
1017
-
1018
- // src/commands/GetResourcePolicyCommand.ts
1019
-
1020
-
1021
-
1022
- var GetResourcePolicyCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1023
- return [
1024
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1025
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1026
- ];
1027
- }).s("AWSBCMDashboardsService", "GetResourcePolicy", {}).n("BCMDashboardsClient", "GetResourcePolicyCommand").f(void 0, void 0).ser(se_GetResourcePolicyCommand).de(de_GetResourcePolicyCommand).build() {
1028
- static {
1029
- __name(this, "GetResourcePolicyCommand");
1030
- }
566
+ const se_Expression = (input, context) => {
567
+ return smithyClient.take(input, {
568
+ and: (_) => se_Expressions(_),
569
+ costCategories: smithyClient._json,
570
+ dimensions: smithyClient._json,
571
+ not: (_) => se_Expression(_),
572
+ or: (_) => se_Expressions(_),
573
+ tags: smithyClient._json,
574
+ });
1031
575
  };
1032
-
1033
- // src/commands/ListDashboardsCommand.ts
1034
-
1035
-
1036
-
1037
- var ListDashboardsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1038
- return [
1039
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1040
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1041
- ];
1042
- }).s("AWSBCMDashboardsService", "ListDashboards", {}).n("BCMDashboardsClient", "ListDashboardsCommand").f(void 0, void 0).ser(se_ListDashboardsCommand).de(de_ListDashboardsCommand).build() {
1043
- static {
1044
- __name(this, "ListDashboardsCommand");
1045
- }
576
+ const se_Expressions = (input, context) => {
577
+ return input
578
+ .filter((e) => e != null)
579
+ .map((entry) => {
580
+ return se_Expression(entry);
581
+ });
1046
582
  };
1047
-
1048
- // src/commands/ListTagsForResourceCommand.ts
1049
-
1050
-
1051
-
1052
- var ListTagsForResourceCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1053
- return [
1054
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1055
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1056
- ];
1057
- }).s("AWSBCMDashboardsService", "ListTagsForResource", {}).n("BCMDashboardsClient", "ListTagsForResourceCommand").f(void 0, void 0).ser(se_ListTagsForResourceCommand).de(de_ListTagsForResourceCommand).build() {
1058
- static {
1059
- __name(this, "ListTagsForResourceCommand");
1060
- }
583
+ const se_QueryParameters = (input, context) => {
584
+ return exports.QueryParameters.visit(input, {
585
+ costAndUsage: (value) => ({ costAndUsage: se_CostAndUsageQuery(value) }),
586
+ reservationCoverage: (value) => ({ reservationCoverage: se_ReservationCoverageQuery(value) }),
587
+ reservationUtilization: (value) => ({ reservationUtilization: se_ReservationUtilizationQuery(value) }),
588
+ savingsPlansCoverage: (value) => ({ savingsPlansCoverage: se_SavingsPlansCoverageQuery(value) }),
589
+ savingsPlansUtilization: (value) => ({ savingsPlansUtilization: se_SavingsPlansUtilizationQuery(value) }),
590
+ _: (name, value) => ({ [name]: value }),
591
+ });
1061
592
  };
1062
-
1063
- // src/commands/TagResourceCommand.ts
1064
-
1065
-
1066
-
1067
- var TagResourceCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1068
- return [
1069
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1070
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1071
- ];
1072
- }).s("AWSBCMDashboardsService", "TagResource", {}).n("BCMDashboardsClient", "TagResourceCommand").f(void 0, void 0).ser(se_TagResourceCommand).de(de_TagResourceCommand).build() {
1073
- static {
1074
- __name(this, "TagResourceCommand");
1075
- }
593
+ const se_ReservationCoverageQuery = (input, context) => {
594
+ return smithyClient.take(input, {
595
+ filter: (_) => se_Expression(_),
596
+ granularity: [],
597
+ groupBy: smithyClient._json,
598
+ metrics: smithyClient._json,
599
+ timeRange: smithyClient._json,
600
+ });
601
+ };
602
+ const se_ReservationUtilizationQuery = (input, context) => {
603
+ return smithyClient.take(input, {
604
+ filter: (_) => se_Expression(_),
605
+ granularity: [],
606
+ groupBy: smithyClient._json,
607
+ timeRange: smithyClient._json,
608
+ });
609
+ };
610
+ const se_SavingsPlansCoverageQuery = (input, context) => {
611
+ return smithyClient.take(input, {
612
+ filter: (_) => se_Expression(_),
613
+ granularity: [],
614
+ groupBy: smithyClient._json,
615
+ metrics: smithyClient._json,
616
+ timeRange: smithyClient._json,
617
+ });
618
+ };
619
+ const se_SavingsPlansUtilizationQuery = (input, context) => {
620
+ return smithyClient.take(input, {
621
+ filter: (_) => se_Expression(_),
622
+ granularity: [],
623
+ timeRange: smithyClient._json,
624
+ });
625
+ };
626
+ const se_UpdateDashboardRequest = (input, context) => {
627
+ return smithyClient.take(input, {
628
+ arn: [],
629
+ description: [],
630
+ name: [],
631
+ widgets: (_) => se_WidgetList(_),
632
+ });
633
+ };
634
+ const se_Widget = (input, context) => {
635
+ return smithyClient.take(input, {
636
+ configs: (_) => se_WidgetConfigList(_),
637
+ description: [],
638
+ height: [],
639
+ horizontalOffset: [],
640
+ title: [],
641
+ width: [],
642
+ });
643
+ };
644
+ const se_WidgetConfig = (input, context) => {
645
+ return smithyClient.take(input, {
646
+ displayConfig: smithyClient._json,
647
+ queryParameters: (_) => se_QueryParameters(_),
648
+ });
649
+ };
650
+ const se_WidgetConfigList = (input, context) => {
651
+ return input
652
+ .filter((e) => e != null)
653
+ .map((entry) => {
654
+ return se_WidgetConfig(entry);
655
+ });
656
+ };
657
+ const se_WidgetList = (input, context) => {
658
+ return input
659
+ .filter((e) => e != null)
660
+ .map((entry) => {
661
+ return se_Widget(entry);
662
+ });
663
+ };
664
+ const de_CostAndUsageQuery = (output, context) => {
665
+ return smithyClient.take(output, {
666
+ filter: (_) => de_Expression(_),
667
+ granularity: smithyClient.expectString,
668
+ groupBy: smithyClient._json,
669
+ metrics: smithyClient._json,
670
+ timeRange: smithyClient._json,
671
+ });
672
+ };
673
+ const de_DashboardReference = (output, context) => {
674
+ return smithyClient.take(output, {
675
+ arn: smithyClient.expectString,
676
+ createdAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
677
+ description: smithyClient.expectString,
678
+ name: smithyClient.expectString,
679
+ type: smithyClient.expectString,
680
+ updatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
681
+ });
682
+ };
683
+ const de_DashboardReferenceList = (output, context) => {
684
+ const retVal = (output || [])
685
+ .filter((e) => e != null)
686
+ .map((entry) => {
687
+ return de_DashboardReference(entry);
688
+ });
689
+ return retVal;
690
+ };
691
+ const de_Expression = (output, context) => {
692
+ return smithyClient.take(output, {
693
+ and: (_) => de_Expressions(_),
694
+ costCategories: smithyClient._json,
695
+ dimensions: smithyClient._json,
696
+ not: (_) => de_Expression(_),
697
+ or: (_) => de_Expressions(_),
698
+ tags: smithyClient._json,
699
+ });
700
+ };
701
+ const de_Expressions = (output, context) => {
702
+ const retVal = (output || [])
703
+ .filter((e) => e != null)
704
+ .map((entry) => {
705
+ return de_Expression(entry);
706
+ });
707
+ return retVal;
708
+ };
709
+ const de_GetDashboardResponse = (output, context) => {
710
+ return smithyClient.take(output, {
711
+ arn: smithyClient.expectString,
712
+ createdAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
713
+ description: smithyClient.expectString,
714
+ name: smithyClient.expectString,
715
+ type: smithyClient.expectString,
716
+ updatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
717
+ widgets: (_) => de_WidgetList(_),
718
+ });
719
+ };
720
+ const de_ListDashboardsResponse = (output, context) => {
721
+ return smithyClient.take(output, {
722
+ dashboards: (_) => de_DashboardReferenceList(_),
723
+ nextToken: smithyClient.expectString,
724
+ });
725
+ };
726
+ const de_QueryParameters = (output, context) => {
727
+ if (output.costAndUsage != null) {
728
+ return {
729
+ costAndUsage: de_CostAndUsageQuery(output.costAndUsage),
730
+ };
731
+ }
732
+ if (output.reservationCoverage != null) {
733
+ return {
734
+ reservationCoverage: de_ReservationCoverageQuery(output.reservationCoverage),
735
+ };
736
+ }
737
+ if (output.reservationUtilization != null) {
738
+ return {
739
+ reservationUtilization: de_ReservationUtilizationQuery(output.reservationUtilization),
740
+ };
741
+ }
742
+ if (output.savingsPlansCoverage != null) {
743
+ return {
744
+ savingsPlansCoverage: de_SavingsPlansCoverageQuery(output.savingsPlansCoverage),
745
+ };
746
+ }
747
+ if (output.savingsPlansUtilization != null) {
748
+ return {
749
+ savingsPlansUtilization: de_SavingsPlansUtilizationQuery(output.savingsPlansUtilization),
750
+ };
751
+ }
752
+ return { $unknown: Object.entries(output)[0] };
753
+ };
754
+ const de_ReservationCoverageQuery = (output, context) => {
755
+ return smithyClient.take(output, {
756
+ filter: (_) => de_Expression(_),
757
+ granularity: smithyClient.expectString,
758
+ groupBy: smithyClient._json,
759
+ metrics: smithyClient._json,
760
+ timeRange: smithyClient._json,
761
+ });
762
+ };
763
+ const de_ReservationUtilizationQuery = (output, context) => {
764
+ return smithyClient.take(output, {
765
+ filter: (_) => de_Expression(_),
766
+ granularity: smithyClient.expectString,
767
+ groupBy: smithyClient._json,
768
+ timeRange: smithyClient._json,
769
+ });
770
+ };
771
+ const de_SavingsPlansCoverageQuery = (output, context) => {
772
+ return smithyClient.take(output, {
773
+ filter: (_) => de_Expression(_),
774
+ granularity: smithyClient.expectString,
775
+ groupBy: smithyClient._json,
776
+ metrics: smithyClient._json,
777
+ timeRange: smithyClient._json,
778
+ });
779
+ };
780
+ const de_SavingsPlansUtilizationQuery = (output, context) => {
781
+ return smithyClient.take(output, {
782
+ filter: (_) => de_Expression(_),
783
+ granularity: smithyClient.expectString,
784
+ timeRange: smithyClient._json,
785
+ });
786
+ };
787
+ const de_Widget = (output, context) => {
788
+ return smithyClient.take(output, {
789
+ configs: (_) => de_WidgetConfigList(_),
790
+ description: smithyClient.expectString,
791
+ height: smithyClient.expectInt32,
792
+ horizontalOffset: smithyClient.expectInt32,
793
+ title: smithyClient.expectString,
794
+ width: smithyClient.expectInt32,
795
+ });
796
+ };
797
+ const de_WidgetConfig = (output, context) => {
798
+ return smithyClient.take(output, {
799
+ displayConfig: (_) => smithyClient._json(core$1.awsExpectUnion(_)),
800
+ queryParameters: (_) => de_QueryParameters(core$1.awsExpectUnion(_)),
801
+ });
802
+ };
803
+ const de_WidgetConfigList = (output, context) => {
804
+ const retVal = (output || [])
805
+ .filter((e) => e != null)
806
+ .map((entry) => {
807
+ return de_WidgetConfig(entry);
808
+ });
809
+ return retVal;
810
+ };
811
+ const de_WidgetList = (output, context) => {
812
+ const retVal = (output || [])
813
+ .filter((e) => e != null)
814
+ .map((entry) => {
815
+ return de_Widget(entry);
816
+ });
817
+ return retVal;
818
+ };
819
+ const deserializeMetadata = (output) => ({
820
+ httpStatusCode: output.statusCode,
821
+ requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
822
+ extendedRequestId: output.headers["x-amz-id-2"],
823
+ cfId: output.headers["x-amz-cf-id"],
824
+ });
825
+ const throwDefaultError = smithyClient.withBaseException(BCMDashboardsServiceException);
826
+ const buildHttpRpcRequest = async (context, headers, path, resolvedHostname, body) => {
827
+ const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
828
+ const contents = {
829
+ protocol,
830
+ hostname,
831
+ port,
832
+ method: "POST",
833
+ path: basePath.endsWith("/") ? basePath.slice(0, -1) + path : basePath + path,
834
+ headers,
835
+ };
836
+ if (body !== undefined) {
837
+ contents.body = body;
838
+ }
839
+ return new protocolHttp.HttpRequest(contents);
1076
840
  };
841
+ function sharedHeaders(operation) {
842
+ return {
843
+ "content-type": "application/x-amz-json-1.0",
844
+ "x-amz-target": `AWSBCMDashboardsService.${operation}`,
845
+ };
846
+ }
1077
847
 
1078
- // src/commands/UntagResourceCommand.ts
848
+ class CreateDashboardCommand extends smithyClient.Command
849
+ .classBuilder()
850
+ .ep(commonParams)
851
+ .m(function (Command, cs, config, o) {
852
+ return [
853
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
854
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
855
+ ];
856
+ })
857
+ .s("AWSBCMDashboardsService", "CreateDashboard", {})
858
+ .n("BCMDashboardsClient", "CreateDashboardCommand")
859
+ .f(void 0, void 0)
860
+ .ser(se_CreateDashboardCommand)
861
+ .de(de_CreateDashboardCommand)
862
+ .build() {
863
+ }
1079
864
 
865
+ class DeleteDashboardCommand extends smithyClient.Command
866
+ .classBuilder()
867
+ .ep(commonParams)
868
+ .m(function (Command, cs, config, o) {
869
+ return [
870
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
871
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
872
+ ];
873
+ })
874
+ .s("AWSBCMDashboardsService", "DeleteDashboard", {})
875
+ .n("BCMDashboardsClient", "DeleteDashboardCommand")
876
+ .f(void 0, void 0)
877
+ .ser(se_DeleteDashboardCommand)
878
+ .de(de_DeleteDashboardCommand)
879
+ .build() {
880
+ }
1080
881
 
882
+ class GetDashboardCommand extends smithyClient.Command
883
+ .classBuilder()
884
+ .ep(commonParams)
885
+ .m(function (Command, cs, config, o) {
886
+ return [
887
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
888
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
889
+ ];
890
+ })
891
+ .s("AWSBCMDashboardsService", "GetDashboard", {})
892
+ .n("BCMDashboardsClient", "GetDashboardCommand")
893
+ .f(void 0, void 0)
894
+ .ser(se_GetDashboardCommand)
895
+ .de(de_GetDashboardCommand)
896
+ .build() {
897
+ }
1081
898
 
1082
- var UntagResourceCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1083
- return [
1084
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1085
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1086
- ];
1087
- }).s("AWSBCMDashboardsService", "UntagResource", {}).n("BCMDashboardsClient", "UntagResourceCommand").f(void 0, void 0).ser(se_UntagResourceCommand).de(de_UntagResourceCommand).build() {
1088
- static {
1089
- __name(this, "UntagResourceCommand");
1090
- }
1091
- };
899
+ class GetResourcePolicyCommand extends smithyClient.Command
900
+ .classBuilder()
901
+ .ep(commonParams)
902
+ .m(function (Command, cs, config, o) {
903
+ return [
904
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
905
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
906
+ ];
907
+ })
908
+ .s("AWSBCMDashboardsService", "GetResourcePolicy", {})
909
+ .n("BCMDashboardsClient", "GetResourcePolicyCommand")
910
+ .f(void 0, void 0)
911
+ .ser(se_GetResourcePolicyCommand)
912
+ .de(de_GetResourcePolicyCommand)
913
+ .build() {
914
+ }
1092
915
 
1093
- // src/commands/UpdateDashboardCommand.ts
916
+ class ListDashboardsCommand extends smithyClient.Command
917
+ .classBuilder()
918
+ .ep(commonParams)
919
+ .m(function (Command, cs, config, o) {
920
+ return [
921
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
922
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
923
+ ];
924
+ })
925
+ .s("AWSBCMDashboardsService", "ListDashboards", {})
926
+ .n("BCMDashboardsClient", "ListDashboardsCommand")
927
+ .f(void 0, void 0)
928
+ .ser(se_ListDashboardsCommand)
929
+ .de(de_ListDashboardsCommand)
930
+ .build() {
931
+ }
1094
932
 
933
+ class ListTagsForResourceCommand extends smithyClient.Command
934
+ .classBuilder()
935
+ .ep(commonParams)
936
+ .m(function (Command, cs, config, o) {
937
+ return [
938
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
939
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
940
+ ];
941
+ })
942
+ .s("AWSBCMDashboardsService", "ListTagsForResource", {})
943
+ .n("BCMDashboardsClient", "ListTagsForResourceCommand")
944
+ .f(void 0, void 0)
945
+ .ser(se_ListTagsForResourceCommand)
946
+ .de(de_ListTagsForResourceCommand)
947
+ .build() {
948
+ }
1095
949
 
950
+ class TagResourceCommand extends smithyClient.Command
951
+ .classBuilder()
952
+ .ep(commonParams)
953
+ .m(function (Command, cs, config, o) {
954
+ return [
955
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
956
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
957
+ ];
958
+ })
959
+ .s("AWSBCMDashboardsService", "TagResource", {})
960
+ .n("BCMDashboardsClient", "TagResourceCommand")
961
+ .f(void 0, void 0)
962
+ .ser(se_TagResourceCommand)
963
+ .de(de_TagResourceCommand)
964
+ .build() {
965
+ }
1096
966
 
1097
- var UpdateDashboardCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1098
- return [
1099
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1100
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1101
- ];
1102
- }).s("AWSBCMDashboardsService", "UpdateDashboard", {}).n("BCMDashboardsClient", "UpdateDashboardCommand").f(void 0, void 0).ser(se_UpdateDashboardCommand).de(de_UpdateDashboardCommand).build() {
1103
- static {
1104
- __name(this, "UpdateDashboardCommand");
1105
- }
1106
- };
967
+ class UntagResourceCommand extends smithyClient.Command
968
+ .classBuilder()
969
+ .ep(commonParams)
970
+ .m(function (Command, cs, config, o) {
971
+ return [
972
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
973
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
974
+ ];
975
+ })
976
+ .s("AWSBCMDashboardsService", "UntagResource", {})
977
+ .n("BCMDashboardsClient", "UntagResourceCommand")
978
+ .f(void 0, void 0)
979
+ .ser(se_UntagResourceCommand)
980
+ .de(de_UntagResourceCommand)
981
+ .build() {
982
+ }
1107
983
 
1108
- // src/BCMDashboards.ts
1109
- var commands = {
1110
- CreateDashboardCommand,
1111
- DeleteDashboardCommand,
1112
- GetDashboardCommand,
1113
- GetResourcePolicyCommand,
1114
- ListDashboardsCommand,
1115
- ListTagsForResourceCommand,
1116
- TagResourceCommand,
1117
- UntagResourceCommand,
1118
- UpdateDashboardCommand
1119
- };
1120
- var BCMDashboards = class extends BCMDashboardsClient {
1121
- static {
1122
- __name(this, "BCMDashboards");
1123
- }
1124
- };
1125
- (0, import_smithy_client.createAggregatedClient)(commands, BCMDashboards);
984
+ class UpdateDashboardCommand extends smithyClient.Command
985
+ .classBuilder()
986
+ .ep(commonParams)
987
+ .m(function (Command, cs, config, o) {
988
+ return [
989
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
990
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
991
+ ];
992
+ })
993
+ .s("AWSBCMDashboardsService", "UpdateDashboard", {})
994
+ .n("BCMDashboardsClient", "UpdateDashboardCommand")
995
+ .f(void 0, void 0)
996
+ .ser(se_UpdateDashboardCommand)
997
+ .de(de_UpdateDashboardCommand)
998
+ .build() {
999
+ }
1126
1000
 
1127
- // src/pagination/ListDashboardsPaginator.ts
1001
+ const commands = {
1002
+ CreateDashboardCommand,
1003
+ DeleteDashboardCommand,
1004
+ GetDashboardCommand,
1005
+ GetResourcePolicyCommand,
1006
+ ListDashboardsCommand,
1007
+ ListTagsForResourceCommand,
1008
+ TagResourceCommand,
1009
+ UntagResourceCommand,
1010
+ UpdateDashboardCommand,
1011
+ };
1012
+ class BCMDashboards extends BCMDashboardsClient {
1013
+ }
1014
+ smithyClient.createAggregatedClient(commands, BCMDashboards);
1128
1015
 
1129
- var paginateListDashboards = (0, import_core.createPaginator)(BCMDashboardsClient, ListDashboardsCommand, "nextToken", "nextToken", "maxResults");
1130
- // Annotate the CommonJS export names for ESM import in node:
1016
+ const paginateListDashboards = core.createPaginator(BCMDashboardsClient, ListDashboardsCommand, "nextToken", "nextToken", "maxResults");
1131
1017
 
1132
- 0 && (module.exports = {
1133
- BCMDashboardsServiceException,
1134
- __Client,
1135
- BCMDashboardsClient,
1136
- BCMDashboards,
1137
- $Command,
1138
- CreateDashboardCommand,
1139
- DeleteDashboardCommand,
1140
- GetDashboardCommand,
1141
- GetResourcePolicyCommand,
1142
- ListDashboardsCommand,
1143
- ListTagsForResourceCommand,
1144
- TagResourceCommand,
1145
- UntagResourceCommand,
1146
- UpdateDashboardCommand,
1147
- paginateListDashboards,
1148
- AccessDeniedException,
1149
- VisualType,
1150
- DisplayConfig,
1151
- MatchOption,
1152
- Dimension,
1153
- Granularity,
1154
- GroupDefinitionType,
1155
- MetricName,
1156
- DateTimeType,
1157
- InternalServerException,
1158
- ServiceQuotaExceededException,
1159
- ThrottlingException,
1160
- ValidationException,
1161
- DashboardType,
1162
- ResourceNotFoundException,
1163
- QueryParameters
1018
+ Object.defineProperty(exports, "$Command", {
1019
+ enumerable: true,
1020
+ get: function () { return smithyClient.Command; }
1164
1021
  });
1165
-
1022
+ Object.defineProperty(exports, "__Client", {
1023
+ enumerable: true,
1024
+ get: function () { return smithyClient.Client; }
1025
+ });
1026
+ exports.AccessDeniedException = AccessDeniedException;
1027
+ exports.BCMDashboards = BCMDashboards;
1028
+ exports.BCMDashboardsClient = BCMDashboardsClient;
1029
+ exports.BCMDashboardsServiceException = BCMDashboardsServiceException;
1030
+ exports.CreateDashboardCommand = CreateDashboardCommand;
1031
+ exports.DashboardType = DashboardType;
1032
+ exports.DateTimeType = DateTimeType;
1033
+ exports.DeleteDashboardCommand = DeleteDashboardCommand;
1034
+ exports.Dimension = Dimension;
1035
+ exports.GetDashboardCommand = GetDashboardCommand;
1036
+ exports.GetResourcePolicyCommand = GetResourcePolicyCommand;
1037
+ exports.Granularity = Granularity;
1038
+ exports.GroupDefinitionType = GroupDefinitionType;
1039
+ exports.InternalServerException = InternalServerException;
1040
+ exports.ListDashboardsCommand = ListDashboardsCommand;
1041
+ exports.ListTagsForResourceCommand = ListTagsForResourceCommand;
1042
+ exports.MatchOption = MatchOption;
1043
+ exports.MetricName = MetricName;
1044
+ exports.ResourceNotFoundException = ResourceNotFoundException;
1045
+ exports.ServiceQuotaExceededException = ServiceQuotaExceededException;
1046
+ exports.TagResourceCommand = TagResourceCommand;
1047
+ exports.ThrottlingException = ThrottlingException;
1048
+ exports.UntagResourceCommand = UntagResourceCommand;
1049
+ exports.UpdateDashboardCommand = UpdateDashboardCommand;
1050
+ exports.ValidationException = ValidationException;
1051
+ exports.VisualType = VisualType;
1052
+ exports.paginateListDashboards = paginateListDashboards;