@aws-sdk/client-repostspace 3.899.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 +1663 -1890
  2. package/package.json +38 -38
package/dist-cjs/index.js CHANGED
@@ -1,1945 +1,1718 @@
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);
20
-
21
- // src/index.ts
22
- var index_exports = {};
23
- __export(index_exports, {
24
- AccessDeniedException: () => AccessDeniedException,
25
- BatchAddChannelRoleToAccessorsCommand: () => BatchAddChannelRoleToAccessorsCommand,
26
- BatchAddRoleCommand: () => BatchAddRoleCommand,
27
- BatchRemoveChannelRoleFromAccessorsCommand: () => BatchRemoveChannelRoleFromAccessorsCommand,
28
- BatchRemoveRoleCommand: () => BatchRemoveRoleCommand,
29
- ChannelDataFilterSensitiveLog: () => ChannelDataFilterSensitiveLog,
30
- ChannelRole: () => ChannelRole,
31
- ChannelStatus: () => ChannelStatus,
32
- ConfigurationStatus: () => ConfigurationStatus,
33
- ConflictException: () => ConflictException,
34
- CreateChannelCommand: () => CreateChannelCommand,
35
- CreateChannelInputFilterSensitiveLog: () => CreateChannelInputFilterSensitiveLog,
36
- CreateSpaceCommand: () => CreateSpaceCommand,
37
- CreateSpaceInputFilterSensitiveLog: () => CreateSpaceInputFilterSensitiveLog,
38
- DeleteSpaceCommand: () => DeleteSpaceCommand,
39
- DeregisterAdminCommand: () => DeregisterAdminCommand,
40
- FeatureEnableParameter: () => FeatureEnableParameter,
41
- FeatureEnableStatus: () => FeatureEnableStatus,
42
- GetChannelCommand: () => GetChannelCommand,
43
- GetChannelOutputFilterSensitiveLog: () => GetChannelOutputFilterSensitiveLog,
44
- GetSpaceCommand: () => GetSpaceCommand,
45
- GetSpaceOutputFilterSensitiveLog: () => GetSpaceOutputFilterSensitiveLog,
46
- InternalServerException: () => InternalServerException,
47
- ListChannelsCommand: () => ListChannelsCommand,
48
- ListChannelsOutputFilterSensitiveLog: () => ListChannelsOutputFilterSensitiveLog,
49
- ListSpacesCommand: () => ListSpacesCommand,
50
- ListSpacesOutputFilterSensitiveLog: () => ListSpacesOutputFilterSensitiveLog,
51
- ListTagsForResourceCommand: () => ListTagsForResourceCommand,
52
- ListTagsForResourceResponseFilterSensitiveLog: () => ListTagsForResourceResponseFilterSensitiveLog,
53
- RegisterAdminCommand: () => RegisterAdminCommand,
54
- Repostspace: () => Repostspace,
55
- RepostspaceClient: () => RepostspaceClient,
56
- RepostspaceServiceException: () => RepostspaceServiceException,
57
- ResourceNotFoundException: () => ResourceNotFoundException,
58
- Role: () => Role,
59
- SendInvitesCommand: () => SendInvitesCommand,
60
- SendInvitesInputFilterSensitiveLog: () => SendInvitesInputFilterSensitiveLog,
61
- ServiceQuotaExceededException: () => ServiceQuotaExceededException,
62
- SpaceDataFilterSensitiveLog: () => SpaceDataFilterSensitiveLog,
63
- SupportedEmailDomainsParametersFilterSensitiveLog: () => SupportedEmailDomainsParametersFilterSensitiveLog,
64
- SupportedEmailDomainsStatusFilterSensitiveLog: () => SupportedEmailDomainsStatusFilterSensitiveLog,
65
- TagResourceCommand: () => TagResourceCommand,
66
- TagResourceRequestFilterSensitiveLog: () => TagResourceRequestFilterSensitiveLog,
67
- ThrottlingException: () => ThrottlingException,
68
- TierLevel: () => TierLevel,
69
- UntagResourceCommand: () => UntagResourceCommand,
70
- UpdateChannelCommand: () => UpdateChannelCommand,
71
- UpdateChannelInputFilterSensitiveLog: () => UpdateChannelInputFilterSensitiveLog,
72
- UpdateSpaceCommand: () => UpdateSpaceCommand,
73
- UpdateSpaceInputFilterSensitiveLog: () => UpdateSpaceInputFilterSensitiveLog,
74
- ValidationException: () => ValidationException,
75
- ValidationExceptionReason: () => ValidationExceptionReason,
76
- VanityDomainStatus: () => VanityDomainStatus,
77
- __Client: () => import_smithy_client.Client,
78
- paginateListChannels: () => paginateListChannels,
79
- paginateListSpaces: () => paginateListSpaces,
80
- waitForChannelCreated: () => waitForChannelCreated,
81
- waitForChannelDeleted: () => waitForChannelDeleted,
82
- waitForSpaceCreated: () => waitForSpaceCreated,
83
- waitForSpaceDeleted: () => waitForSpaceDeleted,
84
- waitUntilChannelCreated: () => waitUntilChannelCreated,
85
- waitUntilChannelDeleted: () => waitUntilChannelDeleted,
86
- waitUntilSpaceCreated: () => waitUntilSpaceCreated,
87
- waitUntilSpaceDeleted: () => waitUntilSpaceDeleted
88
- });
89
- module.exports = __toCommonJS(index_exports);
90
-
91
- // src/RepostspaceClient.ts
92
- var import_middleware_host_header = require("@aws-sdk/middleware-host-header");
93
- var import_middleware_logger = require("@aws-sdk/middleware-logger");
94
- var import_middleware_recursion_detection = require("@aws-sdk/middleware-recursion-detection");
95
- var import_middleware_user_agent = require("@aws-sdk/middleware-user-agent");
96
- var import_config_resolver = require("@smithy/config-resolver");
97
- var import_core = require("@smithy/core");
98
- var import_middleware_content_length = require("@smithy/middleware-content-length");
99
- var import_middleware_endpoint = require("@smithy/middleware-endpoint");
100
- var import_middleware_retry = require("@smithy/middleware-retry");
101
-
102
- var import_httpAuthSchemeProvider = require("./auth/httpAuthSchemeProvider");
103
-
104
- // src/endpoint/EndpointParameters.ts
105
- var resolveClientEndpointParameters = /* @__PURE__ */ __name((options) => {
106
- return Object.assign(options, {
107
- useDualstackEndpoint: options.useDualstackEndpoint ?? false,
108
- useFipsEndpoint: options.useFipsEndpoint ?? false,
109
- defaultSigningName: "repostspace"
110
- });
111
- }, "resolveClientEndpointParameters");
112
- var commonParams = {
113
- UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
114
- Endpoint: { type: "builtInParams", name: "endpoint" },
115
- Region: { type: "builtInParams", name: "region" },
116
- UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
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
+ var utilWaiter = require('@smithy/util-waiter');
20
+
21
+ const resolveClientEndpointParameters = (options) => {
22
+ return Object.assign(options, {
23
+ useDualstackEndpoint: options.useDualstackEndpoint ?? false,
24
+ useFipsEndpoint: options.useFipsEndpoint ?? false,
25
+ defaultSigningName: "repostspace",
26
+ });
27
+ };
28
+ const commonParams = {
29
+ UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
30
+ Endpoint: { type: "builtInParams", name: "endpoint" },
31
+ Region: { type: "builtInParams", name: "region" },
32
+ UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
117
33
  };
118
34
 
119
- // src/RepostspaceClient.ts
120
- var import_runtimeConfig = require("././runtimeConfig");
35
+ const getHttpAuthExtensionConfiguration = (runtimeConfig) => {
36
+ const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
37
+ let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
38
+ let _credentials = runtimeConfig.credentials;
39
+ return {
40
+ setHttpAuthScheme(httpAuthScheme) {
41
+ const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
42
+ if (index === -1) {
43
+ _httpAuthSchemes.push(httpAuthScheme);
44
+ }
45
+ else {
46
+ _httpAuthSchemes.splice(index, 1, httpAuthScheme);
47
+ }
48
+ },
49
+ httpAuthSchemes() {
50
+ return _httpAuthSchemes;
51
+ },
52
+ setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
53
+ _httpAuthSchemeProvider = httpAuthSchemeProvider;
54
+ },
55
+ httpAuthSchemeProvider() {
56
+ return _httpAuthSchemeProvider;
57
+ },
58
+ setCredentials(credentials) {
59
+ _credentials = credentials;
60
+ },
61
+ credentials() {
62
+ return _credentials;
63
+ },
64
+ };
65
+ };
66
+ const resolveHttpAuthRuntimeConfig = (config) => {
67
+ return {
68
+ httpAuthSchemes: config.httpAuthSchemes(),
69
+ httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
70
+ credentials: config.credentials(),
71
+ };
72
+ };
121
73
 
122
- // src/runtimeExtensions.ts
123
- var import_region_config_resolver = require("@aws-sdk/region-config-resolver");
124
- var import_protocol_http = require("@smithy/protocol-http");
125
- var import_smithy_client = require("@smithy/smithy-client");
74
+ const resolveRuntimeExtensions = (runtimeConfig, extensions) => {
75
+ const extensionConfiguration = Object.assign(regionConfigResolver.getAwsRegionExtensionConfiguration(runtimeConfig), smithyClient.getDefaultExtensionConfiguration(runtimeConfig), protocolHttp.getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
76
+ extensions.forEach((extension) => extension.configure(extensionConfiguration));
77
+ return Object.assign(runtimeConfig, regionConfigResolver.resolveAwsRegionExtensionConfiguration(extensionConfiguration), smithyClient.resolveDefaultRuntimeConfig(extensionConfiguration), protocolHttp.resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
78
+ };
126
79
 
127
- // src/auth/httpAuthExtensionConfiguration.ts
128
- var getHttpAuthExtensionConfiguration = /* @__PURE__ */ __name((runtimeConfig) => {
129
- const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
130
- let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
131
- let _credentials = runtimeConfig.credentials;
132
- return {
133
- setHttpAuthScheme(httpAuthScheme) {
134
- const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
135
- if (index === -1) {
136
- _httpAuthSchemes.push(httpAuthScheme);
137
- } else {
138
- _httpAuthSchemes.splice(index, 1, httpAuthScheme);
139
- }
140
- },
141
- httpAuthSchemes() {
142
- return _httpAuthSchemes;
143
- },
144
- setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
145
- _httpAuthSchemeProvider = httpAuthSchemeProvider;
146
- },
147
- httpAuthSchemeProvider() {
148
- return _httpAuthSchemeProvider;
149
- },
150
- setCredentials(credentials) {
151
- _credentials = credentials;
152
- },
153
- credentials() {
154
- return _credentials;
80
+ class RepostspaceClient extends smithyClient.Client {
81
+ config;
82
+ constructor(...[configuration]) {
83
+ const _config_0 = runtimeConfig.getRuntimeConfig(configuration || {});
84
+ super(_config_0);
85
+ this.initConfig = _config_0;
86
+ const _config_1 = resolveClientEndpointParameters(_config_0);
87
+ const _config_2 = middlewareUserAgent.resolveUserAgentConfig(_config_1);
88
+ const _config_3 = middlewareRetry.resolveRetryConfig(_config_2);
89
+ const _config_4 = configResolver.resolveRegionConfig(_config_3);
90
+ const _config_5 = middlewareHostHeader.resolveHostHeaderConfig(_config_4);
91
+ const _config_6 = middlewareEndpoint.resolveEndpointConfig(_config_5);
92
+ const _config_7 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_6);
93
+ const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
94
+ this.config = _config_8;
95
+ this.middlewareStack.use(middlewareUserAgent.getUserAgentPlugin(this.config));
96
+ this.middlewareStack.use(middlewareRetry.getRetryPlugin(this.config));
97
+ this.middlewareStack.use(middlewareContentLength.getContentLengthPlugin(this.config));
98
+ this.middlewareStack.use(middlewareHostHeader.getHostHeaderPlugin(this.config));
99
+ this.middlewareStack.use(middlewareLogger.getLoggerPlugin(this.config));
100
+ this.middlewareStack.use(middlewareRecursionDetection.getRecursionDetectionPlugin(this.config));
101
+ this.middlewareStack.use(core.getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
102
+ httpAuthSchemeParametersProvider: httpAuthSchemeProvider.defaultRepostspaceHttpAuthSchemeParametersProvider,
103
+ identityProviderConfigProvider: async (config) => new core.DefaultIdentityProviderConfig({
104
+ "aws.auth#sigv4": config.credentials,
105
+ }),
106
+ }));
107
+ this.middlewareStack.use(core.getHttpSigningPlugin(this.config));
155
108
  }
156
- };
157
- }, "getHttpAuthExtensionConfiguration");
158
- var resolveHttpAuthRuntimeConfig = /* @__PURE__ */ __name((config) => {
159
- return {
160
- httpAuthSchemes: config.httpAuthSchemes(),
161
- httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
162
- credentials: config.credentials()
163
- };
164
- }, "resolveHttpAuthRuntimeConfig");
165
-
166
- // src/runtimeExtensions.ts
167
- var resolveRuntimeExtensions = /* @__PURE__ */ __name((runtimeConfig, extensions) => {
168
- const extensionConfiguration = Object.assign(
169
- (0, import_region_config_resolver.getAwsRegionExtensionConfiguration)(runtimeConfig),
170
- (0, import_smithy_client.getDefaultExtensionConfiguration)(runtimeConfig),
171
- (0, import_protocol_http.getHttpHandlerExtensionConfiguration)(runtimeConfig),
172
- getHttpAuthExtensionConfiguration(runtimeConfig)
173
- );
174
- extensions.forEach((extension) => extension.configure(extensionConfiguration));
175
- return Object.assign(
176
- runtimeConfig,
177
- (0, import_region_config_resolver.resolveAwsRegionExtensionConfiguration)(extensionConfiguration),
178
- (0, import_smithy_client.resolveDefaultRuntimeConfig)(extensionConfiguration),
179
- (0, import_protocol_http.resolveHttpHandlerRuntimeConfig)(extensionConfiguration),
180
- resolveHttpAuthRuntimeConfig(extensionConfiguration)
181
- );
182
- }, "resolveRuntimeExtensions");
109
+ destroy() {
110
+ super.destroy();
111
+ }
112
+ }
183
113
 
184
- // src/RepostspaceClient.ts
185
- var RepostspaceClient = class extends import_smithy_client.Client {
186
- static {
187
- __name(this, "RepostspaceClient");
188
- }
189
- /**
190
- * The resolved configuration of RepostspaceClient class. This is resolved and normalized from the {@link RepostspaceClientConfig | constructor configuration interface}.
191
- */
192
- config;
193
- constructor(...[configuration]) {
194
- const _config_0 = (0, import_runtimeConfig.getRuntimeConfig)(configuration || {});
195
- super(_config_0);
196
- this.initConfig = _config_0;
197
- const _config_1 = resolveClientEndpointParameters(_config_0);
198
- const _config_2 = (0, import_middleware_user_agent.resolveUserAgentConfig)(_config_1);
199
- const _config_3 = (0, import_middleware_retry.resolveRetryConfig)(_config_2);
200
- const _config_4 = (0, import_config_resolver.resolveRegionConfig)(_config_3);
201
- const _config_5 = (0, import_middleware_host_header.resolveHostHeaderConfig)(_config_4);
202
- const _config_6 = (0, import_middleware_endpoint.resolveEndpointConfig)(_config_5);
203
- const _config_7 = (0, import_httpAuthSchemeProvider.resolveHttpAuthSchemeConfig)(_config_6);
204
- const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
205
- this.config = _config_8;
206
- this.middlewareStack.use((0, import_middleware_user_agent.getUserAgentPlugin)(this.config));
207
- this.middlewareStack.use((0, import_middleware_retry.getRetryPlugin)(this.config));
208
- this.middlewareStack.use((0, import_middleware_content_length.getContentLengthPlugin)(this.config));
209
- this.middlewareStack.use((0, import_middleware_host_header.getHostHeaderPlugin)(this.config));
210
- this.middlewareStack.use((0, import_middleware_logger.getLoggerPlugin)(this.config));
211
- this.middlewareStack.use((0, import_middleware_recursion_detection.getRecursionDetectionPlugin)(this.config));
212
- this.middlewareStack.use(
213
- (0, import_core.getHttpAuthSchemeEndpointRuleSetPlugin)(this.config, {
214
- httpAuthSchemeParametersProvider: import_httpAuthSchemeProvider.defaultRepostspaceHttpAuthSchemeParametersProvider,
215
- identityProviderConfigProvider: /* @__PURE__ */ __name(async (config) => new import_core.DefaultIdentityProviderConfig({
216
- "aws.auth#sigv4": config.credentials
217
- }), "identityProviderConfigProvider")
218
- })
219
- );
220
- this.middlewareStack.use((0, import_core.getHttpSigningPlugin)(this.config));
221
- }
222
- /**
223
- * Destroy underlying resources, like sockets. It's usually not necessary to do this.
224
- * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
225
- * Otherwise, sockets might stay open for quite a long time before the server terminates them.
226
- */
227
- destroy() {
228
- super.destroy();
229
- }
114
+ class RepostspaceServiceException extends smithyClient.ServiceException {
115
+ constructor(options) {
116
+ super(options);
117
+ Object.setPrototypeOf(this, RepostspaceServiceException.prototype);
118
+ }
119
+ }
120
+
121
+ class AccessDeniedException extends RepostspaceServiceException {
122
+ name = "AccessDeniedException";
123
+ $fault = "client";
124
+ constructor(opts) {
125
+ super({
126
+ name: "AccessDeniedException",
127
+ $fault: "client",
128
+ ...opts,
129
+ });
130
+ Object.setPrototypeOf(this, AccessDeniedException.prototype);
131
+ }
132
+ }
133
+ const ChannelRole = {
134
+ ASKER: "ASKER",
135
+ EXPERT: "EXPERT",
136
+ MODERATOR: "MODERATOR",
137
+ SUPPORTREQUESTOR: "SUPPORTREQUESTOR",
230
138
  };
231
-
232
- // src/Repostspace.ts
233
-
234
-
235
- // src/commands/BatchAddChannelRoleToAccessorsCommand.ts
236
-
237
- var import_middleware_serde = require("@smithy/middleware-serde");
238
-
239
-
240
- // src/protocols/Aws_restJson1.ts
241
- var import_core2 = require("@aws-sdk/core");
242
-
243
-
244
-
245
- // src/models/models_0.ts
246
-
247
-
248
- // src/models/RepostspaceServiceException.ts
249
-
250
- var RepostspaceServiceException = class _RepostspaceServiceException extends import_smithy_client.ServiceException {
251
- static {
252
- __name(this, "RepostspaceServiceException");
253
- }
254
- /**
255
- * @internal
256
- */
257
- constructor(options) {
258
- super(options);
259
- Object.setPrototypeOf(this, _RepostspaceServiceException.prototype);
260
- }
139
+ class InternalServerException extends RepostspaceServiceException {
140
+ name = "InternalServerException";
141
+ $fault = "server";
142
+ $retryable = {};
143
+ retryAfterSeconds;
144
+ constructor(opts) {
145
+ super({
146
+ name: "InternalServerException",
147
+ $fault: "server",
148
+ ...opts,
149
+ });
150
+ Object.setPrototypeOf(this, InternalServerException.prototype);
151
+ this.retryAfterSeconds = opts.retryAfterSeconds;
152
+ }
153
+ }
154
+ class ResourceNotFoundException extends RepostspaceServiceException {
155
+ name = "ResourceNotFoundException";
156
+ $fault = "client";
157
+ resourceId;
158
+ resourceType;
159
+ constructor(opts) {
160
+ super({
161
+ name: "ResourceNotFoundException",
162
+ $fault: "client",
163
+ ...opts,
164
+ });
165
+ Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
166
+ this.resourceId = opts.resourceId;
167
+ this.resourceType = opts.resourceType;
168
+ }
169
+ }
170
+ class ThrottlingException extends RepostspaceServiceException {
171
+ name = "ThrottlingException";
172
+ $fault = "client";
173
+ $retryable = {
174
+ throttling: true,
175
+ };
176
+ serviceCode;
177
+ quotaCode;
178
+ retryAfterSeconds;
179
+ constructor(opts) {
180
+ super({
181
+ name: "ThrottlingException",
182
+ $fault: "client",
183
+ ...opts,
184
+ });
185
+ Object.setPrototypeOf(this, ThrottlingException.prototype);
186
+ this.serviceCode = opts.serviceCode;
187
+ this.quotaCode = opts.quotaCode;
188
+ this.retryAfterSeconds = opts.retryAfterSeconds;
189
+ }
190
+ }
191
+ const ValidationExceptionReason = {
192
+ CANNOT_PARSE: "cannotParse",
193
+ FIELD_VALIDATION_FAILED: "fieldValidationFailed",
194
+ OTHER: "other",
195
+ UNKNOWN_OPERATION: "unknownOperation",
196
+ };
197
+ class ValidationException extends RepostspaceServiceException {
198
+ name = "ValidationException";
199
+ $fault = "client";
200
+ reason;
201
+ fieldList;
202
+ constructor(opts) {
203
+ super({
204
+ name: "ValidationException",
205
+ $fault: "client",
206
+ ...opts,
207
+ });
208
+ Object.setPrototypeOf(this, ValidationException.prototype);
209
+ this.reason = opts.reason;
210
+ this.fieldList = opts.fieldList;
211
+ }
212
+ }
213
+ const Role = {
214
+ ADMINISTRATOR: "ADMINISTRATOR",
215
+ EXPERT: "EXPERT",
216
+ MODERATOR: "MODERATOR",
217
+ SUPPORTREQUESTOR: "SUPPORTREQUESTOR",
218
+ };
219
+ const ChannelStatus = {
220
+ CREATED: "CREATED",
221
+ CREATE_FAILED: "CREATE_FAILED",
222
+ CREATING: "CREATING",
223
+ DELETED: "DELETED",
224
+ DELETE_FAILED: "DELETE_FAILED",
225
+ DELETING: "DELETING",
226
+ };
227
+ const ConfigurationStatus = {
228
+ CONFIGURED: "CONFIGURED",
229
+ UNCONFIGURED: "UNCONFIGURED",
261
230
  };
231
+ class ConflictException extends RepostspaceServiceException {
232
+ name = "ConflictException";
233
+ $fault = "client";
234
+ resourceId;
235
+ resourceType;
236
+ constructor(opts) {
237
+ super({
238
+ name: "ConflictException",
239
+ $fault: "client",
240
+ ...opts,
241
+ });
242
+ Object.setPrototypeOf(this, ConflictException.prototype);
243
+ this.resourceId = opts.resourceId;
244
+ this.resourceType = opts.resourceType;
245
+ }
246
+ }
247
+ class ServiceQuotaExceededException extends RepostspaceServiceException {
248
+ name = "ServiceQuotaExceededException";
249
+ $fault = "client";
250
+ resourceId;
251
+ resourceType;
252
+ serviceCode;
253
+ quotaCode;
254
+ constructor(opts) {
255
+ super({
256
+ name: "ServiceQuotaExceededException",
257
+ $fault: "client",
258
+ ...opts,
259
+ });
260
+ Object.setPrototypeOf(this, ServiceQuotaExceededException.prototype);
261
+ this.resourceId = opts.resourceId;
262
+ this.resourceType = opts.resourceType;
263
+ this.serviceCode = opts.serviceCode;
264
+ this.quotaCode = opts.quotaCode;
265
+ }
266
+ }
267
+ const FeatureEnableParameter = {
268
+ DISABLED: "DISABLED",
269
+ ENABLED: "ENABLED",
270
+ };
271
+ const TierLevel = {
272
+ BASIC: "BASIC",
273
+ STANDARD: "STANDARD",
274
+ };
275
+ const FeatureEnableStatus = {
276
+ DISABLED: "DISABLED",
277
+ ENABLED: "ENABLED",
278
+ NOT_ALLOWED: "NOT_ALLOWED",
279
+ };
280
+ const VanityDomainStatus = {
281
+ APPROVED: "APPROVED",
282
+ PENDING: "PENDING",
283
+ UNAPPROVED: "UNAPPROVED",
284
+ };
285
+ const ChannelDataFilterSensitiveLog = (obj) => ({
286
+ ...obj,
287
+ ...(obj.channelName && { channelName: smithyClient.SENSITIVE_STRING }),
288
+ ...(obj.channelDescription && { channelDescription: smithyClient.SENSITIVE_STRING }),
289
+ });
290
+ const CreateChannelInputFilterSensitiveLog = (obj) => ({
291
+ ...obj,
292
+ ...(obj.channelName && { channelName: smithyClient.SENSITIVE_STRING }),
293
+ ...(obj.channelDescription && { channelDescription: smithyClient.SENSITIVE_STRING }),
294
+ });
295
+ const SupportedEmailDomainsParametersFilterSensitiveLog = (obj) => ({
296
+ ...obj,
297
+ ...(obj.allowedDomains && { allowedDomains: smithyClient.SENSITIVE_STRING }),
298
+ });
299
+ const CreateSpaceInputFilterSensitiveLog = (obj) => ({
300
+ ...obj,
301
+ ...(obj.name && { name: smithyClient.SENSITIVE_STRING }),
302
+ ...(obj.description && { description: smithyClient.SENSITIVE_STRING }),
303
+ ...(obj.tags && { tags: smithyClient.SENSITIVE_STRING }),
304
+ ...(obj.supportedEmailDomains && {
305
+ supportedEmailDomains: SupportedEmailDomainsParametersFilterSensitiveLog(obj.supportedEmailDomains),
306
+ }),
307
+ });
308
+ const GetChannelOutputFilterSensitiveLog = (obj) => ({
309
+ ...obj,
310
+ ...(obj.channelName && { channelName: smithyClient.SENSITIVE_STRING }),
311
+ ...(obj.channelDescription && { channelDescription: smithyClient.SENSITIVE_STRING }),
312
+ });
313
+ const SupportedEmailDomainsStatusFilterSensitiveLog = (obj) => ({
314
+ ...obj,
315
+ ...(obj.allowedDomains && { allowedDomains: smithyClient.SENSITIVE_STRING }),
316
+ });
317
+ const GetSpaceOutputFilterSensitiveLog = (obj) => ({
318
+ ...obj,
319
+ ...(obj.name && { name: smithyClient.SENSITIVE_STRING }),
320
+ ...(obj.description && { description: smithyClient.SENSITIVE_STRING }),
321
+ ...(obj.supportedEmailDomains && {
322
+ supportedEmailDomains: SupportedEmailDomainsStatusFilterSensitiveLog(obj.supportedEmailDomains),
323
+ }),
324
+ });
325
+ const ListChannelsOutputFilterSensitiveLog = (obj) => ({
326
+ ...obj,
327
+ ...(obj.channels && { channels: obj.channels.map((item) => ChannelDataFilterSensitiveLog(item)) }),
328
+ });
329
+ const SpaceDataFilterSensitiveLog = (obj) => ({
330
+ ...obj,
331
+ ...(obj.name && { name: smithyClient.SENSITIVE_STRING }),
332
+ ...(obj.description && { description: smithyClient.SENSITIVE_STRING }),
333
+ ...(obj.supportedEmailDomains && {
334
+ supportedEmailDomains: SupportedEmailDomainsStatusFilterSensitiveLog(obj.supportedEmailDomains),
335
+ }),
336
+ });
337
+ const ListSpacesOutputFilterSensitiveLog = (obj) => ({
338
+ ...obj,
339
+ ...(obj.spaces && { spaces: obj.spaces.map((item) => SpaceDataFilterSensitiveLog(item)) }),
340
+ });
341
+ const ListTagsForResourceResponseFilterSensitiveLog = (obj) => ({
342
+ ...obj,
343
+ ...(obj.tags && { tags: smithyClient.SENSITIVE_STRING }),
344
+ });
345
+ const SendInvitesInputFilterSensitiveLog = (obj) => ({
346
+ ...obj,
347
+ ...(obj.title && { title: smithyClient.SENSITIVE_STRING }),
348
+ ...(obj.body && { body: smithyClient.SENSITIVE_STRING }),
349
+ });
350
+ const TagResourceRequestFilterSensitiveLog = (obj) => ({
351
+ ...obj,
352
+ ...(obj.tags && { tags: smithyClient.SENSITIVE_STRING }),
353
+ });
354
+ const UpdateChannelInputFilterSensitiveLog = (obj) => ({
355
+ ...obj,
356
+ ...(obj.channelName && { channelName: smithyClient.SENSITIVE_STRING }),
357
+ ...(obj.channelDescription && { channelDescription: smithyClient.SENSITIVE_STRING }),
358
+ });
359
+ const UpdateSpaceInputFilterSensitiveLog = (obj) => ({
360
+ ...obj,
361
+ ...(obj.description && { description: smithyClient.SENSITIVE_STRING }),
362
+ ...(obj.supportedEmailDomains && {
363
+ supportedEmailDomains: SupportedEmailDomainsParametersFilterSensitiveLog(obj.supportedEmailDomains),
364
+ }),
365
+ });
262
366
 
263
- // src/models/models_0.ts
264
- var AccessDeniedException = class _AccessDeniedException extends RepostspaceServiceException {
265
- static {
266
- __name(this, "AccessDeniedException");
267
- }
268
- name = "AccessDeniedException";
269
- $fault = "client";
270
- /**
271
- * @internal
272
- */
273
- constructor(opts) {
274
- super({
275
- name: "AccessDeniedException",
276
- $fault: "client",
277
- ...opts
367
+ const se_BatchAddChannelRoleToAccessorsCommand = async (input, context) => {
368
+ const b = core.requestBuilder(input, context);
369
+ const headers = {
370
+ "content-type": "application/json",
371
+ };
372
+ b.bp("/spaces/{spaceId}/channels/{channelId}/roles");
373
+ b.p("spaceId", () => input.spaceId, "{spaceId}", false);
374
+ b.p("channelId", () => input.channelId, "{channelId}", false);
375
+ let body;
376
+ body = JSON.stringify(smithyClient.take(input, {
377
+ accessorIds: (_) => smithyClient._json(_),
378
+ channelRole: [],
379
+ }));
380
+ b.m("POST").h(headers).b(body);
381
+ return b.build();
382
+ };
383
+ const se_BatchAddRoleCommand = async (input, context) => {
384
+ const b = core.requestBuilder(input, context);
385
+ const headers = {
386
+ "content-type": "application/json",
387
+ };
388
+ b.bp("/spaces/{spaceId}/roles");
389
+ b.p("spaceId", () => input.spaceId, "{spaceId}", false);
390
+ let body;
391
+ body = JSON.stringify(smithyClient.take(input, {
392
+ accessorIds: (_) => smithyClient._json(_),
393
+ role: [],
394
+ }));
395
+ b.m("POST").h(headers).b(body);
396
+ return b.build();
397
+ };
398
+ const se_BatchRemoveChannelRoleFromAccessorsCommand = async (input, context) => {
399
+ const b = core.requestBuilder(input, context);
400
+ const headers = {
401
+ "content-type": "application/json",
402
+ };
403
+ b.bp("/spaces/{spaceId}/channels/{channelId}/roles");
404
+ b.p("spaceId", () => input.spaceId, "{spaceId}", false);
405
+ b.p("channelId", () => input.channelId, "{channelId}", false);
406
+ let body;
407
+ body = JSON.stringify(smithyClient.take(input, {
408
+ accessorIds: (_) => smithyClient._json(_),
409
+ channelRole: [],
410
+ }));
411
+ b.m("PATCH").h(headers).b(body);
412
+ return b.build();
413
+ };
414
+ const se_BatchRemoveRoleCommand = async (input, context) => {
415
+ const b = core.requestBuilder(input, context);
416
+ const headers = {
417
+ "content-type": "application/json",
418
+ };
419
+ b.bp("/spaces/{spaceId}/roles");
420
+ b.p("spaceId", () => input.spaceId, "{spaceId}", false);
421
+ let body;
422
+ body = JSON.stringify(smithyClient.take(input, {
423
+ accessorIds: (_) => smithyClient._json(_),
424
+ role: [],
425
+ }));
426
+ b.m("PATCH").h(headers).b(body);
427
+ return b.build();
428
+ };
429
+ const se_CreateChannelCommand = async (input, context) => {
430
+ const b = core.requestBuilder(input, context);
431
+ const headers = {
432
+ "content-type": "application/json",
433
+ };
434
+ b.bp("/spaces/{spaceId}/channels");
435
+ b.p("spaceId", () => input.spaceId, "{spaceId}", false);
436
+ let body;
437
+ body = JSON.stringify(smithyClient.take(input, {
438
+ channelDescription: [],
439
+ channelName: [],
440
+ }));
441
+ b.m("POST").h(headers).b(body);
442
+ return b.build();
443
+ };
444
+ const se_CreateSpaceCommand = async (input, context) => {
445
+ const b = core.requestBuilder(input, context);
446
+ const headers = {
447
+ "content-type": "application/json",
448
+ };
449
+ b.bp("/spaces");
450
+ let body;
451
+ body = JSON.stringify(smithyClient.take(input, {
452
+ description: [],
453
+ name: [],
454
+ roleArn: [],
455
+ subdomain: [],
456
+ supportedEmailDomains: (_) => smithyClient._json(_),
457
+ tags: (_) => smithyClient._json(_),
458
+ tier: [],
459
+ userKMSKey: [],
460
+ }));
461
+ b.m("POST").h(headers).b(body);
462
+ return b.build();
463
+ };
464
+ const se_DeleteSpaceCommand = async (input, context) => {
465
+ const b = core.requestBuilder(input, context);
466
+ const headers = {};
467
+ b.bp("/spaces/{spaceId}");
468
+ b.p("spaceId", () => input.spaceId, "{spaceId}", false);
469
+ let body;
470
+ b.m("DELETE").h(headers).b(body);
471
+ return b.build();
472
+ };
473
+ const se_DeregisterAdminCommand = async (input, context) => {
474
+ const b = core.requestBuilder(input, context);
475
+ const headers = {};
476
+ b.bp("/spaces/{spaceId}/admins/{adminId}");
477
+ b.p("spaceId", () => input.spaceId, "{spaceId}", false);
478
+ b.p("adminId", () => input.adminId, "{adminId}", false);
479
+ let body;
480
+ b.m("DELETE").h(headers).b(body);
481
+ return b.build();
482
+ };
483
+ const se_GetChannelCommand = async (input, context) => {
484
+ const b = core.requestBuilder(input, context);
485
+ const headers = {};
486
+ b.bp("/spaces/{spaceId}/channels/{channelId}");
487
+ b.p("spaceId", () => input.spaceId, "{spaceId}", false);
488
+ b.p("channelId", () => input.channelId, "{channelId}", false);
489
+ let body;
490
+ b.m("GET").h(headers).b(body);
491
+ return b.build();
492
+ };
493
+ const se_GetSpaceCommand = async (input, context) => {
494
+ const b = core.requestBuilder(input, context);
495
+ const headers = {};
496
+ b.bp("/spaces/{spaceId}");
497
+ b.p("spaceId", () => input.spaceId, "{spaceId}", false);
498
+ let body;
499
+ b.m("GET").h(headers).b(body);
500
+ return b.build();
501
+ };
502
+ const se_ListChannelsCommand = async (input, context) => {
503
+ const b = core.requestBuilder(input, context);
504
+ const headers = {};
505
+ b.bp("/spaces/{spaceId}/channels");
506
+ b.p("spaceId", () => input.spaceId, "{spaceId}", false);
507
+ const query = smithyClient.map({
508
+ [_nT]: [, input[_nT]],
509
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
278
510
  });
279
- Object.setPrototypeOf(this, _AccessDeniedException.prototype);
280
- }
281
- };
282
- var ChannelRole = {
283
- ASKER: "ASKER",
284
- EXPERT: "EXPERT",
285
- MODERATOR: "MODERATOR",
286
- SUPPORTREQUESTOR: "SUPPORTREQUESTOR"
287
- };
288
- var InternalServerException = class _InternalServerException extends RepostspaceServiceException {
289
- static {
290
- __name(this, "InternalServerException");
291
- }
292
- name = "InternalServerException";
293
- $fault = "server";
294
- $retryable = {};
295
- /**
296
- * <p>Advice to clients on when the call can be safely retried.</p>
297
- * @public
298
- */
299
- retryAfterSeconds;
300
- /**
301
- * @internal
302
- */
303
- constructor(opts) {
304
- super({
305
- name: "InternalServerException",
306
- $fault: "server",
307
- ...opts
511
+ let body;
512
+ b.m("GET").h(headers).q(query).b(body);
513
+ return b.build();
514
+ };
515
+ const se_ListSpacesCommand = async (input, context) => {
516
+ const b = core.requestBuilder(input, context);
517
+ const headers = {};
518
+ b.bp("/spaces");
519
+ const query = smithyClient.map({
520
+ [_nT]: [, input[_nT]],
521
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
308
522
  });
309
- Object.setPrototypeOf(this, _InternalServerException.prototype);
310
- this.retryAfterSeconds = opts.retryAfterSeconds;
311
- }
312
- };
313
- var ResourceNotFoundException = class _ResourceNotFoundException extends RepostspaceServiceException {
314
- static {
315
- __name(this, "ResourceNotFoundException");
316
- }
317
- name = "ResourceNotFoundException";
318
- $fault = "client";
319
- /**
320
- * <p>The ID of the resource.</p>
321
- * @public
322
- */
323
- resourceId;
324
- /**
325
- * <p>The type of the resource.</p>
326
- * @public
327
- */
328
- resourceType;
329
- /**
330
- * @internal
331
- */
332
- constructor(opts) {
333
- super({
334
- name: "ResourceNotFoundException",
335
- $fault: "client",
336
- ...opts
523
+ let body;
524
+ b.m("GET").h(headers).q(query).b(body);
525
+ return b.build();
526
+ };
527
+ const se_ListTagsForResourceCommand = async (input, context) => {
528
+ const b = core.requestBuilder(input, context);
529
+ const headers = {};
530
+ b.bp("/tags/{resourceArn}");
531
+ b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
532
+ let body;
533
+ b.m("GET").h(headers).b(body);
534
+ return b.build();
535
+ };
536
+ const se_RegisterAdminCommand = async (input, context) => {
537
+ const b = core.requestBuilder(input, context);
538
+ const headers = {};
539
+ b.bp("/spaces/{spaceId}/admins/{adminId}");
540
+ b.p("spaceId", () => input.spaceId, "{spaceId}", false);
541
+ b.p("adminId", () => input.adminId, "{adminId}", false);
542
+ let body;
543
+ b.m("POST").h(headers).b(body);
544
+ return b.build();
545
+ };
546
+ const se_SendInvitesCommand = async (input, context) => {
547
+ const b = core.requestBuilder(input, context);
548
+ const headers = {
549
+ "content-type": "application/json",
550
+ };
551
+ b.bp("/spaces/{spaceId}/invite");
552
+ b.p("spaceId", () => input.spaceId, "{spaceId}", false);
553
+ let body;
554
+ body = JSON.stringify(smithyClient.take(input, {
555
+ accessorIds: (_) => smithyClient._json(_),
556
+ body: [],
557
+ title: [],
558
+ }));
559
+ b.m("POST").h(headers).b(body);
560
+ return b.build();
561
+ };
562
+ const se_TagResourceCommand = async (input, context) => {
563
+ const b = core.requestBuilder(input, context);
564
+ const headers = {
565
+ "content-type": "application/json",
566
+ };
567
+ b.bp("/tags/{resourceArn}");
568
+ b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
569
+ let body;
570
+ body = JSON.stringify(smithyClient.take(input, {
571
+ tags: (_) => smithyClient._json(_),
572
+ }));
573
+ b.m("POST").h(headers).b(body);
574
+ return b.build();
575
+ };
576
+ const se_UntagResourceCommand = async (input, context) => {
577
+ const b = core.requestBuilder(input, context);
578
+ const headers = {};
579
+ b.bp("/tags/{resourceArn}");
580
+ b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
581
+ const query = smithyClient.map({
582
+ [_tK]: [smithyClient.expectNonNull(input.tagKeys, `tagKeys`) != null, () => input[_tK] || []],
337
583
  });
338
- Object.setPrototypeOf(this, _ResourceNotFoundException.prototype);
339
- this.resourceId = opts.resourceId;
340
- this.resourceType = opts.resourceType;
341
- }
342
- };
343
- var ThrottlingException = class _ThrottlingException extends RepostspaceServiceException {
344
- static {
345
- __name(this, "ThrottlingException");
346
- }
347
- name = "ThrottlingException";
348
- $fault = "client";
349
- $retryable = {
350
- throttling: true
351
- };
352
- /**
353
- * <p>The code to identify the service.</p>
354
- * @public
355
- */
356
- serviceCode;
357
- /**
358
- * <p>The code to identify the quota.</p>
359
- * @public
360
- */
361
- quotaCode;
362
- /**
363
- * <p> Advice to clients on when the call can be safely retried.</p>
364
- * @public
365
- */
366
- retryAfterSeconds;
367
- /**
368
- * @internal
369
- */
370
- constructor(opts) {
371
- super({
372
- name: "ThrottlingException",
373
- $fault: "client",
374
- ...opts
584
+ let body;
585
+ b.m("DELETE").h(headers).q(query).b(body);
586
+ return b.build();
587
+ };
588
+ const se_UpdateChannelCommand = async (input, context) => {
589
+ const b = core.requestBuilder(input, context);
590
+ const headers = {
591
+ "content-type": "application/json",
592
+ };
593
+ b.bp("/spaces/{spaceId}/channels/{channelId}");
594
+ b.p("spaceId", () => input.spaceId, "{spaceId}", false);
595
+ b.p("channelId", () => input.channelId, "{channelId}", false);
596
+ let body;
597
+ body = JSON.stringify(smithyClient.take(input, {
598
+ channelDescription: [],
599
+ channelName: [],
600
+ }));
601
+ b.m("PUT").h(headers).b(body);
602
+ return b.build();
603
+ };
604
+ const se_UpdateSpaceCommand = async (input, context) => {
605
+ const b = core.requestBuilder(input, context);
606
+ const headers = {
607
+ "content-type": "application/json",
608
+ };
609
+ b.bp("/spaces/{spaceId}");
610
+ b.p("spaceId", () => input.spaceId, "{spaceId}", false);
611
+ let body;
612
+ body = JSON.stringify(smithyClient.take(input, {
613
+ description: [],
614
+ roleArn: [],
615
+ supportedEmailDomains: (_) => smithyClient._json(_),
616
+ tier: [],
617
+ }));
618
+ b.m("PUT").h(headers).b(body);
619
+ return b.build();
620
+ };
621
+ const de_BatchAddChannelRoleToAccessorsCommand = async (output, context) => {
622
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
623
+ return de_CommandError(output, context);
624
+ }
625
+ const contents = smithyClient.map({
626
+ $metadata: deserializeMetadata(output),
375
627
  });
376
- Object.setPrototypeOf(this, _ThrottlingException.prototype);
377
- this.serviceCode = opts.serviceCode;
378
- this.quotaCode = opts.quotaCode;
379
- this.retryAfterSeconds = opts.retryAfterSeconds;
380
- }
381
- };
382
- var ValidationExceptionReason = {
383
- CANNOT_PARSE: "cannotParse",
384
- FIELD_VALIDATION_FAILED: "fieldValidationFailed",
385
- OTHER: "other",
386
- UNKNOWN_OPERATION: "unknownOperation"
387
- };
388
- var ValidationException = class _ValidationException extends RepostspaceServiceException {
389
- static {
390
- __name(this, "ValidationException");
391
- }
392
- name = "ValidationException";
393
- $fault = "client";
394
- /**
395
- * <p>The reason why the request failed validation.</p>
396
- * @public
397
- */
398
- reason;
399
- /**
400
- * <p>The field that caused the error, if applicable.</p>
401
- * @public
402
- */
403
- fieldList;
404
- /**
405
- * @internal
406
- */
407
- constructor(opts) {
408
- super({
409
- name: "ValidationException",
410
- $fault: "client",
411
- ...opts
628
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
629
+ const doc = smithyClient.take(data, {
630
+ addedAccessorIds: smithyClient._json,
631
+ errors: smithyClient._json,
412
632
  });
413
- Object.setPrototypeOf(this, _ValidationException.prototype);
414
- this.reason = opts.reason;
415
- this.fieldList = opts.fieldList;
416
- }
417
- };
418
- var Role = {
419
- ADMINISTRATOR: "ADMINISTRATOR",
420
- EXPERT: "EXPERT",
421
- MODERATOR: "MODERATOR",
422
- SUPPORTREQUESTOR: "SUPPORTREQUESTOR"
423
- };
424
- var ChannelStatus = {
425
- CREATED: "CREATED",
426
- CREATE_FAILED: "CREATE_FAILED",
427
- CREATING: "CREATING",
428
- DELETED: "DELETED",
429
- DELETE_FAILED: "DELETE_FAILED",
430
- DELETING: "DELETING"
431
- };
432
- var ConfigurationStatus = {
433
- CONFIGURED: "CONFIGURED",
434
- UNCONFIGURED: "UNCONFIGURED"
435
- };
436
- var ConflictException = class _ConflictException extends RepostspaceServiceException {
437
- static {
438
- __name(this, "ConflictException");
439
- }
440
- name = "ConflictException";
441
- $fault = "client";
442
- /**
443
- * <p>The ID of the resource.</p>
444
- * @public
445
- */
446
- resourceId;
447
- /**
448
- * <p>The type of the resource.</p>
449
- * @public
450
- */
451
- resourceType;
452
- /**
453
- * @internal
454
- */
455
- constructor(opts) {
456
- super({
457
- name: "ConflictException",
458
- $fault: "client",
459
- ...opts
633
+ Object.assign(contents, doc);
634
+ return contents;
635
+ };
636
+ const de_BatchAddRoleCommand = async (output, context) => {
637
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
638
+ return de_CommandError(output, context);
639
+ }
640
+ const contents = smithyClient.map({
641
+ $metadata: deserializeMetadata(output),
460
642
  });
461
- Object.setPrototypeOf(this, _ConflictException.prototype);
462
- this.resourceId = opts.resourceId;
463
- this.resourceType = opts.resourceType;
464
- }
465
- };
466
- var ServiceQuotaExceededException = class _ServiceQuotaExceededException extends RepostspaceServiceException {
467
- static {
468
- __name(this, "ServiceQuotaExceededException");
469
- }
470
- name = "ServiceQuotaExceededException";
471
- $fault = "client";
472
- /**
473
- * <p>The id of the resource.</p>
474
- * @public
475
- */
476
- resourceId;
477
- /**
478
- * <p>The type of the resource.</p>
479
- * @public
480
- */
481
- resourceType;
482
- /**
483
- * <p>The code to identify the service.</p>
484
- * @public
485
- */
486
- serviceCode;
487
- /**
488
- * <p>The code to identify the quota.</p>
489
- * @public
490
- */
491
- quotaCode;
492
- /**
493
- * @internal
494
- */
495
- constructor(opts) {
496
- super({
497
- name: "ServiceQuotaExceededException",
498
- $fault: "client",
499
- ...opts
643
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
644
+ const doc = smithyClient.take(data, {
645
+ addedAccessorIds: smithyClient._json,
646
+ errors: smithyClient._json,
500
647
  });
501
- Object.setPrototypeOf(this, _ServiceQuotaExceededException.prototype);
502
- this.resourceId = opts.resourceId;
503
- this.resourceType = opts.resourceType;
504
- this.serviceCode = opts.serviceCode;
505
- this.quotaCode = opts.quotaCode;
506
- }
507
- };
508
- var FeatureEnableParameter = {
509
- DISABLED: "DISABLED",
510
- ENABLED: "ENABLED"
511
- };
512
- var TierLevel = {
513
- BASIC: "BASIC",
514
- STANDARD: "STANDARD"
515
- };
516
- var FeatureEnableStatus = {
517
- DISABLED: "DISABLED",
518
- ENABLED: "ENABLED",
519
- NOT_ALLOWED: "NOT_ALLOWED"
520
- };
521
- var VanityDomainStatus = {
522
- APPROVED: "APPROVED",
523
- PENDING: "PENDING",
524
- UNAPPROVED: "UNAPPROVED"
525
- };
526
- var ChannelDataFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
527
- ...obj,
528
- ...obj.channelName && { channelName: import_smithy_client.SENSITIVE_STRING },
529
- ...obj.channelDescription && { channelDescription: import_smithy_client.SENSITIVE_STRING }
530
- }), "ChannelDataFilterSensitiveLog");
531
- var CreateChannelInputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
532
- ...obj,
533
- ...obj.channelName && { channelName: import_smithy_client.SENSITIVE_STRING },
534
- ...obj.channelDescription && { channelDescription: import_smithy_client.SENSITIVE_STRING }
535
- }), "CreateChannelInputFilterSensitiveLog");
536
- var SupportedEmailDomainsParametersFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
537
- ...obj,
538
- ...obj.allowedDomains && { allowedDomains: import_smithy_client.SENSITIVE_STRING }
539
- }), "SupportedEmailDomainsParametersFilterSensitiveLog");
540
- var CreateSpaceInputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
541
- ...obj,
542
- ...obj.name && { name: import_smithy_client.SENSITIVE_STRING },
543
- ...obj.description && { description: import_smithy_client.SENSITIVE_STRING },
544
- ...obj.tags && { tags: import_smithy_client.SENSITIVE_STRING },
545
- ...obj.supportedEmailDomains && {
546
- supportedEmailDomains: SupportedEmailDomainsParametersFilterSensitiveLog(obj.supportedEmailDomains)
547
- }
548
- }), "CreateSpaceInputFilterSensitiveLog");
549
- var GetChannelOutputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
550
- ...obj,
551
- ...obj.channelName && { channelName: import_smithy_client.SENSITIVE_STRING },
552
- ...obj.channelDescription && { channelDescription: import_smithy_client.SENSITIVE_STRING }
553
- }), "GetChannelOutputFilterSensitiveLog");
554
- var SupportedEmailDomainsStatusFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
555
- ...obj,
556
- ...obj.allowedDomains && { allowedDomains: import_smithy_client.SENSITIVE_STRING }
557
- }), "SupportedEmailDomainsStatusFilterSensitiveLog");
558
- var GetSpaceOutputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
559
- ...obj,
560
- ...obj.name && { name: import_smithy_client.SENSITIVE_STRING },
561
- ...obj.description && { description: import_smithy_client.SENSITIVE_STRING },
562
- ...obj.supportedEmailDomains && {
563
- supportedEmailDomains: SupportedEmailDomainsStatusFilterSensitiveLog(obj.supportedEmailDomains)
564
- }
565
- }), "GetSpaceOutputFilterSensitiveLog");
566
- var ListChannelsOutputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
567
- ...obj,
568
- ...obj.channels && { channels: obj.channels.map((item) => ChannelDataFilterSensitiveLog(item)) }
569
- }), "ListChannelsOutputFilterSensitiveLog");
570
- var SpaceDataFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
571
- ...obj,
572
- ...obj.name && { name: import_smithy_client.SENSITIVE_STRING },
573
- ...obj.description && { description: import_smithy_client.SENSITIVE_STRING },
574
- ...obj.supportedEmailDomains && {
575
- supportedEmailDomains: SupportedEmailDomainsStatusFilterSensitiveLog(obj.supportedEmailDomains)
576
- }
577
- }), "SpaceDataFilterSensitiveLog");
578
- var ListSpacesOutputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
579
- ...obj,
580
- ...obj.spaces && { spaces: obj.spaces.map((item) => SpaceDataFilterSensitiveLog(item)) }
581
- }), "ListSpacesOutputFilterSensitiveLog");
582
- var ListTagsForResourceResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
583
- ...obj,
584
- ...obj.tags && { tags: import_smithy_client.SENSITIVE_STRING }
585
- }), "ListTagsForResourceResponseFilterSensitiveLog");
586
- var SendInvitesInputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
587
- ...obj,
588
- ...obj.title && { title: import_smithy_client.SENSITIVE_STRING },
589
- ...obj.body && { body: import_smithy_client.SENSITIVE_STRING }
590
- }), "SendInvitesInputFilterSensitiveLog");
591
- var TagResourceRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
592
- ...obj,
593
- ...obj.tags && { tags: import_smithy_client.SENSITIVE_STRING }
594
- }), "TagResourceRequestFilterSensitiveLog");
595
- var UpdateChannelInputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
596
- ...obj,
597
- ...obj.channelName && { channelName: import_smithy_client.SENSITIVE_STRING },
598
- ...obj.channelDescription && { channelDescription: import_smithy_client.SENSITIVE_STRING }
599
- }), "UpdateChannelInputFilterSensitiveLog");
600
- var UpdateSpaceInputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
601
- ...obj,
602
- ...obj.description && { description: import_smithy_client.SENSITIVE_STRING },
603
- ...obj.supportedEmailDomains && {
604
- supportedEmailDomains: SupportedEmailDomainsParametersFilterSensitiveLog(obj.supportedEmailDomains)
605
- }
606
- }), "UpdateSpaceInputFilterSensitiveLog");
607
-
608
- // src/protocols/Aws_restJson1.ts
609
- var se_BatchAddChannelRoleToAccessorsCommand = /* @__PURE__ */ __name(async (input, context) => {
610
- const b = (0, import_core.requestBuilder)(input, context);
611
- const headers = {
612
- "content-type": "application/json"
613
- };
614
- b.bp("/spaces/{spaceId}/channels/{channelId}/roles");
615
- b.p("spaceId", () => input.spaceId, "{spaceId}", false);
616
- b.p("channelId", () => input.channelId, "{channelId}", false);
617
- let body;
618
- body = JSON.stringify(
619
- (0, import_smithy_client.take)(input, {
620
- accessorIds: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "accessorIds"),
621
- channelRole: []
622
- })
623
- );
624
- b.m("POST").h(headers).b(body);
625
- return b.build();
626
- }, "se_BatchAddChannelRoleToAccessorsCommand");
627
- var se_BatchAddRoleCommand = /* @__PURE__ */ __name(async (input, context) => {
628
- const b = (0, import_core.requestBuilder)(input, context);
629
- const headers = {
630
- "content-type": "application/json"
631
- };
632
- b.bp("/spaces/{spaceId}/roles");
633
- b.p("spaceId", () => input.spaceId, "{spaceId}", false);
634
- let body;
635
- body = JSON.stringify(
636
- (0, import_smithy_client.take)(input, {
637
- accessorIds: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "accessorIds"),
638
- role: []
639
- })
640
- );
641
- b.m("POST").h(headers).b(body);
642
- return b.build();
643
- }, "se_BatchAddRoleCommand");
644
- var se_BatchRemoveChannelRoleFromAccessorsCommand = /* @__PURE__ */ __name(async (input, context) => {
645
- const b = (0, import_core.requestBuilder)(input, context);
646
- const headers = {
647
- "content-type": "application/json"
648
- };
649
- b.bp("/spaces/{spaceId}/channels/{channelId}/roles");
650
- b.p("spaceId", () => input.spaceId, "{spaceId}", false);
651
- b.p("channelId", () => input.channelId, "{channelId}", false);
652
- let body;
653
- body = JSON.stringify(
654
- (0, import_smithy_client.take)(input, {
655
- accessorIds: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "accessorIds"),
656
- channelRole: []
657
- })
658
- );
659
- b.m("PATCH").h(headers).b(body);
660
- return b.build();
661
- }, "se_BatchRemoveChannelRoleFromAccessorsCommand");
662
- var se_BatchRemoveRoleCommand = /* @__PURE__ */ __name(async (input, context) => {
663
- const b = (0, import_core.requestBuilder)(input, context);
664
- const headers = {
665
- "content-type": "application/json"
666
- };
667
- b.bp("/spaces/{spaceId}/roles");
668
- b.p("spaceId", () => input.spaceId, "{spaceId}", false);
669
- let body;
670
- body = JSON.stringify(
671
- (0, import_smithy_client.take)(input, {
672
- accessorIds: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "accessorIds"),
673
- role: []
674
- })
675
- );
676
- b.m("PATCH").h(headers).b(body);
677
- return b.build();
678
- }, "se_BatchRemoveRoleCommand");
679
- var se_CreateChannelCommand = /* @__PURE__ */ __name(async (input, context) => {
680
- const b = (0, import_core.requestBuilder)(input, context);
681
- const headers = {
682
- "content-type": "application/json"
683
- };
684
- b.bp("/spaces/{spaceId}/channels");
685
- b.p("spaceId", () => input.spaceId, "{spaceId}", false);
686
- let body;
687
- body = JSON.stringify(
688
- (0, import_smithy_client.take)(input, {
689
- channelDescription: [],
690
- channelName: []
691
- })
692
- );
693
- b.m("POST").h(headers).b(body);
694
- return b.build();
695
- }, "se_CreateChannelCommand");
696
- var se_CreateSpaceCommand = /* @__PURE__ */ __name(async (input, context) => {
697
- const b = (0, import_core.requestBuilder)(input, context);
698
- const headers = {
699
- "content-type": "application/json"
700
- };
701
- b.bp("/spaces");
702
- let body;
703
- body = JSON.stringify(
704
- (0, import_smithy_client.take)(input, {
705
- description: [],
706
- name: [],
707
- roleArn: [],
708
- subdomain: [],
709
- supportedEmailDomains: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "supportedEmailDomains"),
710
- tags: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "tags"),
711
- tier: [],
712
- userKMSKey: []
713
- })
714
- );
715
- b.m("POST").h(headers).b(body);
716
- return b.build();
717
- }, "se_CreateSpaceCommand");
718
- var se_DeleteSpaceCommand = /* @__PURE__ */ __name(async (input, context) => {
719
- const b = (0, import_core.requestBuilder)(input, context);
720
- const headers = {};
721
- b.bp("/spaces/{spaceId}");
722
- b.p("spaceId", () => input.spaceId, "{spaceId}", false);
723
- let body;
724
- b.m("DELETE").h(headers).b(body);
725
- return b.build();
726
- }, "se_DeleteSpaceCommand");
727
- var se_DeregisterAdminCommand = /* @__PURE__ */ __name(async (input, context) => {
728
- const b = (0, import_core.requestBuilder)(input, context);
729
- const headers = {};
730
- b.bp("/spaces/{spaceId}/admins/{adminId}");
731
- b.p("spaceId", () => input.spaceId, "{spaceId}", false);
732
- b.p("adminId", () => input.adminId, "{adminId}", false);
733
- let body;
734
- b.m("DELETE").h(headers).b(body);
735
- return b.build();
736
- }, "se_DeregisterAdminCommand");
737
- var se_GetChannelCommand = /* @__PURE__ */ __name(async (input, context) => {
738
- const b = (0, import_core.requestBuilder)(input, context);
739
- const headers = {};
740
- b.bp("/spaces/{spaceId}/channels/{channelId}");
741
- b.p("spaceId", () => input.spaceId, "{spaceId}", false);
742
- b.p("channelId", () => input.channelId, "{channelId}", false);
743
- let body;
744
- b.m("GET").h(headers).b(body);
745
- return b.build();
746
- }, "se_GetChannelCommand");
747
- var se_GetSpaceCommand = /* @__PURE__ */ __name(async (input, context) => {
748
- const b = (0, import_core.requestBuilder)(input, context);
749
- const headers = {};
750
- b.bp("/spaces/{spaceId}");
751
- b.p("spaceId", () => input.spaceId, "{spaceId}", false);
752
- let body;
753
- b.m("GET").h(headers).b(body);
754
- return b.build();
755
- }, "se_GetSpaceCommand");
756
- var se_ListChannelsCommand = /* @__PURE__ */ __name(async (input, context) => {
757
- const b = (0, import_core.requestBuilder)(input, context);
758
- const headers = {};
759
- b.bp("/spaces/{spaceId}/channels");
760
- b.p("spaceId", () => input.spaceId, "{spaceId}", false);
761
- const query = (0, import_smithy_client.map)({
762
- [_nT]: [, input[_nT]],
763
- [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()]
764
- });
765
- let body;
766
- b.m("GET").h(headers).q(query).b(body);
767
- return b.build();
768
- }, "se_ListChannelsCommand");
769
- var se_ListSpacesCommand = /* @__PURE__ */ __name(async (input, context) => {
770
- const b = (0, import_core.requestBuilder)(input, context);
771
- const headers = {};
772
- b.bp("/spaces");
773
- const query = (0, import_smithy_client.map)({
774
- [_nT]: [, input[_nT]],
775
- [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()]
776
- });
777
- let body;
778
- b.m("GET").h(headers).q(query).b(body);
779
- return b.build();
780
- }, "se_ListSpacesCommand");
781
- var se_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
782
- const b = (0, import_core.requestBuilder)(input, context);
783
- const headers = {};
784
- b.bp("/tags/{resourceArn}");
785
- b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
786
- let body;
787
- b.m("GET").h(headers).b(body);
788
- return b.build();
789
- }, "se_ListTagsForResourceCommand");
790
- var se_RegisterAdminCommand = /* @__PURE__ */ __name(async (input, context) => {
791
- const b = (0, import_core.requestBuilder)(input, context);
792
- const headers = {};
793
- b.bp("/spaces/{spaceId}/admins/{adminId}");
794
- b.p("spaceId", () => input.spaceId, "{spaceId}", false);
795
- b.p("adminId", () => input.adminId, "{adminId}", false);
796
- let body;
797
- b.m("POST").h(headers).b(body);
798
- return b.build();
799
- }, "se_RegisterAdminCommand");
800
- var se_SendInvitesCommand = /* @__PURE__ */ __name(async (input, context) => {
801
- const b = (0, import_core.requestBuilder)(input, context);
802
- const headers = {
803
- "content-type": "application/json"
804
- };
805
- b.bp("/spaces/{spaceId}/invite");
806
- b.p("spaceId", () => input.spaceId, "{spaceId}", false);
807
- let body;
808
- body = JSON.stringify(
809
- (0, import_smithy_client.take)(input, {
810
- accessorIds: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "accessorIds"),
811
- body: [],
812
- title: []
813
- })
814
- );
815
- b.m("POST").h(headers).b(body);
816
- return b.build();
817
- }, "se_SendInvitesCommand");
818
- var se_TagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
819
- const b = (0, import_core.requestBuilder)(input, context);
820
- const headers = {
821
- "content-type": "application/json"
822
- };
823
- b.bp("/tags/{resourceArn}");
824
- b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
825
- let body;
826
- body = JSON.stringify(
827
- (0, import_smithy_client.take)(input, {
828
- tags: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "tags")
829
- })
830
- );
831
- b.m("POST").h(headers).b(body);
832
- return b.build();
833
- }, "se_TagResourceCommand");
834
- var se_UntagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
835
- const b = (0, import_core.requestBuilder)(input, context);
836
- const headers = {};
837
- b.bp("/tags/{resourceArn}");
838
- b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
839
- const query = (0, import_smithy_client.map)({
840
- [_tK]: [(0, import_smithy_client.expectNonNull)(input.tagKeys, `tagKeys`) != null, () => input[_tK] || []]
841
- });
842
- let body;
843
- b.m("DELETE").h(headers).q(query).b(body);
844
- return b.build();
845
- }, "se_UntagResourceCommand");
846
- var se_UpdateChannelCommand = /* @__PURE__ */ __name(async (input, context) => {
847
- const b = (0, import_core.requestBuilder)(input, context);
848
- const headers = {
849
- "content-type": "application/json"
850
- };
851
- b.bp("/spaces/{spaceId}/channels/{channelId}");
852
- b.p("spaceId", () => input.spaceId, "{spaceId}", false);
853
- b.p("channelId", () => input.channelId, "{channelId}", false);
854
- let body;
855
- body = JSON.stringify(
856
- (0, import_smithy_client.take)(input, {
857
- channelDescription: [],
858
- channelName: []
859
- })
860
- );
861
- b.m("PUT").h(headers).b(body);
862
- return b.build();
863
- }, "se_UpdateChannelCommand");
864
- var se_UpdateSpaceCommand = /* @__PURE__ */ __name(async (input, context) => {
865
- const b = (0, import_core.requestBuilder)(input, context);
866
- const headers = {
867
- "content-type": "application/json"
868
- };
869
- b.bp("/spaces/{spaceId}");
870
- b.p("spaceId", () => input.spaceId, "{spaceId}", false);
871
- let body;
872
- body = JSON.stringify(
873
- (0, import_smithy_client.take)(input, {
874
- description: [],
875
- roleArn: [],
876
- supportedEmailDomains: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "supportedEmailDomains"),
877
- tier: []
878
- })
879
- );
880
- b.m("PUT").h(headers).b(body);
881
- return b.build();
882
- }, "se_UpdateSpaceCommand");
883
- var de_BatchAddChannelRoleToAccessorsCommand = /* @__PURE__ */ __name(async (output, context) => {
884
- if (output.statusCode !== 200 && output.statusCode >= 300) {
885
- return de_CommandError(output, context);
886
- }
887
- const contents = (0, import_smithy_client.map)({
888
- $metadata: deserializeMetadata(output)
889
- });
890
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
891
- const doc = (0, import_smithy_client.take)(data, {
892
- addedAccessorIds: import_smithy_client._json,
893
- errors: import_smithy_client._json
894
- });
895
- Object.assign(contents, doc);
896
- return contents;
897
- }, "de_BatchAddChannelRoleToAccessorsCommand");
898
- var de_BatchAddRoleCommand = /* @__PURE__ */ __name(async (output, context) => {
899
- if (output.statusCode !== 200 && output.statusCode >= 300) {
900
- return de_CommandError(output, context);
901
- }
902
- const contents = (0, import_smithy_client.map)({
903
- $metadata: deserializeMetadata(output)
904
- });
905
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
906
- const doc = (0, import_smithy_client.take)(data, {
907
- addedAccessorIds: import_smithy_client._json,
908
- errors: import_smithy_client._json
909
- });
910
- Object.assign(contents, doc);
911
- return contents;
912
- }, "de_BatchAddRoleCommand");
913
- var de_BatchRemoveChannelRoleFromAccessorsCommand = /* @__PURE__ */ __name(async (output, context) => {
914
- if (output.statusCode !== 200 && output.statusCode >= 300) {
915
- return de_CommandError(output, context);
916
- }
917
- const contents = (0, import_smithy_client.map)({
918
- $metadata: deserializeMetadata(output)
919
- });
920
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
921
- const doc = (0, import_smithy_client.take)(data, {
922
- errors: import_smithy_client._json,
923
- removedAccessorIds: import_smithy_client._json
924
- });
925
- Object.assign(contents, doc);
926
- return contents;
927
- }, "de_BatchRemoveChannelRoleFromAccessorsCommand");
928
- var de_BatchRemoveRoleCommand = /* @__PURE__ */ __name(async (output, context) => {
929
- if (output.statusCode !== 200 && output.statusCode >= 300) {
930
- return de_CommandError(output, context);
931
- }
932
- const contents = (0, import_smithy_client.map)({
933
- $metadata: deserializeMetadata(output)
934
- });
935
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
936
- const doc = (0, import_smithy_client.take)(data, {
937
- errors: import_smithy_client._json,
938
- removedAccessorIds: import_smithy_client._json
939
- });
940
- Object.assign(contents, doc);
941
- return contents;
942
- }, "de_BatchRemoveRoleCommand");
943
- var de_CreateChannelCommand = /* @__PURE__ */ __name(async (output, context) => {
944
- if (output.statusCode !== 200 && output.statusCode >= 300) {
945
- return de_CommandError(output, context);
946
- }
947
- const contents = (0, import_smithy_client.map)({
948
- $metadata: deserializeMetadata(output)
949
- });
950
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
951
- const doc = (0, import_smithy_client.take)(data, {
952
- channelId: import_smithy_client.expectString
953
- });
954
- Object.assign(contents, doc);
955
- return contents;
956
- }, "de_CreateChannelCommand");
957
- var de_CreateSpaceCommand = /* @__PURE__ */ __name(async (output, context) => {
958
- if (output.statusCode !== 200 && output.statusCode >= 300) {
959
- return de_CommandError(output, context);
960
- }
961
- const contents = (0, import_smithy_client.map)({
962
- $metadata: deserializeMetadata(output)
963
- });
964
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
965
- const doc = (0, import_smithy_client.take)(data, {
966
- spaceId: import_smithy_client.expectString
967
- });
968
- Object.assign(contents, doc);
969
- return contents;
970
- }, "de_CreateSpaceCommand");
971
- var de_DeleteSpaceCommand = /* @__PURE__ */ __name(async (output, context) => {
972
- if (output.statusCode !== 200 && output.statusCode >= 300) {
973
- return de_CommandError(output, context);
974
- }
975
- const contents = (0, import_smithy_client.map)({
976
- $metadata: deserializeMetadata(output)
977
- });
978
- await (0, import_smithy_client.collectBody)(output.body, context);
979
- return contents;
980
- }, "de_DeleteSpaceCommand");
981
- var de_DeregisterAdminCommand = /* @__PURE__ */ __name(async (output, context) => {
982
- if (output.statusCode !== 200 && output.statusCode >= 300) {
983
- return de_CommandError(output, context);
984
- }
985
- const contents = (0, import_smithy_client.map)({
986
- $metadata: deserializeMetadata(output)
987
- });
988
- await (0, import_smithy_client.collectBody)(output.body, context);
989
- return contents;
990
- }, "de_DeregisterAdminCommand");
991
- var de_GetChannelCommand = /* @__PURE__ */ __name(async (output, context) => {
992
- if (output.statusCode !== 200 && output.statusCode >= 300) {
993
- return de_CommandError(output, context);
994
- }
995
- const contents = (0, import_smithy_client.map)({
996
- $metadata: deserializeMetadata(output)
997
- });
998
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
999
- const doc = (0, import_smithy_client.take)(data, {
1000
- channelDescription: import_smithy_client.expectString,
1001
- channelId: import_smithy_client.expectString,
1002
- channelName: import_smithy_client.expectString,
1003
- channelRoles: import_smithy_client._json,
1004
- channelStatus: import_smithy_client.expectString,
1005
- createDateTime: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), "createDateTime"),
1006
- deleteDateTime: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), "deleteDateTime"),
1007
- spaceId: import_smithy_client.expectString
1008
- });
1009
- Object.assign(contents, doc);
1010
- return contents;
1011
- }, "de_GetChannelCommand");
1012
- var de_GetSpaceCommand = /* @__PURE__ */ __name(async (output, context) => {
1013
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1014
- return de_CommandError(output, context);
1015
- }
1016
- const contents = (0, import_smithy_client.map)({
1017
- $metadata: deserializeMetadata(output)
1018
- });
1019
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
1020
- const doc = (0, import_smithy_client.take)(data, {
1021
- applicationArn: import_smithy_client.expectString,
1022
- arn: import_smithy_client.expectString,
1023
- clientId: import_smithy_client.expectString,
1024
- configurationStatus: import_smithy_client.expectString,
1025
- contentSize: import_smithy_client.expectLong,
1026
- createDateTime: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), "createDateTime"),
1027
- customerRoleArn: import_smithy_client.expectString,
1028
- deleteDateTime: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), "deleteDateTime"),
1029
- description: import_smithy_client.expectString,
1030
- groupAdmins: import_smithy_client._json,
1031
- identityStoreId: import_smithy_client.expectString,
1032
- name: import_smithy_client.expectString,
1033
- randomDomain: import_smithy_client.expectString,
1034
- roles: import_smithy_client._json,
1035
- spaceId: import_smithy_client.expectString,
1036
- status: import_smithy_client.expectString,
1037
- storageLimit: import_smithy_client.expectLong,
1038
- supportedEmailDomains: import_smithy_client._json,
1039
- tier: import_smithy_client.expectString,
1040
- userAdmins: import_smithy_client._json,
1041
- userCount: import_smithy_client.expectInt32,
1042
- userKMSKey: import_smithy_client.expectString,
1043
- vanityDomain: import_smithy_client.expectString,
1044
- vanityDomainStatus: import_smithy_client.expectString
1045
- });
1046
- Object.assign(contents, doc);
1047
- return contents;
1048
- }, "de_GetSpaceCommand");
1049
- var de_ListChannelsCommand = /* @__PURE__ */ __name(async (output, context) => {
1050
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1051
- return de_CommandError(output, context);
1052
- }
1053
- const contents = (0, import_smithy_client.map)({
1054
- $metadata: deserializeMetadata(output)
1055
- });
1056
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
1057
- const doc = (0, import_smithy_client.take)(data, {
1058
- channels: /* @__PURE__ */ __name((_) => de_ChannelsList(_, context), "channels"),
1059
- nextToken: import_smithy_client.expectString
1060
- });
1061
- Object.assign(contents, doc);
1062
- return contents;
1063
- }, "de_ListChannelsCommand");
1064
- var de_ListSpacesCommand = /* @__PURE__ */ __name(async (output, context) => {
1065
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1066
- return de_CommandError(output, context);
1067
- }
1068
- const contents = (0, import_smithy_client.map)({
1069
- $metadata: deserializeMetadata(output)
1070
- });
1071
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
1072
- const doc = (0, import_smithy_client.take)(data, {
1073
- nextToken: import_smithy_client.expectString,
1074
- spaces: /* @__PURE__ */ __name((_) => de_SpacesList(_, context), "spaces")
1075
- });
1076
- Object.assign(contents, doc);
1077
- return contents;
1078
- }, "de_ListSpacesCommand");
1079
- var de_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
1080
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1081
- return de_CommandError(output, context);
1082
- }
1083
- const contents = (0, import_smithy_client.map)({
1084
- $metadata: deserializeMetadata(output)
1085
- });
1086
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
1087
- const doc = (0, import_smithy_client.take)(data, {
1088
- tags: import_smithy_client._json
1089
- });
1090
- Object.assign(contents, doc);
1091
- return contents;
1092
- }, "de_ListTagsForResourceCommand");
1093
- var de_RegisterAdminCommand = /* @__PURE__ */ __name(async (output, context) => {
1094
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1095
- return de_CommandError(output, context);
1096
- }
1097
- const contents = (0, import_smithy_client.map)({
1098
- $metadata: deserializeMetadata(output)
1099
- });
1100
- await (0, import_smithy_client.collectBody)(output.body, context);
1101
- return contents;
1102
- }, "de_RegisterAdminCommand");
1103
- var de_SendInvitesCommand = /* @__PURE__ */ __name(async (output, context) => {
1104
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1105
- return de_CommandError(output, context);
1106
- }
1107
- const contents = (0, import_smithy_client.map)({
1108
- $metadata: deserializeMetadata(output)
1109
- });
1110
- await (0, import_smithy_client.collectBody)(output.body, context);
1111
- return contents;
1112
- }, "de_SendInvitesCommand");
1113
- var de_TagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
1114
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1115
- return de_CommandError(output, context);
1116
- }
1117
- const contents = (0, import_smithy_client.map)({
1118
- $metadata: deserializeMetadata(output)
1119
- });
1120
- await (0, import_smithy_client.collectBody)(output.body, context);
1121
- return contents;
1122
- }, "de_TagResourceCommand");
1123
- var de_UntagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
1124
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1125
- return de_CommandError(output, context);
1126
- }
1127
- const contents = (0, import_smithy_client.map)({
1128
- $metadata: deserializeMetadata(output)
1129
- });
1130
- await (0, import_smithy_client.collectBody)(output.body, context);
1131
- return contents;
1132
- }, "de_UntagResourceCommand");
1133
- var de_UpdateChannelCommand = /* @__PURE__ */ __name(async (output, context) => {
1134
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1135
- return de_CommandError(output, context);
1136
- }
1137
- const contents = (0, import_smithy_client.map)({
1138
- $metadata: deserializeMetadata(output)
1139
- });
1140
- await (0, import_smithy_client.collectBody)(output.body, context);
1141
- return contents;
1142
- }, "de_UpdateChannelCommand");
1143
- var de_UpdateSpaceCommand = /* @__PURE__ */ __name(async (output, context) => {
1144
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1145
- return de_CommandError(output, context);
1146
- }
1147
- const contents = (0, import_smithy_client.map)({
1148
- $metadata: deserializeMetadata(output)
1149
- });
1150
- await (0, import_smithy_client.collectBody)(output.body, context);
1151
- return contents;
1152
- }, "de_UpdateSpaceCommand");
1153
- var de_CommandError = /* @__PURE__ */ __name(async (output, context) => {
1154
- const parsedOutput = {
1155
- ...output,
1156
- body: await (0, import_core2.parseJsonErrorBody)(output.body, context)
1157
- };
1158
- const errorCode = (0, import_core2.loadRestJsonErrorCode)(output, parsedOutput.body);
1159
- switch (errorCode) {
1160
- case "AccessDeniedException":
1161
- case "com.amazonaws.repostspace#AccessDeniedException":
1162
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1163
- case "InternalServerException":
1164
- case "com.amazonaws.repostspace#InternalServerException":
1165
- throw await de_InternalServerExceptionRes(parsedOutput, context);
1166
- case "ResourceNotFoundException":
1167
- case "com.amazonaws.repostspace#ResourceNotFoundException":
1168
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1169
- case "ThrottlingException":
1170
- case "com.amazonaws.repostspace#ThrottlingException":
1171
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
1172
- case "ValidationException":
1173
- case "com.amazonaws.repostspace#ValidationException":
1174
- throw await de_ValidationExceptionRes(parsedOutput, context);
1175
- case "ConflictException":
1176
- case "com.amazonaws.repostspace#ConflictException":
1177
- throw await de_ConflictExceptionRes(parsedOutput, context);
1178
- case "ServiceQuotaExceededException":
1179
- case "com.amazonaws.repostspace#ServiceQuotaExceededException":
1180
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
1181
- default:
1182
- const parsedBody = parsedOutput.body;
1183
- return throwDefaultError({
1184
- output,
1185
- parsedBody,
1186
- errorCode
1187
- });
1188
- }
1189
- }, "de_CommandError");
1190
- var throwDefaultError = (0, import_smithy_client.withBaseException)(RepostspaceServiceException);
1191
- var de_AccessDeniedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
1192
- const contents = (0, import_smithy_client.map)({});
1193
- const data = parsedOutput.body;
1194
- const doc = (0, import_smithy_client.take)(data, {
1195
- message: import_smithy_client.expectString
1196
- });
1197
- Object.assign(contents, doc);
1198
- const exception = new AccessDeniedException({
1199
- $metadata: deserializeMetadata(parsedOutput),
1200
- ...contents
1201
- });
1202
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
1203
- }, "de_AccessDeniedExceptionRes");
1204
- var de_ConflictExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
1205
- const contents = (0, import_smithy_client.map)({});
1206
- const data = parsedOutput.body;
1207
- const doc = (0, import_smithy_client.take)(data, {
1208
- message: import_smithy_client.expectString,
1209
- resourceId: import_smithy_client.expectString,
1210
- resourceType: import_smithy_client.expectString
1211
- });
1212
- Object.assign(contents, doc);
1213
- const exception = new ConflictException({
1214
- $metadata: deserializeMetadata(parsedOutput),
1215
- ...contents
1216
- });
1217
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
1218
- }, "de_ConflictExceptionRes");
1219
- var de_InternalServerExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
1220
- const contents = (0, import_smithy_client.map)({
1221
- [_rAS]: [() => void 0 !== parsedOutput.headers[_ra], () => (0, import_smithy_client.strictParseInt32)(parsedOutput.headers[_ra])]
1222
- });
1223
- const data = parsedOutput.body;
1224
- const doc = (0, import_smithy_client.take)(data, {
1225
- message: import_smithy_client.expectString
1226
- });
1227
- Object.assign(contents, doc);
1228
- const exception = new InternalServerException({
1229
- $metadata: deserializeMetadata(parsedOutput),
1230
- ...contents
1231
- });
1232
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
1233
- }, "de_InternalServerExceptionRes");
1234
- var de_ResourceNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
1235
- const contents = (0, import_smithy_client.map)({});
1236
- const data = parsedOutput.body;
1237
- const doc = (0, import_smithy_client.take)(data, {
1238
- message: import_smithy_client.expectString,
1239
- resourceId: import_smithy_client.expectString,
1240
- resourceType: import_smithy_client.expectString
1241
- });
1242
- Object.assign(contents, doc);
1243
- const exception = new ResourceNotFoundException({
1244
- $metadata: deserializeMetadata(parsedOutput),
1245
- ...contents
1246
- });
1247
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
1248
- }, "de_ResourceNotFoundExceptionRes");
1249
- var de_ServiceQuotaExceededExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
1250
- const contents = (0, import_smithy_client.map)({});
1251
- const data = parsedOutput.body;
1252
- const doc = (0, import_smithy_client.take)(data, {
1253
- message: import_smithy_client.expectString,
1254
- quotaCode: import_smithy_client.expectString,
1255
- resourceId: import_smithy_client.expectString,
1256
- resourceType: import_smithy_client.expectString,
1257
- serviceCode: import_smithy_client.expectString
1258
- });
1259
- Object.assign(contents, doc);
1260
- const exception = new ServiceQuotaExceededException({
1261
- $metadata: deserializeMetadata(parsedOutput),
1262
- ...contents
1263
- });
1264
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
1265
- }, "de_ServiceQuotaExceededExceptionRes");
1266
- var de_ThrottlingExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
1267
- const contents = (0, import_smithy_client.map)({
1268
- [_rAS]: [() => void 0 !== parsedOutput.headers[_ra], () => (0, import_smithy_client.strictParseInt32)(parsedOutput.headers[_ra])]
1269
- });
1270
- const data = parsedOutput.body;
1271
- const doc = (0, import_smithy_client.take)(data, {
1272
- message: import_smithy_client.expectString,
1273
- quotaCode: import_smithy_client.expectString,
1274
- serviceCode: import_smithy_client.expectString
1275
- });
1276
- Object.assign(contents, doc);
1277
- const exception = new ThrottlingException({
1278
- $metadata: deserializeMetadata(parsedOutput),
1279
- ...contents
1280
- });
1281
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
1282
- }, "de_ThrottlingExceptionRes");
1283
- var de_ValidationExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
1284
- const contents = (0, import_smithy_client.map)({});
1285
- const data = parsedOutput.body;
1286
- const doc = (0, import_smithy_client.take)(data, {
1287
- fieldList: import_smithy_client._json,
1288
- message: import_smithy_client.expectString,
1289
- reason: import_smithy_client.expectString
1290
- });
1291
- Object.assign(contents, doc);
1292
- const exception = new ValidationException({
1293
- $metadata: deserializeMetadata(parsedOutput),
1294
- ...contents
1295
- });
1296
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
1297
- }, "de_ValidationExceptionRes");
1298
- var de_ChannelData = /* @__PURE__ */ __name((output, context) => {
1299
- return (0, import_smithy_client.take)(output, {
1300
- channelDescription: import_smithy_client.expectString,
1301
- channelId: import_smithy_client.expectString,
1302
- channelName: import_smithy_client.expectString,
1303
- channelStatus: import_smithy_client.expectString,
1304
- createDateTime: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), "createDateTime"),
1305
- deleteDateTime: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), "deleteDateTime"),
1306
- groupCount: import_smithy_client.expectInt32,
1307
- spaceId: import_smithy_client.expectString,
1308
- userCount: import_smithy_client.expectInt32
1309
- });
1310
- }, "de_ChannelData");
1311
- var de_ChannelsList = /* @__PURE__ */ __name((output, context) => {
1312
- const retVal = (output || []).filter((e) => e != null).map((entry) => {
1313
- return de_ChannelData(entry, context);
1314
- });
1315
- return retVal;
1316
- }, "de_ChannelsList");
1317
- var de_SpaceData = /* @__PURE__ */ __name((output, context) => {
1318
- return (0, import_smithy_client.take)(output, {
1319
- arn: import_smithy_client.expectString,
1320
- configurationStatus: import_smithy_client.expectString,
1321
- contentSize: import_smithy_client.expectLong,
1322
- createDateTime: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), "createDateTime"),
1323
- deleteDateTime: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), "deleteDateTime"),
1324
- description: import_smithy_client.expectString,
1325
- name: import_smithy_client.expectString,
1326
- randomDomain: import_smithy_client.expectString,
1327
- spaceId: import_smithy_client.expectString,
1328
- status: import_smithy_client.expectString,
1329
- storageLimit: import_smithy_client.expectLong,
1330
- supportedEmailDomains: import_smithy_client._json,
1331
- tier: import_smithy_client.expectString,
1332
- userCount: import_smithy_client.expectInt32,
1333
- userKMSKey: import_smithy_client.expectString,
1334
- vanityDomain: import_smithy_client.expectString,
1335
- vanityDomainStatus: import_smithy_client.expectString
1336
- });
1337
- }, "de_SpaceData");
1338
- var de_SpacesList = /* @__PURE__ */ __name((output, context) => {
1339
- const retVal = (output || []).filter((e) => e != null).map((entry) => {
1340
- return de_SpaceData(entry, context);
1341
- });
1342
- return retVal;
1343
- }, "de_SpacesList");
1344
- var deserializeMetadata = /* @__PURE__ */ __name((output) => ({
1345
- httpStatusCode: output.statusCode,
1346
- requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
1347
- extendedRequestId: output.headers["x-amz-id-2"],
1348
- cfId: output.headers["x-amz-cf-id"]
1349
- }), "deserializeMetadata");
1350
- var _mR = "maxResults";
1351
- var _nT = "nextToken";
1352
- var _rAS = "retryAfterSeconds";
1353
- var _ra = "retry-after";
1354
- var _tK = "tagKeys";
1355
-
1356
- // src/commands/BatchAddChannelRoleToAccessorsCommand.ts
1357
- var BatchAddChannelRoleToAccessorsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1358
- return [
1359
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1360
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1361
- ];
1362
- }).s("RepostSpace", "BatchAddChannelRoleToAccessors", {}).n("RepostspaceClient", "BatchAddChannelRoleToAccessorsCommand").f(void 0, void 0).ser(se_BatchAddChannelRoleToAccessorsCommand).de(de_BatchAddChannelRoleToAccessorsCommand).build() {
1363
- static {
1364
- __name(this, "BatchAddChannelRoleToAccessorsCommand");
1365
- }
648
+ Object.assign(contents, doc);
649
+ return contents;
1366
650
  };
1367
-
1368
- // src/commands/BatchAddRoleCommand.ts
1369
-
1370
-
1371
-
1372
- var BatchAddRoleCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1373
- return [
1374
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1375
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1376
- ];
1377
- }).s("RepostSpace", "BatchAddRole", {}).n("RepostspaceClient", "BatchAddRoleCommand").f(void 0, void 0).ser(se_BatchAddRoleCommand).de(de_BatchAddRoleCommand).build() {
1378
- static {
1379
- __name(this, "BatchAddRoleCommand");
1380
- }
651
+ const de_BatchRemoveChannelRoleFromAccessorsCommand = async (output, context) => {
652
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
653
+ return de_CommandError(output, context);
654
+ }
655
+ const contents = smithyClient.map({
656
+ $metadata: deserializeMetadata(output),
657
+ });
658
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
659
+ const doc = smithyClient.take(data, {
660
+ errors: smithyClient._json,
661
+ removedAccessorIds: smithyClient._json,
662
+ });
663
+ Object.assign(contents, doc);
664
+ return contents;
1381
665
  };
1382
-
1383
- // src/commands/BatchRemoveChannelRoleFromAccessorsCommand.ts
1384
-
1385
-
1386
-
1387
- var BatchRemoveChannelRoleFromAccessorsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1388
- return [
1389
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1390
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1391
- ];
1392
- }).s("RepostSpace", "BatchRemoveChannelRoleFromAccessors", {}).n("RepostspaceClient", "BatchRemoveChannelRoleFromAccessorsCommand").f(void 0, void 0).ser(se_BatchRemoveChannelRoleFromAccessorsCommand).de(de_BatchRemoveChannelRoleFromAccessorsCommand).build() {
1393
- static {
1394
- __name(this, "BatchRemoveChannelRoleFromAccessorsCommand");
1395
- }
666
+ const de_BatchRemoveRoleCommand = async (output, context) => {
667
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
668
+ return de_CommandError(output, context);
669
+ }
670
+ const contents = smithyClient.map({
671
+ $metadata: deserializeMetadata(output),
672
+ });
673
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
674
+ const doc = smithyClient.take(data, {
675
+ errors: smithyClient._json,
676
+ removedAccessorIds: smithyClient._json,
677
+ });
678
+ Object.assign(contents, doc);
679
+ return contents;
1396
680
  };
1397
-
1398
- // src/commands/BatchRemoveRoleCommand.ts
1399
-
1400
-
1401
-
1402
- var BatchRemoveRoleCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1403
- return [
1404
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1405
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1406
- ];
1407
- }).s("RepostSpace", "BatchRemoveRole", {}).n("RepostspaceClient", "BatchRemoveRoleCommand").f(void 0, void 0).ser(se_BatchRemoveRoleCommand).de(de_BatchRemoveRoleCommand).build() {
1408
- static {
1409
- __name(this, "BatchRemoveRoleCommand");
1410
- }
681
+ const de_CreateChannelCommand = async (output, context) => {
682
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
683
+ return de_CommandError(output, context);
684
+ }
685
+ const contents = smithyClient.map({
686
+ $metadata: deserializeMetadata(output),
687
+ });
688
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
689
+ const doc = smithyClient.take(data, {
690
+ channelId: smithyClient.expectString,
691
+ });
692
+ Object.assign(contents, doc);
693
+ return contents;
1411
694
  };
1412
-
1413
- // src/commands/CreateChannelCommand.ts
1414
-
1415
-
1416
-
1417
- var CreateChannelCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1418
- return [
1419
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1420
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1421
- ];
1422
- }).s("RepostSpace", "CreateChannel", {}).n("RepostspaceClient", "CreateChannelCommand").f(CreateChannelInputFilterSensitiveLog, void 0).ser(se_CreateChannelCommand).de(de_CreateChannelCommand).build() {
1423
- static {
1424
- __name(this, "CreateChannelCommand");
1425
- }
695
+ const de_CreateSpaceCommand = async (output, context) => {
696
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
697
+ return de_CommandError(output, context);
698
+ }
699
+ const contents = smithyClient.map({
700
+ $metadata: deserializeMetadata(output),
701
+ });
702
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
703
+ const doc = smithyClient.take(data, {
704
+ spaceId: smithyClient.expectString,
705
+ });
706
+ Object.assign(contents, doc);
707
+ return contents;
1426
708
  };
1427
-
1428
- // src/commands/CreateSpaceCommand.ts
1429
-
1430
-
1431
-
1432
- var CreateSpaceCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1433
- return [
1434
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1435
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1436
- ];
1437
- }).s("RepostSpace", "CreateSpace", {}).n("RepostspaceClient", "CreateSpaceCommand").f(CreateSpaceInputFilterSensitiveLog, void 0).ser(se_CreateSpaceCommand).de(de_CreateSpaceCommand).build() {
1438
- static {
1439
- __name(this, "CreateSpaceCommand");
1440
- }
709
+ const de_DeleteSpaceCommand = async (output, context) => {
710
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
711
+ return de_CommandError(output, context);
712
+ }
713
+ const contents = smithyClient.map({
714
+ $metadata: deserializeMetadata(output),
715
+ });
716
+ await smithyClient.collectBody(output.body, context);
717
+ return contents;
1441
718
  };
1442
-
1443
- // src/commands/DeleteSpaceCommand.ts
1444
-
1445
-
1446
-
1447
- var DeleteSpaceCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1448
- return [
1449
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1450
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1451
- ];
1452
- }).s("RepostSpace", "DeleteSpace", {}).n("RepostspaceClient", "DeleteSpaceCommand").f(void 0, void 0).ser(se_DeleteSpaceCommand).de(de_DeleteSpaceCommand).build() {
1453
- static {
1454
- __name(this, "DeleteSpaceCommand");
1455
- }
719
+ const de_DeregisterAdminCommand = async (output, context) => {
720
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
721
+ return de_CommandError(output, context);
722
+ }
723
+ const contents = smithyClient.map({
724
+ $metadata: deserializeMetadata(output),
725
+ });
726
+ await smithyClient.collectBody(output.body, context);
727
+ return contents;
1456
728
  };
1457
-
1458
- // src/commands/DeregisterAdminCommand.ts
1459
-
1460
-
1461
-
1462
- var DeregisterAdminCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1463
- return [
1464
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1465
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1466
- ];
1467
- }).s("RepostSpace", "DeregisterAdmin", {}).n("RepostspaceClient", "DeregisterAdminCommand").f(void 0, void 0).ser(se_DeregisterAdminCommand).de(de_DeregisterAdminCommand).build() {
1468
- static {
1469
- __name(this, "DeregisterAdminCommand");
1470
- }
729
+ const de_GetChannelCommand = async (output, context) => {
730
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
731
+ return de_CommandError(output, context);
732
+ }
733
+ const contents = smithyClient.map({
734
+ $metadata: deserializeMetadata(output),
735
+ });
736
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
737
+ const doc = smithyClient.take(data, {
738
+ channelDescription: smithyClient.expectString,
739
+ channelId: smithyClient.expectString,
740
+ channelName: smithyClient.expectString,
741
+ channelRoles: smithyClient._json,
742
+ channelStatus: smithyClient.expectString,
743
+ createDateTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
744
+ deleteDateTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
745
+ spaceId: smithyClient.expectString,
746
+ });
747
+ Object.assign(contents, doc);
748
+ return contents;
1471
749
  };
1472
-
1473
- // src/commands/GetChannelCommand.ts
1474
-
1475
-
1476
-
1477
- var GetChannelCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1478
- return [
1479
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1480
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1481
- ];
1482
- }).s("RepostSpace", "GetChannel", {}).n("RepostspaceClient", "GetChannelCommand").f(void 0, GetChannelOutputFilterSensitiveLog).ser(se_GetChannelCommand).de(de_GetChannelCommand).build() {
1483
- static {
1484
- __name(this, "GetChannelCommand");
1485
- }
750
+ const de_GetSpaceCommand = async (output, context) => {
751
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
752
+ return de_CommandError(output, context);
753
+ }
754
+ const contents = smithyClient.map({
755
+ $metadata: deserializeMetadata(output),
756
+ });
757
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
758
+ const doc = smithyClient.take(data, {
759
+ applicationArn: smithyClient.expectString,
760
+ arn: smithyClient.expectString,
761
+ clientId: smithyClient.expectString,
762
+ configurationStatus: smithyClient.expectString,
763
+ contentSize: smithyClient.expectLong,
764
+ createDateTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
765
+ customerRoleArn: smithyClient.expectString,
766
+ deleteDateTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
767
+ description: smithyClient.expectString,
768
+ groupAdmins: smithyClient._json,
769
+ identityStoreId: smithyClient.expectString,
770
+ name: smithyClient.expectString,
771
+ randomDomain: smithyClient.expectString,
772
+ roles: smithyClient._json,
773
+ spaceId: smithyClient.expectString,
774
+ status: smithyClient.expectString,
775
+ storageLimit: smithyClient.expectLong,
776
+ supportedEmailDomains: smithyClient._json,
777
+ tier: smithyClient.expectString,
778
+ userAdmins: smithyClient._json,
779
+ userCount: smithyClient.expectInt32,
780
+ userKMSKey: smithyClient.expectString,
781
+ vanityDomain: smithyClient.expectString,
782
+ vanityDomainStatus: smithyClient.expectString,
783
+ });
784
+ Object.assign(contents, doc);
785
+ return contents;
1486
786
  };
1487
-
1488
- // src/commands/GetSpaceCommand.ts
1489
-
1490
-
1491
-
1492
- var GetSpaceCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1493
- return [
1494
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1495
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1496
- ];
1497
- }).s("RepostSpace", "GetSpace", {}).n("RepostspaceClient", "GetSpaceCommand").f(void 0, GetSpaceOutputFilterSensitiveLog).ser(se_GetSpaceCommand).de(de_GetSpaceCommand).build() {
1498
- static {
1499
- __name(this, "GetSpaceCommand");
1500
- }
787
+ const de_ListChannelsCommand = async (output, context) => {
788
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
789
+ return de_CommandError(output, context);
790
+ }
791
+ const contents = smithyClient.map({
792
+ $metadata: deserializeMetadata(output),
793
+ });
794
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
795
+ const doc = smithyClient.take(data, {
796
+ channels: (_) => de_ChannelsList(_),
797
+ nextToken: smithyClient.expectString,
798
+ });
799
+ Object.assign(contents, doc);
800
+ return contents;
1501
801
  };
1502
-
1503
- // src/commands/ListChannelsCommand.ts
1504
-
1505
-
1506
-
1507
- var ListChannelsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1508
- return [
1509
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1510
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1511
- ];
1512
- }).s("RepostSpace", "ListChannels", {}).n("RepostspaceClient", "ListChannelsCommand").f(void 0, ListChannelsOutputFilterSensitiveLog).ser(se_ListChannelsCommand).de(de_ListChannelsCommand).build() {
1513
- static {
1514
- __name(this, "ListChannelsCommand");
1515
- }
802
+ const de_ListSpacesCommand = async (output, context) => {
803
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
804
+ return de_CommandError(output, context);
805
+ }
806
+ const contents = smithyClient.map({
807
+ $metadata: deserializeMetadata(output),
808
+ });
809
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
810
+ const doc = smithyClient.take(data, {
811
+ nextToken: smithyClient.expectString,
812
+ spaces: (_) => de_SpacesList(_),
813
+ });
814
+ Object.assign(contents, doc);
815
+ return contents;
1516
816
  };
1517
-
1518
- // src/commands/ListSpacesCommand.ts
1519
-
1520
-
1521
-
1522
- var ListSpacesCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1523
- return [
1524
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1525
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1526
- ];
1527
- }).s("RepostSpace", "ListSpaces", {}).n("RepostspaceClient", "ListSpacesCommand").f(void 0, ListSpacesOutputFilterSensitiveLog).ser(se_ListSpacesCommand).de(de_ListSpacesCommand).build() {
1528
- static {
1529
- __name(this, "ListSpacesCommand");
1530
- }
817
+ const de_ListTagsForResourceCommand = async (output, context) => {
818
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
819
+ return de_CommandError(output, context);
820
+ }
821
+ const contents = smithyClient.map({
822
+ $metadata: deserializeMetadata(output),
823
+ });
824
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
825
+ const doc = smithyClient.take(data, {
826
+ tags: smithyClient._json,
827
+ });
828
+ Object.assign(contents, doc);
829
+ return contents;
1531
830
  };
1532
-
1533
- // src/commands/ListTagsForResourceCommand.ts
1534
-
1535
-
1536
-
1537
- var ListTagsForResourceCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1538
- return [
1539
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1540
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1541
- ];
1542
- }).s("RepostSpace", "ListTagsForResource", {}).n("RepostspaceClient", "ListTagsForResourceCommand").f(void 0, ListTagsForResourceResponseFilterSensitiveLog).ser(se_ListTagsForResourceCommand).de(de_ListTagsForResourceCommand).build() {
1543
- static {
1544
- __name(this, "ListTagsForResourceCommand");
1545
- }
831
+ const de_RegisterAdminCommand = async (output, context) => {
832
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
833
+ return de_CommandError(output, context);
834
+ }
835
+ const contents = smithyClient.map({
836
+ $metadata: deserializeMetadata(output),
837
+ });
838
+ await smithyClient.collectBody(output.body, context);
839
+ return contents;
1546
840
  };
1547
-
1548
- // src/commands/RegisterAdminCommand.ts
1549
-
1550
-
1551
-
1552
- var RegisterAdminCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1553
- return [
1554
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1555
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1556
- ];
1557
- }).s("RepostSpace", "RegisterAdmin", {}).n("RepostspaceClient", "RegisterAdminCommand").f(void 0, void 0).ser(se_RegisterAdminCommand).de(de_RegisterAdminCommand).build() {
1558
- static {
1559
- __name(this, "RegisterAdminCommand");
1560
- }
841
+ const de_SendInvitesCommand = async (output, context) => {
842
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
843
+ return de_CommandError(output, context);
844
+ }
845
+ const contents = smithyClient.map({
846
+ $metadata: deserializeMetadata(output),
847
+ });
848
+ await smithyClient.collectBody(output.body, context);
849
+ return contents;
1561
850
  };
1562
-
1563
- // src/commands/SendInvitesCommand.ts
1564
-
1565
-
1566
-
1567
- var SendInvitesCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1568
- return [
1569
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1570
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1571
- ];
1572
- }).s("RepostSpace", "SendInvites", {}).n("RepostspaceClient", "SendInvitesCommand").f(SendInvitesInputFilterSensitiveLog, void 0).ser(se_SendInvitesCommand).de(de_SendInvitesCommand).build() {
1573
- static {
1574
- __name(this, "SendInvitesCommand");
1575
- }
851
+ const de_TagResourceCommand = async (output, context) => {
852
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
853
+ return de_CommandError(output, context);
854
+ }
855
+ const contents = smithyClient.map({
856
+ $metadata: deserializeMetadata(output),
857
+ });
858
+ await smithyClient.collectBody(output.body, context);
859
+ return contents;
1576
860
  };
1577
-
1578
- // src/commands/TagResourceCommand.ts
1579
-
1580
-
1581
-
1582
- var TagResourceCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1583
- return [
1584
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1585
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1586
- ];
1587
- }).s("RepostSpace", "TagResource", {}).n("RepostspaceClient", "TagResourceCommand").f(TagResourceRequestFilterSensitiveLog, void 0).ser(se_TagResourceCommand).de(de_TagResourceCommand).build() {
1588
- static {
1589
- __name(this, "TagResourceCommand");
1590
- }
861
+ const de_UntagResourceCommand = async (output, context) => {
862
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
863
+ return de_CommandError(output, context);
864
+ }
865
+ const contents = smithyClient.map({
866
+ $metadata: deserializeMetadata(output),
867
+ });
868
+ await smithyClient.collectBody(output.body, context);
869
+ return contents;
1591
870
  };
1592
-
1593
- // src/commands/UntagResourceCommand.ts
1594
-
1595
-
1596
-
1597
- var UntagResourceCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1598
- return [
1599
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1600
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1601
- ];
1602
- }).s("RepostSpace", "UntagResource", {}).n("RepostspaceClient", "UntagResourceCommand").f(void 0, void 0).ser(se_UntagResourceCommand).de(de_UntagResourceCommand).build() {
1603
- static {
1604
- __name(this, "UntagResourceCommand");
1605
- }
871
+ const de_UpdateChannelCommand = async (output, context) => {
872
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
873
+ return de_CommandError(output, context);
874
+ }
875
+ const contents = smithyClient.map({
876
+ $metadata: deserializeMetadata(output),
877
+ });
878
+ await smithyClient.collectBody(output.body, context);
879
+ return contents;
1606
880
  };
1607
-
1608
- // src/commands/UpdateChannelCommand.ts
1609
-
1610
-
1611
-
1612
- var UpdateChannelCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1613
- return [
1614
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1615
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1616
- ];
1617
- }).s("RepostSpace", "UpdateChannel", {}).n("RepostspaceClient", "UpdateChannelCommand").f(UpdateChannelInputFilterSensitiveLog, void 0).ser(se_UpdateChannelCommand).de(de_UpdateChannelCommand).build() {
1618
- static {
1619
- __name(this, "UpdateChannelCommand");
1620
- }
881
+ const de_UpdateSpaceCommand = async (output, context) => {
882
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
883
+ return de_CommandError(output, context);
884
+ }
885
+ const contents = smithyClient.map({
886
+ $metadata: deserializeMetadata(output),
887
+ });
888
+ await smithyClient.collectBody(output.body, context);
889
+ return contents;
1621
890
  };
1622
-
1623
- // src/commands/UpdateSpaceCommand.ts
1624
-
1625
-
1626
-
1627
- var UpdateSpaceCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1628
- return [
1629
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1630
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1631
- ];
1632
- }).s("RepostSpace", "UpdateSpace", {}).n("RepostspaceClient", "UpdateSpaceCommand").f(UpdateSpaceInputFilterSensitiveLog, void 0).ser(se_UpdateSpaceCommand).de(de_UpdateSpaceCommand).build() {
1633
- static {
1634
- __name(this, "UpdateSpaceCommand");
1635
- }
891
+ const de_CommandError = async (output, context) => {
892
+ const parsedOutput = {
893
+ ...output,
894
+ body: await core$1.parseJsonErrorBody(output.body, context),
895
+ };
896
+ const errorCode = core$1.loadRestJsonErrorCode(output, parsedOutput.body);
897
+ switch (errorCode) {
898
+ case "AccessDeniedException":
899
+ case "com.amazonaws.repostspace#AccessDeniedException":
900
+ throw await de_AccessDeniedExceptionRes(parsedOutput);
901
+ case "InternalServerException":
902
+ case "com.amazonaws.repostspace#InternalServerException":
903
+ throw await de_InternalServerExceptionRes(parsedOutput);
904
+ case "ResourceNotFoundException":
905
+ case "com.amazonaws.repostspace#ResourceNotFoundException":
906
+ throw await de_ResourceNotFoundExceptionRes(parsedOutput);
907
+ case "ThrottlingException":
908
+ case "com.amazonaws.repostspace#ThrottlingException":
909
+ throw await de_ThrottlingExceptionRes(parsedOutput);
910
+ case "ValidationException":
911
+ case "com.amazonaws.repostspace#ValidationException":
912
+ throw await de_ValidationExceptionRes(parsedOutput);
913
+ case "ConflictException":
914
+ case "com.amazonaws.repostspace#ConflictException":
915
+ throw await de_ConflictExceptionRes(parsedOutput);
916
+ case "ServiceQuotaExceededException":
917
+ case "com.amazonaws.repostspace#ServiceQuotaExceededException":
918
+ throw await de_ServiceQuotaExceededExceptionRes(parsedOutput);
919
+ default:
920
+ const parsedBody = parsedOutput.body;
921
+ return throwDefaultError({
922
+ output,
923
+ parsedBody,
924
+ errorCode,
925
+ });
926
+ }
1636
927
  };
928
+ const throwDefaultError = smithyClient.withBaseException(RepostspaceServiceException);
929
+ const de_AccessDeniedExceptionRes = async (parsedOutput, context) => {
930
+ const contents = smithyClient.map({});
931
+ const data = parsedOutput.body;
932
+ const doc = smithyClient.take(data, {
933
+ message: smithyClient.expectString,
934
+ });
935
+ Object.assign(contents, doc);
936
+ const exception = new AccessDeniedException({
937
+ $metadata: deserializeMetadata(parsedOutput),
938
+ ...contents,
939
+ });
940
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
941
+ };
942
+ const de_ConflictExceptionRes = async (parsedOutput, context) => {
943
+ const contents = smithyClient.map({});
944
+ const data = parsedOutput.body;
945
+ const doc = smithyClient.take(data, {
946
+ message: smithyClient.expectString,
947
+ resourceId: smithyClient.expectString,
948
+ resourceType: smithyClient.expectString,
949
+ });
950
+ Object.assign(contents, doc);
951
+ const exception = new ConflictException({
952
+ $metadata: deserializeMetadata(parsedOutput),
953
+ ...contents,
954
+ });
955
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
956
+ };
957
+ const de_InternalServerExceptionRes = async (parsedOutput, context) => {
958
+ const contents = smithyClient.map({
959
+ [_rAS]: [() => void 0 !== parsedOutput.headers[_ra], () => smithyClient.strictParseInt32(parsedOutput.headers[_ra])],
960
+ });
961
+ const data = parsedOutput.body;
962
+ const doc = smithyClient.take(data, {
963
+ message: smithyClient.expectString,
964
+ });
965
+ Object.assign(contents, doc);
966
+ const exception = new InternalServerException({
967
+ $metadata: deserializeMetadata(parsedOutput),
968
+ ...contents,
969
+ });
970
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
971
+ };
972
+ const de_ResourceNotFoundExceptionRes = async (parsedOutput, context) => {
973
+ const contents = smithyClient.map({});
974
+ const data = parsedOutput.body;
975
+ const doc = smithyClient.take(data, {
976
+ message: smithyClient.expectString,
977
+ resourceId: smithyClient.expectString,
978
+ resourceType: smithyClient.expectString,
979
+ });
980
+ Object.assign(contents, doc);
981
+ const exception = new ResourceNotFoundException({
982
+ $metadata: deserializeMetadata(parsedOutput),
983
+ ...contents,
984
+ });
985
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
986
+ };
987
+ const de_ServiceQuotaExceededExceptionRes = async (parsedOutput, context) => {
988
+ const contents = smithyClient.map({});
989
+ const data = parsedOutput.body;
990
+ const doc = smithyClient.take(data, {
991
+ message: smithyClient.expectString,
992
+ quotaCode: smithyClient.expectString,
993
+ resourceId: smithyClient.expectString,
994
+ resourceType: smithyClient.expectString,
995
+ serviceCode: smithyClient.expectString,
996
+ });
997
+ Object.assign(contents, doc);
998
+ const exception = new ServiceQuotaExceededException({
999
+ $metadata: deserializeMetadata(parsedOutput),
1000
+ ...contents,
1001
+ });
1002
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
1003
+ };
1004
+ const de_ThrottlingExceptionRes = async (parsedOutput, context) => {
1005
+ const contents = smithyClient.map({
1006
+ [_rAS]: [() => void 0 !== parsedOutput.headers[_ra], () => smithyClient.strictParseInt32(parsedOutput.headers[_ra])],
1007
+ });
1008
+ const data = parsedOutput.body;
1009
+ const doc = smithyClient.take(data, {
1010
+ message: smithyClient.expectString,
1011
+ quotaCode: smithyClient.expectString,
1012
+ serviceCode: smithyClient.expectString,
1013
+ });
1014
+ Object.assign(contents, doc);
1015
+ const exception = new ThrottlingException({
1016
+ $metadata: deserializeMetadata(parsedOutput),
1017
+ ...contents,
1018
+ });
1019
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
1020
+ };
1021
+ const de_ValidationExceptionRes = async (parsedOutput, context) => {
1022
+ const contents = smithyClient.map({});
1023
+ const data = parsedOutput.body;
1024
+ const doc = smithyClient.take(data, {
1025
+ fieldList: smithyClient._json,
1026
+ message: smithyClient.expectString,
1027
+ reason: smithyClient.expectString,
1028
+ });
1029
+ Object.assign(contents, doc);
1030
+ const exception = new ValidationException({
1031
+ $metadata: deserializeMetadata(parsedOutput),
1032
+ ...contents,
1033
+ });
1034
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
1035
+ };
1036
+ const de_ChannelData = (output, context) => {
1037
+ return smithyClient.take(output, {
1038
+ channelDescription: smithyClient.expectString,
1039
+ channelId: smithyClient.expectString,
1040
+ channelName: smithyClient.expectString,
1041
+ channelStatus: smithyClient.expectString,
1042
+ createDateTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
1043
+ deleteDateTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
1044
+ groupCount: smithyClient.expectInt32,
1045
+ spaceId: smithyClient.expectString,
1046
+ userCount: smithyClient.expectInt32,
1047
+ });
1048
+ };
1049
+ const de_ChannelsList = (output, context) => {
1050
+ const retVal = (output || [])
1051
+ .filter((e) => e != null)
1052
+ .map((entry) => {
1053
+ return de_ChannelData(entry);
1054
+ });
1055
+ return retVal;
1056
+ };
1057
+ const de_SpaceData = (output, context) => {
1058
+ return smithyClient.take(output, {
1059
+ arn: smithyClient.expectString,
1060
+ configurationStatus: smithyClient.expectString,
1061
+ contentSize: smithyClient.expectLong,
1062
+ createDateTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
1063
+ deleteDateTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
1064
+ description: smithyClient.expectString,
1065
+ name: smithyClient.expectString,
1066
+ randomDomain: smithyClient.expectString,
1067
+ spaceId: smithyClient.expectString,
1068
+ status: smithyClient.expectString,
1069
+ storageLimit: smithyClient.expectLong,
1070
+ supportedEmailDomains: smithyClient._json,
1071
+ tier: smithyClient.expectString,
1072
+ userCount: smithyClient.expectInt32,
1073
+ userKMSKey: smithyClient.expectString,
1074
+ vanityDomain: smithyClient.expectString,
1075
+ vanityDomainStatus: smithyClient.expectString,
1076
+ });
1077
+ };
1078
+ const de_SpacesList = (output, context) => {
1079
+ const retVal = (output || [])
1080
+ .filter((e) => e != null)
1081
+ .map((entry) => {
1082
+ return de_SpaceData(entry);
1083
+ });
1084
+ return retVal;
1085
+ };
1086
+ const deserializeMetadata = (output) => ({
1087
+ httpStatusCode: output.statusCode,
1088
+ requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
1089
+ extendedRequestId: output.headers["x-amz-id-2"],
1090
+ cfId: output.headers["x-amz-cf-id"],
1091
+ });
1092
+ const _mR = "maxResults";
1093
+ const _nT = "nextToken";
1094
+ const _rAS = "retryAfterSeconds";
1095
+ const _ra = "retry-after";
1096
+ const _tK = "tagKeys";
1097
+
1098
+ class BatchAddChannelRoleToAccessorsCommand extends smithyClient.Command
1099
+ .classBuilder()
1100
+ .ep(commonParams)
1101
+ .m(function (Command, cs, config, o) {
1102
+ return [
1103
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1104
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1105
+ ];
1106
+ })
1107
+ .s("RepostSpace", "BatchAddChannelRoleToAccessors", {})
1108
+ .n("RepostspaceClient", "BatchAddChannelRoleToAccessorsCommand")
1109
+ .f(void 0, void 0)
1110
+ .ser(se_BatchAddChannelRoleToAccessorsCommand)
1111
+ .de(de_BatchAddChannelRoleToAccessorsCommand)
1112
+ .build() {
1113
+ }
1114
+
1115
+ class BatchAddRoleCommand extends smithyClient.Command
1116
+ .classBuilder()
1117
+ .ep(commonParams)
1118
+ .m(function (Command, cs, config, o) {
1119
+ return [
1120
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1121
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1122
+ ];
1123
+ })
1124
+ .s("RepostSpace", "BatchAddRole", {})
1125
+ .n("RepostspaceClient", "BatchAddRoleCommand")
1126
+ .f(void 0, void 0)
1127
+ .ser(se_BatchAddRoleCommand)
1128
+ .de(de_BatchAddRoleCommand)
1129
+ .build() {
1130
+ }
1131
+
1132
+ class BatchRemoveChannelRoleFromAccessorsCommand extends smithyClient.Command
1133
+ .classBuilder()
1134
+ .ep(commonParams)
1135
+ .m(function (Command, cs, config, o) {
1136
+ return [
1137
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1138
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1139
+ ];
1140
+ })
1141
+ .s("RepostSpace", "BatchRemoveChannelRoleFromAccessors", {})
1142
+ .n("RepostspaceClient", "BatchRemoveChannelRoleFromAccessorsCommand")
1143
+ .f(void 0, void 0)
1144
+ .ser(se_BatchRemoveChannelRoleFromAccessorsCommand)
1145
+ .de(de_BatchRemoveChannelRoleFromAccessorsCommand)
1146
+ .build() {
1147
+ }
1148
+
1149
+ class BatchRemoveRoleCommand extends smithyClient.Command
1150
+ .classBuilder()
1151
+ .ep(commonParams)
1152
+ .m(function (Command, cs, config, o) {
1153
+ return [
1154
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1155
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1156
+ ];
1157
+ })
1158
+ .s("RepostSpace", "BatchRemoveRole", {})
1159
+ .n("RepostspaceClient", "BatchRemoveRoleCommand")
1160
+ .f(void 0, void 0)
1161
+ .ser(se_BatchRemoveRoleCommand)
1162
+ .de(de_BatchRemoveRoleCommand)
1163
+ .build() {
1164
+ }
1165
+
1166
+ class CreateChannelCommand extends smithyClient.Command
1167
+ .classBuilder()
1168
+ .ep(commonParams)
1169
+ .m(function (Command, cs, config, o) {
1170
+ return [
1171
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1172
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1173
+ ];
1174
+ })
1175
+ .s("RepostSpace", "CreateChannel", {})
1176
+ .n("RepostspaceClient", "CreateChannelCommand")
1177
+ .f(CreateChannelInputFilterSensitiveLog, void 0)
1178
+ .ser(se_CreateChannelCommand)
1179
+ .de(de_CreateChannelCommand)
1180
+ .build() {
1181
+ }
1182
+
1183
+ class CreateSpaceCommand extends smithyClient.Command
1184
+ .classBuilder()
1185
+ .ep(commonParams)
1186
+ .m(function (Command, cs, config, o) {
1187
+ return [
1188
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1189
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1190
+ ];
1191
+ })
1192
+ .s("RepostSpace", "CreateSpace", {})
1193
+ .n("RepostspaceClient", "CreateSpaceCommand")
1194
+ .f(CreateSpaceInputFilterSensitiveLog, void 0)
1195
+ .ser(se_CreateSpaceCommand)
1196
+ .de(de_CreateSpaceCommand)
1197
+ .build() {
1198
+ }
1199
+
1200
+ class DeleteSpaceCommand extends smithyClient.Command
1201
+ .classBuilder()
1202
+ .ep(commonParams)
1203
+ .m(function (Command, cs, config, o) {
1204
+ return [
1205
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1206
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1207
+ ];
1208
+ })
1209
+ .s("RepostSpace", "DeleteSpace", {})
1210
+ .n("RepostspaceClient", "DeleteSpaceCommand")
1211
+ .f(void 0, void 0)
1212
+ .ser(se_DeleteSpaceCommand)
1213
+ .de(de_DeleteSpaceCommand)
1214
+ .build() {
1215
+ }
1216
+
1217
+ class DeregisterAdminCommand extends smithyClient.Command
1218
+ .classBuilder()
1219
+ .ep(commonParams)
1220
+ .m(function (Command, cs, config, o) {
1221
+ return [
1222
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1223
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1224
+ ];
1225
+ })
1226
+ .s("RepostSpace", "DeregisterAdmin", {})
1227
+ .n("RepostspaceClient", "DeregisterAdminCommand")
1228
+ .f(void 0, void 0)
1229
+ .ser(se_DeregisterAdminCommand)
1230
+ .de(de_DeregisterAdminCommand)
1231
+ .build() {
1232
+ }
1233
+
1234
+ class GetChannelCommand extends smithyClient.Command
1235
+ .classBuilder()
1236
+ .ep(commonParams)
1237
+ .m(function (Command, cs, config, o) {
1238
+ return [
1239
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1240
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1241
+ ];
1242
+ })
1243
+ .s("RepostSpace", "GetChannel", {})
1244
+ .n("RepostspaceClient", "GetChannelCommand")
1245
+ .f(void 0, GetChannelOutputFilterSensitiveLog)
1246
+ .ser(se_GetChannelCommand)
1247
+ .de(de_GetChannelCommand)
1248
+ .build() {
1249
+ }
1250
+
1251
+ class GetSpaceCommand extends smithyClient.Command
1252
+ .classBuilder()
1253
+ .ep(commonParams)
1254
+ .m(function (Command, cs, config, o) {
1255
+ return [
1256
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1257
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1258
+ ];
1259
+ })
1260
+ .s("RepostSpace", "GetSpace", {})
1261
+ .n("RepostspaceClient", "GetSpaceCommand")
1262
+ .f(void 0, GetSpaceOutputFilterSensitiveLog)
1263
+ .ser(se_GetSpaceCommand)
1264
+ .de(de_GetSpaceCommand)
1265
+ .build() {
1266
+ }
1267
+
1268
+ class ListChannelsCommand extends smithyClient.Command
1269
+ .classBuilder()
1270
+ .ep(commonParams)
1271
+ .m(function (Command, cs, config, o) {
1272
+ return [
1273
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1274
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1275
+ ];
1276
+ })
1277
+ .s("RepostSpace", "ListChannels", {})
1278
+ .n("RepostspaceClient", "ListChannelsCommand")
1279
+ .f(void 0, ListChannelsOutputFilterSensitiveLog)
1280
+ .ser(se_ListChannelsCommand)
1281
+ .de(de_ListChannelsCommand)
1282
+ .build() {
1283
+ }
1284
+
1285
+ class ListSpacesCommand extends smithyClient.Command
1286
+ .classBuilder()
1287
+ .ep(commonParams)
1288
+ .m(function (Command, cs, config, o) {
1289
+ return [
1290
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1291
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1292
+ ];
1293
+ })
1294
+ .s("RepostSpace", "ListSpaces", {})
1295
+ .n("RepostspaceClient", "ListSpacesCommand")
1296
+ .f(void 0, ListSpacesOutputFilterSensitiveLog)
1297
+ .ser(se_ListSpacesCommand)
1298
+ .de(de_ListSpacesCommand)
1299
+ .build() {
1300
+ }
1301
+
1302
+ class ListTagsForResourceCommand extends smithyClient.Command
1303
+ .classBuilder()
1304
+ .ep(commonParams)
1305
+ .m(function (Command, cs, config, o) {
1306
+ return [
1307
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1308
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1309
+ ];
1310
+ })
1311
+ .s("RepostSpace", "ListTagsForResource", {})
1312
+ .n("RepostspaceClient", "ListTagsForResourceCommand")
1313
+ .f(void 0, ListTagsForResourceResponseFilterSensitiveLog)
1314
+ .ser(se_ListTagsForResourceCommand)
1315
+ .de(de_ListTagsForResourceCommand)
1316
+ .build() {
1317
+ }
1318
+
1319
+ class RegisterAdminCommand extends smithyClient.Command
1320
+ .classBuilder()
1321
+ .ep(commonParams)
1322
+ .m(function (Command, cs, config, o) {
1323
+ return [
1324
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1325
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1326
+ ];
1327
+ })
1328
+ .s("RepostSpace", "RegisterAdmin", {})
1329
+ .n("RepostspaceClient", "RegisterAdminCommand")
1330
+ .f(void 0, void 0)
1331
+ .ser(se_RegisterAdminCommand)
1332
+ .de(de_RegisterAdminCommand)
1333
+ .build() {
1334
+ }
1335
+
1336
+ class SendInvitesCommand extends smithyClient.Command
1337
+ .classBuilder()
1338
+ .ep(commonParams)
1339
+ .m(function (Command, cs, config, o) {
1340
+ return [
1341
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1342
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1343
+ ];
1344
+ })
1345
+ .s("RepostSpace", "SendInvites", {})
1346
+ .n("RepostspaceClient", "SendInvitesCommand")
1347
+ .f(SendInvitesInputFilterSensitiveLog, void 0)
1348
+ .ser(se_SendInvitesCommand)
1349
+ .de(de_SendInvitesCommand)
1350
+ .build() {
1351
+ }
1352
+
1353
+ class TagResourceCommand extends smithyClient.Command
1354
+ .classBuilder()
1355
+ .ep(commonParams)
1356
+ .m(function (Command, cs, config, o) {
1357
+ return [
1358
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1359
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1360
+ ];
1361
+ })
1362
+ .s("RepostSpace", "TagResource", {})
1363
+ .n("RepostspaceClient", "TagResourceCommand")
1364
+ .f(TagResourceRequestFilterSensitiveLog, void 0)
1365
+ .ser(se_TagResourceCommand)
1366
+ .de(de_TagResourceCommand)
1367
+ .build() {
1368
+ }
1369
+
1370
+ class UntagResourceCommand extends smithyClient.Command
1371
+ .classBuilder()
1372
+ .ep(commonParams)
1373
+ .m(function (Command, cs, config, o) {
1374
+ return [
1375
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1376
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1377
+ ];
1378
+ })
1379
+ .s("RepostSpace", "UntagResource", {})
1380
+ .n("RepostspaceClient", "UntagResourceCommand")
1381
+ .f(void 0, void 0)
1382
+ .ser(se_UntagResourceCommand)
1383
+ .de(de_UntagResourceCommand)
1384
+ .build() {
1385
+ }
1386
+
1387
+ class UpdateChannelCommand extends smithyClient.Command
1388
+ .classBuilder()
1389
+ .ep(commonParams)
1390
+ .m(function (Command, cs, config, o) {
1391
+ return [
1392
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1393
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1394
+ ];
1395
+ })
1396
+ .s("RepostSpace", "UpdateChannel", {})
1397
+ .n("RepostspaceClient", "UpdateChannelCommand")
1398
+ .f(UpdateChannelInputFilterSensitiveLog, void 0)
1399
+ .ser(se_UpdateChannelCommand)
1400
+ .de(de_UpdateChannelCommand)
1401
+ .build() {
1402
+ }
1403
+
1404
+ class UpdateSpaceCommand extends smithyClient.Command
1405
+ .classBuilder()
1406
+ .ep(commonParams)
1407
+ .m(function (Command, cs, config, o) {
1408
+ return [
1409
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1410
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1411
+ ];
1412
+ })
1413
+ .s("RepostSpace", "UpdateSpace", {})
1414
+ .n("RepostspaceClient", "UpdateSpaceCommand")
1415
+ .f(UpdateSpaceInputFilterSensitiveLog, void 0)
1416
+ .ser(se_UpdateSpaceCommand)
1417
+ .de(de_UpdateSpaceCommand)
1418
+ .build() {
1419
+ }
1420
+
1421
+ const commands = {
1422
+ BatchAddChannelRoleToAccessorsCommand,
1423
+ BatchAddRoleCommand,
1424
+ BatchRemoveChannelRoleFromAccessorsCommand,
1425
+ BatchRemoveRoleCommand,
1426
+ CreateChannelCommand,
1427
+ CreateSpaceCommand,
1428
+ DeleteSpaceCommand,
1429
+ DeregisterAdminCommand,
1430
+ GetChannelCommand,
1431
+ GetSpaceCommand,
1432
+ ListChannelsCommand,
1433
+ ListSpacesCommand,
1434
+ ListTagsForResourceCommand,
1435
+ RegisterAdminCommand,
1436
+ SendInvitesCommand,
1437
+ TagResourceCommand,
1438
+ UntagResourceCommand,
1439
+ UpdateChannelCommand,
1440
+ UpdateSpaceCommand,
1441
+ };
1442
+ class Repostspace extends RepostspaceClient {
1443
+ }
1444
+ smithyClient.createAggregatedClient(commands, Repostspace);
1637
1445
 
1638
- // src/Repostspace.ts
1639
- var commands = {
1640
- BatchAddChannelRoleToAccessorsCommand,
1641
- BatchAddRoleCommand,
1642
- BatchRemoveChannelRoleFromAccessorsCommand,
1643
- BatchRemoveRoleCommand,
1644
- CreateChannelCommand,
1645
- CreateSpaceCommand,
1646
- DeleteSpaceCommand,
1647
- DeregisterAdminCommand,
1648
- GetChannelCommand,
1649
- GetSpaceCommand,
1650
- ListChannelsCommand,
1651
- ListSpacesCommand,
1652
- ListTagsForResourceCommand,
1653
- RegisterAdminCommand,
1654
- SendInvitesCommand,
1655
- TagResourceCommand,
1656
- UntagResourceCommand,
1657
- UpdateChannelCommand,
1658
- UpdateSpaceCommand
1659
- };
1660
- var Repostspace = class extends RepostspaceClient {
1661
- static {
1662
- __name(this, "Repostspace");
1663
- }
1664
- };
1665
- (0, import_smithy_client.createAggregatedClient)(commands, Repostspace);
1666
-
1667
- // src/pagination/ListChannelsPaginator.ts
1668
-
1669
- var paginateListChannels = (0, import_core.createPaginator)(RepostspaceClient, ListChannelsCommand, "nextToken", "nextToken", "maxResults");
1670
-
1671
- // src/pagination/ListSpacesPaginator.ts
1446
+ const paginateListChannels = core.createPaginator(RepostspaceClient, ListChannelsCommand, "nextToken", "nextToken", "maxResults");
1672
1447
 
1673
- var paginateListSpaces = (0, import_core.createPaginator)(RepostspaceClient, ListSpacesCommand, "nextToken", "nextToken", "maxResults");
1448
+ const paginateListSpaces = core.createPaginator(RepostspaceClient, ListSpacesCommand, "nextToken", "nextToken", "maxResults");
1674
1449
 
1675
- // src/waiters/waitForChannelCreated.ts
1676
- var import_util_waiter = require("@smithy/util-waiter");
1677
- var checkState = /* @__PURE__ */ __name(async (client, input) => {
1678
- let reason;
1679
- try {
1680
- const result = await client.send(new GetChannelCommand(input));
1681
- reason = result;
1682
- try {
1683
- const returnComparator = /* @__PURE__ */ __name(() => {
1684
- return result.channelStatus;
1685
- }, "returnComparator");
1686
- if (returnComparator() === "CREATED") {
1687
- return { state: import_util_waiter.WaiterState.SUCCESS, reason };
1688
- }
1689
- } catch (e) {
1690
- }
1450
+ const checkState$3 = async (client, input) => {
1451
+ let reason;
1691
1452
  try {
1692
- const returnComparator = /* @__PURE__ */ __name(() => {
1693
- return result.channelStatus;
1694
- }, "returnComparator");
1695
- if (returnComparator() === "CREATE_FAILED") {
1696
- return { state: import_util_waiter.WaiterState.FAILURE, reason };
1697
- }
1698
- } catch (e) {
1453
+ const result = await client.send(new GetChannelCommand(input));
1454
+ reason = result;
1455
+ try {
1456
+ const returnComparator = () => {
1457
+ return result.channelStatus;
1458
+ };
1459
+ if (returnComparator() === "CREATED") {
1460
+ return { state: utilWaiter.WaiterState.SUCCESS, reason };
1461
+ }
1462
+ }
1463
+ catch (e) { }
1464
+ try {
1465
+ const returnComparator = () => {
1466
+ return result.channelStatus;
1467
+ };
1468
+ if (returnComparator() === "CREATE_FAILED") {
1469
+ return { state: utilWaiter.WaiterState.FAILURE, reason };
1470
+ }
1471
+ }
1472
+ catch (e) { }
1473
+ try {
1474
+ const returnComparator = () => {
1475
+ return result.channelStatus;
1476
+ };
1477
+ if (returnComparator() === "CREATING") {
1478
+ return { state: utilWaiter.WaiterState.RETRY, reason };
1479
+ }
1480
+ }
1481
+ catch (e) { }
1699
1482
  }
1700
- try {
1701
- const returnComparator = /* @__PURE__ */ __name(() => {
1702
- return result.channelStatus;
1703
- }, "returnComparator");
1704
- if (returnComparator() === "CREATING") {
1705
- return { state: import_util_waiter.WaiterState.RETRY, reason };
1706
- }
1707
- } catch (e) {
1483
+ catch (exception) {
1484
+ reason = exception;
1708
1485
  }
1709
- } catch (exception) {
1710
- reason = exception;
1711
- }
1712
- return { state: import_util_waiter.WaiterState.RETRY, reason };
1713
- }, "checkState");
1714
- var waitForChannelCreated = /* @__PURE__ */ __name(async (params, input) => {
1715
- const serviceDefaults = { minDelay: 2, maxDelay: 120 };
1716
- return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
1717
- }, "waitForChannelCreated");
1718
- var waitUntilChannelCreated = /* @__PURE__ */ __name(async (params, input) => {
1719
- const serviceDefaults = { minDelay: 2, maxDelay: 120 };
1720
- const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
1721
- return (0, import_util_waiter.checkExceptions)(result);
1722
- }, "waitUntilChannelCreated");
1723
-
1724
- // src/waiters/waitForChannelDeleted.ts
1486
+ return { state: utilWaiter.WaiterState.RETRY, reason };
1487
+ };
1488
+ const waitForChannelCreated = async (params, input) => {
1489
+ const serviceDefaults = { minDelay: 2, maxDelay: 120 };
1490
+ return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$3);
1491
+ };
1492
+ const waitUntilChannelCreated = async (params, input) => {
1493
+ const serviceDefaults = { minDelay: 2, maxDelay: 120 };
1494
+ const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$3);
1495
+ return utilWaiter.checkExceptions(result);
1496
+ };
1725
1497
 
1726
- var checkState2 = /* @__PURE__ */ __name(async (client, input) => {
1727
- let reason;
1728
- try {
1729
- const result = await client.send(new GetChannelCommand(input));
1730
- reason = result;
1498
+ const checkState$2 = async (client, input) => {
1499
+ let reason;
1731
1500
  try {
1732
- const returnComparator = /* @__PURE__ */ __name(() => {
1733
- return result.channelStatus;
1734
- }, "returnComparator");
1735
- if (returnComparator() === "DELETED") {
1736
- return { state: import_util_waiter.WaiterState.SUCCESS, reason };
1737
- }
1738
- } catch (e) {
1501
+ const result = await client.send(new GetChannelCommand(input));
1502
+ reason = result;
1503
+ try {
1504
+ const returnComparator = () => {
1505
+ return result.channelStatus;
1506
+ };
1507
+ if (returnComparator() === "DELETED") {
1508
+ return { state: utilWaiter.WaiterState.SUCCESS, reason };
1509
+ }
1510
+ }
1511
+ catch (e) { }
1512
+ try {
1513
+ const returnComparator = () => {
1514
+ return result.channelStatus;
1515
+ };
1516
+ if (returnComparator() === "DELETE_FAILED") {
1517
+ return { state: utilWaiter.WaiterState.FAILURE, reason };
1518
+ }
1519
+ }
1520
+ catch (e) { }
1521
+ try {
1522
+ const returnComparator = () => {
1523
+ return result.channelStatus;
1524
+ };
1525
+ if (returnComparator() === "DELETING") {
1526
+ return { state: utilWaiter.WaiterState.RETRY, reason };
1527
+ }
1528
+ }
1529
+ catch (e) { }
1739
1530
  }
1740
- try {
1741
- const returnComparator = /* @__PURE__ */ __name(() => {
1742
- return result.channelStatus;
1743
- }, "returnComparator");
1744
- if (returnComparator() === "DELETE_FAILED") {
1745
- return { state: import_util_waiter.WaiterState.FAILURE, reason };
1746
- }
1747
- } catch (e) {
1748
- }
1749
- try {
1750
- const returnComparator = /* @__PURE__ */ __name(() => {
1751
- return result.channelStatus;
1752
- }, "returnComparator");
1753
- if (returnComparator() === "DELETING") {
1754
- return { state: import_util_waiter.WaiterState.RETRY, reason };
1755
- }
1756
- } catch (e) {
1757
- }
1758
- } catch (exception) {
1759
- reason = exception;
1760
- if (exception.name && exception.name == "ResourceNotFoundException") {
1761
- return { state: import_util_waiter.WaiterState.SUCCESS, reason };
1531
+ catch (exception) {
1532
+ reason = exception;
1533
+ if (exception.name && exception.name == "ResourceNotFoundException") {
1534
+ return { state: utilWaiter.WaiterState.SUCCESS, reason };
1535
+ }
1762
1536
  }
1763
- }
1764
- return { state: import_util_waiter.WaiterState.RETRY, reason };
1765
- }, "checkState");
1766
- var waitForChannelDeleted = /* @__PURE__ */ __name(async (params, input) => {
1767
- const serviceDefaults = { minDelay: 2, maxDelay: 120 };
1768
- return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState2);
1769
- }, "waitForChannelDeleted");
1770
- var waitUntilChannelDeleted = /* @__PURE__ */ __name(async (params, input) => {
1771
- const serviceDefaults = { minDelay: 2, maxDelay: 120 };
1772
- const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState2);
1773
- return (0, import_util_waiter.checkExceptions)(result);
1774
- }, "waitUntilChannelDeleted");
1775
-
1776
- // src/waiters/waitForSpaceCreated.ts
1537
+ return { state: utilWaiter.WaiterState.RETRY, reason };
1538
+ };
1539
+ const waitForChannelDeleted = async (params, input) => {
1540
+ const serviceDefaults = { minDelay: 2, maxDelay: 120 };
1541
+ return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);
1542
+ };
1543
+ const waitUntilChannelDeleted = async (params, input) => {
1544
+ const serviceDefaults = { minDelay: 2, maxDelay: 120 };
1545
+ const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);
1546
+ return utilWaiter.checkExceptions(result);
1547
+ };
1777
1548
 
1778
- var checkState3 = /* @__PURE__ */ __name(async (client, input) => {
1779
- let reason;
1780
- try {
1781
- const result = await client.send(new GetSpaceCommand(input));
1782
- reason = result;
1549
+ const checkState$1 = async (client, input) => {
1550
+ let reason;
1783
1551
  try {
1784
- const returnComparator = /* @__PURE__ */ __name(() => {
1785
- return result.status;
1786
- }, "returnComparator");
1787
- if (returnComparator() === "CREATED") {
1788
- return { state: import_util_waiter.WaiterState.SUCCESS, reason };
1789
- }
1790
- } catch (e) {
1552
+ const result = await client.send(new GetSpaceCommand(input));
1553
+ reason = result;
1554
+ try {
1555
+ const returnComparator = () => {
1556
+ return result.status;
1557
+ };
1558
+ if (returnComparator() === "CREATED") {
1559
+ return { state: utilWaiter.WaiterState.SUCCESS, reason };
1560
+ }
1561
+ }
1562
+ catch (e) { }
1563
+ try {
1564
+ const returnComparator = () => {
1565
+ return result.status;
1566
+ };
1567
+ if (returnComparator() === "CREATE_FAILED") {
1568
+ return { state: utilWaiter.WaiterState.FAILURE, reason };
1569
+ }
1570
+ }
1571
+ catch (e) { }
1572
+ try {
1573
+ const returnComparator = () => {
1574
+ return result.status;
1575
+ };
1576
+ if (returnComparator() === "CREATING") {
1577
+ return { state: utilWaiter.WaiterState.RETRY, reason };
1578
+ }
1579
+ }
1580
+ catch (e) { }
1791
1581
  }
1792
- try {
1793
- const returnComparator = /* @__PURE__ */ __name(() => {
1794
- return result.status;
1795
- }, "returnComparator");
1796
- if (returnComparator() === "CREATE_FAILED") {
1797
- return { state: import_util_waiter.WaiterState.FAILURE, reason };
1798
- }
1799
- } catch (e) {
1800
- }
1801
- try {
1802
- const returnComparator = /* @__PURE__ */ __name(() => {
1803
- return result.status;
1804
- }, "returnComparator");
1805
- if (returnComparator() === "CREATING") {
1806
- return { state: import_util_waiter.WaiterState.RETRY, reason };
1807
- }
1808
- } catch (e) {
1582
+ catch (exception) {
1583
+ reason = exception;
1809
1584
  }
1810
- } catch (exception) {
1811
- reason = exception;
1812
- }
1813
- return { state: import_util_waiter.WaiterState.RETRY, reason };
1814
- }, "checkState");
1815
- var waitForSpaceCreated = /* @__PURE__ */ __name(async (params, input) => {
1816
- const serviceDefaults = { minDelay: 300, maxDelay: 7200 };
1817
- return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState3);
1818
- }, "waitForSpaceCreated");
1819
- var waitUntilSpaceCreated = /* @__PURE__ */ __name(async (params, input) => {
1820
- const serviceDefaults = { minDelay: 300, maxDelay: 7200 };
1821
- const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState3);
1822
- return (0, import_util_waiter.checkExceptions)(result);
1823
- }, "waitUntilSpaceCreated");
1824
-
1825
- // src/waiters/waitForSpaceDeleted.ts
1585
+ return { state: utilWaiter.WaiterState.RETRY, reason };
1586
+ };
1587
+ const waitForSpaceCreated = async (params, input) => {
1588
+ const serviceDefaults = { minDelay: 300, maxDelay: 7200 };
1589
+ return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);
1590
+ };
1591
+ const waitUntilSpaceCreated = async (params, input) => {
1592
+ const serviceDefaults = { minDelay: 300, maxDelay: 7200 };
1593
+ const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);
1594
+ return utilWaiter.checkExceptions(result);
1595
+ };
1826
1596
 
1827
- var checkState4 = /* @__PURE__ */ __name(async (client, input) => {
1828
- let reason;
1829
- try {
1830
- const result = await client.send(new GetSpaceCommand(input));
1831
- reason = result;
1832
- try {
1833
- const returnComparator = /* @__PURE__ */ __name(() => {
1834
- return result.status;
1835
- }, "returnComparator");
1836
- if (returnComparator() === "DELETED") {
1837
- return { state: import_util_waiter.WaiterState.SUCCESS, reason };
1838
- }
1839
- } catch (e) {
1840
- }
1841
- try {
1842
- const returnComparator = /* @__PURE__ */ __name(() => {
1843
- return result.status;
1844
- }, "returnComparator");
1845
- if (returnComparator() === "DELETE_FAILED") {
1846
- return { state: import_util_waiter.WaiterState.FAILURE, reason };
1847
- }
1848
- } catch (e) {
1849
- }
1597
+ const checkState = async (client, input) => {
1598
+ let reason;
1850
1599
  try {
1851
- const returnComparator = /* @__PURE__ */ __name(() => {
1852
- return result.status;
1853
- }, "returnComparator");
1854
- if (returnComparator() === "DELETING") {
1855
- return { state: import_util_waiter.WaiterState.RETRY, reason };
1856
- }
1857
- } catch (e) {
1600
+ const result = await client.send(new GetSpaceCommand(input));
1601
+ reason = result;
1602
+ try {
1603
+ const returnComparator = () => {
1604
+ return result.status;
1605
+ };
1606
+ if (returnComparator() === "DELETED") {
1607
+ return { state: utilWaiter.WaiterState.SUCCESS, reason };
1608
+ }
1609
+ }
1610
+ catch (e) { }
1611
+ try {
1612
+ const returnComparator = () => {
1613
+ return result.status;
1614
+ };
1615
+ if (returnComparator() === "DELETE_FAILED") {
1616
+ return { state: utilWaiter.WaiterState.FAILURE, reason };
1617
+ }
1618
+ }
1619
+ catch (e) { }
1620
+ try {
1621
+ const returnComparator = () => {
1622
+ return result.status;
1623
+ };
1624
+ if (returnComparator() === "DELETING") {
1625
+ return { state: utilWaiter.WaiterState.RETRY, reason };
1626
+ }
1627
+ }
1628
+ catch (e) { }
1858
1629
  }
1859
- } catch (exception) {
1860
- reason = exception;
1861
- if (exception.name && exception.name == "ResourceNotFoundException") {
1862
- return { state: import_util_waiter.WaiterState.SUCCESS, reason };
1630
+ catch (exception) {
1631
+ reason = exception;
1632
+ if (exception.name && exception.name == "ResourceNotFoundException") {
1633
+ return { state: utilWaiter.WaiterState.SUCCESS, reason };
1634
+ }
1863
1635
  }
1864
- }
1865
- return { state: import_util_waiter.WaiterState.RETRY, reason };
1866
- }, "checkState");
1867
- var waitForSpaceDeleted = /* @__PURE__ */ __name(async (params, input) => {
1868
- const serviceDefaults = { minDelay: 300, maxDelay: 7200 };
1869
- return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState4);
1870
- }, "waitForSpaceDeleted");
1871
- var waitUntilSpaceDeleted = /* @__PURE__ */ __name(async (params, input) => {
1872
- const serviceDefaults = { minDelay: 300, maxDelay: 7200 };
1873
- const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState4);
1874
- return (0, import_util_waiter.checkExceptions)(result);
1875
- }, "waitUntilSpaceDeleted");
1876
- // Annotate the CommonJS export names for ESM import in node:
1636
+ return { state: utilWaiter.WaiterState.RETRY, reason };
1637
+ };
1638
+ const waitForSpaceDeleted = async (params, input) => {
1639
+ const serviceDefaults = { minDelay: 300, maxDelay: 7200 };
1640
+ return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState);
1641
+ };
1642
+ const waitUntilSpaceDeleted = async (params, input) => {
1643
+ const serviceDefaults = { minDelay: 300, maxDelay: 7200 };
1644
+ const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState);
1645
+ return utilWaiter.checkExceptions(result);
1646
+ };
1877
1647
 
1878
- 0 && (module.exports = {
1879
- RepostspaceServiceException,
1880
- __Client,
1881
- RepostspaceClient,
1882
- Repostspace,
1883
- $Command,
1884
- BatchAddChannelRoleToAccessorsCommand,
1885
- BatchAddRoleCommand,
1886
- BatchRemoveChannelRoleFromAccessorsCommand,
1887
- BatchRemoveRoleCommand,
1888
- CreateChannelCommand,
1889
- CreateSpaceCommand,
1890
- DeleteSpaceCommand,
1891
- DeregisterAdminCommand,
1892
- GetChannelCommand,
1893
- GetSpaceCommand,
1894
- ListChannelsCommand,
1895
- ListSpacesCommand,
1896
- ListTagsForResourceCommand,
1897
- RegisterAdminCommand,
1898
- SendInvitesCommand,
1899
- TagResourceCommand,
1900
- UntagResourceCommand,
1901
- UpdateChannelCommand,
1902
- UpdateSpaceCommand,
1903
- paginateListChannels,
1904
- paginateListSpaces,
1905
- waitForChannelCreated,
1906
- waitUntilChannelCreated,
1907
- waitForChannelDeleted,
1908
- waitUntilChannelDeleted,
1909
- waitForSpaceCreated,
1910
- waitUntilSpaceCreated,
1911
- waitForSpaceDeleted,
1912
- waitUntilSpaceDeleted,
1913
- AccessDeniedException,
1914
- ChannelRole,
1915
- InternalServerException,
1916
- ResourceNotFoundException,
1917
- ThrottlingException,
1918
- ValidationExceptionReason,
1919
- ValidationException,
1920
- Role,
1921
- ChannelStatus,
1922
- ConfigurationStatus,
1923
- ConflictException,
1924
- ServiceQuotaExceededException,
1925
- FeatureEnableParameter,
1926
- TierLevel,
1927
- FeatureEnableStatus,
1928
- VanityDomainStatus,
1929
- ChannelDataFilterSensitiveLog,
1930
- CreateChannelInputFilterSensitiveLog,
1931
- SupportedEmailDomainsParametersFilterSensitiveLog,
1932
- CreateSpaceInputFilterSensitiveLog,
1933
- GetChannelOutputFilterSensitiveLog,
1934
- SupportedEmailDomainsStatusFilterSensitiveLog,
1935
- GetSpaceOutputFilterSensitiveLog,
1936
- ListChannelsOutputFilterSensitiveLog,
1937
- SpaceDataFilterSensitiveLog,
1938
- ListSpacesOutputFilterSensitiveLog,
1939
- ListTagsForResourceResponseFilterSensitiveLog,
1940
- SendInvitesInputFilterSensitiveLog,
1941
- TagResourceRequestFilterSensitiveLog,
1942
- UpdateChannelInputFilterSensitiveLog,
1943
- UpdateSpaceInputFilterSensitiveLog
1648
+ Object.defineProperty(exports, "$Command", {
1649
+ enumerable: true,
1650
+ get: function () { return smithyClient.Command; }
1944
1651
  });
1945
-
1652
+ Object.defineProperty(exports, "__Client", {
1653
+ enumerable: true,
1654
+ get: function () { return smithyClient.Client; }
1655
+ });
1656
+ exports.AccessDeniedException = AccessDeniedException;
1657
+ exports.BatchAddChannelRoleToAccessorsCommand = BatchAddChannelRoleToAccessorsCommand;
1658
+ exports.BatchAddRoleCommand = BatchAddRoleCommand;
1659
+ exports.BatchRemoveChannelRoleFromAccessorsCommand = BatchRemoveChannelRoleFromAccessorsCommand;
1660
+ exports.BatchRemoveRoleCommand = BatchRemoveRoleCommand;
1661
+ exports.ChannelDataFilterSensitiveLog = ChannelDataFilterSensitiveLog;
1662
+ exports.ChannelRole = ChannelRole;
1663
+ exports.ChannelStatus = ChannelStatus;
1664
+ exports.ConfigurationStatus = ConfigurationStatus;
1665
+ exports.ConflictException = ConflictException;
1666
+ exports.CreateChannelCommand = CreateChannelCommand;
1667
+ exports.CreateChannelInputFilterSensitiveLog = CreateChannelInputFilterSensitiveLog;
1668
+ exports.CreateSpaceCommand = CreateSpaceCommand;
1669
+ exports.CreateSpaceInputFilterSensitiveLog = CreateSpaceInputFilterSensitiveLog;
1670
+ exports.DeleteSpaceCommand = DeleteSpaceCommand;
1671
+ exports.DeregisterAdminCommand = DeregisterAdminCommand;
1672
+ exports.FeatureEnableParameter = FeatureEnableParameter;
1673
+ exports.FeatureEnableStatus = FeatureEnableStatus;
1674
+ exports.GetChannelCommand = GetChannelCommand;
1675
+ exports.GetChannelOutputFilterSensitiveLog = GetChannelOutputFilterSensitiveLog;
1676
+ exports.GetSpaceCommand = GetSpaceCommand;
1677
+ exports.GetSpaceOutputFilterSensitiveLog = GetSpaceOutputFilterSensitiveLog;
1678
+ exports.InternalServerException = InternalServerException;
1679
+ exports.ListChannelsCommand = ListChannelsCommand;
1680
+ exports.ListChannelsOutputFilterSensitiveLog = ListChannelsOutputFilterSensitiveLog;
1681
+ exports.ListSpacesCommand = ListSpacesCommand;
1682
+ exports.ListSpacesOutputFilterSensitiveLog = ListSpacesOutputFilterSensitiveLog;
1683
+ exports.ListTagsForResourceCommand = ListTagsForResourceCommand;
1684
+ exports.ListTagsForResourceResponseFilterSensitiveLog = ListTagsForResourceResponseFilterSensitiveLog;
1685
+ exports.RegisterAdminCommand = RegisterAdminCommand;
1686
+ exports.Repostspace = Repostspace;
1687
+ exports.RepostspaceClient = RepostspaceClient;
1688
+ exports.RepostspaceServiceException = RepostspaceServiceException;
1689
+ exports.ResourceNotFoundException = ResourceNotFoundException;
1690
+ exports.Role = Role;
1691
+ exports.SendInvitesCommand = SendInvitesCommand;
1692
+ exports.SendInvitesInputFilterSensitiveLog = SendInvitesInputFilterSensitiveLog;
1693
+ exports.ServiceQuotaExceededException = ServiceQuotaExceededException;
1694
+ exports.SpaceDataFilterSensitiveLog = SpaceDataFilterSensitiveLog;
1695
+ exports.SupportedEmailDomainsParametersFilterSensitiveLog = SupportedEmailDomainsParametersFilterSensitiveLog;
1696
+ exports.SupportedEmailDomainsStatusFilterSensitiveLog = SupportedEmailDomainsStatusFilterSensitiveLog;
1697
+ exports.TagResourceCommand = TagResourceCommand;
1698
+ exports.TagResourceRequestFilterSensitiveLog = TagResourceRequestFilterSensitiveLog;
1699
+ exports.ThrottlingException = ThrottlingException;
1700
+ exports.TierLevel = TierLevel;
1701
+ exports.UntagResourceCommand = UntagResourceCommand;
1702
+ exports.UpdateChannelCommand = UpdateChannelCommand;
1703
+ exports.UpdateChannelInputFilterSensitiveLog = UpdateChannelInputFilterSensitiveLog;
1704
+ exports.UpdateSpaceCommand = UpdateSpaceCommand;
1705
+ exports.UpdateSpaceInputFilterSensitiveLog = UpdateSpaceInputFilterSensitiveLog;
1706
+ exports.ValidationException = ValidationException;
1707
+ exports.ValidationExceptionReason = ValidationExceptionReason;
1708
+ exports.VanityDomainStatus = VanityDomainStatus;
1709
+ exports.paginateListChannels = paginateListChannels;
1710
+ exports.paginateListSpaces = paginateListSpaces;
1711
+ exports.waitForChannelCreated = waitForChannelCreated;
1712
+ exports.waitForChannelDeleted = waitForChannelDeleted;
1713
+ exports.waitForSpaceCreated = waitForSpaceCreated;
1714
+ exports.waitForSpaceDeleted = waitForSpaceDeleted;
1715
+ exports.waitUntilChannelCreated = waitUntilChannelCreated;
1716
+ exports.waitUntilChannelDeleted = waitUntilChannelDeleted;
1717
+ exports.waitUntilSpaceCreated = waitUntilSpaceCreated;
1718
+ exports.waitUntilSpaceDeleted = waitUntilSpaceDeleted;