@aws-sdk/client-repostspace 3.840.0 → 3.845.0

package/dist-cjs/index.js

@@ -22,17 +22,30 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   AccessDeniedException: () => AccessDeniedException,
+  BatchAddChannelRoleToAccessorsCommand: () => BatchAddChannelRoleToAccessorsCommand,
   BatchAddRoleCommand: () => BatchAddRoleCommand,
+  BatchRemoveChannelRoleFromAccessorsCommand: () => BatchRemoveChannelRoleFromAccessorsCommand,
   BatchRemoveRoleCommand: () => BatchRemoveRoleCommand,
+  ChannelDataFilterSensitiveLog: () => ChannelDataFilterSensitiveLog,
+  ChannelRole: () => ChannelRole,
+  ChannelStatus: () => ChannelStatus,
   ConfigurationStatus: () => ConfigurationStatus,
   ConflictException: () => ConflictException,
+  CreateChannelCommand: () => CreateChannelCommand,
+  CreateChannelInputFilterSensitiveLog: () => CreateChannelInputFilterSensitiveLog,
   CreateSpaceCommand: () => CreateSpaceCommand,
   CreateSpaceInputFilterSensitiveLog: () => CreateSpaceInputFilterSensitiveLog,
   DeleteSpaceCommand: () => DeleteSpaceCommand,
   DeregisterAdminCommand: () => DeregisterAdminCommand,
+  FeatureEnableParameter: () => FeatureEnableParameter,
+  FeatureEnableStatus: () => FeatureEnableStatus,
+  GetChannelCommand: () => GetChannelCommand,
+  GetChannelOutputFilterSensitiveLog: () => GetChannelOutputFilterSensitiveLog,
   GetSpaceCommand: () => GetSpaceCommand,
   GetSpaceOutputFilterSensitiveLog: () => GetSpaceOutputFilterSensitiveLog,
   InternalServerException: () => InternalServerException,
+  ListChannelsCommand: () => ListChannelsCommand,
+  ListChannelsOutputFilterSensitiveLog: () => ListChannelsOutputFilterSensitiveLog,
   ListSpacesCommand: () => ListSpacesCommand,
   ListSpacesOutputFilterSensitiveLog: () => ListSpacesOutputFilterSensitiveLog,
   ListTagsForResourceCommand: () => ListTagsForResourceCommand,
@@ -47,18 +60,31 @@ __export(index_exports, {
   SendInvitesInputFilterSensitiveLog: () => SendInvitesInputFilterSensitiveLog,
   ServiceQuotaExceededException: () => ServiceQuotaExceededException,
   SpaceDataFilterSensitiveLog: () => SpaceDataFilterSensitiveLog,
+  SupportedEmailDomainsParametersFilterSensitiveLog: () => SupportedEmailDomainsParametersFilterSensitiveLog,
+  SupportedEmailDomainsStatusFilterSensitiveLog: () => SupportedEmailDomainsStatusFilterSensitiveLog,
   TagResourceCommand: () => TagResourceCommand,
   TagResourceRequestFilterSensitiveLog: () => TagResourceRequestFilterSensitiveLog,
   ThrottlingException: () => ThrottlingException,
   TierLevel: () => TierLevel,
   UntagResourceCommand: () => UntagResourceCommand,
+  UpdateChannelCommand: () => UpdateChannelCommand,
+  UpdateChannelInputFilterSensitiveLog: () => UpdateChannelInputFilterSensitiveLog,
   UpdateSpaceCommand: () => UpdateSpaceCommand,
   UpdateSpaceInputFilterSensitiveLog: () => UpdateSpaceInputFilterSensitiveLog,
   ValidationException: () => ValidationException,
   ValidationExceptionReason: () => ValidationExceptionReason,
   VanityDomainStatus: () => VanityDomainStatus,
   __Client: () => import_smithy_client.Client,
-  paginateListSpaces: () => paginateListSpaces
+  paginateListChannels: () => paginateListChannels,
+  paginateListSpaces: () => paginateListSpaces,
+  waitForChannelCreated: () => waitForChannelCreated,
+  waitForChannelDeleted: () => waitForChannelDeleted,
+  waitForSpaceCreated: () => waitForSpaceCreated,
+  waitForSpaceDeleted: () => waitForSpaceDeleted,
+  waitUntilChannelCreated: () => waitUntilChannelCreated,
+  waitUntilChannelDeleted: () => waitUntilChannelDeleted,
+  waitUntilSpaceCreated: () => waitUntilSpaceCreated,
+  waitUntilSpaceDeleted: () => waitUntilSpaceDeleted
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -206,7 +232,7 @@ var RepostspaceClient = class extends import_smithy_client.Client {
 // src/Repostspace.ts
 
 
-// src/commands/BatchAddRoleCommand.ts
+// src/commands/BatchAddChannelRoleToAccessorsCommand.ts
 
 var import_middleware_serde = require("@smithy/middleware-serde");
 
@@ -253,8 +279,8 @@ var AccessDeniedException = class _AccessDeniedException extends RepostspaceServ
     Object.setPrototypeOf(this, _AccessDeniedException.prototype);
   }
 };
-var Role = {
-  ADMINISTRATOR: "ADMINISTRATOR",
+var ChannelRole = {
+  ASKER: "ASKER",
   EXPERT: "EXPERT",
   MODERATOR: "MODERATOR",
   SUPPORTREQUESTOR: "SUPPORTREQUESTOR"
@@ -389,6 +415,20 @@ var ValidationException = class _ValidationException extends RepostspaceServiceE
     this.fieldList = opts.fieldList;
   }
 };
+var Role = {
+  ADMINISTRATOR: "ADMINISTRATOR",
+  EXPERT: "EXPERT",
+  MODERATOR: "MODERATOR",
+  SUPPORTREQUESTOR: "SUPPORTREQUESTOR"
+};
+var ChannelStatus = {
+  CREATED: "CREATED",
+  CREATE_FAILED: "CREATE_FAILED",
+  CREATING: "CREATING",
+  DELETED: "DELETED",
+  DELETE_FAILED: "DELETE_FAILED",
+  DELETING: "DELETING"
+};
 var ConfigurationStatus = {
   CONFIGURED: "CONFIGURED",
   UNCONFIGURED: "UNCONFIGURED"
@@ -423,10 +463,6 @@ var ConflictException = class _ConflictException extends RepostspaceServiceExcep
     this.resourceType = opts.resourceType;
   }
 };
-var TierLevel = {
-  BASIC: "BASIC",
-  STANDARD: "STANDARD"
-};
 var ServiceQuotaExceededException = class _ServiceQuotaExceededException extends RepostspaceServiceException {
   static {
     __name(this, "ServiceQuotaExceededException");
@@ -469,26 +505,75 @@ var ServiceQuotaExceededException = class _ServiceQuotaExceededException extends
     this.quotaCode = opts.quotaCode;
   }
 };
+var FeatureEnableParameter = {
+  DISABLED: "DISABLED",
+  ENABLED: "ENABLED"
+};
+var TierLevel = {
+  BASIC: "BASIC",
+  STANDARD: "STANDARD"
+};
+var FeatureEnableStatus = {
+  DISABLED: "DISABLED",
+  ENABLED: "ENABLED",
+  NOT_ALLOWED: "NOT_ALLOWED"
+};
 var VanityDomainStatus = {
   APPROVED: "APPROVED",
   PENDING: "PENDING",
   UNAPPROVED: "UNAPPROVED"
 };
+var ChannelDataFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.channelName && { channelName: import_smithy_client.SENSITIVE_STRING },
+  ...obj.channelDescription && { channelDescription: import_smithy_client.SENSITIVE_STRING }
+}), "ChannelDataFilterSensitiveLog");
+var CreateChannelInputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.channelName && { channelName: import_smithy_client.SENSITIVE_STRING },
+  ...obj.channelDescription && { channelDescription: import_smithy_client.SENSITIVE_STRING }
+}), "CreateChannelInputFilterSensitiveLog");
+var SupportedEmailDomainsParametersFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.allowedDomains && { allowedDomains: import_smithy_client.SENSITIVE_STRING }
+}), "SupportedEmailDomainsParametersFilterSensitiveLog");
 var CreateSpaceInputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
   ...obj,
   ...obj.name && { name: import_smithy_client.SENSITIVE_STRING },
   ...obj.description && { description: import_smithy_client.SENSITIVE_STRING },
-  ...obj.tags && { tags: import_smithy_client.SENSITIVE_STRING }
+  ...obj.tags && { tags: import_smithy_client.SENSITIVE_STRING },
+  ...obj.supportedEmailDomains && {
+    supportedEmailDomains: SupportedEmailDomainsParametersFilterSensitiveLog(obj.supportedEmailDomains)
+  }
 }), "CreateSpaceInputFilterSensitiveLog");
+var GetChannelOutputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.channelName && { channelName: import_smithy_client.SENSITIVE_STRING },
+  ...obj.channelDescription && { channelDescription: import_smithy_client.SENSITIVE_STRING }
+}), "GetChannelOutputFilterSensitiveLog");
+var SupportedEmailDomainsStatusFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.allowedDomains && { allowedDomains: import_smithy_client.SENSITIVE_STRING }
+}), "SupportedEmailDomainsStatusFilterSensitiveLog");
 var GetSpaceOutputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
   ...obj,
   ...obj.name && { name: import_smithy_client.SENSITIVE_STRING },
-  ...obj.description && { description: import_smithy_client.SENSITIVE_STRING }
+  ...obj.description && { description: import_smithy_client.SENSITIVE_STRING },
+  ...obj.supportedEmailDomains && {
+    supportedEmailDomains: SupportedEmailDomainsStatusFilterSensitiveLog(obj.supportedEmailDomains)
+  }
 }), "GetSpaceOutputFilterSensitiveLog");
+var ListChannelsOutputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.channels && { channels: obj.channels.map((item) => ChannelDataFilterSensitiveLog(item)) }
+}), "ListChannelsOutputFilterSensitiveLog");
 var SpaceDataFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
   ...obj,
   ...obj.name && { name: import_smithy_client.SENSITIVE_STRING },
-  ...obj.description && { description: import_smithy_client.SENSITIVE_STRING }
+  ...obj.description && { description: import_smithy_client.SENSITIVE_STRING },
+  ...obj.supportedEmailDomains && {
+    supportedEmailDomains: SupportedEmailDomainsStatusFilterSensitiveLog(obj.supportedEmailDomains)
+  }
 }), "SpaceDataFilterSensitiveLog");
 var ListSpacesOutputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
   ...obj,
@@ -507,12 +592,38 @@ var TagResourceRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
   ...obj,
   ...obj.tags && { tags: import_smithy_client.SENSITIVE_STRING }
 }), "TagResourceRequestFilterSensitiveLog");
+var UpdateChannelInputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.channelName && { channelName: import_smithy_client.SENSITIVE_STRING },
+  ...obj.channelDescription && { channelDescription: import_smithy_client.SENSITIVE_STRING }
+}), "UpdateChannelInputFilterSensitiveLog");
 var UpdateSpaceInputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
   ...obj,
-  ...obj.description && { description: import_smithy_client.SENSITIVE_STRING }
+  ...obj.description && { description: import_smithy_client.SENSITIVE_STRING },
+  ...obj.supportedEmailDomains && {
+    supportedEmailDomains: SupportedEmailDomainsParametersFilterSensitiveLog(obj.supportedEmailDomains)
+  }
 }), "UpdateSpaceInputFilterSensitiveLog");
 
 // src/protocols/Aws_restJson1.ts
+var se_BatchAddChannelRoleToAccessorsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/spaces/{spaceId}/channels/{channelId}/roles");
+  b.p("spaceId", () => input.spaceId, "{spaceId}", false);
+  b.p("channelId", () => input.channelId, "{channelId}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      accessorIds: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "accessorIds"),
+      channelRole: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_BatchAddChannelRoleToAccessorsCommand");
 var se_BatchAddRoleCommand = /* @__PURE__ */ __name(async (input, context) => {
   const b = (0, import_core.requestBuilder)(input, context);
   const headers = {
@@ -530,6 +641,24 @@ var se_BatchAddRoleCommand = /* @__PURE__ */ __name(async (input, context) => {
   b.m("POST").h(headers).b(body);
   return b.build();
 }, "se_BatchAddRoleCommand");
+var se_BatchRemoveChannelRoleFromAccessorsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/spaces/{spaceId}/channels/{channelId}/roles");
+  b.p("spaceId", () => input.spaceId, "{spaceId}", false);
+  b.p("channelId", () => input.channelId, "{channelId}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      accessorIds: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "accessorIds"),
+      channelRole: []
+    })
+  );
+  b.m("PATCH").h(headers).b(body);
+  return b.build();
+}, "se_BatchRemoveChannelRoleFromAccessorsCommand");
 var se_BatchRemoveRoleCommand = /* @__PURE__ */ __name(async (input, context) => {
   const b = (0, import_core.requestBuilder)(input, context);
   const headers = {
@@ -547,6 +676,23 @@ var se_BatchRemoveRoleCommand = /* @__PURE__ */ __name(async (input, context) =>
   b.m("PATCH").h(headers).b(body);
   return b.build();
 }, "se_BatchRemoveRoleCommand");
+var se_CreateChannelCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/spaces/{spaceId}/channels");
+  b.p("spaceId", () => input.spaceId, "{spaceId}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      channelDescription: [],
+      channelName: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreateChannelCommand");
 var se_CreateSpaceCommand = /* @__PURE__ */ __name(async (input, context) => {
   const b = (0, import_core.requestBuilder)(input, context);
   const headers = {
@@ -560,6 +706,7 @@ var se_CreateSpaceCommand = /* @__PURE__ */ __name(async (input, context) => {
       name: [],
       roleArn: [],
       subdomain: [],
+      supportedEmailDomains: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "supportedEmailDomains"),
       tags: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "tags"),
       tier: [],
       userKMSKey: []
@@ -587,6 +734,16 @@ var se_DeregisterAdminCommand = /* @__PURE__ */ __name(async (input, context) =>
   b.m("DELETE").h(headers).b(body);
   return b.build();
 }, "se_DeregisterAdminCommand");
+var se_GetChannelCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/spaces/{spaceId}/channels/{channelId}");
+  b.p("spaceId", () => input.spaceId, "{spaceId}", false);
+  b.p("channelId", () => input.channelId, "{channelId}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_GetChannelCommand");
 var se_GetSpaceCommand = /* @__PURE__ */ __name(async (input, context) => {
   const b = (0, import_core.requestBuilder)(input, context);
   const headers = {};
@@ -596,6 +753,19 @@ var se_GetSpaceCommand = /* @__PURE__ */ __name(async (input, context) => {
   b.m("GET").h(headers).b(body);
   return b.build();
 }, "se_GetSpaceCommand");
+var se_ListChannelsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/spaces/{spaceId}/channels");
+  b.p("spaceId", () => input.spaceId, "{spaceId}", false);
+  const query = (0, import_smithy_client.map)({
+    [_nT]: [, input[_nT]],
+    [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_ListChannelsCommand");
 var se_ListSpacesCommand = /* @__PURE__ */ __name(async (input, context) => {
   const b = (0, import_core.requestBuilder)(input, context);
   const headers = {};
@@ -673,6 +843,24 @@ var se_UntagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
   b.m("DELETE").h(headers).q(query).b(body);
   return b.build();
 }, "se_UntagResourceCommand");
+var se_UpdateChannelCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/spaces/{spaceId}/channels/{channelId}");
+  b.p("spaceId", () => input.spaceId, "{spaceId}", false);
+  b.p("channelId", () => input.channelId, "{channelId}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      channelDescription: [],
+      channelName: []
+    })
+  );
+  b.m("PUT").h(headers).b(body);
+  return b.build();
+}, "se_UpdateChannelCommand");
 var se_UpdateSpaceCommand = /* @__PURE__ */ __name(async (input, context) => {
   const b = (0, import_core.requestBuilder)(input, context);
   const headers = {
@@ -685,12 +873,28 @@ var se_UpdateSpaceCommand = /* @__PURE__ */ __name(async (input, context) => {
     (0, import_smithy_client.take)(input, {
       description: [],
       roleArn: [],
+      supportedEmailDomains: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "supportedEmailDomains"),
       tier: []
     })
   );
   b.m("PUT").h(headers).b(body);
   return b.build();
 }, "se_UpdateSpaceCommand");
+var de_BatchAddChannelRoleToAccessorsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    addedAccessorIds: import_smithy_client._json,
+    errors: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_BatchAddChannelRoleToAccessorsCommand");
 var de_BatchAddRoleCommand = /* @__PURE__ */ __name(async (output, context) => {
   if (output.statusCode !== 200 && output.statusCode >= 300) {
     return de_CommandError(output, context);
@@ -706,6 +910,21 @@ var de_BatchAddRoleCommand = /* @__PURE__ */ __name(async (output, context) => {
   Object.assign(contents, doc);
   return contents;
 }, "de_BatchAddRoleCommand");
+var de_BatchRemoveChannelRoleFromAccessorsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    errors: import_smithy_client._json,
+    removedAccessorIds: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_BatchRemoveChannelRoleFromAccessorsCommand");
 var de_BatchRemoveRoleCommand = /* @__PURE__ */ __name(async (output, context) => {
   if (output.statusCode !== 200 && output.statusCode >= 300) {
     return de_CommandError(output, context);
@@ -721,6 +940,20 @@ var de_BatchRemoveRoleCommand = /* @__PURE__ */ __name(async (output, context) =
   Object.assign(contents, doc);
   return contents;
 }, "de_BatchRemoveRoleCommand");
+var de_CreateChannelCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    channelId: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateChannelCommand");
 var de_CreateSpaceCommand = /* @__PURE__ */ __name(async (output, context) => {
   if (output.statusCode !== 200 && output.statusCode >= 300) {
     return de_CommandError(output, context);
@@ -755,6 +988,27 @@ var de_DeregisterAdminCommand = /* @__PURE__ */ __name(async (output, context) =
   await (0, import_smithy_client.collectBody)(output.body, context);
   return contents;
 }, "de_DeregisterAdminCommand");
+var de_GetChannelCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    channelDescription: import_smithy_client.expectString,
+    channelId: import_smithy_client.expectString,
+    channelName: import_smithy_client.expectString,
+    channelRoles: import_smithy_client._json,
+    channelStatus: import_smithy_client.expectString,
+    createDateTime: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), "createDateTime"),
+    deleteDateTime: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), "deleteDateTime"),
+    spaceId: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetChannelCommand");
 var de_GetSpaceCommand = /* @__PURE__ */ __name(async (output, context) => {
   if (output.statusCode !== 200 && output.statusCode >= 300) {
     return de_CommandError(output, context);
@@ -764,6 +1018,7 @@ var de_GetSpaceCommand = /* @__PURE__ */ __name(async (output, context) => {
   });
   const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
   const doc = (0, import_smithy_client.take)(data, {
+    applicationArn: import_smithy_client.expectString,
     arn: import_smithy_client.expectString,
     clientId: import_smithy_client.expectString,
     configurationStatus: import_smithy_client.expectString,
@@ -773,12 +1028,14 @@ var de_GetSpaceCommand = /* @__PURE__ */ __name(async (output, context) => {
     deleteDateTime: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), "deleteDateTime"),
     description: import_smithy_client.expectString,
     groupAdmins: import_smithy_client._json,
+    identityStoreId: import_smithy_client.expectString,
     name: import_smithy_client.expectString,
     randomDomain: import_smithy_client.expectString,
     roles: import_smithy_client._json,
     spaceId: import_smithy_client.expectString,
     status: import_smithy_client.expectString,
     storageLimit: import_smithy_client.expectLong,
+    supportedEmailDomains: import_smithy_client._json,
     tier: import_smithy_client.expectString,
     userAdmins: import_smithy_client._json,
     userCount: import_smithy_client.expectInt32,
@@ -789,6 +1046,21 @@ var de_GetSpaceCommand = /* @__PURE__ */ __name(async (output, context) => {
   Object.assign(contents, doc);
   return contents;
 }, "de_GetSpaceCommand");
+var de_ListChannelsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    channels: /* @__PURE__ */ __name((_) => de_ChannelsList(_, context), "channels"),
+    nextToken: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListChannelsCommand");
 var de_ListSpacesCommand = /* @__PURE__ */ __name(async (output, context) => {
   if (output.statusCode !== 200 && output.statusCode >= 300) {
     return de_CommandError(output, context);
@@ -858,6 +1130,16 @@ var de_UntagResourceCommand = /* @__PURE__ */ __name(async (output, context) =>
   await (0, import_smithy_client.collectBody)(output.body, context);
   return contents;
 }, "de_UntagResourceCommand");
+var de_UpdateChannelCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_UpdateChannelCommand");
 var de_UpdateSpaceCommand = /* @__PURE__ */ __name(async (output, context) => {
   if (output.statusCode !== 200 && output.statusCode >= 300) {
     return de_CommandError(output, context);
@@ -1013,6 +1295,25 @@ var de_ValidationExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, cont
   });
   return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
 }, "de_ValidationExceptionRes");
+var de_ChannelData = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    channelDescription: import_smithy_client.expectString,
+    channelId: import_smithy_client.expectString,
+    channelName: import_smithy_client.expectString,
+    channelStatus: import_smithy_client.expectString,
+    createDateTime: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), "createDateTime"),
+    deleteDateTime: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), "deleteDateTime"),
+    groupCount: import_smithy_client.expectInt32,
+    spaceId: import_smithy_client.expectString,
+    userCount: import_smithy_client.expectInt32
+  });
+}, "de_ChannelData");
+var de_ChannelsList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_ChannelData(entry, context);
+  });
+  return retVal;
+}, "de_ChannelsList");
 var de_SpaceData = /* @__PURE__ */ __name((output, context) => {
   return (0, import_smithy_client.take)(output, {
     arn: import_smithy_client.expectString,
@@ -1026,6 +1327,7 @@ var de_SpaceData = /* @__PURE__ */ __name((output, context) => {
     spaceId: import_smithy_client.expectString,
     status: import_smithy_client.expectString,
     storageLimit: import_smithy_client.expectLong,
+    supportedEmailDomains: import_smithy_client._json,
     tier: import_smithy_client.expectString,
     userCount: import_smithy_client.expectInt32,
     userKMSKey: import_smithy_client.expectString,
@@ -1051,7 +1353,22 @@ var _rAS = "retryAfterSeconds";
 var _ra = "retry-after";
 var _tK = "tagKeys";
 
+// src/commands/BatchAddChannelRoleToAccessorsCommand.ts
+var BatchAddChannelRoleToAccessorsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("RepostSpace", "BatchAddChannelRoleToAccessors", {}).n("RepostspaceClient", "BatchAddChannelRoleToAccessorsCommand").f(void 0, void 0).ser(se_BatchAddChannelRoleToAccessorsCommand).de(de_BatchAddChannelRoleToAccessorsCommand).build() {
+  static {
+    __name(this, "BatchAddChannelRoleToAccessorsCommand");
+  }
+};
+
 // src/commands/BatchAddRoleCommand.ts
+
+
+
 var BatchAddRoleCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
   return [
     (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
@@ -1063,6 +1380,21 @@ var BatchAddRoleCommand = class extends import_smithy_client.Command.classBuilde
   }
 };
 
+// src/commands/BatchRemoveChannelRoleFromAccessorsCommand.ts
+
+
+
+var BatchRemoveChannelRoleFromAccessorsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("RepostSpace", "BatchRemoveChannelRoleFromAccessors", {}).n("RepostspaceClient", "BatchRemoveChannelRoleFromAccessorsCommand").f(void 0, void 0).ser(se_BatchRemoveChannelRoleFromAccessorsCommand).de(de_BatchRemoveChannelRoleFromAccessorsCommand).build() {
+  static {
+    __name(this, "BatchRemoveChannelRoleFromAccessorsCommand");
+  }
+};
+
 // src/commands/BatchRemoveRoleCommand.ts
 
 
@@ -1078,6 +1410,21 @@ var BatchRemoveRoleCommand = class extends import_smithy_client.Command.classBui
   }
 };
 
+// src/commands/CreateChannelCommand.ts
+
+
+
+var CreateChannelCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("RepostSpace", "CreateChannel", {}).n("RepostspaceClient", "CreateChannelCommand").f(CreateChannelInputFilterSensitiveLog, void 0).ser(se_CreateChannelCommand).de(de_CreateChannelCommand).build() {
+  static {
+    __name(this, "CreateChannelCommand");
+  }
+};
+
 // src/commands/CreateSpaceCommand.ts
 
 
@@ -1123,6 +1470,21 @@ var DeregisterAdminCommand = class extends import_smithy_client.Command.classBui
   }
 };
 
+// src/commands/GetChannelCommand.ts
+
+
+
+var GetChannelCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("RepostSpace", "GetChannel", {}).n("RepostspaceClient", "GetChannelCommand").f(void 0, GetChannelOutputFilterSensitiveLog).ser(se_GetChannelCommand).de(de_GetChannelCommand).build() {
+  static {
+    __name(this, "GetChannelCommand");
+  }
+};
+
 // src/commands/GetSpaceCommand.ts
 
 
@@ -1138,6 +1500,21 @@ var GetSpaceCommand = class extends import_smithy_client.Command.classBuilder().
   }
 };
 
+// src/commands/ListChannelsCommand.ts
+
+
+
+var ListChannelsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("RepostSpace", "ListChannels", {}).n("RepostspaceClient", "ListChannelsCommand").f(void 0, ListChannelsOutputFilterSensitiveLog).ser(se_ListChannelsCommand).de(de_ListChannelsCommand).build() {
+  static {
+    __name(this, "ListChannelsCommand");
+  }
+};
+
 // src/commands/ListSpacesCommand.ts
 
 
@@ -1228,6 +1605,21 @@ var UntagResourceCommand = class extends import_smithy_client.Command.classBuild
   }
 };
 
+// src/commands/UpdateChannelCommand.ts
+
+
+
+var UpdateChannelCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("RepostSpace", "UpdateChannel", {}).n("RepostspaceClient", "UpdateChannelCommand").f(UpdateChannelInputFilterSensitiveLog, void 0).ser(se_UpdateChannelCommand).de(de_UpdateChannelCommand).build() {
+  static {
+    __name(this, "UpdateChannelCommand");
+  }
+};
+
 // src/commands/UpdateSpaceCommand.ts
 
 
@@ -1245,18 +1637,24 @@ var UpdateSpaceCommand = class extends import_smithy_client.Command.classBuilder
 
 // src/Repostspace.ts
 var commands = {
+  BatchAddChannelRoleToAccessorsCommand,
   BatchAddRoleCommand,
+  BatchRemoveChannelRoleFromAccessorsCommand,
   BatchRemoveRoleCommand,
+  CreateChannelCommand,
   CreateSpaceCommand,
   DeleteSpaceCommand,
   DeregisterAdminCommand,
+  GetChannelCommand,
   GetSpaceCommand,
+  ListChannelsCommand,
   ListSpacesCommand,
   ListTagsForResourceCommand,
   RegisterAdminCommand,
   SendInvitesCommand,
   TagResourceCommand,
   UntagResourceCommand,
+  UpdateChannelCommand,
   UpdateSpaceCommand
 };
 var Repostspace = class extends RepostspaceClient {
@@ -1266,9 +1664,215 @@ var Repostspace = class extends RepostspaceClient {
 };
 (0, import_smithy_client.createAggregatedClient)(commands, Repostspace);
 
+// src/pagination/ListChannelsPaginator.ts
+
+var paginateListChannels = (0, import_core.createPaginator)(RepostspaceClient, ListChannelsCommand, "nextToken", "nextToken", "maxResults");
+
 // src/pagination/ListSpacesPaginator.ts
 
 var paginateListSpaces = (0, import_core.createPaginator)(RepostspaceClient, ListSpacesCommand, "nextToken", "nextToken", "maxResults");
+
+// src/waiters/waitForChannelCreated.ts
+var import_util_waiter = require("@smithy/util-waiter");
+var checkState = /* @__PURE__ */ __name(async (client, input) => {
+  let reason;
+  try {
+    const result = await client.send(new GetChannelCommand(input));
+    reason = result;
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.channelStatus;
+      }, "returnComparator");
+      if (returnComparator() === "CREATED") {
+        return { state: import_util_waiter.WaiterState.SUCCESS, reason };
+      }
+    } catch (e) {
+    }
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.channelStatus;
+      }, "returnComparator");
+      if (returnComparator() === "CREATE_FAILED") {
+        return { state: import_util_waiter.WaiterState.FAILURE, reason };
+      }
+    } catch (e) {
+    }
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.channelStatus;
+      }, "returnComparator");
+      if (returnComparator() === "CREATING") {
+        return { state: import_util_waiter.WaiterState.RETRY, reason };
+      }
+    } catch (e) {
+    }
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: import_util_waiter.WaiterState.RETRY, reason };
+}, "checkState");
+var waitForChannelCreated = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 2, maxDelay: 120 };
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
+}, "waitForChannelCreated");
+var waitUntilChannelCreated = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 2, maxDelay: 120 };
+  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
+  return (0, import_util_waiter.checkExceptions)(result);
+}, "waitUntilChannelCreated");
+
+// src/waiters/waitForChannelDeleted.ts
+
+var checkState2 = /* @__PURE__ */ __name(async (client, input) => {
+  let reason;
+  try {
+    const result = await client.send(new GetChannelCommand(input));
+    reason = result;
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.channelStatus;
+      }, "returnComparator");
+      if (returnComparator() === "DELETED") {
+        return { state: import_util_waiter.WaiterState.SUCCESS, reason };
+      }
+    } catch (e) {
+    }
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.channelStatus;
+      }, "returnComparator");
+      if (returnComparator() === "DELETE_FAILED") {
+        return { state: import_util_waiter.WaiterState.FAILURE, reason };
+      }
+    } catch (e) {
+    }
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.channelStatus;
+      }, "returnComparator");
+      if (returnComparator() === "DELETING") {
+        return { state: import_util_waiter.WaiterState.RETRY, reason };
+      }
+    } catch (e) {
+    }
+  } catch (exception) {
+    reason = exception;
+    if (exception.name && exception.name == "ResourceNotFoundException") {
+      return { state: import_util_waiter.WaiterState.SUCCESS, reason };
+    }
+  }
+  return { state: import_util_waiter.WaiterState.RETRY, reason };
+}, "checkState");
+var waitForChannelDeleted = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 2, maxDelay: 120 };
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState2);
+}, "waitForChannelDeleted");
+var waitUntilChannelDeleted = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 2, maxDelay: 120 };
+  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState2);
+  return (0, import_util_waiter.checkExceptions)(result);
+}, "waitUntilChannelDeleted");
+
+// src/waiters/waitForSpaceCreated.ts
+
+var checkState3 = /* @__PURE__ */ __name(async (client, input) => {
+  let reason;
+  try {
+    const result = await client.send(new GetSpaceCommand(input));
+    reason = result;
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.status;
+      }, "returnComparator");
+      if (returnComparator() === "CREATED") {
+        return { state: import_util_waiter.WaiterState.SUCCESS, reason };
+      }
+    } catch (e) {
+    }
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.status;
+      }, "returnComparator");
+      if (returnComparator() === "CREATE_FAILED") {
+        return { state: import_util_waiter.WaiterState.FAILURE, reason };
+      }
+    } catch (e) {
+    }
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.status;
+      }, "returnComparator");
+      if (returnComparator() === "CREATING") {
+        return { state: import_util_waiter.WaiterState.RETRY, reason };
+      }
+    } catch (e) {
+    }
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: import_util_waiter.WaiterState.RETRY, reason };
+}, "checkState");
+var waitForSpaceCreated = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 300, maxDelay: 7200 };
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState3);
+}, "waitForSpaceCreated");
+var waitUntilSpaceCreated = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 300, maxDelay: 7200 };
+  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState3);
+  return (0, import_util_waiter.checkExceptions)(result);
+}, "waitUntilSpaceCreated");
+
+// src/waiters/waitForSpaceDeleted.ts
+
+var checkState4 = /* @__PURE__ */ __name(async (client, input) => {
+  let reason;
+  try {
+    const result = await client.send(new GetSpaceCommand(input));
+    reason = result;
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.status;
+      }, "returnComparator");
+      if (returnComparator() === "DELETED") {
+        return { state: import_util_waiter.WaiterState.SUCCESS, reason };
+      }
+    } catch (e) {
+    }
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.status;
+      }, "returnComparator");
+      if (returnComparator() === "DELETE_FAILED") {
+        return { state: import_util_waiter.WaiterState.FAILURE, reason };
+      }
+    } catch (e) {
+    }
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.status;
+      }, "returnComparator");
+      if (returnComparator() === "DELETING") {
+        return { state: import_util_waiter.WaiterState.RETRY, reason };
+      }
+    } catch (e) {
+    }
+  } catch (exception) {
+    reason = exception;
+    if (exception.name && exception.name == "ResourceNotFoundException") {
+      return { state: import_util_waiter.WaiterState.SUCCESS, reason };
+    }
+  }
+  return { state: import_util_waiter.WaiterState.RETRY, reason };
+}, "checkState");
+var waitForSpaceDeleted = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 300, maxDelay: 7200 };
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState4);
+}, "waitForSpaceDeleted");
+var waitUntilSpaceDeleted = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 300, maxDelay: 7200 };
+  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState4);
+  return (0, import_util_waiter.checkExceptions)(result);
+}, "waitUntilSpaceDeleted");
 // Annotate the CommonJS export names for ESM import in node:
 
 0 && (module.exports = {
@@ -1277,39 +1881,65 @@ var paginateListSpaces = (0, import_core.createPaginator)(RepostspaceClient, Lis
   RepostspaceClient,
   Repostspace,
   $Command,
+  BatchAddChannelRoleToAccessorsCommand,
   BatchAddRoleCommand,
+  BatchRemoveChannelRoleFromAccessorsCommand,
   BatchRemoveRoleCommand,
+  CreateChannelCommand,
   CreateSpaceCommand,
   DeleteSpaceCommand,
   DeregisterAdminCommand,
+  GetChannelCommand,
   GetSpaceCommand,
+  ListChannelsCommand,
   ListSpacesCommand,
   ListTagsForResourceCommand,
   RegisterAdminCommand,
   SendInvitesCommand,
   TagResourceCommand,
   UntagResourceCommand,
+  UpdateChannelCommand,
   UpdateSpaceCommand,
+  paginateListChannels,
   paginateListSpaces,
+  waitForChannelCreated,
+  waitUntilChannelCreated,
+  waitForChannelDeleted,
+  waitUntilChannelDeleted,
+  waitForSpaceCreated,
+  waitUntilSpaceCreated,
+  waitForSpaceDeleted,
+  waitUntilSpaceDeleted,
   AccessDeniedException,
-  Role,
+  ChannelRole,
   InternalServerException,
   ResourceNotFoundException,
   ThrottlingException,
   ValidationExceptionReason,
   ValidationException,
+  Role,
+  ChannelStatus,
   ConfigurationStatus,
   ConflictException,
-  TierLevel,
   ServiceQuotaExceededException,
+  FeatureEnableParameter,
+  TierLevel,
+  FeatureEnableStatus,
   VanityDomainStatus,
+  ChannelDataFilterSensitiveLog,
+  CreateChannelInputFilterSensitiveLog,
+  SupportedEmailDomainsParametersFilterSensitiveLog,
   CreateSpaceInputFilterSensitiveLog,
+  GetChannelOutputFilterSensitiveLog,
+  SupportedEmailDomainsStatusFilterSensitiveLog,
   GetSpaceOutputFilterSensitiveLog,
+  ListChannelsOutputFilterSensitiveLog,
   SpaceDataFilterSensitiveLog,
   ListSpacesOutputFilterSensitiveLog,
   ListTagsForResourceResponseFilterSensitiveLog,
   SendInvitesInputFilterSensitiveLog,
   TagResourceRequestFilterSensitiveLog,
+  UpdateChannelInputFilterSensitiveLog,
   UpdateSpaceInputFilterSensitiveLog
 });