@aws-sdk/client-license-manager-linux-subscriptions 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 +814 -1005
  2. package/package.json +5 -5
package/dist-cjs/index.js CHANGED
@@ -1,1044 +1,853 @@
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 });
1
+ 'use strict';
2
+
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');
19
+
20
+ const resolveClientEndpointParameters = (options) => {
21
+ return Object.assign(options, {
22
+ useDualstackEndpoint: options.useDualstackEndpoint ?? false,
23
+ useFipsEndpoint: options.useFipsEndpoint ?? false,
24
+ defaultSigningName: "license-manager-linux-subscriptions",
25
+ });
10
26
  };
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;
27
+ const commonParams = {
28
+ UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
29
+ Endpoint: { type: "builtInParams", name: "endpoint" },
30
+ Region: { type: "builtInParams", name: "region" },
31
+ UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
18
32
  };
19
- var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
20
-
21
- // src/index.ts
22
- var index_exports = {};
23
- __export(index_exports, {
24
- DeregisterSubscriptionProviderCommand: () => DeregisterSubscriptionProviderCommand,
25
- GetRegisteredSubscriptionProviderCommand: () => GetRegisteredSubscriptionProviderCommand,
26
- GetServiceSettingsCommand: () => GetServiceSettingsCommand,
27
- InternalServerException: () => InternalServerException,
28
- LicenseManagerLinuxSubscriptions: () => LicenseManagerLinuxSubscriptions,
29
- LicenseManagerLinuxSubscriptionsClient: () => LicenseManagerLinuxSubscriptionsClient,
30
- LicenseManagerLinuxSubscriptionsServiceException: () => LicenseManagerLinuxSubscriptionsServiceException,
31
- LinuxSubscriptionsDiscovery: () => LinuxSubscriptionsDiscovery,
32
- ListLinuxSubscriptionInstancesCommand: () => ListLinuxSubscriptionInstancesCommand,
33
- ListLinuxSubscriptionsCommand: () => ListLinuxSubscriptionsCommand,
34
- ListRegisteredSubscriptionProvidersCommand: () => ListRegisteredSubscriptionProvidersCommand,
35
- ListTagsForResourceCommand: () => ListTagsForResourceCommand,
36
- ListTagsForResourceResponseFilterSensitiveLog: () => ListTagsForResourceResponseFilterSensitiveLog,
37
- Operator: () => Operator,
38
- OrganizationIntegration: () => OrganizationIntegration,
39
- RegisterSubscriptionProviderCommand: () => RegisterSubscriptionProviderCommand,
40
- RegisterSubscriptionProviderRequestFilterSensitiveLog: () => RegisterSubscriptionProviderRequestFilterSensitiveLog,
41
- ResourceNotFoundException: () => ResourceNotFoundException,
42
- Status: () => Status,
43
- SubscriptionProviderSource: () => SubscriptionProviderSource,
44
- SubscriptionProviderStatus: () => SubscriptionProviderStatus,
45
- TagResourceCommand: () => TagResourceCommand,
46
- TagResourceRequestFilterSensitiveLog: () => TagResourceRequestFilterSensitiveLog,
47
- ThrottlingException: () => ThrottlingException,
48
- UntagResourceCommand: () => UntagResourceCommand,
49
- UntagResourceRequestFilterSensitiveLog: () => UntagResourceRequestFilterSensitiveLog,
50
- UpdateServiceSettingsCommand: () => UpdateServiceSettingsCommand,
51
- ValidationException: () => ValidationException,
52
- __Client: () => import_smithy_client.Client,
53
- paginateListLinuxSubscriptionInstances: () => paginateListLinuxSubscriptionInstances,
54
- paginateListLinuxSubscriptions: () => paginateListLinuxSubscriptions,
55
- paginateListRegisteredSubscriptionProviders: () => paginateListRegisteredSubscriptionProviders
56
- });
57
- module.exports = __toCommonJS(index_exports);
58
-
59
- // src/LicenseManagerLinuxSubscriptionsClient.ts
60
- var import_middleware_host_header = require("@aws-sdk/middleware-host-header");
61
- var import_middleware_logger = require("@aws-sdk/middleware-logger");
62
- var import_middleware_recursion_detection = require("@aws-sdk/middleware-recursion-detection");
63
- var import_middleware_user_agent = require("@aws-sdk/middleware-user-agent");
64
- var import_config_resolver = require("@smithy/config-resolver");
65
- var import_core = require("@smithy/core");
66
- var import_middleware_content_length = require("@smithy/middleware-content-length");
67
- var import_middleware_endpoint = require("@smithy/middleware-endpoint");
68
- var import_middleware_retry = require("@smithy/middleware-retry");
69
-
70
- var import_httpAuthSchemeProvider = require("./auth/httpAuthSchemeProvider");
71
33
 
72
- // src/endpoint/EndpointParameters.ts
73
- var resolveClientEndpointParameters = /* @__PURE__ */ __name((options) => {
74
- return Object.assign(options, {
75
- useDualstackEndpoint: options.useDualstackEndpoint ?? false,
76
- useFipsEndpoint: options.useFipsEndpoint ?? false,
77
- defaultSigningName: "license-manager-linux-subscriptions"
78
- });
79
- }, "resolveClientEndpointParameters");
80
- var commonParams = {
81
- UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
82
- Endpoint: { type: "builtInParams", name: "endpoint" },
83
- Region: { type: "builtInParams", name: "region" },
84
- UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
34
+ const getHttpAuthExtensionConfiguration = (runtimeConfig) => {
35
+ const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
36
+ let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
37
+ let _credentials = runtimeConfig.credentials;
38
+ return {
39
+ setHttpAuthScheme(httpAuthScheme) {
40
+ const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
41
+ if (index === -1) {
42
+ _httpAuthSchemes.push(httpAuthScheme);
43
+ }
44
+ else {
45
+ _httpAuthSchemes.splice(index, 1, httpAuthScheme);
46
+ }
47
+ },
48
+ httpAuthSchemes() {
49
+ return _httpAuthSchemes;
50
+ },
51
+ setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
52
+ _httpAuthSchemeProvider = httpAuthSchemeProvider;
53
+ },
54
+ httpAuthSchemeProvider() {
55
+ return _httpAuthSchemeProvider;
56
+ },
57
+ setCredentials(credentials) {
58
+ _credentials = credentials;
59
+ },
60
+ credentials() {
61
+ return _credentials;
62
+ },
63
+ };
64
+ };
65
+ const resolveHttpAuthRuntimeConfig = (config) => {
66
+ return {
67
+ httpAuthSchemes: config.httpAuthSchemes(),
68
+ httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
69
+ credentials: config.credentials(),
70
+ };
85
71
  };
86
72
 
87
- // src/LicenseManagerLinuxSubscriptionsClient.ts
88
- var import_runtimeConfig = require("././runtimeConfig");
89
-
90
- // src/runtimeExtensions.ts
91
- var import_region_config_resolver = require("@aws-sdk/region-config-resolver");
92
- var import_protocol_http = require("@smithy/protocol-http");
93
- var import_smithy_client = require("@smithy/smithy-client");
73
+ const resolveRuntimeExtensions = (runtimeConfig, extensions) => {
74
+ const extensionConfiguration = Object.assign(regionConfigResolver.getAwsRegionExtensionConfiguration(runtimeConfig), smithyClient.getDefaultExtensionConfiguration(runtimeConfig), protocolHttp.getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
75
+ extensions.forEach((extension) => extension.configure(extensionConfiguration));
76
+ return Object.assign(runtimeConfig, regionConfigResolver.resolveAwsRegionExtensionConfiguration(extensionConfiguration), smithyClient.resolveDefaultRuntimeConfig(extensionConfiguration), protocolHttp.resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
77
+ };
94
78
 
95
- // src/auth/httpAuthExtensionConfiguration.ts
96
- var getHttpAuthExtensionConfiguration = /* @__PURE__ */ __name((runtimeConfig) => {
97
- const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
98
- let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
99
- let _credentials = runtimeConfig.credentials;
100
- return {
101
- setHttpAuthScheme(httpAuthScheme) {
102
- const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
103
- if (index === -1) {
104
- _httpAuthSchemes.push(httpAuthScheme);
105
- } else {
106
- _httpAuthSchemes.splice(index, 1, httpAuthScheme);
107
- }
108
- },
109
- httpAuthSchemes() {
110
- return _httpAuthSchemes;
111
- },
112
- setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
113
- _httpAuthSchemeProvider = httpAuthSchemeProvider;
114
- },
115
- httpAuthSchemeProvider() {
116
- return _httpAuthSchemeProvider;
117
- },
118
- setCredentials(credentials) {
119
- _credentials = credentials;
120
- },
121
- credentials() {
122
- return _credentials;
79
+ class LicenseManagerLinuxSubscriptionsClient extends smithyClient.Client {
80
+ config;
81
+ constructor(...[configuration]) {
82
+ const _config_0 = runtimeConfig.getRuntimeConfig(configuration || {});
83
+ super(_config_0);
84
+ this.initConfig = _config_0;
85
+ const _config_1 = resolveClientEndpointParameters(_config_0);
86
+ const _config_2 = middlewareUserAgent.resolveUserAgentConfig(_config_1);
87
+ const _config_3 = middlewareRetry.resolveRetryConfig(_config_2);
88
+ const _config_4 = configResolver.resolveRegionConfig(_config_3);
89
+ const _config_5 = middlewareHostHeader.resolveHostHeaderConfig(_config_4);
90
+ const _config_6 = middlewareEndpoint.resolveEndpointConfig(_config_5);
91
+ const _config_7 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_6);
92
+ const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
93
+ this.config = _config_8;
94
+ this.middlewareStack.use(middlewareUserAgent.getUserAgentPlugin(this.config));
95
+ this.middlewareStack.use(middlewareRetry.getRetryPlugin(this.config));
96
+ this.middlewareStack.use(middlewareContentLength.getContentLengthPlugin(this.config));
97
+ this.middlewareStack.use(middlewareHostHeader.getHostHeaderPlugin(this.config));
98
+ this.middlewareStack.use(middlewareLogger.getLoggerPlugin(this.config));
99
+ this.middlewareStack.use(middlewareRecursionDetection.getRecursionDetectionPlugin(this.config));
100
+ this.middlewareStack.use(core.getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
101
+ httpAuthSchemeParametersProvider: httpAuthSchemeProvider.defaultLicenseManagerLinuxSubscriptionsHttpAuthSchemeParametersProvider,
102
+ identityProviderConfigProvider: async (config) => new core.DefaultIdentityProviderConfig({
103
+ "aws.auth#sigv4": config.credentials,
104
+ }),
105
+ }));
106
+ this.middlewareStack.use(core.getHttpSigningPlugin(this.config));
123
107
  }
124
- };
125
- }, "getHttpAuthExtensionConfiguration");
126
- var resolveHttpAuthRuntimeConfig = /* @__PURE__ */ __name((config) => {
127
- return {
128
- httpAuthSchemes: config.httpAuthSchemes(),
129
- httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
130
- credentials: config.credentials()
131
- };
132
- }, "resolveHttpAuthRuntimeConfig");
133
-
134
- // src/runtimeExtensions.ts
135
- var resolveRuntimeExtensions = /* @__PURE__ */ __name((runtimeConfig, extensions) => {
136
- const extensionConfiguration = Object.assign(
137
- (0, import_region_config_resolver.getAwsRegionExtensionConfiguration)(runtimeConfig),
138
- (0, import_smithy_client.getDefaultExtensionConfiguration)(runtimeConfig),
139
- (0, import_protocol_http.getHttpHandlerExtensionConfiguration)(runtimeConfig),
140
- getHttpAuthExtensionConfiguration(runtimeConfig)
141
- );
142
- extensions.forEach((extension) => extension.configure(extensionConfiguration));
143
- return Object.assign(
144
- runtimeConfig,
145
- (0, import_region_config_resolver.resolveAwsRegionExtensionConfiguration)(extensionConfiguration),
146
- (0, import_smithy_client.resolveDefaultRuntimeConfig)(extensionConfiguration),
147
- (0, import_protocol_http.resolveHttpHandlerRuntimeConfig)(extensionConfiguration),
148
- resolveHttpAuthRuntimeConfig(extensionConfiguration)
149
- );
150
- }, "resolveRuntimeExtensions");
108
+ destroy() {
109
+ super.destroy();
110
+ }
111
+ }
151
112
 
152
- // src/LicenseManagerLinuxSubscriptionsClient.ts
153
- var LicenseManagerLinuxSubscriptionsClient = class extends import_smithy_client.Client {
154
- static {
155
- __name(this, "LicenseManagerLinuxSubscriptionsClient");
156
- }
157
- /**
158
- * The resolved configuration of LicenseManagerLinuxSubscriptionsClient class. This is resolved and normalized from the {@link LicenseManagerLinuxSubscriptionsClientConfig | constructor configuration interface}.
159
- */
160
- config;
161
- constructor(...[configuration]) {
162
- const _config_0 = (0, import_runtimeConfig.getRuntimeConfig)(configuration || {});
163
- super(_config_0);
164
- this.initConfig = _config_0;
165
- const _config_1 = resolveClientEndpointParameters(_config_0);
166
- const _config_2 = (0, import_middleware_user_agent.resolveUserAgentConfig)(_config_1);
167
- const _config_3 = (0, import_middleware_retry.resolveRetryConfig)(_config_2);
168
- const _config_4 = (0, import_config_resolver.resolveRegionConfig)(_config_3);
169
- const _config_5 = (0, import_middleware_host_header.resolveHostHeaderConfig)(_config_4);
170
- const _config_6 = (0, import_middleware_endpoint.resolveEndpointConfig)(_config_5);
171
- const _config_7 = (0, import_httpAuthSchemeProvider.resolveHttpAuthSchemeConfig)(_config_6);
172
- const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
173
- this.config = _config_8;
174
- this.middlewareStack.use((0, import_middleware_user_agent.getUserAgentPlugin)(this.config));
175
- this.middlewareStack.use((0, import_middleware_retry.getRetryPlugin)(this.config));
176
- this.middlewareStack.use((0, import_middleware_content_length.getContentLengthPlugin)(this.config));
177
- this.middlewareStack.use((0, import_middleware_host_header.getHostHeaderPlugin)(this.config));
178
- this.middlewareStack.use((0, import_middleware_logger.getLoggerPlugin)(this.config));
179
- this.middlewareStack.use((0, import_middleware_recursion_detection.getRecursionDetectionPlugin)(this.config));
180
- this.middlewareStack.use(
181
- (0, import_core.getHttpAuthSchemeEndpointRuleSetPlugin)(this.config, {
182
- httpAuthSchemeParametersProvider: import_httpAuthSchemeProvider.defaultLicenseManagerLinuxSubscriptionsHttpAuthSchemeParametersProvider,
183
- identityProviderConfigProvider: /* @__PURE__ */ __name(async (config) => new import_core.DefaultIdentityProviderConfig({
184
- "aws.auth#sigv4": config.credentials
185
- }), "identityProviderConfigProvider")
186
- })
187
- );
188
- this.middlewareStack.use((0, import_core.getHttpSigningPlugin)(this.config));
189
- }
190
- /**
191
- * Destroy underlying resources, like sockets. It's usually not necessary to do this.
192
- * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
193
- * Otherwise, sockets might stay open for quite a long time before the server terminates them.
194
- */
195
- destroy() {
196
- super.destroy();
197
- }
113
+ class LicenseManagerLinuxSubscriptionsServiceException extends smithyClient.ServiceException {
114
+ constructor(options) {
115
+ super(options);
116
+ Object.setPrototypeOf(this, LicenseManagerLinuxSubscriptionsServiceException.prototype);
117
+ }
118
+ }
119
+
120
+ class InternalServerException extends LicenseManagerLinuxSubscriptionsServiceException {
121
+ name = "InternalServerException";
122
+ $fault = "server";
123
+ constructor(opts) {
124
+ super({
125
+ name: "InternalServerException",
126
+ $fault: "server",
127
+ ...opts,
128
+ });
129
+ Object.setPrototypeOf(this, InternalServerException.prototype);
130
+ }
131
+ }
132
+ class ResourceNotFoundException extends LicenseManagerLinuxSubscriptionsServiceException {
133
+ name = "ResourceNotFoundException";
134
+ $fault = "client";
135
+ constructor(opts) {
136
+ super({
137
+ name: "ResourceNotFoundException",
138
+ $fault: "client",
139
+ ...opts,
140
+ });
141
+ Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
142
+ }
143
+ }
144
+ class ThrottlingException extends LicenseManagerLinuxSubscriptionsServiceException {
145
+ name = "ThrottlingException";
146
+ $fault = "client";
147
+ constructor(opts) {
148
+ super({
149
+ name: "ThrottlingException",
150
+ $fault: "client",
151
+ ...opts,
152
+ });
153
+ Object.setPrototypeOf(this, ThrottlingException.prototype);
154
+ }
155
+ }
156
+ class ValidationException extends LicenseManagerLinuxSubscriptionsServiceException {
157
+ name = "ValidationException";
158
+ $fault = "client";
159
+ constructor(opts) {
160
+ super({
161
+ name: "ValidationException",
162
+ $fault: "client",
163
+ ...opts,
164
+ });
165
+ Object.setPrototypeOf(this, ValidationException.prototype);
166
+ }
167
+ }
168
+ const Operator = {
169
+ CONTAINS: "Contains",
170
+ EQUAL: "Equal",
171
+ NOT_EQUAL: "NotEqual",
198
172
  };
199
-
200
- // src/LicenseManagerLinuxSubscriptions.ts
201
-
202
-
203
- // src/commands/DeregisterSubscriptionProviderCommand.ts
204
-
205
- var import_middleware_serde = require("@smithy/middleware-serde");
206
-
207
-
208
- // src/protocols/Aws_restJson1.ts
209
- var import_core2 = require("@aws-sdk/core");
210
-
211
-
212
-
213
- // src/models/LicenseManagerLinuxSubscriptionsServiceException.ts
214
-
215
- var LicenseManagerLinuxSubscriptionsServiceException = class _LicenseManagerLinuxSubscriptionsServiceException extends import_smithy_client.ServiceException {
216
- static {
217
- __name(this, "LicenseManagerLinuxSubscriptionsServiceException");
218
- }
219
- /**
220
- * @internal
221
- */
222
- constructor(options) {
223
- super(options);
224
- Object.setPrototypeOf(this, _LicenseManagerLinuxSubscriptionsServiceException.prototype);
225
- }
173
+ const SubscriptionProviderSource = {
174
+ RedHat: "RedHat",
226
175
  };
176
+ const SubscriptionProviderStatus = {
177
+ ACTIVE: "ACTIVE",
178
+ INVALID: "INVALID",
179
+ PENDING: "PENDING",
180
+ };
181
+ const LinuxSubscriptionsDiscovery = {
182
+ Disabled: "Disabled",
183
+ Enabled: "Enabled",
184
+ };
185
+ const OrganizationIntegration = {
186
+ Disabled: "Disabled",
187
+ Enabled: "Enabled",
188
+ };
189
+ const Status = {
190
+ Completed: "Completed",
191
+ Failed: "Failed",
192
+ InProgress: "InProgress",
193
+ Successful: "Successful",
194
+ };
195
+ const ListTagsForResourceResponseFilterSensitiveLog = (obj) => ({
196
+ ...obj,
197
+ ...(obj.tags && { tags: smithyClient.SENSITIVE_STRING }),
198
+ });
199
+ const RegisterSubscriptionProviderRequestFilterSensitiveLog = (obj) => ({
200
+ ...obj,
201
+ ...(obj.Tags && { Tags: smithyClient.SENSITIVE_STRING }),
202
+ });
203
+ const TagResourceRequestFilterSensitiveLog = (obj) => ({
204
+ ...obj,
205
+ ...(obj.tags && { tags: smithyClient.SENSITIVE_STRING }),
206
+ });
207
+ const UntagResourceRequestFilterSensitiveLog = (obj) => ({
208
+ ...obj,
209
+ ...(obj.tagKeys && { tagKeys: smithyClient.SENSITIVE_STRING }),
210
+ });
227
211
 
228
- // src/models/models_0.ts
229
-
230
- var InternalServerException = class _InternalServerException extends LicenseManagerLinuxSubscriptionsServiceException {
231
- static {
232
- __name(this, "InternalServerException");
233
- }
234
- name = "InternalServerException";
235
- $fault = "server";
236
- /**
237
- * @internal
238
- */
239
- constructor(opts) {
240
- super({
241
- name: "InternalServerException",
242
- $fault: "server",
243
- ...opts
244
- });
245
- Object.setPrototypeOf(this, _InternalServerException.prototype);
246
- }
212
+ const se_DeregisterSubscriptionProviderCommand = async (input, context) => {
213
+ const b = core.requestBuilder(input, context);
214
+ const headers = {
215
+ "content-type": "application/json",
216
+ };
217
+ b.bp("/subscription/DeregisterSubscriptionProvider");
218
+ let body;
219
+ body = JSON.stringify(smithyClient.take(input, {
220
+ SubscriptionProviderArn: [],
221
+ }));
222
+ b.m("POST").h(headers).b(body);
223
+ return b.build();
247
224
  };
248
- var ResourceNotFoundException = class _ResourceNotFoundException extends LicenseManagerLinuxSubscriptionsServiceException {
249
- static {
250
- __name(this, "ResourceNotFoundException");
251
- }
252
- name = "ResourceNotFoundException";
253
- $fault = "client";
254
- /**
255
- * @internal
256
- */
257
- constructor(opts) {
258
- super({
259
- name: "ResourceNotFoundException",
260
- $fault: "client",
261
- ...opts
262
- });
263
- Object.setPrototypeOf(this, _ResourceNotFoundException.prototype);
264
- }
225
+ const se_GetRegisteredSubscriptionProviderCommand = async (input, context) => {
226
+ const b = core.requestBuilder(input, context);
227
+ const headers = {
228
+ "content-type": "application/json",
229
+ };
230
+ b.bp("/subscription/GetRegisteredSubscriptionProvider");
231
+ let body;
232
+ body = JSON.stringify(smithyClient.take(input, {
233
+ SubscriptionProviderArn: [],
234
+ }));
235
+ b.m("POST").h(headers).b(body);
236
+ return b.build();
265
237
  };
266
- var ThrottlingException = class _ThrottlingException extends LicenseManagerLinuxSubscriptionsServiceException {
267
- static {
268
- __name(this, "ThrottlingException");
269
- }
270
- name = "ThrottlingException";
271
- $fault = "client";
272
- /**
273
- * @internal
274
- */
275
- constructor(opts) {
276
- super({
277
- name: "ThrottlingException",
278
- $fault: "client",
279
- ...opts
280
- });
281
- Object.setPrototypeOf(this, _ThrottlingException.prototype);
282
- }
238
+ const se_GetServiceSettingsCommand = async (input, context) => {
239
+ const b = core.requestBuilder(input, context);
240
+ const headers = {};
241
+ b.bp("/subscription/GetServiceSettings");
242
+ let body;
243
+ b.m("POST").h(headers).b(body);
244
+ return b.build();
283
245
  };
284
- var ValidationException = class _ValidationException extends LicenseManagerLinuxSubscriptionsServiceException {
285
- static {
286
- __name(this, "ValidationException");
287
- }
288
- name = "ValidationException";
289
- $fault = "client";
290
- /**
291
- * @internal
292
- */
293
- constructor(opts) {
294
- super({
295
- name: "ValidationException",
296
- $fault: "client",
297
- ...opts
298
- });
299
- Object.setPrototypeOf(this, _ValidationException.prototype);
300
- }
246
+ const se_ListLinuxSubscriptionInstancesCommand = async (input, context) => {
247
+ const b = core.requestBuilder(input, context);
248
+ const headers = {
249
+ "content-type": "application/json",
250
+ };
251
+ b.bp("/subscription/ListLinuxSubscriptionInstances");
252
+ let body;
253
+ body = JSON.stringify(smithyClient.take(input, {
254
+ Filters: (_) => smithyClient._json(_),
255
+ MaxResults: [],
256
+ NextToken: [],
257
+ }));
258
+ b.m("POST").h(headers).b(body);
259
+ return b.build();
301
260
  };
302
- var Operator = {
303
- /**
304
- * Contains operator
305
- */
306
- CONTAINS: "Contains",
307
- /**
308
- * Equal operator
309
- */
310
- EQUAL: "Equal",
311
- /**
312
- * Not equal operator
313
- */
314
- NOT_EQUAL: "NotEqual"
261
+ const se_ListLinuxSubscriptionsCommand = async (input, context) => {
262
+ const b = core.requestBuilder(input, context);
263
+ const headers = {
264
+ "content-type": "application/json",
265
+ };
266
+ b.bp("/subscription/ListLinuxSubscriptions");
267
+ let body;
268
+ body = JSON.stringify(smithyClient.take(input, {
269
+ Filters: (_) => smithyClient._json(_),
270
+ MaxResults: [],
271
+ NextToken: [],
272
+ }));
273
+ b.m("POST").h(headers).b(body);
274
+ return b.build();
315
275
  };
316
- var SubscriptionProviderSource = {
317
- /**
318
- * RedHat subscription provider namespace
319
- */
320
- RedHat: "RedHat"
276
+ const se_ListRegisteredSubscriptionProvidersCommand = async (input, context) => {
277
+ const b = core.requestBuilder(input, context);
278
+ const headers = {
279
+ "content-type": "application/json",
280
+ };
281
+ b.bp("/subscription/ListRegisteredSubscriptionProviders");
282
+ let body;
283
+ body = JSON.stringify(smithyClient.take(input, {
284
+ MaxResults: [],
285
+ NextToken: [],
286
+ SubscriptionProviderSources: (_) => smithyClient._json(_),
287
+ }));
288
+ b.m("POST").h(headers).b(body);
289
+ return b.build();
321
290
  };
322
- var SubscriptionProviderStatus = {
323
- /**
324
- * ACTIVE status
325
- */
326
- ACTIVE: "ACTIVE",
327
- /**
328
- * INVALID status
329
- */
330
- INVALID: "INVALID",
331
- /**
332
- * PENDING status
333
- */
334
- PENDING: "PENDING"
291
+ const se_ListTagsForResourceCommand = async (input, context) => {
292
+ const b = core.requestBuilder(input, context);
293
+ const headers = {};
294
+ b.bp("/tags/{resourceArn}");
295
+ b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
296
+ let body;
297
+ b.m("GET").h(headers).b(body);
298
+ return b.build();
335
299
  };
336
- var LinuxSubscriptionsDiscovery = {
337
- /**
338
- * Disabled LinuxSubscriptionsDiscovery
339
- */
340
- Disabled: "Disabled",
341
- /**
342
- * Enabled LinuxSubscriptionsDiscovery
343
- */
344
- Enabled: "Enabled"
300
+ const se_RegisterSubscriptionProviderCommand = async (input, context) => {
301
+ const b = core.requestBuilder(input, context);
302
+ const headers = {
303
+ "content-type": "application/json",
304
+ };
305
+ b.bp("/subscription/RegisterSubscriptionProvider");
306
+ let body;
307
+ body = JSON.stringify(smithyClient.take(input, {
308
+ SecretArn: [],
309
+ SubscriptionProviderSource: [],
310
+ Tags: (_) => smithyClient._json(_),
311
+ }));
312
+ b.m("POST").h(headers).b(body);
313
+ return b.build();
345
314
  };
346
- var OrganizationIntegration = {
347
- /**
348
- * Disabled OrganizationIntegration
349
- */
350
- Disabled: "Disabled",
351
- /**
352
- * Enabled OrganizationIntegration
353
- */
354
- Enabled: "Enabled"
315
+ const se_TagResourceCommand = async (input, context) => {
316
+ const b = core.requestBuilder(input, context);
317
+ const headers = {
318
+ "content-type": "application/json",
319
+ };
320
+ b.bp("/tags/{resourceArn}");
321
+ b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
322
+ let body;
323
+ body = JSON.stringify(smithyClient.take(input, {
324
+ tags: (_) => smithyClient._json(_),
325
+ }));
326
+ b.m("PUT").h(headers).b(body);
327
+ return b.build();
355
328
  };
356
- var Status = {
357
- /**
358
- * Completed status
359
- */
360
- Completed: "Completed",
361
- /**
362
- * Failed status
363
- */
364
- Failed: "Failed",
365
- /**
366
- * InProgress status
367
- */
368
- InProgress: "InProgress",
369
- /**
370
- * Successful status
371
- */
372
- Successful: "Successful"
329
+ const se_UntagResourceCommand = async (input, context) => {
330
+ const b = core.requestBuilder(input, context);
331
+ const headers = {};
332
+ b.bp("/tags/{resourceArn}");
333
+ b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
334
+ const query = smithyClient.map({
335
+ [_tK]: [smithyClient.expectNonNull(input.tagKeys, `tagKeys`) != null, () => input[_tK] || []],
336
+ });
337
+ let body;
338
+ b.m("DELETE").h(headers).q(query).b(body);
339
+ return b.build();
373
340
  };
374
- var ListTagsForResourceResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
375
- ...obj,
376
- ...obj.tags && { tags: import_smithy_client.SENSITIVE_STRING }
377
- }), "ListTagsForResourceResponseFilterSensitiveLog");
378
- var RegisterSubscriptionProviderRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
379
- ...obj,
380
- ...obj.Tags && { Tags: import_smithy_client.SENSITIVE_STRING }
381
- }), "RegisterSubscriptionProviderRequestFilterSensitiveLog");
382
- var TagResourceRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
383
- ...obj,
384
- ...obj.tags && { tags: import_smithy_client.SENSITIVE_STRING }
385
- }), "TagResourceRequestFilterSensitiveLog");
386
- var UntagResourceRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
387
- ...obj,
388
- ...obj.tagKeys && { tagKeys: import_smithy_client.SENSITIVE_STRING }
389
- }), "UntagResourceRequestFilterSensitiveLog");
390
-
391
- // src/protocols/Aws_restJson1.ts
392
- var se_DeregisterSubscriptionProviderCommand = /* @__PURE__ */ __name(async (input, context) => {
393
- const b = (0, import_core.requestBuilder)(input, context);
394
- const headers = {
395
- "content-type": "application/json"
396
- };
397
- b.bp("/subscription/DeregisterSubscriptionProvider");
398
- let body;
399
- body = JSON.stringify(
400
- (0, import_smithy_client.take)(input, {
401
- SubscriptionProviderArn: []
402
- })
403
- );
404
- b.m("POST").h(headers).b(body);
405
- return b.build();
406
- }, "se_DeregisterSubscriptionProviderCommand");
407
- var se_GetRegisteredSubscriptionProviderCommand = /* @__PURE__ */ __name(async (input, context) => {
408
- const b = (0, import_core.requestBuilder)(input, context);
409
- const headers = {
410
- "content-type": "application/json"
411
- };
412
- b.bp("/subscription/GetRegisteredSubscriptionProvider");
413
- let body;
414
- body = JSON.stringify(
415
- (0, import_smithy_client.take)(input, {
416
- SubscriptionProviderArn: []
417
- })
418
- );
419
- b.m("POST").h(headers).b(body);
420
- return b.build();
421
- }, "se_GetRegisteredSubscriptionProviderCommand");
422
- var se_GetServiceSettingsCommand = /* @__PURE__ */ __name(async (input, context) => {
423
- const b = (0, import_core.requestBuilder)(input, context);
424
- const headers = {};
425
- b.bp("/subscription/GetServiceSettings");
426
- let body;
427
- b.m("POST").h(headers).b(body);
428
- return b.build();
429
- }, "se_GetServiceSettingsCommand");
430
- var se_ListLinuxSubscriptionInstancesCommand = /* @__PURE__ */ __name(async (input, context) => {
431
- const b = (0, import_core.requestBuilder)(input, context);
432
- const headers = {
433
- "content-type": "application/json"
434
- };
435
- b.bp("/subscription/ListLinuxSubscriptionInstances");
436
- let body;
437
- body = JSON.stringify(
438
- (0, import_smithy_client.take)(input, {
439
- Filters: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "Filters"),
440
- MaxResults: [],
441
- NextToken: []
442
- })
443
- );
444
- b.m("POST").h(headers).b(body);
445
- return b.build();
446
- }, "se_ListLinuxSubscriptionInstancesCommand");
447
- var se_ListLinuxSubscriptionsCommand = /* @__PURE__ */ __name(async (input, context) => {
448
- const b = (0, import_core.requestBuilder)(input, context);
449
- const headers = {
450
- "content-type": "application/json"
451
- };
452
- b.bp("/subscription/ListLinuxSubscriptions");
453
- let body;
454
- body = JSON.stringify(
455
- (0, import_smithy_client.take)(input, {
456
- Filters: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "Filters"),
457
- MaxResults: [],
458
- NextToken: []
459
- })
460
- );
461
- b.m("POST").h(headers).b(body);
462
- return b.build();
463
- }, "se_ListLinuxSubscriptionsCommand");
464
- var se_ListRegisteredSubscriptionProvidersCommand = /* @__PURE__ */ __name(async (input, context) => {
465
- const b = (0, import_core.requestBuilder)(input, context);
466
- const headers = {
467
- "content-type": "application/json"
468
- };
469
- b.bp("/subscription/ListRegisteredSubscriptionProviders");
470
- let body;
471
- body = JSON.stringify(
472
- (0, import_smithy_client.take)(input, {
473
- MaxResults: [],
474
- NextToken: [],
475
- SubscriptionProviderSources: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "SubscriptionProviderSources")
476
- })
477
- );
478
- b.m("POST").h(headers).b(body);
479
- return b.build();
480
- }, "se_ListRegisteredSubscriptionProvidersCommand");
481
- var se_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
482
- const b = (0, import_core.requestBuilder)(input, context);
483
- const headers = {};
484
- b.bp("/tags/{resourceArn}");
485
- b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
486
- let body;
487
- b.m("GET").h(headers).b(body);
488
- return b.build();
489
- }, "se_ListTagsForResourceCommand");
490
- var se_RegisterSubscriptionProviderCommand = /* @__PURE__ */ __name(async (input, context) => {
491
- const b = (0, import_core.requestBuilder)(input, context);
492
- const headers = {
493
- "content-type": "application/json"
494
- };
495
- b.bp("/subscription/RegisterSubscriptionProvider");
496
- let body;
497
- body = JSON.stringify(
498
- (0, import_smithy_client.take)(input, {
499
- SecretArn: [],
500
- SubscriptionProviderSource: [],
501
- Tags: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "Tags")
502
- })
503
- );
504
- b.m("POST").h(headers).b(body);
505
- return b.build();
506
- }, "se_RegisterSubscriptionProviderCommand");
507
- var se_TagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
508
- const b = (0, import_core.requestBuilder)(input, context);
509
- const headers = {
510
- "content-type": "application/json"
511
- };
512
- b.bp("/tags/{resourceArn}");
513
- b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
514
- let body;
515
- body = JSON.stringify(
516
- (0, import_smithy_client.take)(input, {
517
- tags: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "tags")
518
- })
519
- );
520
- b.m("PUT").h(headers).b(body);
521
- return b.build();
522
- }, "se_TagResourceCommand");
523
- var se_UntagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
524
- const b = (0, import_core.requestBuilder)(input, context);
525
- const headers = {};
526
- b.bp("/tags/{resourceArn}");
527
- b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
528
- const query = (0, import_smithy_client.map)({
529
- [_tK]: [(0, import_smithy_client.expectNonNull)(input.tagKeys, `tagKeys`) != null, () => input[_tK] || []]
530
- });
531
- let body;
532
- b.m("DELETE").h(headers).q(query).b(body);
533
- return b.build();
534
- }, "se_UntagResourceCommand");
535
- var se_UpdateServiceSettingsCommand = /* @__PURE__ */ __name(async (input, context) => {
536
- const b = (0, import_core.requestBuilder)(input, context);
537
- const headers = {
538
- "content-type": "application/json"
539
- };
540
- b.bp("/subscription/UpdateServiceSettings");
541
- let body;
542
- body = JSON.stringify(
543
- (0, import_smithy_client.take)(input, {
544
- AllowUpdate: [],
545
- LinuxSubscriptionsDiscovery: [],
546
- LinuxSubscriptionsDiscoverySettings: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "LinuxSubscriptionsDiscoverySettings")
547
- })
548
- );
549
- b.m("POST").h(headers).b(body);
550
- return b.build();
551
- }, "se_UpdateServiceSettingsCommand");
552
- var de_DeregisterSubscriptionProviderCommand = /* @__PURE__ */ __name(async (output, context) => {
553
- if (output.statusCode !== 200 && output.statusCode >= 300) {
554
- return de_CommandError(output, context);
555
- }
556
- const contents = (0, import_smithy_client.map)({
557
- $metadata: deserializeMetadata(output)
558
- });
559
- await (0, import_smithy_client.collectBody)(output.body, context);
560
- return contents;
561
- }, "de_DeregisterSubscriptionProviderCommand");
562
- var de_GetRegisteredSubscriptionProviderCommand = /* @__PURE__ */ __name(async (output, context) => {
563
- if (output.statusCode !== 200 && output.statusCode >= 300) {
564
- return de_CommandError(output, context);
565
- }
566
- const contents = (0, import_smithy_client.map)({
567
- $metadata: deserializeMetadata(output)
568
- });
569
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
570
- const doc = (0, import_smithy_client.take)(data, {
571
- LastSuccessfulDataRetrievalTime: import_smithy_client.expectString,
572
- SecretArn: import_smithy_client.expectString,
573
- SubscriptionProviderArn: import_smithy_client.expectString,
574
- SubscriptionProviderSource: import_smithy_client.expectString,
575
- SubscriptionProviderStatus: import_smithy_client.expectString,
576
- SubscriptionProviderStatusMessage: import_smithy_client.expectString
577
- });
578
- Object.assign(contents, doc);
579
- return contents;
580
- }, "de_GetRegisteredSubscriptionProviderCommand");
581
- var de_GetServiceSettingsCommand = /* @__PURE__ */ __name(async (output, context) => {
582
- if (output.statusCode !== 200 && output.statusCode >= 300) {
583
- return de_CommandError(output, context);
584
- }
585
- const contents = (0, import_smithy_client.map)({
586
- $metadata: deserializeMetadata(output)
587
- });
588
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
589
- const doc = (0, import_smithy_client.take)(data, {
590
- HomeRegions: import_smithy_client._json,
591
- LinuxSubscriptionsDiscovery: import_smithy_client.expectString,
592
- LinuxSubscriptionsDiscoverySettings: import_smithy_client._json,
593
- Status: import_smithy_client.expectString,
594
- StatusMessage: import_smithy_client._json
595
- });
596
- Object.assign(contents, doc);
597
- return contents;
598
- }, "de_GetServiceSettingsCommand");
599
- var de_ListLinuxSubscriptionInstancesCommand = /* @__PURE__ */ __name(async (output, context) => {
600
- if (output.statusCode !== 200 && output.statusCode >= 300) {
601
- return de_CommandError(output, context);
602
- }
603
- const contents = (0, import_smithy_client.map)({
604
- $metadata: deserializeMetadata(output)
605
- });
606
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
607
- const doc = (0, import_smithy_client.take)(data, {
608
- Instances: import_smithy_client._json,
609
- NextToken: import_smithy_client.expectString
610
- });
611
- Object.assign(contents, doc);
612
- return contents;
613
- }, "de_ListLinuxSubscriptionInstancesCommand");
614
- var de_ListLinuxSubscriptionsCommand = /* @__PURE__ */ __name(async (output, context) => {
615
- if (output.statusCode !== 200 && output.statusCode >= 300) {
616
- return de_CommandError(output, context);
617
- }
618
- const contents = (0, import_smithy_client.map)({
619
- $metadata: deserializeMetadata(output)
620
- });
621
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
622
- const doc = (0, import_smithy_client.take)(data, {
623
- NextToken: import_smithy_client.expectString,
624
- Subscriptions: import_smithy_client._json
625
- });
626
- Object.assign(contents, doc);
627
- return contents;
628
- }, "de_ListLinuxSubscriptionsCommand");
629
- var de_ListRegisteredSubscriptionProvidersCommand = /* @__PURE__ */ __name(async (output, context) => {
630
- if (output.statusCode !== 200 && output.statusCode >= 300) {
631
- return de_CommandError(output, context);
632
- }
633
- const contents = (0, import_smithy_client.map)({
634
- $metadata: deserializeMetadata(output)
635
- });
636
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
637
- const doc = (0, import_smithy_client.take)(data, {
638
- NextToken: import_smithy_client.expectString,
639
- RegisteredSubscriptionProviders: import_smithy_client._json
640
- });
641
- Object.assign(contents, doc);
642
- return contents;
643
- }, "de_ListRegisteredSubscriptionProvidersCommand");
644
- var de_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
645
- if (output.statusCode !== 200 && output.statusCode >= 300) {
646
- return de_CommandError(output, context);
647
- }
648
- const contents = (0, import_smithy_client.map)({
649
- $metadata: deserializeMetadata(output)
650
- });
651
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
652
- const doc = (0, import_smithy_client.take)(data, {
653
- tags: import_smithy_client._json
654
- });
655
- Object.assign(contents, doc);
656
- return contents;
657
- }, "de_ListTagsForResourceCommand");
658
- var de_RegisterSubscriptionProviderCommand = /* @__PURE__ */ __name(async (output, context) => {
659
- if (output.statusCode !== 200 && output.statusCode >= 300) {
660
- return de_CommandError(output, context);
661
- }
662
- const contents = (0, import_smithy_client.map)({
663
- $metadata: deserializeMetadata(output)
664
- });
665
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
666
- const doc = (0, import_smithy_client.take)(data, {
667
- SubscriptionProviderArn: import_smithy_client.expectString,
668
- SubscriptionProviderSource: import_smithy_client.expectString,
669
- SubscriptionProviderStatus: import_smithy_client.expectString
670
- });
671
- Object.assign(contents, doc);
672
- return contents;
673
- }, "de_RegisterSubscriptionProviderCommand");
674
- var de_TagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
675
- if (output.statusCode !== 200 && output.statusCode >= 300) {
676
- return de_CommandError(output, context);
677
- }
678
- const contents = (0, import_smithy_client.map)({
679
- $metadata: deserializeMetadata(output)
680
- });
681
- await (0, import_smithy_client.collectBody)(output.body, context);
682
- return contents;
683
- }, "de_TagResourceCommand");
684
- var de_UntagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
685
- if (output.statusCode !== 200 && output.statusCode >= 300) {
686
- return de_CommandError(output, context);
687
- }
688
- const contents = (0, import_smithy_client.map)({
689
- $metadata: deserializeMetadata(output)
690
- });
691
- await (0, import_smithy_client.collectBody)(output.body, context);
692
- return contents;
693
- }, "de_UntagResourceCommand");
694
- var de_UpdateServiceSettingsCommand = /* @__PURE__ */ __name(async (output, context) => {
695
- if (output.statusCode !== 200 && output.statusCode >= 300) {
696
- return de_CommandError(output, context);
697
- }
698
- const contents = (0, import_smithy_client.map)({
699
- $metadata: deserializeMetadata(output)
700
- });
701
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
702
- const doc = (0, import_smithy_client.take)(data, {
703
- HomeRegions: import_smithy_client._json,
704
- LinuxSubscriptionsDiscovery: import_smithy_client.expectString,
705
- LinuxSubscriptionsDiscoverySettings: import_smithy_client._json,
706
- Status: import_smithy_client.expectString,
707
- StatusMessage: import_smithy_client._json
708
- });
709
- Object.assign(contents, doc);
710
- return contents;
711
- }, "de_UpdateServiceSettingsCommand");
712
- var de_CommandError = /* @__PURE__ */ __name(async (output, context) => {
713
- const parsedOutput = {
714
- ...output,
715
- body: await (0, import_core2.parseJsonErrorBody)(output.body, context)
716
- };
717
- const errorCode = (0, import_core2.loadRestJsonErrorCode)(output, parsedOutput.body);
718
- switch (errorCode) {
719
- case "InternalServerException":
720
- case "com.amazonaws.licensemanagerlinuxsubscriptions#InternalServerException":
721
- throw await de_InternalServerExceptionRes(parsedOutput, context);
722
- case "ResourceNotFoundException":
723
- case "com.amazonaws.licensemanagerlinuxsubscriptions#ResourceNotFoundException":
724
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
725
- case "ThrottlingException":
726
- case "com.amazonaws.licensemanagerlinuxsubscriptions#ThrottlingException":
727
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
728
- case "ValidationException":
729
- case "com.amazonaws.licensemanagerlinuxsubscriptions#ValidationException":
730
- throw await de_ValidationExceptionRes(parsedOutput, context);
731
- default:
732
- const parsedBody = parsedOutput.body;
733
- return throwDefaultError({
734
- output,
735
- parsedBody,
736
- errorCode
737
- });
738
- }
739
- }, "de_CommandError");
740
- var throwDefaultError = (0, import_smithy_client.withBaseException)(LicenseManagerLinuxSubscriptionsServiceException);
741
- var de_InternalServerExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
742
- const contents = (0, import_smithy_client.map)({});
743
- const data = parsedOutput.body;
744
- const doc = (0, import_smithy_client.take)(data, {
745
- message: import_smithy_client.expectString
746
- });
747
- Object.assign(contents, doc);
748
- const exception = new InternalServerException({
749
- $metadata: deserializeMetadata(parsedOutput),
750
- ...contents
751
- });
752
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
753
- }, "de_InternalServerExceptionRes");
754
- var de_ResourceNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
755
- const contents = (0, import_smithy_client.map)({});
756
- const data = parsedOutput.body;
757
- const doc = (0, import_smithy_client.take)(data, {
758
- message: import_smithy_client.expectString
759
- });
760
- Object.assign(contents, doc);
761
- const exception = new ResourceNotFoundException({
762
- $metadata: deserializeMetadata(parsedOutput),
763
- ...contents
764
- });
765
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
766
- }, "de_ResourceNotFoundExceptionRes");
767
- var de_ThrottlingExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
768
- const contents = (0, import_smithy_client.map)({});
769
- const data = parsedOutput.body;
770
- const doc = (0, import_smithy_client.take)(data, {
771
- message: import_smithy_client.expectString
772
- });
773
- Object.assign(contents, doc);
774
- const exception = new ThrottlingException({
775
- $metadata: deserializeMetadata(parsedOutput),
776
- ...contents
777
- });
778
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
779
- }, "de_ThrottlingExceptionRes");
780
- var de_ValidationExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
781
- const contents = (0, import_smithy_client.map)({});
782
- const data = parsedOutput.body;
783
- const doc = (0, import_smithy_client.take)(data, {
784
- message: import_smithy_client.expectString
785
- });
786
- Object.assign(contents, doc);
787
- const exception = new ValidationException({
788
- $metadata: deserializeMetadata(parsedOutput),
789
- ...contents
790
- });
791
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
792
- }, "de_ValidationExceptionRes");
793
- var deserializeMetadata = /* @__PURE__ */ __name((output) => ({
794
- httpStatusCode: output.statusCode,
795
- requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
796
- extendedRequestId: output.headers["x-amz-id-2"],
797
- cfId: output.headers["x-amz-cf-id"]
798
- }), "deserializeMetadata");
799
- var _tK = "tagKeys";
800
-
801
- // src/commands/DeregisterSubscriptionProviderCommand.ts
802
- var DeregisterSubscriptionProviderCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
803
- return [
804
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
805
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
806
- ];
807
- }).s("LicenseManagerLinuxSubscriptions", "DeregisterSubscriptionProvider", {}).n("LicenseManagerLinuxSubscriptionsClient", "DeregisterSubscriptionProviderCommand").f(void 0, void 0).ser(se_DeregisterSubscriptionProviderCommand).de(de_DeregisterSubscriptionProviderCommand).build() {
808
- static {
809
- __name(this, "DeregisterSubscriptionProviderCommand");
810
- }
341
+ const se_UpdateServiceSettingsCommand = async (input, context) => {
342
+ const b = core.requestBuilder(input, context);
343
+ const headers = {
344
+ "content-type": "application/json",
345
+ };
346
+ b.bp("/subscription/UpdateServiceSettings");
347
+ let body;
348
+ body = JSON.stringify(smithyClient.take(input, {
349
+ AllowUpdate: [],
350
+ LinuxSubscriptionsDiscovery: [],
351
+ LinuxSubscriptionsDiscoverySettings: (_) => smithyClient._json(_),
352
+ }));
353
+ b.m("POST").h(headers).b(body);
354
+ return b.build();
811
355
  };
812
-
813
- // src/commands/GetRegisteredSubscriptionProviderCommand.ts
814
-
815
-
816
-
817
- var GetRegisteredSubscriptionProviderCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
818
- return [
819
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
820
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
821
- ];
822
- }).s("LicenseManagerLinuxSubscriptions", "GetRegisteredSubscriptionProvider", {}).n("LicenseManagerLinuxSubscriptionsClient", "GetRegisteredSubscriptionProviderCommand").f(void 0, void 0).ser(se_GetRegisteredSubscriptionProviderCommand).de(de_GetRegisteredSubscriptionProviderCommand).build() {
823
- static {
824
- __name(this, "GetRegisteredSubscriptionProviderCommand");
825
- }
356
+ const de_DeregisterSubscriptionProviderCommand = async (output, context) => {
357
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
358
+ return de_CommandError(output, context);
359
+ }
360
+ const contents = smithyClient.map({
361
+ $metadata: deserializeMetadata(output),
362
+ });
363
+ await smithyClient.collectBody(output.body, context);
364
+ return contents;
826
365
  };
827
-
828
- // src/commands/GetServiceSettingsCommand.ts
829
-
830
-
831
-
832
- var GetServiceSettingsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
833
- return [
834
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
835
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
836
- ];
837
- }).s("LicenseManagerLinuxSubscriptions", "GetServiceSettings", {}).n("LicenseManagerLinuxSubscriptionsClient", "GetServiceSettingsCommand").f(void 0, void 0).ser(se_GetServiceSettingsCommand).de(de_GetServiceSettingsCommand).build() {
838
- static {
839
- __name(this, "GetServiceSettingsCommand");
840
- }
366
+ const de_GetRegisteredSubscriptionProviderCommand = async (output, context) => {
367
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
368
+ return de_CommandError(output, context);
369
+ }
370
+ const contents = smithyClient.map({
371
+ $metadata: deserializeMetadata(output),
372
+ });
373
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
374
+ const doc = smithyClient.take(data, {
375
+ LastSuccessfulDataRetrievalTime: smithyClient.expectString,
376
+ SecretArn: smithyClient.expectString,
377
+ SubscriptionProviderArn: smithyClient.expectString,
378
+ SubscriptionProviderSource: smithyClient.expectString,
379
+ SubscriptionProviderStatus: smithyClient.expectString,
380
+ SubscriptionProviderStatusMessage: smithyClient.expectString,
381
+ });
382
+ Object.assign(contents, doc);
383
+ return contents;
841
384
  };
842
-
843
- // src/commands/ListLinuxSubscriptionInstancesCommand.ts
844
-
845
-
846
-
847
- var ListLinuxSubscriptionInstancesCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
848
- return [
849
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
850
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
851
- ];
852
- }).s("LicenseManagerLinuxSubscriptions", "ListLinuxSubscriptionInstances", {}).n("LicenseManagerLinuxSubscriptionsClient", "ListLinuxSubscriptionInstancesCommand").f(void 0, void 0).ser(se_ListLinuxSubscriptionInstancesCommand).de(de_ListLinuxSubscriptionInstancesCommand).build() {
853
- static {
854
- __name(this, "ListLinuxSubscriptionInstancesCommand");
855
- }
385
+ const de_GetServiceSettingsCommand = async (output, context) => {
386
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
387
+ return de_CommandError(output, context);
388
+ }
389
+ const contents = smithyClient.map({
390
+ $metadata: deserializeMetadata(output),
391
+ });
392
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
393
+ const doc = smithyClient.take(data, {
394
+ HomeRegions: smithyClient._json,
395
+ LinuxSubscriptionsDiscovery: smithyClient.expectString,
396
+ LinuxSubscriptionsDiscoverySettings: smithyClient._json,
397
+ Status: smithyClient.expectString,
398
+ StatusMessage: smithyClient._json,
399
+ });
400
+ Object.assign(contents, doc);
401
+ return contents;
856
402
  };
857
-
858
- // src/commands/ListLinuxSubscriptionsCommand.ts
859
-
860
-
861
-
862
- var ListLinuxSubscriptionsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
863
- return [
864
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
865
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
866
- ];
867
- }).s("LicenseManagerLinuxSubscriptions", "ListLinuxSubscriptions", {}).n("LicenseManagerLinuxSubscriptionsClient", "ListLinuxSubscriptionsCommand").f(void 0, void 0).ser(se_ListLinuxSubscriptionsCommand).de(de_ListLinuxSubscriptionsCommand).build() {
868
- static {
869
- __name(this, "ListLinuxSubscriptionsCommand");
870
- }
403
+ const de_ListLinuxSubscriptionInstancesCommand = async (output, context) => {
404
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
405
+ return de_CommandError(output, context);
406
+ }
407
+ const contents = smithyClient.map({
408
+ $metadata: deserializeMetadata(output),
409
+ });
410
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
411
+ const doc = smithyClient.take(data, {
412
+ Instances: smithyClient._json,
413
+ NextToken: smithyClient.expectString,
414
+ });
415
+ Object.assign(contents, doc);
416
+ return contents;
871
417
  };
872
-
873
- // src/commands/ListRegisteredSubscriptionProvidersCommand.ts
874
-
875
-
876
-
877
- var ListRegisteredSubscriptionProvidersCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
878
- return [
879
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
880
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
881
- ];
882
- }).s("LicenseManagerLinuxSubscriptions", "ListRegisteredSubscriptionProviders", {}).n("LicenseManagerLinuxSubscriptionsClient", "ListRegisteredSubscriptionProvidersCommand").f(void 0, void 0).ser(se_ListRegisteredSubscriptionProvidersCommand).de(de_ListRegisteredSubscriptionProvidersCommand).build() {
883
- static {
884
- __name(this, "ListRegisteredSubscriptionProvidersCommand");
885
- }
418
+ const de_ListLinuxSubscriptionsCommand = async (output, context) => {
419
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
420
+ return de_CommandError(output, context);
421
+ }
422
+ const contents = smithyClient.map({
423
+ $metadata: deserializeMetadata(output),
424
+ });
425
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
426
+ const doc = smithyClient.take(data, {
427
+ NextToken: smithyClient.expectString,
428
+ Subscriptions: smithyClient._json,
429
+ });
430
+ Object.assign(contents, doc);
431
+ return contents;
886
432
  };
887
-
888
- // src/commands/ListTagsForResourceCommand.ts
889
-
890
-
891
-
892
- var ListTagsForResourceCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
893
- return [
894
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
895
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
896
- ];
897
- }).s("LicenseManagerLinuxSubscriptions", "ListTagsForResource", {}).n("LicenseManagerLinuxSubscriptionsClient", "ListTagsForResourceCommand").f(void 0, ListTagsForResourceResponseFilterSensitiveLog).ser(se_ListTagsForResourceCommand).de(de_ListTagsForResourceCommand).build() {
898
- static {
899
- __name(this, "ListTagsForResourceCommand");
900
- }
433
+ const de_ListRegisteredSubscriptionProvidersCommand = async (output, context) => {
434
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
435
+ return de_CommandError(output, context);
436
+ }
437
+ const contents = smithyClient.map({
438
+ $metadata: deserializeMetadata(output),
439
+ });
440
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
441
+ const doc = smithyClient.take(data, {
442
+ NextToken: smithyClient.expectString,
443
+ RegisteredSubscriptionProviders: smithyClient._json,
444
+ });
445
+ Object.assign(contents, doc);
446
+ return contents;
901
447
  };
902
-
903
- // src/commands/RegisterSubscriptionProviderCommand.ts
904
-
905
-
906
-
907
- var RegisterSubscriptionProviderCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
908
- return [
909
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
910
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
911
- ];
912
- }).s("LicenseManagerLinuxSubscriptions", "RegisterSubscriptionProvider", {}).n("LicenseManagerLinuxSubscriptionsClient", "RegisterSubscriptionProviderCommand").f(RegisterSubscriptionProviderRequestFilterSensitiveLog, void 0).ser(se_RegisterSubscriptionProviderCommand).de(de_RegisterSubscriptionProviderCommand).build() {
913
- static {
914
- __name(this, "RegisterSubscriptionProviderCommand");
915
- }
448
+ const de_ListTagsForResourceCommand = async (output, context) => {
449
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
450
+ return de_CommandError(output, context);
451
+ }
452
+ const contents = smithyClient.map({
453
+ $metadata: deserializeMetadata(output),
454
+ });
455
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
456
+ const doc = smithyClient.take(data, {
457
+ tags: smithyClient._json,
458
+ });
459
+ Object.assign(contents, doc);
460
+ return contents;
916
461
  };
917
-
918
- // src/commands/TagResourceCommand.ts
919
-
920
-
921
-
922
- var TagResourceCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
923
- return [
924
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
925
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
926
- ];
927
- }).s("LicenseManagerLinuxSubscriptions", "TagResource", {}).n("LicenseManagerLinuxSubscriptionsClient", "TagResourceCommand").f(TagResourceRequestFilterSensitiveLog, void 0).ser(se_TagResourceCommand).de(de_TagResourceCommand).build() {
928
- static {
929
- __name(this, "TagResourceCommand");
930
- }
462
+ const de_RegisterSubscriptionProviderCommand = async (output, context) => {
463
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
464
+ return de_CommandError(output, context);
465
+ }
466
+ const contents = smithyClient.map({
467
+ $metadata: deserializeMetadata(output),
468
+ });
469
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
470
+ const doc = smithyClient.take(data, {
471
+ SubscriptionProviderArn: smithyClient.expectString,
472
+ SubscriptionProviderSource: smithyClient.expectString,
473
+ SubscriptionProviderStatus: smithyClient.expectString,
474
+ });
475
+ Object.assign(contents, doc);
476
+ return contents;
931
477
  };
932
-
933
- // src/commands/UntagResourceCommand.ts
934
-
935
-
936
-
937
- var UntagResourceCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
938
- return [
939
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
940
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
941
- ];
942
- }).s("LicenseManagerLinuxSubscriptions", "UntagResource", {}).n("LicenseManagerLinuxSubscriptionsClient", "UntagResourceCommand").f(UntagResourceRequestFilterSensitiveLog, void 0).ser(se_UntagResourceCommand).de(de_UntagResourceCommand).build() {
943
- static {
944
- __name(this, "UntagResourceCommand");
945
- }
478
+ const de_TagResourceCommand = async (output, context) => {
479
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
480
+ return de_CommandError(output, context);
481
+ }
482
+ const contents = smithyClient.map({
483
+ $metadata: deserializeMetadata(output),
484
+ });
485
+ await smithyClient.collectBody(output.body, context);
486
+ return contents;
946
487
  };
947
-
948
- // src/commands/UpdateServiceSettingsCommand.ts
949
-
950
-
951
-
952
- var UpdateServiceSettingsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
953
- return [
954
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
955
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
956
- ];
957
- }).s("LicenseManagerLinuxSubscriptions", "UpdateServiceSettings", {}).n("LicenseManagerLinuxSubscriptionsClient", "UpdateServiceSettingsCommand").f(void 0, void 0).ser(se_UpdateServiceSettingsCommand).de(de_UpdateServiceSettingsCommand).build() {
958
- static {
959
- __name(this, "UpdateServiceSettingsCommand");
960
- }
488
+ const de_UntagResourceCommand = async (output, context) => {
489
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
490
+ return de_CommandError(output, context);
491
+ }
492
+ const contents = smithyClient.map({
493
+ $metadata: deserializeMetadata(output),
494
+ });
495
+ await smithyClient.collectBody(output.body, context);
496
+ return contents;
961
497
  };
962
-
963
- // src/LicenseManagerLinuxSubscriptions.ts
964
- var commands = {
965
- DeregisterSubscriptionProviderCommand,
966
- GetRegisteredSubscriptionProviderCommand,
967
- GetServiceSettingsCommand,
968
- ListLinuxSubscriptionInstancesCommand,
969
- ListLinuxSubscriptionsCommand,
970
- ListRegisteredSubscriptionProvidersCommand,
971
- ListTagsForResourceCommand,
972
- RegisterSubscriptionProviderCommand,
973
- TagResourceCommand,
974
- UntagResourceCommand,
975
- UpdateServiceSettingsCommand
498
+ const de_UpdateServiceSettingsCommand = async (output, context) => {
499
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
500
+ return de_CommandError(output, context);
501
+ }
502
+ const contents = smithyClient.map({
503
+ $metadata: deserializeMetadata(output),
504
+ });
505
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
506
+ const doc = smithyClient.take(data, {
507
+ HomeRegions: smithyClient._json,
508
+ LinuxSubscriptionsDiscovery: smithyClient.expectString,
509
+ LinuxSubscriptionsDiscoverySettings: smithyClient._json,
510
+ Status: smithyClient.expectString,
511
+ StatusMessage: smithyClient._json,
512
+ });
513
+ Object.assign(contents, doc);
514
+ return contents;
976
515
  };
977
- var LicenseManagerLinuxSubscriptions = class extends LicenseManagerLinuxSubscriptionsClient {
978
- static {
979
- __name(this, "LicenseManagerLinuxSubscriptions");
980
- }
516
+ const de_CommandError = async (output, context) => {
517
+ const parsedOutput = {
518
+ ...output,
519
+ body: await core$1.parseJsonErrorBody(output.body, context),
520
+ };
521
+ const errorCode = core$1.loadRestJsonErrorCode(output, parsedOutput.body);
522
+ switch (errorCode) {
523
+ case "InternalServerException":
524
+ case "com.amazonaws.licensemanagerlinuxsubscriptions#InternalServerException":
525
+ throw await de_InternalServerExceptionRes(parsedOutput);
526
+ case "ResourceNotFoundException":
527
+ case "com.amazonaws.licensemanagerlinuxsubscriptions#ResourceNotFoundException":
528
+ throw await de_ResourceNotFoundExceptionRes(parsedOutput);
529
+ case "ThrottlingException":
530
+ case "com.amazonaws.licensemanagerlinuxsubscriptions#ThrottlingException":
531
+ throw await de_ThrottlingExceptionRes(parsedOutput);
532
+ case "ValidationException":
533
+ case "com.amazonaws.licensemanagerlinuxsubscriptions#ValidationException":
534
+ throw await de_ValidationExceptionRes(parsedOutput);
535
+ default:
536
+ const parsedBody = parsedOutput.body;
537
+ return throwDefaultError({
538
+ output,
539
+ parsedBody,
540
+ errorCode,
541
+ });
542
+ }
981
543
  };
982
- (0, import_smithy_client.createAggregatedClient)(commands, LicenseManagerLinuxSubscriptions);
983
-
984
- // src/pagination/ListLinuxSubscriptionInstancesPaginator.ts
985
-
986
- var paginateListLinuxSubscriptionInstances = (0, import_core.createPaginator)(
987
- LicenseManagerLinuxSubscriptionsClient,
988
- ListLinuxSubscriptionInstancesCommand,
989
- "NextToken",
990
- "NextToken",
991
- "MaxResults"
992
- );
993
-
994
- // src/pagination/ListLinuxSubscriptionsPaginator.ts
544
+ const throwDefaultError = smithyClient.withBaseException(LicenseManagerLinuxSubscriptionsServiceException);
545
+ const de_InternalServerExceptionRes = async (parsedOutput, context) => {
546
+ const contents = smithyClient.map({});
547
+ const data = parsedOutput.body;
548
+ const doc = smithyClient.take(data, {
549
+ message: smithyClient.expectString,
550
+ });
551
+ Object.assign(contents, doc);
552
+ const exception = new InternalServerException({
553
+ $metadata: deserializeMetadata(parsedOutput),
554
+ ...contents,
555
+ });
556
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
557
+ };
558
+ const de_ResourceNotFoundExceptionRes = async (parsedOutput, context) => {
559
+ const contents = smithyClient.map({});
560
+ const data = parsedOutput.body;
561
+ const doc = smithyClient.take(data, {
562
+ message: smithyClient.expectString,
563
+ });
564
+ Object.assign(contents, doc);
565
+ const exception = new ResourceNotFoundException({
566
+ $metadata: deserializeMetadata(parsedOutput),
567
+ ...contents,
568
+ });
569
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
570
+ };
571
+ const de_ThrottlingExceptionRes = async (parsedOutput, context) => {
572
+ const contents = smithyClient.map({});
573
+ const data = parsedOutput.body;
574
+ const doc = smithyClient.take(data, {
575
+ message: smithyClient.expectString,
576
+ });
577
+ Object.assign(contents, doc);
578
+ const exception = new ThrottlingException({
579
+ $metadata: deserializeMetadata(parsedOutput),
580
+ ...contents,
581
+ });
582
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
583
+ };
584
+ const de_ValidationExceptionRes = async (parsedOutput, context) => {
585
+ const contents = smithyClient.map({});
586
+ const data = parsedOutput.body;
587
+ const doc = smithyClient.take(data, {
588
+ message: smithyClient.expectString,
589
+ });
590
+ Object.assign(contents, doc);
591
+ const exception = new ValidationException({
592
+ $metadata: deserializeMetadata(parsedOutput),
593
+ ...contents,
594
+ });
595
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
596
+ };
597
+ const deserializeMetadata = (output) => ({
598
+ httpStatusCode: output.statusCode,
599
+ requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
600
+ extendedRequestId: output.headers["x-amz-id-2"],
601
+ cfId: output.headers["x-amz-cf-id"],
602
+ });
603
+ const _tK = "tagKeys";
604
+
605
+ class DeregisterSubscriptionProviderCommand extends smithyClient.Command
606
+ .classBuilder()
607
+ .ep(commonParams)
608
+ .m(function (Command, cs, config, o) {
609
+ return [
610
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
611
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
612
+ ];
613
+ })
614
+ .s("LicenseManagerLinuxSubscriptions", "DeregisterSubscriptionProvider", {})
615
+ .n("LicenseManagerLinuxSubscriptionsClient", "DeregisterSubscriptionProviderCommand")
616
+ .f(void 0, void 0)
617
+ .ser(se_DeregisterSubscriptionProviderCommand)
618
+ .de(de_DeregisterSubscriptionProviderCommand)
619
+ .build() {
620
+ }
621
+
622
+ class GetRegisteredSubscriptionProviderCommand extends smithyClient.Command
623
+ .classBuilder()
624
+ .ep(commonParams)
625
+ .m(function (Command, cs, config, o) {
626
+ return [
627
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
628
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
629
+ ];
630
+ })
631
+ .s("LicenseManagerLinuxSubscriptions", "GetRegisteredSubscriptionProvider", {})
632
+ .n("LicenseManagerLinuxSubscriptionsClient", "GetRegisteredSubscriptionProviderCommand")
633
+ .f(void 0, void 0)
634
+ .ser(se_GetRegisteredSubscriptionProviderCommand)
635
+ .de(de_GetRegisteredSubscriptionProviderCommand)
636
+ .build() {
637
+ }
638
+
639
+ class GetServiceSettingsCommand extends smithyClient.Command
640
+ .classBuilder()
641
+ .ep(commonParams)
642
+ .m(function (Command, cs, config, o) {
643
+ return [
644
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
645
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
646
+ ];
647
+ })
648
+ .s("LicenseManagerLinuxSubscriptions", "GetServiceSettings", {})
649
+ .n("LicenseManagerLinuxSubscriptionsClient", "GetServiceSettingsCommand")
650
+ .f(void 0, void 0)
651
+ .ser(se_GetServiceSettingsCommand)
652
+ .de(de_GetServiceSettingsCommand)
653
+ .build() {
654
+ }
655
+
656
+ class ListLinuxSubscriptionInstancesCommand extends smithyClient.Command
657
+ .classBuilder()
658
+ .ep(commonParams)
659
+ .m(function (Command, cs, config, o) {
660
+ return [
661
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
662
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
663
+ ];
664
+ })
665
+ .s("LicenseManagerLinuxSubscriptions", "ListLinuxSubscriptionInstances", {})
666
+ .n("LicenseManagerLinuxSubscriptionsClient", "ListLinuxSubscriptionInstancesCommand")
667
+ .f(void 0, void 0)
668
+ .ser(se_ListLinuxSubscriptionInstancesCommand)
669
+ .de(de_ListLinuxSubscriptionInstancesCommand)
670
+ .build() {
671
+ }
672
+
673
+ class ListLinuxSubscriptionsCommand extends smithyClient.Command
674
+ .classBuilder()
675
+ .ep(commonParams)
676
+ .m(function (Command, cs, config, o) {
677
+ return [
678
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
679
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
680
+ ];
681
+ })
682
+ .s("LicenseManagerLinuxSubscriptions", "ListLinuxSubscriptions", {})
683
+ .n("LicenseManagerLinuxSubscriptionsClient", "ListLinuxSubscriptionsCommand")
684
+ .f(void 0, void 0)
685
+ .ser(se_ListLinuxSubscriptionsCommand)
686
+ .de(de_ListLinuxSubscriptionsCommand)
687
+ .build() {
688
+ }
689
+
690
+ class ListRegisteredSubscriptionProvidersCommand extends smithyClient.Command
691
+ .classBuilder()
692
+ .ep(commonParams)
693
+ .m(function (Command, cs, config, o) {
694
+ return [
695
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
696
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
697
+ ];
698
+ })
699
+ .s("LicenseManagerLinuxSubscriptions", "ListRegisteredSubscriptionProviders", {})
700
+ .n("LicenseManagerLinuxSubscriptionsClient", "ListRegisteredSubscriptionProvidersCommand")
701
+ .f(void 0, void 0)
702
+ .ser(se_ListRegisteredSubscriptionProvidersCommand)
703
+ .de(de_ListRegisteredSubscriptionProvidersCommand)
704
+ .build() {
705
+ }
706
+
707
+ class ListTagsForResourceCommand extends smithyClient.Command
708
+ .classBuilder()
709
+ .ep(commonParams)
710
+ .m(function (Command, cs, config, o) {
711
+ return [
712
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
713
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
714
+ ];
715
+ })
716
+ .s("LicenseManagerLinuxSubscriptions", "ListTagsForResource", {})
717
+ .n("LicenseManagerLinuxSubscriptionsClient", "ListTagsForResourceCommand")
718
+ .f(void 0, ListTagsForResourceResponseFilterSensitiveLog)
719
+ .ser(se_ListTagsForResourceCommand)
720
+ .de(de_ListTagsForResourceCommand)
721
+ .build() {
722
+ }
723
+
724
+ class RegisterSubscriptionProviderCommand extends smithyClient.Command
725
+ .classBuilder()
726
+ .ep(commonParams)
727
+ .m(function (Command, cs, config, o) {
728
+ return [
729
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
730
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
731
+ ];
732
+ })
733
+ .s("LicenseManagerLinuxSubscriptions", "RegisterSubscriptionProvider", {})
734
+ .n("LicenseManagerLinuxSubscriptionsClient", "RegisterSubscriptionProviderCommand")
735
+ .f(RegisterSubscriptionProviderRequestFilterSensitiveLog, void 0)
736
+ .ser(se_RegisterSubscriptionProviderCommand)
737
+ .de(de_RegisterSubscriptionProviderCommand)
738
+ .build() {
739
+ }
740
+
741
+ class TagResourceCommand extends smithyClient.Command
742
+ .classBuilder()
743
+ .ep(commonParams)
744
+ .m(function (Command, cs, config, o) {
745
+ return [
746
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
747
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
748
+ ];
749
+ })
750
+ .s("LicenseManagerLinuxSubscriptions", "TagResource", {})
751
+ .n("LicenseManagerLinuxSubscriptionsClient", "TagResourceCommand")
752
+ .f(TagResourceRequestFilterSensitiveLog, void 0)
753
+ .ser(se_TagResourceCommand)
754
+ .de(de_TagResourceCommand)
755
+ .build() {
756
+ }
757
+
758
+ class UntagResourceCommand extends smithyClient.Command
759
+ .classBuilder()
760
+ .ep(commonParams)
761
+ .m(function (Command, cs, config, o) {
762
+ return [
763
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
764
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
765
+ ];
766
+ })
767
+ .s("LicenseManagerLinuxSubscriptions", "UntagResource", {})
768
+ .n("LicenseManagerLinuxSubscriptionsClient", "UntagResourceCommand")
769
+ .f(UntagResourceRequestFilterSensitiveLog, void 0)
770
+ .ser(se_UntagResourceCommand)
771
+ .de(de_UntagResourceCommand)
772
+ .build() {
773
+ }
774
+
775
+ class UpdateServiceSettingsCommand extends smithyClient.Command
776
+ .classBuilder()
777
+ .ep(commonParams)
778
+ .m(function (Command, cs, config, o) {
779
+ return [
780
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
781
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
782
+ ];
783
+ })
784
+ .s("LicenseManagerLinuxSubscriptions", "UpdateServiceSettings", {})
785
+ .n("LicenseManagerLinuxSubscriptionsClient", "UpdateServiceSettingsCommand")
786
+ .f(void 0, void 0)
787
+ .ser(se_UpdateServiceSettingsCommand)
788
+ .de(de_UpdateServiceSettingsCommand)
789
+ .build() {
790
+ }
791
+
792
+ const commands = {
793
+ DeregisterSubscriptionProviderCommand,
794
+ GetRegisteredSubscriptionProviderCommand,
795
+ GetServiceSettingsCommand,
796
+ ListLinuxSubscriptionInstancesCommand,
797
+ ListLinuxSubscriptionsCommand,
798
+ ListRegisteredSubscriptionProvidersCommand,
799
+ ListTagsForResourceCommand,
800
+ RegisterSubscriptionProviderCommand,
801
+ TagResourceCommand,
802
+ UntagResourceCommand,
803
+ UpdateServiceSettingsCommand,
804
+ };
805
+ class LicenseManagerLinuxSubscriptions extends LicenseManagerLinuxSubscriptionsClient {
806
+ }
807
+ smithyClient.createAggregatedClient(commands, LicenseManagerLinuxSubscriptions);
995
808
 
996
- var paginateListLinuxSubscriptions = (0, import_core.createPaginator)(LicenseManagerLinuxSubscriptionsClient, ListLinuxSubscriptionsCommand, "NextToken", "NextToken", "MaxResults");
809
+ const paginateListLinuxSubscriptionInstances = core.createPaginator(LicenseManagerLinuxSubscriptionsClient, ListLinuxSubscriptionInstancesCommand, "NextToken", "NextToken", "MaxResults");
997
810
 
998
- // src/pagination/ListRegisteredSubscriptionProvidersPaginator.ts
811
+ const paginateListLinuxSubscriptions = core.createPaginator(LicenseManagerLinuxSubscriptionsClient, ListLinuxSubscriptionsCommand, "NextToken", "NextToken", "MaxResults");
999
812
 
1000
- var paginateListRegisteredSubscriptionProviders = (0, import_core.createPaginator)(
1001
- LicenseManagerLinuxSubscriptionsClient,
1002
- ListRegisteredSubscriptionProvidersCommand,
1003
- "NextToken",
1004
- "NextToken",
1005
- "MaxResults"
1006
- );
1007
- // Annotate the CommonJS export names for ESM import in node:
813
+ const paginateListRegisteredSubscriptionProviders = core.createPaginator(LicenseManagerLinuxSubscriptionsClient, ListRegisteredSubscriptionProvidersCommand, "NextToken", "NextToken", "MaxResults");
1008
814
 
1009
- 0 && (module.exports = {
1010
- LicenseManagerLinuxSubscriptionsServiceException,
1011
- __Client,
1012
- LicenseManagerLinuxSubscriptionsClient,
1013
- LicenseManagerLinuxSubscriptions,
1014
- $Command,
1015
- DeregisterSubscriptionProviderCommand,
1016
- GetRegisteredSubscriptionProviderCommand,
1017
- GetServiceSettingsCommand,
1018
- ListLinuxSubscriptionInstancesCommand,
1019
- ListLinuxSubscriptionsCommand,
1020
- ListRegisteredSubscriptionProvidersCommand,
1021
- ListTagsForResourceCommand,
1022
- RegisterSubscriptionProviderCommand,
1023
- TagResourceCommand,
1024
- UntagResourceCommand,
1025
- UpdateServiceSettingsCommand,
1026
- paginateListLinuxSubscriptionInstances,
1027
- paginateListLinuxSubscriptions,
1028
- paginateListRegisteredSubscriptionProviders,
1029
- InternalServerException,
1030
- ResourceNotFoundException,
1031
- ThrottlingException,
1032
- ValidationException,
1033
- Operator,
1034
- SubscriptionProviderSource,
1035
- SubscriptionProviderStatus,
1036
- LinuxSubscriptionsDiscovery,
1037
- OrganizationIntegration,
1038
- Status,
1039
- ListTagsForResourceResponseFilterSensitiveLog,
1040
- RegisterSubscriptionProviderRequestFilterSensitiveLog,
1041
- TagResourceRequestFilterSensitiveLog,
1042
- UntagResourceRequestFilterSensitiveLog
815
+ Object.defineProperty(exports, "$Command", {
816
+ enumerable: true,
817
+ get: function () { return smithyClient.Command; }
1043
818
  });
1044
-
819
+ Object.defineProperty(exports, "__Client", {
820
+ enumerable: true,
821
+ get: function () { return smithyClient.Client; }
822
+ });
823
+ exports.DeregisterSubscriptionProviderCommand = DeregisterSubscriptionProviderCommand;
824
+ exports.GetRegisteredSubscriptionProviderCommand = GetRegisteredSubscriptionProviderCommand;
825
+ exports.GetServiceSettingsCommand = GetServiceSettingsCommand;
826
+ exports.InternalServerException = InternalServerException;
827
+ exports.LicenseManagerLinuxSubscriptions = LicenseManagerLinuxSubscriptions;
828
+ exports.LicenseManagerLinuxSubscriptionsClient = LicenseManagerLinuxSubscriptionsClient;
829
+ exports.LicenseManagerLinuxSubscriptionsServiceException = LicenseManagerLinuxSubscriptionsServiceException;
830
+ exports.LinuxSubscriptionsDiscovery = LinuxSubscriptionsDiscovery;
831
+ exports.ListLinuxSubscriptionInstancesCommand = ListLinuxSubscriptionInstancesCommand;
832
+ exports.ListLinuxSubscriptionsCommand = ListLinuxSubscriptionsCommand;
833
+ exports.ListRegisteredSubscriptionProvidersCommand = ListRegisteredSubscriptionProvidersCommand;
834
+ exports.ListTagsForResourceCommand = ListTagsForResourceCommand;
835
+ exports.ListTagsForResourceResponseFilterSensitiveLog = ListTagsForResourceResponseFilterSensitiveLog;
836
+ exports.Operator = Operator;
837
+ exports.OrganizationIntegration = OrganizationIntegration;
838
+ exports.RegisterSubscriptionProviderCommand = RegisterSubscriptionProviderCommand;
839
+ exports.RegisterSubscriptionProviderRequestFilterSensitiveLog = RegisterSubscriptionProviderRequestFilterSensitiveLog;
840
+ exports.ResourceNotFoundException = ResourceNotFoundException;
841
+ exports.Status = Status;
842
+ exports.SubscriptionProviderSource = SubscriptionProviderSource;
843
+ exports.SubscriptionProviderStatus = SubscriptionProviderStatus;
844
+ exports.TagResourceCommand = TagResourceCommand;
845
+ exports.TagResourceRequestFilterSensitiveLog = TagResourceRequestFilterSensitiveLog;
846
+ exports.ThrottlingException = ThrottlingException;
847
+ exports.UntagResourceCommand = UntagResourceCommand;
848
+ exports.UntagResourceRequestFilterSensitiveLog = UntagResourceRequestFilterSensitiveLog;
849
+ exports.UpdateServiceSettingsCommand = UpdateServiceSettingsCommand;
850
+ exports.ValidationException = ValidationException;
851
+ exports.paginateListLinuxSubscriptionInstances = paginateListLinuxSubscriptionInstances;
852
+ exports.paginateListLinuxSubscriptions = paginateListLinuxSubscriptions;
853
+ exports.paginateListRegisteredSubscriptionProviders = paginateListRegisteredSubscriptionProviders;