@aws-sdk/client-verifiedpermissions 3.927.0 → 3.928.0

package/dist-cjs/index.js

@@ -6,6 +6,7 @@ var middlewareRecursionDetection = require('@aws-sdk/middleware-recursion-detect
 var middlewareUserAgent = require('@aws-sdk/middleware-user-agent');
 var configResolver = require('@smithy/config-resolver');
 var core = require('@smithy/core');
+var schema = require('@smithy/core/schema');
 var middlewareContentLength = require('@smithy/middleware-content-length');
 var middlewareEndpoint = require('@smithy/middleware-endpoint');
 var middlewareRetry = require('@smithy/middleware-retry');
@@ -14,9 +15,6 @@ var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
 var runtimeConfig = require('./runtimeConfig');
 var regionConfigResolver = require('@aws-sdk/region-config-resolver');
 var protocolHttp = require('@smithy/protocol-http');
-var middlewareSerde = require('@smithy/middleware-serde');
-var core$1 = require('@aws-sdk/core');
-var uuid = require('@smithy/uuid');
 
 const resolveClientEndpointParameters = (options) => {
     return Object.assign(options, {
@@ -92,6 +90,7 @@ class VerifiedPermissionsClient extends smithyClient.Client {
         const _config_7 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_6);
         const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
         this.config = _config_8;
+        this.middlewareStack.use(schema.getSchemaSerdePlugin(this.config));
         this.middlewareStack.use(middlewareUserAgent.getUserAgentPlugin(this.config));
         this.middlewareStack.use(middlewareRetry.getRetryPlugin(this.config));
         this.middlewareStack.use(middlewareContentLength.getContentLengthPlugin(this.config));
@@ -111,14 +110,14 @@ class VerifiedPermissionsClient extends smithyClient.Client {
     }
 }
 
-class VerifiedPermissionsServiceException extends smithyClient.ServiceException {
+let VerifiedPermissionsServiceException$1 = class VerifiedPermissionsServiceException extends smithyClient.ServiceException {
     constructor(options) {
         super(options);
         Object.setPrototypeOf(this, VerifiedPermissionsServiceException.prototype);
     }
-}
+};
 
-class AccessDeniedException extends VerifiedPermissionsServiceException {
+let AccessDeniedException$1 = class AccessDeniedException extends VerifiedPermissionsServiceException$1 {
     name = "AccessDeniedException";
     $fault = "client";
     constructor(opts) {
@@ -129,7 +128,7 @@ class AccessDeniedException extends VerifiedPermissionsServiceException {
         });
         Object.setPrototypeOf(this, AccessDeniedException.prototype);
     }
-}
+};
 const BatchGetPolicyErrorCode = {
     POLICY_NOT_FOUND: "POLICY_NOT_FOUND",
     POLICY_STORE_NOT_FOUND: "POLICY_STORE_NOT_FOUND",
@@ -148,7 +147,7 @@ const PolicyType = {
     STATIC: "STATIC",
     TEMPLATE_LINKED: "TEMPLATE_LINKED",
 };
-class InternalServerException extends VerifiedPermissionsServiceException {
+let InternalServerException$1 = class InternalServerException extends VerifiedPermissionsServiceException$1 {
     name = "InternalServerException";
     $fault = "server";
     $retryable = {};
@@ -160,8 +159,8 @@ class InternalServerException extends VerifiedPermissionsServiceException {
         });
         Object.setPrototypeOf(this, InternalServerException.prototype);
     }
-}
-class ThrottlingException extends VerifiedPermissionsServiceException {
+};
+let ThrottlingException$1 = class ThrottlingException extends VerifiedPermissionsServiceException$1 {
     name = "ThrottlingException";
     $fault = "client";
     $retryable = {
@@ -179,8 +178,8 @@ class ThrottlingException extends VerifiedPermissionsServiceException {
         this.serviceCode = opts.serviceCode;
         this.quotaCode = opts.quotaCode;
     }
-}
-class ValidationException extends VerifiedPermissionsServiceException {
+};
+let ValidationException$1 = class ValidationException extends VerifiedPermissionsServiceException$1 {
     name = "ValidationException";
     $fault = "client";
     fieldList;
@@ -193,7 +192,7 @@ class ValidationException extends VerifiedPermissionsServiceException {
         Object.setPrototypeOf(this, ValidationException.prototype);
         this.fieldList = opts.fieldList;
     }
-}
+};
 const Decision = {
     ALLOW: "ALLOW",
     DENY: "DENY",
@@ -205,7 +204,7 @@ const ResourceType = {
     POLICY_TEMPLATE: "POLICY_TEMPLATE",
     SCHEMA: "SCHEMA",
 };
-class ResourceNotFoundException extends VerifiedPermissionsServiceException {
+let ResourceNotFoundException$1 = class ResourceNotFoundException extends VerifiedPermissionsServiceException$1 {
     name = "ResourceNotFoundException";
     $fault = "client";
     resourceId;
@@ -220,7 +219,7 @@ class ResourceNotFoundException extends VerifiedPermissionsServiceException {
         this.resourceId = opts.resourceId;
         this.resourceType = opts.resourceType;
     }
-}
+};
 const CedarVersion = {
     CEDAR_2: "CEDAR_2",
     CEDAR_4: "CEDAR_4",
@@ -285,7 +284,7 @@ exports.ConfigurationItem = void 0;
         return visitor._(value.$unknown[0], value.$unknown[1]);
     };
 })(exports.ConfigurationItem || (exports.ConfigurationItem = {}));
-class ConflictException extends VerifiedPermissionsServiceException {
+let ConflictException$1 = class ConflictException extends VerifiedPermissionsServiceException$1 {
     name = "ConflictException";
     $fault = "client";
     resources;
@@ -298,8 +297,8 @@ class ConflictException extends VerifiedPermissionsServiceException {
         Object.setPrototypeOf(this, ConflictException.prototype);
         this.resources = opts.resources;
     }
-}
-class ServiceQuotaExceededException extends VerifiedPermissionsServiceException {
+};
+let ServiceQuotaExceededException$1 = class ServiceQuotaExceededException extends VerifiedPermissionsServiceException$1 {
     name = "ServiceQuotaExceededException";
     $fault = "client";
     resourceId;
@@ -318,7 +317,7 @@ class ServiceQuotaExceededException extends VerifiedPermissionsServiceException
         this.serviceCode = opts.serviceCode;
         this.quotaCode = opts.quotaCode;
     }
-}
+};
 exports.PolicyDefinition = void 0;
 (function (PolicyDefinition) {
     PolicyDefinition.visit = (value, visitor) => {
@@ -341,7 +340,7 @@ const ValidationMode = {
     OFF: "OFF",
     STRICT: "STRICT",
 };
-class InvalidStateException extends VerifiedPermissionsServiceException {
+let InvalidStateException$1 = class InvalidStateException extends VerifiedPermissionsServiceException$1 {
     name = "InvalidStateException";
     $fault = "client";
     constructor(opts) {
@@ -352,7 +351,7 @@ class InvalidStateException extends VerifiedPermissionsServiceException {
         });
         Object.setPrototypeOf(this, InvalidStateException.prototype);
     }
-}
+};
 exports.EntityReference = void 0;
 (function (EntityReference) {
     EntityReference.visit = (value, visitor) => {
@@ -412,7 +411,7 @@ exports.SchemaDefinition = void 0;
         return visitor._(value.$unknown[0], value.$unknown[1]);
     };
 })(exports.SchemaDefinition || (exports.SchemaDefinition = {}));
-class TooManyTagsException extends VerifiedPermissionsServiceException {
+let TooManyTagsException$1 = class TooManyTagsException extends VerifiedPermissionsServiceException$1 {
     name = "TooManyTagsException";
     $fault = "client";
     resourceName;
@@ -425,7 +424,7 @@ class TooManyTagsException extends VerifiedPermissionsServiceException {
         Object.setPrototypeOf(this, TooManyTagsException.prototype);
         this.resourceName = opts.resourceName;
     }
-}
+};
 exports.AttributeValue = void 0;
 (function (AttributeValue) {
     AttributeValue.visit = (value, visitor) => {
@@ -452,6 +451,32 @@ exports.AttributeValue = void 0;
         return visitor._(value.$unknown[0], value.$unknown[1]);
     };
 })(exports.AttributeValue || (exports.AttributeValue = {}));
+exports.CedarTagValue = void 0;
+(function (CedarTagValue) {
+    CedarTagValue.visit = (value, visitor) => {
+        if (value.boolean !== undefined)
+            return visitor.boolean(value.boolean);
+        if (value.entityIdentifier !== undefined)
+            return visitor.entityIdentifier(value.entityIdentifier);
+        if (value.long !== undefined)
+            return visitor.long(value.long);
+        if (value.string !== undefined)
+            return visitor.string(value.string);
+        if (value.set !== undefined)
+            return visitor.set(value.set);
+        if (value.record !== undefined)
+            return visitor.record(value.record);
+        if (value.ipaddr !== undefined)
+            return visitor.ipaddr(value.ipaddr);
+        if (value.decimal !== undefined)
+            return visitor.decimal(value.decimal);
+        if (value.datetime !== undefined)
+            return visitor.datetime(value.datetime);
+        if (value.duration !== undefined)
+            return visitor.duration(value.duration);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(exports.CedarTagValue || (exports.CedarTagValue = {}));
 exports.ContextDefinition = void 0;
 (function (ContextDefinition) {
     ContextDefinition.visit = (value, visitor) => {
@@ -472,1907 +497,1638 @@ exports.EntitiesDefinition = void 0;
         return visitor._(value.$unknown[0], value.$unknown[1]);
     };
 })(exports.EntitiesDefinition || (exports.EntitiesDefinition = {}));
-const ActionIdentifierFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.actionType && { actionType: smithyClient.SENSITIVE_STRING }),
-    ...(obj.actionId && { actionId: smithyClient.SENSITIVE_STRING }),
-});
-const EntityIdentifierFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.entityType && { entityType: smithyClient.SENSITIVE_STRING }),
-    ...(obj.entityId && { entityId: smithyClient.SENSITIVE_STRING }),
-});
-const StaticPolicyDefinitionDetailFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.description && { description: smithyClient.SENSITIVE_STRING }),
-    ...(obj.statement && { statement: smithyClient.SENSITIVE_STRING }),
-});
-const TemplateLinkedPolicyDefinitionDetailFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.principal && { principal: EntityIdentifierFilterSensitiveLog(obj.principal) }),
-    ...(obj.resource && { resource: EntityIdentifierFilterSensitiveLog(obj.resource) }),
-});
-const PolicyDefinitionDetailFilterSensitiveLog = (obj) => {
-    if (obj.static !== undefined)
-        return { static: StaticPolicyDefinitionDetailFilterSensitiveLog(obj.static) };
-    if (obj.templateLinked !== undefined)
-        return { templateLinked: TemplateLinkedPolicyDefinitionDetailFilterSensitiveLog(obj.templateLinked) };
-    if (obj.$unknown !== undefined)
-        return { [obj.$unknown[0]]: "UNKNOWN" };
-};
-const BatchGetPolicyOutputItemFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.definition && { definition: PolicyDefinitionDetailFilterSensitiveLog(obj.definition) }),
-});
-const BatchGetPolicyOutputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.results && { results: obj.results.map((item) => BatchGetPolicyOutputItemFilterSensitiveLog(item)) }),
-});
-const EvaluationErrorItemFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-const CognitoGroupConfigurationFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.groupEntityType && { groupEntityType: smithyClient.SENSITIVE_STRING }),
-});
-const CognitoGroupConfigurationDetailFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.groupEntityType && { groupEntityType: smithyClient.SENSITIVE_STRING }),
-});
-const CognitoGroupConfigurationItemFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.groupEntityType && { groupEntityType: smithyClient.SENSITIVE_STRING }),
-});
-const CognitoUserPoolConfigurationFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.clientIds && { clientIds: smithyClient.SENSITIVE_STRING }),
-    ...(obj.groupConfiguration && {
-        groupConfiguration: CognitoGroupConfigurationFilterSensitiveLog(obj.groupConfiguration),
-    }),
-});
-const CognitoUserPoolConfigurationDetailFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.clientIds && { clientIds: smithyClient.SENSITIVE_STRING }),
-    ...(obj.groupConfiguration && {
-        groupConfiguration: CognitoGroupConfigurationDetailFilterSensitiveLog(obj.groupConfiguration),
-    }),
-});
-const CognitoUserPoolConfigurationItemFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.clientIds && { clientIds: smithyClient.SENSITIVE_STRING }),
-    ...(obj.groupConfiguration && {
-        groupConfiguration: CognitoGroupConfigurationItemFilterSensitiveLog(obj.groupConfiguration),
-    }),
-});
-const OpenIdConnectGroupConfigurationFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.groupClaim && { groupClaim: smithyClient.SENSITIVE_STRING }),
-    ...(obj.groupEntityType && { groupEntityType: smithyClient.SENSITIVE_STRING }),
-});
-const OpenIdConnectAccessTokenConfigurationFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.principalIdClaim && { principalIdClaim: smithyClient.SENSITIVE_STRING }),
-});
-const OpenIdConnectIdentityTokenConfigurationFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.principalIdClaim && { principalIdClaim: smithyClient.SENSITIVE_STRING }),
-    ...(obj.clientIds && { clientIds: smithyClient.SENSITIVE_STRING }),
-});
-const OpenIdConnectTokenSelectionFilterSensitiveLog = (obj) => {
-    if (obj.accessTokenOnly !== undefined)
-        return { accessTokenOnly: OpenIdConnectAccessTokenConfigurationFilterSensitiveLog(obj.accessTokenOnly) };
-    if (obj.identityTokenOnly !== undefined)
-        return { identityTokenOnly: OpenIdConnectIdentityTokenConfigurationFilterSensitiveLog(obj.identityTokenOnly) };
-    if (obj.$unknown !== undefined)
-        return { [obj.$unknown[0]]: "UNKNOWN" };
-};
-const OpenIdConnectConfigurationFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.entityIdPrefix && { entityIdPrefix: smithyClient.SENSITIVE_STRING }),
-    ...(obj.groupConfiguration && {
-        groupConfiguration: OpenIdConnectGroupConfigurationFilterSensitiveLog(obj.groupConfiguration),
-    }),
-    ...(obj.tokenSelection && { tokenSelection: OpenIdConnectTokenSelectionFilterSensitiveLog(obj.tokenSelection) }),
-});
-const ConfigurationFilterSensitiveLog = (obj) => {
-    if (obj.cognitoUserPoolConfiguration !== undefined)
-        return {
-            cognitoUserPoolConfiguration: CognitoUserPoolConfigurationFilterSensitiveLog(obj.cognitoUserPoolConfiguration),
-        };
-    if (obj.openIdConnectConfiguration !== undefined)
-        return { openIdConnectConfiguration: OpenIdConnectConfigurationFilterSensitiveLog(obj.openIdConnectConfiguration) };
-    if (obj.$unknown !== undefined)
-        return { [obj.$unknown[0]]: "UNKNOWN" };
-};
-const OpenIdConnectGroupConfigurationDetailFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.groupClaim && { groupClaim: smithyClient.SENSITIVE_STRING }),
-    ...(obj.groupEntityType && { groupEntityType: smithyClient.SENSITIVE_STRING }),
-});
-const OpenIdConnectAccessTokenConfigurationDetailFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.principalIdClaim && { principalIdClaim: smithyClient.SENSITIVE_STRING }),
-});
-const OpenIdConnectIdentityTokenConfigurationDetailFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.principalIdClaim && { principalIdClaim: smithyClient.SENSITIVE_STRING }),
-    ...(obj.clientIds && { clientIds: smithyClient.SENSITIVE_STRING }),
-});
-const OpenIdConnectTokenSelectionDetailFilterSensitiveLog = (obj) => {
-    if (obj.accessTokenOnly !== undefined)
-        return { accessTokenOnly: OpenIdConnectAccessTokenConfigurationDetailFilterSensitiveLog(obj.accessTokenOnly) };
-    if (obj.identityTokenOnly !== undefined)
-        return {
-            identityTokenOnly: OpenIdConnectIdentityTokenConfigurationDetailFilterSensitiveLog(obj.identityTokenOnly),
-        };
-    if (obj.$unknown !== undefined)
-        return { [obj.$unknown[0]]: "UNKNOWN" };
-};
-const OpenIdConnectConfigurationDetailFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.entityIdPrefix && { entityIdPrefix: smithyClient.SENSITIVE_STRING }),
-    ...(obj.groupConfiguration && {
-        groupConfiguration: OpenIdConnectGroupConfigurationDetailFilterSensitiveLog(obj.groupConfiguration),
-    }),
-    ...(obj.tokenSelection && {
-        tokenSelection: OpenIdConnectTokenSelectionDetailFilterSensitiveLog(obj.tokenSelection),
-    }),
-});
-const ConfigurationDetailFilterSensitiveLog = (obj) => {
-    if (obj.cognitoUserPoolConfiguration !== undefined)
-        return {
-            cognitoUserPoolConfiguration: CognitoUserPoolConfigurationDetailFilterSensitiveLog(obj.cognitoUserPoolConfiguration),
-        };
-    if (obj.openIdConnectConfiguration !== undefined)
-        return {
-            openIdConnectConfiguration: OpenIdConnectConfigurationDetailFilterSensitiveLog(obj.openIdConnectConfiguration),
-        };
-    if (obj.$unknown !== undefined)
-        return { [obj.$unknown[0]]: "UNKNOWN" };
-};
-const OpenIdConnectGroupConfigurationItemFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.groupClaim && { groupClaim: smithyClient.SENSITIVE_STRING }),
-    ...(obj.groupEntityType && { groupEntityType: smithyClient.SENSITIVE_STRING }),
-});
-const OpenIdConnectAccessTokenConfigurationItemFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.principalIdClaim && { principalIdClaim: smithyClient.SENSITIVE_STRING }),
-});
-const OpenIdConnectIdentityTokenConfigurationItemFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.principalIdClaim && { principalIdClaim: smithyClient.SENSITIVE_STRING }),
-    ...(obj.clientIds && { clientIds: smithyClient.SENSITIVE_STRING }),
-});
-const OpenIdConnectTokenSelectionItemFilterSensitiveLog = (obj) => {
-    if (obj.accessTokenOnly !== undefined)
-        return { accessTokenOnly: OpenIdConnectAccessTokenConfigurationItemFilterSensitiveLog(obj.accessTokenOnly) };
-    if (obj.identityTokenOnly !== undefined)
-        return { identityTokenOnly: OpenIdConnectIdentityTokenConfigurationItemFilterSensitiveLog(obj.identityTokenOnly) };
-    if (obj.$unknown !== undefined)
-        return { [obj.$unknown[0]]: "UNKNOWN" };
-};
-const OpenIdConnectConfigurationItemFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.entityIdPrefix && { entityIdPrefix: smithyClient.SENSITIVE_STRING }),
-    ...(obj.groupConfiguration && {
-        groupConfiguration: OpenIdConnectGroupConfigurationItemFilterSensitiveLog(obj.groupConfiguration),
-    }),
-    ...(obj.tokenSelection && { tokenSelection: OpenIdConnectTokenSelectionItemFilterSensitiveLog(obj.tokenSelection) }),
-});
-const ConfigurationItemFilterSensitiveLog = (obj) => {
-    if (obj.cognitoUserPoolConfiguration !== undefined)
-        return {
-            cognitoUserPoolConfiguration: CognitoUserPoolConfigurationItemFilterSensitiveLog(obj.cognitoUserPoolConfiguration),
-        };
-    if (obj.openIdConnectConfiguration !== undefined)
-        return {
-            openIdConnectConfiguration: OpenIdConnectConfigurationItemFilterSensitiveLog(obj.openIdConnectConfiguration),
-        };
-    if (obj.$unknown !== undefined)
-        return { [obj.$unknown[0]]: "UNKNOWN" };
-};
-const CreateIdentitySourceInputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.configuration && { configuration: ConfigurationFilterSensitiveLog(obj.configuration) }),
-    ...(obj.principalEntityType && { principalEntityType: smithyClient.SENSITIVE_STRING }),
-});
-const StaticPolicyDefinitionFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.description && { description: smithyClient.SENSITIVE_STRING }),
-    ...(obj.statement && { statement: smithyClient.SENSITIVE_STRING }),
-});
-const TemplateLinkedPolicyDefinitionFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.principal && { principal: EntityIdentifierFilterSensitiveLog(obj.principal) }),
-    ...(obj.resource && { resource: EntityIdentifierFilterSensitiveLog(obj.resource) }),
-});
-const PolicyDefinitionFilterSensitiveLog = (obj) => {
-    if (obj.static !== undefined)
-        return { static: StaticPolicyDefinitionFilterSensitiveLog(obj.static) };
-    if (obj.templateLinked !== undefined)
-        return { templateLinked: TemplateLinkedPolicyDefinitionFilterSensitiveLog(obj.templateLinked) };
-    if (obj.$unknown !== undefined)
-        return { [obj.$unknown[0]]: "UNKNOWN" };
-};
-const CreatePolicyInputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.definition && { definition: PolicyDefinitionFilterSensitiveLog(obj.definition) }),
-});
-const CreatePolicyOutputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.principal && { principal: EntityIdentifierFilterSensitiveLog(obj.principal) }),
-    ...(obj.resource && { resource: EntityIdentifierFilterSensitiveLog(obj.resource) }),
-    ...(obj.actions && { actions: obj.actions.map((item) => ActionIdentifierFilterSensitiveLog(item)) }),
-});
-const CreatePolicyStoreInputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.description && { description: smithyClient.SENSITIVE_STRING }),
-});
-const CreatePolicyTemplateInputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.description && { description: smithyClient.SENSITIVE_STRING }),
-    ...(obj.statement && { statement: smithyClient.SENSITIVE_STRING }),
-});
-const EntityReferenceFilterSensitiveLog = (obj) => {
-    if (obj.unspecified !== undefined)
-        return { unspecified: obj.unspecified };
-    if (obj.identifier !== undefined)
-        return { identifier: EntityIdentifierFilterSensitiveLog(obj.identifier) };
-    if (obj.$unknown !== undefined)
-        return { [obj.$unknown[0]]: "UNKNOWN" };
-};
-const IdentitySourceDetailsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.clientIds && { clientIds: smithyClient.SENSITIVE_STRING }),
-});
-const GetIdentitySourceOutputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.details && { details: IdentitySourceDetailsFilterSensitiveLog(obj.details) }),
-    ...(obj.principalEntityType && { principalEntityType: smithyClient.SENSITIVE_STRING }),
-    ...(obj.configuration && { configuration: ConfigurationDetailFilterSensitiveLog(obj.configuration) }),
-});
-const GetPolicyOutputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.principal && { principal: EntityIdentifierFilterSensitiveLog(obj.principal) }),
-    ...(obj.resource && { resource: EntityIdentifierFilterSensitiveLog(obj.resource) }),
-    ...(obj.actions && { actions: obj.actions.map((item) => ActionIdentifierFilterSensitiveLog(item)) }),
-    ...(obj.definition && { definition: PolicyDefinitionDetailFilterSensitiveLog(obj.definition) }),
-});
-const GetPolicyStoreOutputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.description && { description: smithyClient.SENSITIVE_STRING }),
-});
-const GetPolicyTemplateOutputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.description && { description: smithyClient.SENSITIVE_STRING }),
-    ...(obj.statement && { statement: smithyClient.SENSITIVE_STRING }),
-});
-const GetSchemaOutputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.schema && { schema: smithyClient.SENSITIVE_STRING }),
-    ...(obj.namespaces && { namespaces: smithyClient.SENSITIVE_STRING }),
-});
-const IdentitySourceFilterFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.principalEntityType && { principalEntityType: smithyClient.SENSITIVE_STRING }),
-});
-const ListIdentitySourcesInputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.filters && { filters: obj.filters.map((item) => IdentitySourceFilterFilterSensitiveLog(item)) }),
-});
-const IdentitySourceItemDetailsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.clientIds && { clientIds: smithyClient.SENSITIVE_STRING }),
-});
-const IdentitySourceItemFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.details && { details: IdentitySourceItemDetailsFilterSensitiveLog(obj.details) }),
-    ...(obj.principalEntityType && { principalEntityType: smithyClient.SENSITIVE_STRING }),
-    ...(obj.configuration && { configuration: ConfigurationItemFilterSensitiveLog(obj.configuration) }),
-});
-const ListIdentitySourcesOutputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.identitySources && {
-        identitySources: obj.identitySources.map((item) => IdentitySourceItemFilterSensitiveLog(item)),
-    }),
-});
-const UpdateCognitoGroupConfigurationFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.groupEntityType && { groupEntityType: smithyClient.SENSITIVE_STRING }),
-});
-const UpdateCognitoUserPoolConfigurationFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.clientIds && { clientIds: smithyClient.SENSITIVE_STRING }),
-    ...(obj.groupConfiguration && {
-        groupConfiguration: UpdateCognitoGroupConfigurationFilterSensitiveLog(obj.groupConfiguration),
-    }),
-});
-const UpdateOpenIdConnectGroupConfigurationFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.groupClaim && { groupClaim: smithyClient.SENSITIVE_STRING }),
-    ...(obj.groupEntityType && { groupEntityType: smithyClient.SENSITIVE_STRING }),
-});
-const UpdateOpenIdConnectAccessTokenConfigurationFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.principalIdClaim && { principalIdClaim: smithyClient.SENSITIVE_STRING }),
-});
-const UpdateOpenIdConnectIdentityTokenConfigurationFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.principalIdClaim && { principalIdClaim: smithyClient.SENSITIVE_STRING }),
-    ...(obj.clientIds && { clientIds: smithyClient.SENSITIVE_STRING }),
-});
-const UpdateOpenIdConnectTokenSelectionFilterSensitiveLog = (obj) => {
-    if (obj.accessTokenOnly !== undefined)
-        return { accessTokenOnly: UpdateOpenIdConnectAccessTokenConfigurationFilterSensitiveLog(obj.accessTokenOnly) };
-    if (obj.identityTokenOnly !== undefined)
-        return {
-            identityTokenOnly: UpdateOpenIdConnectIdentityTokenConfigurationFilterSensitiveLog(obj.identityTokenOnly),
-        };
-    if (obj.$unknown !== undefined)
-        return { [obj.$unknown[0]]: "UNKNOWN" };
-};
-const UpdateOpenIdConnectConfigurationFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.entityIdPrefix && { entityIdPrefix: smithyClient.SENSITIVE_STRING }),
-    ...(obj.groupConfiguration && {
-        groupConfiguration: UpdateOpenIdConnectGroupConfigurationFilterSensitiveLog(obj.groupConfiguration),
-    }),
-    ...(obj.tokenSelection && {
-        tokenSelection: UpdateOpenIdConnectTokenSelectionFilterSensitiveLog(obj.tokenSelection),
-    }),
-});
-const UpdateConfigurationFilterSensitiveLog = (obj) => {
-    if (obj.cognitoUserPoolConfiguration !== undefined)
-        return {
-            cognitoUserPoolConfiguration: UpdateCognitoUserPoolConfigurationFilterSensitiveLog(obj.cognitoUserPoolConfiguration),
-        };
-    if (obj.openIdConnectConfiguration !== undefined)
-        return {
-            openIdConnectConfiguration: UpdateOpenIdConnectConfigurationFilterSensitiveLog(obj.openIdConnectConfiguration),
-        };
-    if (obj.$unknown !== undefined)
-        return { [obj.$unknown[0]]: "UNKNOWN" };
-};
-const UpdateIdentitySourceInputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.updateConfiguration && {
-        updateConfiguration: UpdateConfigurationFilterSensitiveLog(obj.updateConfiguration),
-    }),
-    ...(obj.principalEntityType && { principalEntityType: smithyClient.SENSITIVE_STRING }),
-});
-const IsAuthorizedOutputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.errors && { errors: smithyClient.SENSITIVE_STRING }),
-});
-const IsAuthorizedWithTokenOutputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.errors && { errors: smithyClient.SENSITIVE_STRING }),
-    ...(obj.principal && { principal: EntityIdentifierFilterSensitiveLog(obj.principal) }),
-});
-const PolicyFilterFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.principal && { principal: EntityReferenceFilterSensitiveLog(obj.principal) }),
-    ...(obj.resource && { resource: EntityReferenceFilterSensitiveLog(obj.resource) }),
-});
-const ListPoliciesInputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.filter && { filter: PolicyFilterFilterSensitiveLog(obj.filter) }),
-});
-const StaticPolicyDefinitionItemFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.description && { description: smithyClient.SENSITIVE_STRING }),
-});
-const TemplateLinkedPolicyDefinitionItemFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.principal && { principal: EntityIdentifierFilterSensitiveLog(obj.principal) }),
-    ...(obj.resource && { resource: EntityIdentifierFilterSensitiveLog(obj.resource) }),
-});
-const PolicyDefinitionItemFilterSensitiveLog = (obj) => {
-    if (obj.static !== undefined)
-        return { static: StaticPolicyDefinitionItemFilterSensitiveLog(obj.static) };
-    if (obj.templateLinked !== undefined)
-        return { templateLinked: TemplateLinkedPolicyDefinitionItemFilterSensitiveLog(obj.templateLinked) };
-    if (obj.$unknown !== undefined)
-        return { [obj.$unknown[0]]: "UNKNOWN" };
-};
-const PolicyItemFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.principal && { principal: EntityIdentifierFilterSensitiveLog(obj.principal) }),
-    ...(obj.resource && { resource: EntityIdentifierFilterSensitiveLog(obj.resource) }),
-    ...(obj.actions && { actions: obj.actions.map((item) => ActionIdentifierFilterSensitiveLog(item)) }),
-    ...(obj.definition && { definition: PolicyDefinitionItemFilterSensitiveLog(obj.definition) }),
-});
-const ListPoliciesOutputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.policies && { policies: obj.policies.map((item) => PolicyItemFilterSensitiveLog(item)) }),
-});
-const PolicyStoreItemFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.description && { description: smithyClient.SENSITIVE_STRING }),
-});
-const ListPolicyStoresOutputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.policyStores && { policyStores: obj.policyStores.map((item) => PolicyStoreItemFilterSensitiveLog(item)) }),
-});
-const PolicyTemplateItemFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.description && { description: smithyClient.SENSITIVE_STRING }),
-});
-const ListPolicyTemplatesOutputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.policyTemplates && {
-        policyTemplates: obj.policyTemplates.map((item) => PolicyTemplateItemFilterSensitiveLog(item)),
-    }),
-});
-const UpdateStaticPolicyDefinitionFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.description && { description: smithyClient.SENSITIVE_STRING }),
-    ...(obj.statement && { statement: smithyClient.SENSITIVE_STRING }),
-});
-const UpdatePolicyDefinitionFilterSensitiveLog = (obj) => {
-    if (obj.static !== undefined)
-        return { static: UpdateStaticPolicyDefinitionFilterSensitiveLog(obj.static) };
-    if (obj.$unknown !== undefined)
-        return { [obj.$unknown[0]]: "UNKNOWN" };
-};
-const UpdatePolicyInputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.definition && { definition: UpdatePolicyDefinitionFilterSensitiveLog(obj.definition) }),
-});
-const UpdatePolicyOutputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.principal && { principal: EntityIdentifierFilterSensitiveLog(obj.principal) }),
-    ...(obj.resource && { resource: EntityIdentifierFilterSensitiveLog(obj.resource) }),
-    ...(obj.actions && { actions: obj.actions.map((item) => ActionIdentifierFilterSensitiveLog(item)) }),
-});
-const UpdatePolicyTemplateInputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.description && { description: smithyClient.SENSITIVE_STRING }),
-    ...(obj.statement && { statement: smithyClient.SENSITIVE_STRING }),
-});
-const SchemaDefinitionFilterSensitiveLog = (obj) => {
-    if (obj.cedarJson !== undefined)
-        return { cedarJson: smithyClient.SENSITIVE_STRING };
-    if (obj.$unknown !== undefined)
-        return { [obj.$unknown[0]]: "UNKNOWN" };
-};
-const PutSchemaInputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.definition && { definition: SchemaDefinitionFilterSensitiveLog(obj.definition) }),
-});
-const PutSchemaOutputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.namespaces && { namespaces: smithyClient.SENSITIVE_STRING }),
-});
-const UpdatePolicyStoreInputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.description && { description: smithyClient.SENSITIVE_STRING }),
-});
-const AttributeValueFilterSensitiveLog = (obj) => {
-    if (obj.boolean !== undefined)
-        return { boolean: smithyClient.SENSITIVE_STRING };
-    if (obj.entityIdentifier !== undefined)
-        return { entityIdentifier: EntityIdentifierFilterSensitiveLog(obj.entityIdentifier) };
-    if (obj.long !== undefined)
-        return { long: smithyClient.SENSITIVE_STRING };
-    if (obj.string !== undefined)
-        return { string: smithyClient.SENSITIVE_STRING };
-    if (obj.set !== undefined)
-        return { set: obj.set.map((item) => AttributeValueFilterSensitiveLog(item)) };
-    if (obj.record !== undefined)
-        return {
-            record: Object.entries(obj.record).reduce((acc, [key, value]) => ((acc[key] = AttributeValueFilterSensitiveLog(value)), acc), {}),
-        };
-    if (obj.ipaddr !== undefined)
-        return { ipaddr: smithyClient.SENSITIVE_STRING };
-    if (obj.decimal !== undefined)
-        return { decimal: smithyClient.SENSITIVE_STRING };
-    if (obj.datetime !== undefined)
-        return { datetime: smithyClient.SENSITIVE_STRING };
-    if (obj.duration !== undefined)
-        return { duration: smithyClient.SENSITIVE_STRING };
-    if (obj.$unknown !== undefined)
-        return { [obj.$unknown[0]]: "UNKNOWN" };
-};
-const ContextDefinitionFilterSensitiveLog = (obj) => {
-    if (obj.contextMap !== undefined)
-        return { contextMap: smithyClient.SENSITIVE_STRING };
-    if (obj.cedarJson !== undefined)
-        return { cedarJson: smithyClient.SENSITIVE_STRING };
-    if (obj.$unknown !== undefined)
-        return { [obj.$unknown[0]]: "UNKNOWN" };
-};
-const EntityItemFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.identifier && { identifier: EntityIdentifierFilterSensitiveLog(obj.identifier) }),
-    ...(obj.attributes && {
-        attributes: Object.entries(obj.attributes).reduce((acc, [key, value]) => ((acc[key] = AttributeValueFilterSensitiveLog(value)), acc), {}),
-    }),
-    ...(obj.parents && { parents: obj.parents.map((item) => EntityIdentifierFilterSensitiveLog(item)) }),
-});
-const BatchIsAuthorizedInputItemFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.principal && { principal: EntityIdentifierFilterSensitiveLog(obj.principal) }),
-    ...(obj.action && { action: ActionIdentifierFilterSensitiveLog(obj.action) }),
-    ...(obj.resource && { resource: EntityIdentifierFilterSensitiveLog(obj.resource) }),
-    ...(obj.context && { context: ContextDefinitionFilterSensitiveLog(obj.context) }),
-});
-const BatchIsAuthorizedWithTokenInputItemFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.action && { action: ActionIdentifierFilterSensitiveLog(obj.action) }),
-    ...(obj.resource && { resource: EntityIdentifierFilterSensitiveLog(obj.resource) }),
-    ...(obj.context && { context: ContextDefinitionFilterSensitiveLog(obj.context) }),
-});
-const BatchIsAuthorizedOutputItemFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.request && { request: BatchIsAuthorizedInputItemFilterSensitiveLog(obj.request) }),
-    ...(obj.errors && { errors: smithyClient.SENSITIVE_STRING }),
-});
-const BatchIsAuthorizedWithTokenOutputItemFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.request && { request: BatchIsAuthorizedWithTokenInputItemFilterSensitiveLog(obj.request) }),
-    ...(obj.errors && { errors: smithyClient.SENSITIVE_STRING }),
-});
-const EntitiesDefinitionFilterSensitiveLog = (obj) => {
-    if (obj.entityList !== undefined)
-        return { entityList: obj.entityList.map((item) => EntityItemFilterSensitiveLog(item)) };
-    if (obj.cedarJson !== undefined)
-        return { cedarJson: smithyClient.SENSITIVE_STRING };
-    if (obj.$unknown !== undefined)
-        return { [obj.$unknown[0]]: "UNKNOWN" };
-};
-const BatchIsAuthorizedOutputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.results && { results: obj.results.map((item) => BatchIsAuthorizedOutputItemFilterSensitiveLog(item)) }),
-});
-const BatchIsAuthorizedWithTokenOutputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.principal && { principal: EntityIdentifierFilterSensitiveLog(obj.principal) }),
-    ...(obj.results && {
-        results: obj.results.map((item) => BatchIsAuthorizedWithTokenOutputItemFilterSensitiveLog(item)),
-    }),
-});
-const IsAuthorizedInputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.principal && { principal: EntityIdentifierFilterSensitiveLog(obj.principal) }),
-    ...(obj.action && { action: ActionIdentifierFilterSensitiveLog(obj.action) }),
-    ...(obj.resource && { resource: EntityIdentifierFilterSensitiveLog(obj.resource) }),
-    ...(obj.context && { context: ContextDefinitionFilterSensitiveLog(obj.context) }),
-    ...(obj.entities && { entities: EntitiesDefinitionFilterSensitiveLog(obj.entities) }),
-});
-const IsAuthorizedWithTokenInputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.identityToken && { identityToken: smithyClient.SENSITIVE_STRING }),
-    ...(obj.accessToken && { accessToken: smithyClient.SENSITIVE_STRING }),
-    ...(obj.action && { action: ActionIdentifierFilterSensitiveLog(obj.action) }),
-    ...(obj.resource && { resource: EntityIdentifierFilterSensitiveLog(obj.resource) }),
-    ...(obj.context && { context: ContextDefinitionFilterSensitiveLog(obj.context) }),
-    ...(obj.entities && { entities: EntitiesDefinitionFilterSensitiveLog(obj.entities) }),
-});
-const BatchIsAuthorizedInputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.entities && { entities: EntitiesDefinitionFilterSensitiveLog(obj.entities) }),
-    ...(obj.requests && { requests: obj.requests.map((item) => BatchIsAuthorizedInputItemFilterSensitiveLog(item)) }),
-});
-const BatchIsAuthorizedWithTokenInputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.identityToken && { identityToken: smithyClient.SENSITIVE_STRING }),
-    ...(obj.accessToken && { accessToken: smithyClient.SENSITIVE_STRING }),
-    ...(obj.entities && { entities: EntitiesDefinitionFilterSensitiveLog(obj.entities) }),
-    ...(obj.requests && {
-        requests: obj.requests.map((item) => BatchIsAuthorizedWithTokenInputItemFilterSensitiveLog(item)),
-    }),
-});
 
-const se_BatchGetPolicyCommand = async (input, context) => {
-    const headers = sharedHeaders("BatchGetPolicy");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_BatchIsAuthorizedCommand = async (input, context) => {
-    const headers = sharedHeaders("BatchIsAuthorized");
-    let body;
-    body = JSON.stringify(se_BatchIsAuthorizedInput(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_BatchIsAuthorizedWithTokenCommand = async (input, context) => {
-    const headers = sharedHeaders("BatchIsAuthorizedWithToken");
-    let body;
-    body = JSON.stringify(se_BatchIsAuthorizedWithTokenInput(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_CreateIdentitySourceCommand = async (input, context) => {
-    const headers = sharedHeaders("CreateIdentitySource");
-    let body;
-    body = JSON.stringify(se_CreateIdentitySourceInput(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_CreatePolicyCommand = async (input, context) => {
-    const headers = sharedHeaders("CreatePolicy");
-    let body;
-    body = JSON.stringify(se_CreatePolicyInput(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_CreatePolicyStoreCommand = async (input, context) => {
-    const headers = sharedHeaders("CreatePolicyStore");
-    let body;
-    body = JSON.stringify(se_CreatePolicyStoreInput(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_CreatePolicyTemplateCommand = async (input, context) => {
-    const headers = sharedHeaders("CreatePolicyTemplate");
-    let body;
-    body = JSON.stringify(se_CreatePolicyTemplateInput(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DeleteIdentitySourceCommand = async (input, context) => {
-    const headers = sharedHeaders("DeleteIdentitySource");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DeletePolicyCommand = async (input, context) => {
-    const headers = sharedHeaders("DeletePolicy");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DeletePolicyStoreCommand = async (input, context) => {
-    const headers = sharedHeaders("DeletePolicyStore");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DeletePolicyTemplateCommand = async (input, context) => {
-    const headers = sharedHeaders("DeletePolicyTemplate");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_GetIdentitySourceCommand = async (input, context) => {
-    const headers = sharedHeaders("GetIdentitySource");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_GetPolicyCommand = async (input, context) => {
-    const headers = sharedHeaders("GetPolicy");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_GetPolicyStoreCommand = async (input, context) => {
-    const headers = sharedHeaders("GetPolicyStore");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_GetPolicyTemplateCommand = async (input, context) => {
-    const headers = sharedHeaders("GetPolicyTemplate");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_GetSchemaCommand = async (input, context) => {
-    const headers = sharedHeaders("GetSchema");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_IsAuthorizedCommand = async (input, context) => {
-    const headers = sharedHeaders("IsAuthorized");
-    let body;
-    body = JSON.stringify(se_IsAuthorizedInput(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_IsAuthorizedWithTokenCommand = async (input, context) => {
-    const headers = sharedHeaders("IsAuthorizedWithToken");
-    let body;
-    body = JSON.stringify(se_IsAuthorizedWithTokenInput(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_ListIdentitySourcesCommand = async (input, context) => {
-    const headers = sharedHeaders("ListIdentitySources");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_ListPoliciesCommand = async (input, context) => {
-    const headers = sharedHeaders("ListPolicies");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_ListPolicyStoresCommand = async (input, context) => {
-    const headers = sharedHeaders("ListPolicyStores");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_ListPolicyTemplatesCommand = async (input, context) => {
-    const headers = sharedHeaders("ListPolicyTemplates");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_ListTagsForResourceCommand = async (input, context) => {
-    const headers = sharedHeaders("ListTagsForResource");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_PutSchemaCommand = async (input, context) => {
-    const headers = sharedHeaders("PutSchema");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_TagResourceCommand = async (input, context) => {
-    const headers = sharedHeaders("TagResource");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_UntagResourceCommand = async (input, context) => {
-    const headers = sharedHeaders("UntagResource");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_UpdateIdentitySourceCommand = async (input, context) => {
-    const headers = sharedHeaders("UpdateIdentitySource");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_UpdatePolicyCommand = async (input, context) => {
-    const headers = sharedHeaders("UpdatePolicy");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_UpdatePolicyStoreCommand = async (input, context) => {
-    const headers = sharedHeaders("UpdatePolicyStore");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_UpdatePolicyTemplateCommand = async (input, context) => {
-    const headers = sharedHeaders("UpdatePolicyTemplate");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const de_BatchGetPolicyCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_BatchGetPolicyOutput(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_BatchIsAuthorizedCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_BatchIsAuthorizedOutput(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_BatchIsAuthorizedWithTokenCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_BatchIsAuthorizedWithTokenOutput(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_CreateIdentitySourceCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_CreateIdentitySourceOutput(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_CreatePolicyCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_CreatePolicyOutput(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_CreatePolicyStoreCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_CreatePolicyStoreOutput(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_CreatePolicyTemplateCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_CreatePolicyTemplateOutput(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DeleteIdentitySourceCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DeletePolicyCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DeletePolicyStoreCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DeletePolicyTemplateCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_GetIdentitySourceCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_GetIdentitySourceOutput(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_GetPolicyCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_GetPolicyOutput(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_GetPolicyStoreCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_GetPolicyStoreOutput(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_GetPolicyTemplateCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_GetPolicyTemplateOutput(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_GetSchemaCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_GetSchemaOutput(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_IsAuthorizedCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_IsAuthorizedWithTokenCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_ListIdentitySourcesCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_ListIdentitySourcesOutput(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_ListPoliciesCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_ListPoliciesOutput(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_ListPolicyStoresCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_ListPolicyStoresOutput(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_ListPolicyTemplatesCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_ListPolicyTemplatesOutput(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_ListTagsForResourceCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_PutSchemaCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_PutSchemaOutput(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_TagResourceCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_UntagResourceCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_UpdateIdentitySourceCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_UpdateIdentitySourceOutput(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_UpdatePolicyCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_UpdatePolicyOutput(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_UpdatePolicyStoreCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_UpdatePolicyStoreOutput(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_UpdatePolicyTemplateCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_UpdatePolicyTemplateOutput(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_CommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await core$1.parseJsonErrorBody(output.body, context),
-    };
-    const errorCode = core$1.loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "AccessDeniedException":
-        case "com.amazonaws.verifiedpermissions#AccessDeniedException":
-            throw await de_AccessDeniedExceptionRes(parsedOutput);
-        case "InternalServerException":
-        case "com.amazonaws.verifiedpermissions#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput);
-        case "ThrottlingException":
-        case "com.amazonaws.verifiedpermissions#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput);
-        case "ValidationException":
-        case "com.amazonaws.verifiedpermissions#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.verifiedpermissions#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput);
-        case "ConflictException":
-        case "com.amazonaws.verifiedpermissions#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.verifiedpermissions#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput);
-        case "InvalidStateException":
-        case "com.amazonaws.verifiedpermissions#InvalidStateException":
-            throw await de_InvalidStateExceptionRes(parsedOutput);
-        case "TooManyTagsException":
-        case "com.amazonaws.verifiedpermissions#TooManyTagsException":
-            throw await de_TooManyTagsExceptionRes(parsedOutput);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-const de_AccessDeniedExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new AccessDeniedException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_ConflictExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new ConflictException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_InternalServerExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new InternalServerException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_InvalidStateExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new InvalidStateException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_ResourceNotFoundExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new ResourceNotFoundException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_ServiceQuotaExceededExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new ServiceQuotaExceededException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_ThrottlingExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new ThrottlingException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_TooManyTagsExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new TooManyTagsException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_ValidationExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new ValidationException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const se_AttributeValue = (input, context) => {
-    return exports.AttributeValue.visit(input, {
-        boolean: (value) => ({ boolean: value }),
-        datetime: (value) => ({ datetime: value }),
-        decimal: (value) => ({ decimal: value }),
-        duration: (value) => ({ duration: value }),
-        entityIdentifier: (value) => ({ entityIdentifier: smithyClient._json(value) }),
-        ipaddr: (value) => ({ ipaddr: value }),
-        long: (value) => ({ long: value }),
-        record: (value) => ({ record: se_RecordAttribute(value) }),
-        set: (value) => ({ set: se_SetAttribute(value) }),
-        string: (value) => ({ string: value }),
-        _: (name, value) => ({ [name]: value }),
-    });
-};
-const se_BatchIsAuthorizedInput = (input, context) => {
-    return smithyClient.take(input, {
-        entities: (_) => se_EntitiesDefinition(_),
-        policyStoreId: [],
-        requests: (_) => se_BatchIsAuthorizedInputList(_),
-    });
-};
-const se_BatchIsAuthorizedInputItem = (input, context) => {
-    return smithyClient.take(input, {
-        action: smithyClient._json,
-        context: (_) => se_ContextDefinition(_),
-        principal: smithyClient._json,
-        resource: smithyClient._json,
-    });
-};
-const se_BatchIsAuthorizedInputList = (input, context) => {
-    return input
-        .filter((e) => e != null)
-        .map((entry) => {
-        return se_BatchIsAuthorizedInputItem(entry);
-    });
-};
-const se_BatchIsAuthorizedWithTokenInput = (input, context) => {
-    return smithyClient.take(input, {
-        accessToken: [],
-        entities: (_) => se_EntitiesDefinition(_),
-        identityToken: [],
-        policyStoreId: [],
-        requests: (_) => se_BatchIsAuthorizedWithTokenInputList(_),
-    });
-};
-const se_BatchIsAuthorizedWithTokenInputItem = (input, context) => {
-    return smithyClient.take(input, {
-        action: smithyClient._json,
-        context: (_) => se_ContextDefinition(_),
-        resource: smithyClient._json,
-    });
-};
-const se_BatchIsAuthorizedWithTokenInputList = (input, context) => {
-    return input
-        .filter((e) => e != null)
-        .map((entry) => {
-        return se_BatchIsAuthorizedWithTokenInputItem(entry);
-    });
-};
-const se_ContextDefinition = (input, context) => {
-    return exports.ContextDefinition.visit(input, {
-        cedarJson: (value) => ({ cedarJson: value }),
-        contextMap: (value) => ({ contextMap: se_ContextMap(value) }),
-        _: (name, value) => ({ [name]: value }),
-    });
-};
-const se_ContextMap = (input, context) => {
-    return Object.entries(input).reduce((acc, [key, value]) => {
-        if (value === null) {
-            return acc;
-        }
-        acc[key] = se_AttributeValue(value);
-        return acc;
-    }, {});
-};
-const se_CreateIdentitySourceInput = (input, context) => {
-    return smithyClient.take(input, {
-        clientToken: [true, (_) => _ ?? uuid.v4()],
-        configuration: smithyClient._json,
-        policyStoreId: [],
-        principalEntityType: [],
-    });
-};
-const se_CreatePolicyInput = (input, context) => {
-    return smithyClient.take(input, {
-        clientToken: [true, (_) => _ ?? uuid.v4()],
-        definition: smithyClient._json,
-        policyStoreId: [],
-    });
-};
-const se_CreatePolicyStoreInput = (input, context) => {
-    return smithyClient.take(input, {
-        clientToken: [true, (_) => _ ?? uuid.v4()],
-        deletionProtection: [],
-        description: [],
-        tags: smithyClient._json,
-        validationSettings: smithyClient._json,
-    });
-};
-const se_CreatePolicyTemplateInput = (input, context) => {
-    return smithyClient.take(input, {
-        clientToken: [true, (_) => _ ?? uuid.v4()],
-        description: [],
-        policyStoreId: [],
-        statement: [],
-    });
-};
-const se_EntitiesDefinition = (input, context) => {
-    return exports.EntitiesDefinition.visit(input, {
-        cedarJson: (value) => ({ cedarJson: value }),
-        entityList: (value) => ({ entityList: se_EntityList(value) }),
-        _: (name, value) => ({ [name]: value }),
-    });
-};
-const se_EntityAttributes = (input, context) => {
-    return Object.entries(input).reduce((acc, [key, value]) => {
-        if (value === null) {
-            return acc;
-        }
-        acc[key] = se_AttributeValue(value);
-        return acc;
-    }, {});
-};
-const se_EntityItem = (input, context) => {
-    return smithyClient.take(input, {
-        attributes: (_) => se_EntityAttributes(_),
-        identifier: smithyClient._json,
-        parents: smithyClient._json,
-    });
-};
-const se_EntityList = (input, context) => {
-    return input
-        .filter((e) => e != null)
-        .map((entry) => {
-        return se_EntityItem(entry);
-    });
-};
-const se_IsAuthorizedInput = (input, context) => {
-    return smithyClient.take(input, {
-        action: smithyClient._json,
-        context: (_) => se_ContextDefinition(_),
-        entities: (_) => se_EntitiesDefinition(_),
-        policyStoreId: [],
-        principal: smithyClient._json,
-        resource: smithyClient._json,
-    });
-};
-const se_IsAuthorizedWithTokenInput = (input, context) => {
-    return smithyClient.take(input, {
-        accessToken: [],
-        action: smithyClient._json,
-        context: (_) => se_ContextDefinition(_),
-        entities: (_) => se_EntitiesDefinition(_),
-        identityToken: [],
-        policyStoreId: [],
-        resource: smithyClient._json,
-    });
-};
-const se_RecordAttribute = (input, context) => {
-    return Object.entries(input).reduce((acc, [key, value]) => {
-        if (value === null) {
-            return acc;
-        }
-        acc[key] = se_AttributeValue(value);
-        return acc;
-    }, {});
-};
-const se_SetAttribute = (input, context) => {
-    return input
-        .filter((e) => e != null)
-        .map((entry) => {
-        return se_AttributeValue(entry);
-    });
-};
-const de_AttributeValue = (output, context) => {
-    if (smithyClient.expectBoolean(output.boolean) !== undefined) {
-        return { boolean: smithyClient.expectBoolean(output.boolean) };
-    }
-    if (smithyClient.expectString(output.datetime) !== undefined) {
-        return { datetime: smithyClient.expectString(output.datetime) };
-    }
-    if (smithyClient.expectString(output.decimal) !== undefined) {
-        return { decimal: smithyClient.expectString(output.decimal) };
-    }
-    if (smithyClient.expectString(output.duration) !== undefined) {
-        return { duration: smithyClient.expectString(output.duration) };
-    }
-    if (output.entityIdentifier != null) {
-        return {
-            entityIdentifier: smithyClient._json(output.entityIdentifier),
-        };
-    }
-    if (smithyClient.expectString(output.ipaddr) !== undefined) {
-        return { ipaddr: smithyClient.expectString(output.ipaddr) };
-    }
-    if (smithyClient.expectLong(output.long) !== undefined) {
-        return { long: smithyClient.expectLong(output.long) };
-    }
-    if (output.record != null) {
-        return {
-            record: de_RecordAttribute(output.record),
-        };
-    }
-    if (output.set != null) {
-        return {
-            set: de_SetAttribute(output.set),
-        };
-    }
-    if (smithyClient.expectString(output.string) !== undefined) {
-        return { string: smithyClient.expectString(output.string) };
-    }
-    return { $unknown: Object.entries(output)[0] };
-};
-const de_BatchGetPolicyOutput = (output, context) => {
-    return smithyClient.take(output, {
-        errors: smithyClient._json,
-        results: (_) => de_BatchGetPolicyOutputList(_),
-    });
-};
-const de_BatchGetPolicyOutputItem = (output, context) => {
-    return smithyClient.take(output, {
-        createdDate: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        definition: (_) => smithyClient._json(core$1.awsExpectUnion(_)),
-        lastUpdatedDate: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        policyId: smithyClient.expectString,
-        policyStoreId: smithyClient.expectString,
-        policyType: smithyClient.expectString,
-    });
-};
-const de_BatchGetPolicyOutputList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_BatchGetPolicyOutputItem(entry);
-    });
-    return retVal;
-};
-const de_BatchIsAuthorizedInputItem = (output, context) => {
-    return smithyClient.take(output, {
-        action: smithyClient._json,
-        context: (_) => de_ContextDefinition(core$1.awsExpectUnion(_)),
-        principal: smithyClient._json,
-        resource: smithyClient._json,
-    });
-};
-const de_BatchIsAuthorizedOutput = (output, context) => {
-    return smithyClient.take(output, {
-        results: (_) => de_BatchIsAuthorizedOutputList(_),
-    });
-};
-const de_BatchIsAuthorizedOutputItem = (output, context) => {
-    return smithyClient.take(output, {
-        decision: smithyClient.expectString,
-        determiningPolicies: smithyClient._json,
-        errors: smithyClient._json,
-        request: (_) => de_BatchIsAuthorizedInputItem(_),
-    });
-};
-const de_BatchIsAuthorizedOutputList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_BatchIsAuthorizedOutputItem(entry);
-    });
-    return retVal;
-};
-const de_BatchIsAuthorizedWithTokenInputItem = (output, context) => {
-    return smithyClient.take(output, {
-        action: smithyClient._json,
-        context: (_) => de_ContextDefinition(core$1.awsExpectUnion(_)),
-        resource: smithyClient._json,
-    });
-};
-const de_BatchIsAuthorizedWithTokenOutput = (output, context) => {
-    return smithyClient.take(output, {
-        principal: smithyClient._json,
-        results: (_) => de_BatchIsAuthorizedWithTokenOutputList(_),
-    });
-};
-const de_BatchIsAuthorizedWithTokenOutputItem = (output, context) => {
-    return smithyClient.take(output, {
-        decision: smithyClient.expectString,
-        determiningPolicies: smithyClient._json,
-        errors: smithyClient._json,
-        request: (_) => de_BatchIsAuthorizedWithTokenInputItem(_),
-    });
-};
-const de_BatchIsAuthorizedWithTokenOutputList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_BatchIsAuthorizedWithTokenOutputItem(entry);
-    });
-    return retVal;
-};
-const de_ContextDefinition = (output, context) => {
-    if (smithyClient.expectString(output.cedarJson) !== undefined) {
-        return { cedarJson: smithyClient.expectString(output.cedarJson) };
-    }
-    if (output.contextMap != null) {
-        return {
-            contextMap: de_ContextMap(output.contextMap),
-        };
-    }
-    return { $unknown: Object.entries(output)[0] };
-};
-const de_ContextMap = (output, context) => {
-    return Object.entries(output).reduce((acc, [key, value]) => {
-        if (value === null) {
-            return acc;
-        }
-        acc[key] = de_AttributeValue(core$1.awsExpectUnion(value));
-        return acc;
-    }, {});
-};
-const de_CreateIdentitySourceOutput = (output, context) => {
-    return smithyClient.take(output, {
-        createdDate: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        identitySourceId: smithyClient.expectString,
-        lastUpdatedDate: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        policyStoreId: smithyClient.expectString,
-    });
-};
-const de_CreatePolicyOutput = (output, context) => {
-    return smithyClient.take(output, {
-        actions: smithyClient._json,
-        createdDate: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        effect: smithyClient.expectString,
-        lastUpdatedDate: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        policyId: smithyClient.expectString,
-        policyStoreId: smithyClient.expectString,
-        policyType: smithyClient.expectString,
-        principal: smithyClient._json,
-        resource: smithyClient._json,
-    });
-};
-const de_CreatePolicyStoreOutput = (output, context) => {
-    return smithyClient.take(output, {
-        arn: smithyClient.expectString,
-        createdDate: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        lastUpdatedDate: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        policyStoreId: smithyClient.expectString,
-    });
-};
-const de_CreatePolicyTemplateOutput = (output, context) => {
-    return smithyClient.take(output, {
-        createdDate: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        lastUpdatedDate: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        policyStoreId: smithyClient.expectString,
-        policyTemplateId: smithyClient.expectString,
-    });
-};
-const de_GetIdentitySourceOutput = (output, context) => {
-    return smithyClient.take(output, {
-        configuration: (_) => smithyClient._json(core$1.awsExpectUnion(_)),
-        createdDate: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        details: smithyClient._json,
-        identitySourceId: smithyClient.expectString,
-        lastUpdatedDate: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        policyStoreId: smithyClient.expectString,
-        principalEntityType: smithyClient.expectString,
-    });
-};
-const de_GetPolicyOutput = (output, context) => {
-    return smithyClient.take(output, {
-        actions: smithyClient._json,
-        createdDate: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        definition: (_) => smithyClient._json(core$1.awsExpectUnion(_)),
-        effect: smithyClient.expectString,
-        lastUpdatedDate: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        policyId: smithyClient.expectString,
-        policyStoreId: smithyClient.expectString,
-        policyType: smithyClient.expectString,
-        principal: smithyClient._json,
-        resource: smithyClient._json,
-    });
-};
-const de_GetPolicyStoreOutput = (output, context) => {
-    return smithyClient.take(output, {
-        arn: smithyClient.expectString,
-        cedarVersion: smithyClient.expectString,
-        createdDate: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        deletionProtection: smithyClient.expectString,
-        description: smithyClient.expectString,
-        lastUpdatedDate: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        policyStoreId: smithyClient.expectString,
-        tags: smithyClient._json,
-        validationSettings: smithyClient._json,
-    });
-};
-const de_GetPolicyTemplateOutput = (output, context) => {
-    return smithyClient.take(output, {
-        createdDate: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        description: smithyClient.expectString,
-        lastUpdatedDate: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        policyStoreId: smithyClient.expectString,
-        policyTemplateId: smithyClient.expectString,
-        statement: smithyClient.expectString,
-    });
-};
-const de_GetSchemaOutput = (output, context) => {
-    return smithyClient.take(output, {
-        createdDate: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        lastUpdatedDate: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        namespaces: smithyClient._json,
-        policyStoreId: smithyClient.expectString,
-        schema: smithyClient.expectString,
-    });
-};
-const de_IdentitySourceItem = (output, context) => {
-    return smithyClient.take(output, {
-        configuration: (_) => smithyClient._json(core$1.awsExpectUnion(_)),
-        createdDate: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        details: smithyClient._json,
-        identitySourceId: smithyClient.expectString,
-        lastUpdatedDate: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        policyStoreId: smithyClient.expectString,
-        principalEntityType: smithyClient.expectString,
-    });
-};
-const de_IdentitySources = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_IdentitySourceItem(entry);
-    });
-    return retVal;
-};
-const de_ListIdentitySourcesOutput = (output, context) => {
-    return smithyClient.take(output, {
-        identitySources: (_) => de_IdentitySources(_),
-        nextToken: smithyClient.expectString,
-    });
-};
-const de_ListPoliciesOutput = (output, context) => {
-    return smithyClient.take(output, {
-        nextToken: smithyClient.expectString,
-        policies: (_) => de_PolicyList(_),
-    });
-};
-const de_ListPolicyStoresOutput = (output, context) => {
-    return smithyClient.take(output, {
-        nextToken: smithyClient.expectString,
-        policyStores: (_) => de_PolicyStoreList(_),
-    });
-};
-const de_ListPolicyTemplatesOutput = (output, context) => {
-    return smithyClient.take(output, {
-        nextToken: smithyClient.expectString,
-        policyTemplates: (_) => de_PolicyTemplatesList(_),
-    });
-};
-const de_PolicyItem = (output, context) => {
-    return smithyClient.take(output, {
-        actions: smithyClient._json,
-        createdDate: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        definition: (_) => smithyClient._json(core$1.awsExpectUnion(_)),
-        effect: smithyClient.expectString,
-        lastUpdatedDate: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        policyId: smithyClient.expectString,
-        policyStoreId: smithyClient.expectString,
-        policyType: smithyClient.expectString,
-        principal: smithyClient._json,
-        resource: smithyClient._json,
-    });
-};
-const de_PolicyList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_PolicyItem(entry);
-    });
-    return retVal;
-};
-const de_PolicyStoreItem = (output, context) => {
-    return smithyClient.take(output, {
-        arn: smithyClient.expectString,
-        createdDate: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        description: smithyClient.expectString,
-        lastUpdatedDate: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        policyStoreId: smithyClient.expectString,
-    });
-};
-const de_PolicyStoreList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_PolicyStoreItem(entry);
-    });
-    return retVal;
-};
-const de_PolicyTemplateItem = (output, context) => {
-    return smithyClient.take(output, {
-        createdDate: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        description: smithyClient.expectString,
-        lastUpdatedDate: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        policyStoreId: smithyClient.expectString,
-        policyTemplateId: smithyClient.expectString,
-    });
-};
-const de_PolicyTemplatesList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_PolicyTemplateItem(entry);
-    });
-    return retVal;
-};
-const de_PutSchemaOutput = (output, context) => {
-    return smithyClient.take(output, {
-        createdDate: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        lastUpdatedDate: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        namespaces: smithyClient._json,
-        policyStoreId: smithyClient.expectString,
-    });
-};
-const de_RecordAttribute = (output, context) => {
-    return Object.entries(output).reduce((acc, [key, value]) => {
-        if (value === null) {
-            return acc;
-        }
-        acc[key] = de_AttributeValue(core$1.awsExpectUnion(value));
-        return acc;
-    }, {});
-};
-const de_SetAttribute = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_AttributeValue(core$1.awsExpectUnion(entry));
-    });
-    return retVal;
-};
-const de_UpdateIdentitySourceOutput = (output, context) => {
-    return smithyClient.take(output, {
-        createdDate: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        identitySourceId: smithyClient.expectString,
-        lastUpdatedDate: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        policyStoreId: smithyClient.expectString,
-    });
-};
-const de_UpdatePolicyOutput = (output, context) => {
-    return smithyClient.take(output, {
-        actions: smithyClient._json,
-        createdDate: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        effect: smithyClient.expectString,
-        lastUpdatedDate: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        policyId: smithyClient.expectString,
-        policyStoreId: smithyClient.expectString,
-        policyType: smithyClient.expectString,
-        principal: smithyClient._json,
-        resource: smithyClient._json,
-    });
-};
-const de_UpdatePolicyStoreOutput = (output, context) => {
-    return smithyClient.take(output, {
-        arn: smithyClient.expectString,
-        createdDate: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        lastUpdatedDate: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        policyStoreId: smithyClient.expectString,
-    });
-};
-const de_UpdatePolicyTemplateOutput = (output, context) => {
-    return smithyClient.take(output, {
-        createdDate: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        lastUpdatedDate: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        policyStoreId: smithyClient.expectString,
-        policyTemplateId: smithyClient.expectString,
-    });
-};
-const deserializeMetadata = (output) => ({
-    httpStatusCode: output.statusCode,
-    requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
-    extendedRequestId: output.headers["x-amz-id-2"],
-    cfId: output.headers["x-amz-cf-id"],
-});
-const throwDefaultError = smithyClient.withBaseException(VerifiedPermissionsServiceException);
-const buildHttpRpcRequest = async (context, headers, path, resolvedHostname, body) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
-    const contents = {
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        path: basePath.endsWith("/") ? basePath.slice(0, -1) + path : basePath + path,
-        headers,
-    };
-    if (body !== undefined) {
-        contents.body = body;
-    }
-    return new protocolHttp.HttpRequest(contents);
-};
-function sharedHeaders(operation) {
-    return {
-        "content-type": "application/x-amz-json-1.0",
-        "x-amz-target": `VerifiedPermissions.${operation}`,
-    };
-}
+const _ADE = "AccessDeniedException";
+const _AI = "ActionId";
+const _AIL = "ActionIdentifierList";
+const _AIc = "ActionIdentifier";
+const _AT = "ActionType";
+const _AV = "AttributeValue";
+const _BA = "BooleanAttribute";
+const _BGP = "BatchGetPolicy";
+const _BGPEI = "BatchGetPolicyErrorItem";
+const _BGPEL = "BatchGetPolicyErrorList";
+const _BGPI = "BatchGetPolicyInput";
+const _BGPII = "BatchGetPolicyInputItem";
+const _BGPIL = "BatchGetPolicyInputList";
+const _BGPO = "BatchGetPolicyOutput";
+const _BGPOI = "BatchGetPolicyOutputItem";
+const _BGPOL = "BatchGetPolicyOutputList";
+const _BIA = "BatchIsAuthorized";
+const _BIAI = "BatchIsAuthorizedInput";
+const _BIAII = "BatchIsAuthorizedInputItem";
+const _BIAIL = "BatchIsAuthorizedInputList";
+const _BIAO = "BatchIsAuthorizedOutput";
+const _BIAOI = "BatchIsAuthorizedOutputItem";
+const _BIAOL = "BatchIsAuthorizedOutputList";
+const _BIAWT = "BatchIsAuthorizedWithToken";
+const _BIAWTI = "BatchIsAuthorizedWithTokenInput";
+const _BIAWTII = "BatchIsAuthorizedWithTokenInputItem";
+const _BIAWTIL = "BatchIsAuthorizedWithTokenInputList";
+const _BIAWTO = "BatchIsAuthorizedWithTokenOutput";
+const _BIAWTOI = "BatchIsAuthorizedWithTokenOutputItem";
+const _BIAWTOL = "BatchIsAuthorizedWithTokenOutputList";
+const _C = "Claim";
+const _CD = "ConfigurationDetail";
+const _CDo = "ContextDefinition";
+const _CE = "ConflictException";
+const _CGC = "CognitoGroupConfiguration";
+const _CGCD = "CognitoGroupConfigurationDetail";
+const _CGCI = "CognitoGroupConfigurationItem";
+const _CI = "ClientId";
+const _CIS = "CreateIdentitySource";
+const _CISI = "CreateIdentitySourceInput";
+const _CISO = "CreateIdentitySourceOutput";
+const _CIl = "ClientIds";
+const _CIo = "ConfigurationItem";
+const _CJ = "CedarJson";
+const _CM = "ContextMap";
+const _CP = "CreatePolicy";
+const _CPI = "CreatePolicyInput";
+const _CPO = "CreatePolicyOutput";
+const _CPS = "CreatePolicyStore";
+const _CPSI = "CreatePolicyStoreInput";
+const _CPSO = "CreatePolicyStoreOutput";
+const _CPT = "CreatePolicyTemplate";
+const _CPTI = "CreatePolicyTemplateInput";
+const _CPTO = "CreatePolicyTemplateOutput";
+const _CTRA = "CedarTagRecordAttribute";
+const _CTSA = "CedarTagSetAttribute";
+const _CTV = "CedarTagValue";
+const _CUPC = "CognitoUserPoolConfiguration";
+const _CUPCD = "CognitoUserPoolConfigurationDetail";
+const _CUPCI = "CognitoUserPoolConfigurationItem";
+const _Co = "Configuration";
+const _D = "Decimal";
+const _DA = "DatetimeAttribute";
+const _DIS = "DeleteIdentitySource";
+const _DISI = "DeleteIdentitySourceInput";
+const _DISO = "DeleteIdentitySourceOutput";
+const _DP = "DeletePolicy";
+const _DPI = "DeletePolicyInput";
+const _DPIe = "DeterminingPolicyItem";
+const _DPL = "DeterminingPolicyList";
+const _DPO = "DeletePolicyOutput";
+const _DPS = "DeletePolicyStore";
+const _DPSI = "DeletePolicyStoreInput";
+const _DPSO = "DeletePolicyStoreOutput";
+const _DPT = "DeletePolicyTemplate";
+const _DPTI = "DeletePolicyTemplateInput";
+const _DPTO = "DeletePolicyTemplateOutput";
+const _Du = "Duration";
+const _EA = "EntityAttributes";
+const _ECT = "EntityCedarTags";
+const _ED = "EntitiesDefinition";
+const _EEI = "EvaluationErrorItem";
+const _EEL = "EvaluationErrorList";
+const _EI = "EntityId";
+const _EIP = "EntityIdPrefix";
+const _EIn = "EntityIdentifier";
+const _EInt = "EntityItem";
+const _EL = "EntityList";
+const _ER = "EntityReference";
+const _ET = "EntityType";
+const _GET = "GroupEntityType";
+const _GIS = "GetIdentitySource";
+const _GISI = "GetIdentitySourceInput";
+const _GISO = "GetIdentitySourceOutput";
+const _GP = "GetPolicy";
+const _GPI = "GetPolicyInput";
+const _GPO = "GetPolicyOutput";
+const _GPS = "GetPolicyStore";
+const _GPSI = "GetPolicyStoreInput";
+const _GPSO = "GetPolicyStoreOutput";
+const _GPT = "GetPolicyTemplate";
+const _GPTI = "GetPolicyTemplateInput";
+const _GPTO = "GetPolicyTemplateOutput";
+const _GS = "GetSchema";
+const _GSI = "GetSchemaInput";
+const _GSO = "GetSchemaOutput";
+const _IA = "IpAddr";
+const _IAI = "IsAuthorizedInput";
+const _IAO = "IsAuthorizedOutput";
+const _IAWT = "IsAuthorizedWithToken";
+const _IAWTI = "IsAuthorizedWithTokenInput";
+const _IAWTO = "IsAuthorizedWithTokenOutput";
+const _IAs = "IsAuthorized";
+const _IS = "IdentitySources";
+const _ISD = "IdentitySourceDetails";
+const _ISE = "InternalServerException";
+const _ISEn = "InvalidStateException";
+const _ISF = "IdentitySourceFilter";
+const _ISFd = "IdentitySourceFilters";
+const _ISI = "IdentitySourceItem";
+const _ISID = "IdentitySourceItemDetails";
+const _LA = "LongAttribute";
+const _LIS = "ListIdentitySources";
+const _LISI = "ListIdentitySourcesInput";
+const _LISO = "ListIdentitySourcesOutput";
+const _LP = "ListPolicies";
+const _LPI = "ListPoliciesInput";
+const _LPO = "ListPoliciesOutput";
+const _LPS = "ListPolicyStores";
+const _LPSI = "ListPolicyStoresInput";
+const _LPSO = "ListPolicyStoresOutput";
+const _LPT = "ListPolicyTemplates";
+const _LPTI = "ListPolicyTemplatesInput";
+const _LPTO = "ListPolicyTemplatesOutput";
+const _LTFR = "ListTagsForResource";
+const _LTFRI = "ListTagsForResourceInput";
+const _LTFRO = "ListTagsForResourceOutput";
+const _N = "Namespace";
+const _NL = "NamespaceList";
+const _OICATC = "OpenIdConnectAccessTokenConfiguration";
+const _OICATCD = "OpenIdConnectAccessTokenConfigurationDetail";
+const _OICATCI = "OpenIdConnectAccessTokenConfigurationItem";
+const _OICC = "OpenIdConnectConfiguration";
+const _OICCD = "OpenIdConnectConfigurationDetail";
+const _OICCI = "OpenIdConnectConfigurationItem";
+const _OICGC = "OpenIdConnectGroupConfiguration";
+const _OICGCD = "OpenIdConnectGroupConfigurationDetail";
+const _OICGCI = "OpenIdConnectGroupConfigurationItem";
+const _OICITC = "OpenIdConnectIdentityTokenConfiguration";
+const _OICITCD = "OpenIdConnectIdentityTokenConfigurationDetail";
+const _OICITCI = "OpenIdConnectIdentityTokenConfigurationItem";
+const _OICTS = "OpenIdConnectTokenSelection";
+const _OICTSD = "OpenIdConnectTokenSelectionDetail";
+const _OICTSI = "OpenIdConnectTokenSelectionItem";
+const _PD = "PolicyDefinition";
+const _PDD = "PolicyDefinitionDetail";
+const _PDI = "PolicyDefinitionItem";
+const _PET = "PrincipalEntityType";
+const _PF = "PolicyFilter";
+const _PI = "PolicyItem";
+const _PL = "ParentList";
+const _PLo = "PolicyList";
+const _PS = "PolicyStatement";
+const _PSD = "PolicyStoreDescription";
+const _PSI = "PolicyStoreItem";
+const _PSIu = "PutSchemaInput";
+const _PSL = "PolicyStoreList";
+const _PSO = "PutSchemaOutput";
+const _PSu = "PutSchema";
+const _PTD = "PolicyTemplateDescription";
+const _PTI = "PolicyTemplateItem";
+const _PTL = "PolicyTemplatesList";
+const _RA = "RecordAttribute";
+const _RC = "ResourceConflict";
+const _RCL = "ResourceConflictList";
+const _RNFE = "ResourceNotFoundException";
+const _SA = "StringAttribute";
+const _SAe = "SetAttribute";
+const _SD = "SchemaDefinition";
+const _SJ = "SchemaJson";
+const _SPD = "StaticPolicyDescription";
+const _SPDD = "StaticPolicyDefinitionDetail";
+const _SPDI = "StaticPolicyDefinitionItem";
+const _SPDt = "StaticPolicyDefinition";
+const _SQEE = "ServiceQuotaExceededException";
+const _T = "Token";
+const _TE = "ThrottlingException";
+const _TLPD = "TemplateLinkedPolicyDefinition";
+const _TLPDD = "TemplateLinkedPolicyDefinitionDetail";
+const _TLPDI = "TemplateLinkedPolicyDefinitionItem";
+const _TMTE = "TooManyTagsException";
+const _TR = "TagResource";
+const _TRI = "TagResourceInput";
+const _TRO = "TagResourceOutput";
+const _UC = "UpdateConfiguration";
+const _UCGC = "UpdateCognitoGroupConfiguration";
+const _UCUPC = "UpdateCognitoUserPoolConfiguration";
+const _UIS = "UpdateIdentitySource";
+const _UISI = "UpdateIdentitySourceInput";
+const _UISO = "UpdateIdentitySourceOutput";
+const _UOICATC = "UpdateOpenIdConnectAccessTokenConfiguration";
+const _UOICC = "UpdateOpenIdConnectConfiguration";
+const _UOICGC = "UpdateOpenIdConnectGroupConfiguration";
+const _UOICITC = "UpdateOpenIdConnectIdentityTokenConfiguration";
+const _UOICTS = "UpdateOpenIdConnectTokenSelection";
+const _UP = "UpdatePolicy";
+const _UPD = "UpdatePolicyDefinition";
+const _UPI = "UpdatePolicyInput";
+const _UPO = "UpdatePolicyOutput";
+const _UPS = "UpdatePolicyStore";
+const _UPSI = "UpdatePolicyStoreInput";
+const _UPSO = "UpdatePolicyStoreOutput";
+const _UPT = "UpdatePolicyTemplate";
+const _UPTI = "UpdatePolicyTemplateInput";
+const _UPTO = "UpdatePolicyTemplateOutput";
+const _UR = "UntagResource";
+const _URI = "UntagResourceInput";
+const _URO = "UntagResourceOutput";
+const _USPD = "UpdateStaticPolicyDefinition";
+const _VE = "ValidationException";
+const _VEF = "ValidationExceptionField";
+const _VEFL = "ValidationExceptionFieldList";
+const _VS = "ValidationSettings";
+const _a = "action";
+const _aI = "actionId";
+const _aT = "actionType";
+const _aTO = "accessTokenOnly";
+const _aTc = "accessToken";
+const _ac = "actions";
+const _ar = "arn";
+const _at = "attributes";
+const _au = "audiences";
+const _b = "boolean";
+const _c = "client";
+const _cD = "createdDate";
+const _cI = "clientIds";
+const _cJ = "cedarJson";
+const _cM = "contextMap";
+const _cT = "clientToken";
+const _cUPC = "cognitoUserPoolConfiguration";
+const _cV = "cedarVersion";
+const _co = "code";
+const _con = "context";
+const _conf = "configuration";
+const _d = "definition";
+const _dP = "determiningPolicies";
+const _dPe = "deletionProtection";
+const _dU = "discoveryUrl";
+const _da = "datetime";
+const _de = "decision";
+const _dec = "decimal";
+const _des = "description";
+const _det = "details";
+const _du = "duration";
+const _e = "error";
+const _eD = "errorDescription";
+const _eI = "entityId";
+const _eIP = "entityIdPrefix";
+const _eIn = "entityIdentifier";
+const _eL = "entityList";
+const _eT = "entityType";
+const _ef = "effect";
+const _en = "entities";
+const _er = "errors";
+const _f = "filters";
+const _fL = "fieldList";
+const _fi = "filter";
+const _gC = "groupConfiguration";
+const _gCr = "groupClaim";
+const _gET = "groupEntityType";
+const _hE = "httpError";
+const _i = "issuer";
+const _iS = "identitySources";
+const _iSI = "identitySourceId";
+const _iT = "identityToken";
+const _iTO = "identityTokenOnly";
+const _id = "identifier";
+const _ip = "ipaddr";
+const _l = "long";
+const _lUD = "lastUpdatedDate";
+const _m = "message";
+const _mR = "maxResults";
+const _mo = "mode";
+const _n = "namespaces";
+const _nT = "nextToken";
+const _oICC = "openIdConnectConfiguration";
+const _oII = "openIdIssuer";
+const _p = "principal";
+const _pET = "principalEntityType";
+const _pI = "policyId";
+const _pIC = "principalIdClaim";
+const _pS = "policyStores";
+const _pSI = "policyStoreId";
+const _pT = "policyType";
+const _pTI = "policyTemplateId";
+const _pTo = "policyTemplates";
+const _pa = "parents";
+const _pat = "path";
+const _po = "policies";
+const _qC = "quotaCode";
+const _r = "requests";
+const _rA = "resourceArn";
+const _rI = "resourceId";
+const _rN = "resourceName";
+const _rT = "resourceType";
+const _re = "results";
+const _rec = "record";
+const _req = "request";
+const _res = "resource";
+const _reso = "resources";
+const _s = "statement";
+const _sC = "serviceCode";
+const _sc = "schema";
+const _se = "server";
+const _set = "set";
+const _sm = "smithy.ts.sdk.synthetic.com.amazonaws.verifiedpermissions";
+const _st = "string";
+const _sta = "static";
+const _t = "tags";
+const _tK = "tagKeys";
+const _tL = "templateLinked";
+const _tS = "tokenSelection";
+const _u = "unspecified";
+const _uC = "updateConfiguration";
+const _uPA = "userPoolArn";
+const _vS = "validationSettings";
+const n0 = "com.amazonaws.verifiedpermissions";
+var ActionId = [0, n0, _AI, 8, 0];
+var ActionType = [0, n0, _AT, 8, 0];
+var BooleanAttribute = [0, n0, _BA, 8, 2];
+var CedarJson = [0, n0, _CJ, 8, 0];
+var Claim = [0, n0, _C, 8, 0];
+var ClientId = [0, n0, _CI, 8, 0];
+var DatetimeAttribute = [0, n0, _DA, 8, 0];
+var Decimal = [0, n0, _D, 8, 0];
+var Duration = [0, n0, _Du, 8, 0];
+var EntityId = [0, n0, _EI, 8, 0];
+var EntityIdPrefix = [0, n0, _EIP, 8, 0];
+var EntityType = [0, n0, _ET, 8, 0];
+var GroupEntityType = [0, n0, _GET, 8, 0];
+var IpAddr = [0, n0, _IA, 8, 0];
+var LongAttribute = [0, n0, _LA, 8, 1];
+var Namespace = [0, n0, _N, 8, 0];
+var PolicyStatement = [0, n0, _PS, 8, 0];
+var PolicyStoreDescription = [0, n0, _PSD, 8, 0];
+var PolicyTemplateDescription = [0, n0, _PTD, 8, 0];
+var PrincipalEntityType = [0, n0, _PET, 8, 0];
+var SchemaJson = [0, n0, _SJ, 8, 0];
+var StaticPolicyDescription = [0, n0, _SPD, 8, 0];
+var StringAttribute = [0, n0, _SA, 8, 0];
+var Token = [0, n0, _T, 8, 0];
+var AccessDeniedException = [
+    -3,
+    n0,
+    _ADE,
+    {
+        [_e]: _c,
+        [_hE]: 403,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(AccessDeniedException, AccessDeniedException$1);
+var ActionIdentifier = [
+    3,
+    n0,
+    _AIc,
+    0,
+    [_aT, _aI],
+    [
+        [() => ActionType, 0],
+        [() => ActionId, 0],
+    ],
+];
+var BatchGetPolicyErrorItem = [3, n0, _BGPEI, 0, [_co, _pSI, _pI, _m], [0, 0, 0, 0]];
+var BatchGetPolicyInput = [3, n0, _BGPI, 0, [_r], [() => BatchGetPolicyInputList]];
+var BatchGetPolicyInputItem = [3, n0, _BGPII, 0, [_pSI, _pI], [0, 0]];
+var BatchGetPolicyOutput = [
+    3,
+    n0,
+    _BGPO,
+    0,
+    [_re, _er],
+    [[() => BatchGetPolicyOutputList, 0], () => BatchGetPolicyErrorList],
+];
+var BatchGetPolicyOutputItem = [
+    3,
+    n0,
+    _BGPOI,
+    0,
+    [_pSI, _pI, _pT, _d, _cD, _lUD],
+    [0, 0, 0, [() => PolicyDefinitionDetail, 0], 5, 5],
+];
+var BatchIsAuthorizedInput = [
+    3,
+    n0,
+    _BIAI,
+    0,
+    [_pSI, _en, _r],
+    [0, [() => EntitiesDefinition, 0], [() => BatchIsAuthorizedInputList, 0]],
+];
+var BatchIsAuthorizedInputItem = [
+    3,
+    n0,
+    _BIAII,
+    0,
+    [_p, _a, _res, _con],
+    [
+        [() => EntityIdentifier, 0],
+        [() => ActionIdentifier, 0],
+        [() => EntityIdentifier, 0],
+        [() => ContextDefinition, 0],
+    ],
+];
+var BatchIsAuthorizedOutput = [
+    3,
+    n0,
+    _BIAO,
+    0,
+    [_re],
+    [[() => BatchIsAuthorizedOutputList, 0]],
+];
+var BatchIsAuthorizedOutputItem = [
+    3,
+    n0,
+    _BIAOI,
+    0,
+    [_req, _de, _dP, _er],
+    [[() => BatchIsAuthorizedInputItem, 0], 0, () => DeterminingPolicyList, [() => EvaluationErrorList, 0]],
+];
+var BatchIsAuthorizedWithTokenInput = [
+    3,
+    n0,
+    _BIAWTI,
+    0,
+    [_pSI, _iT, _aTc, _en, _r],
+    [
+        0,
+        [() => Token, 0],
+        [() => Token, 0],
+        [() => EntitiesDefinition, 0],
+        [() => BatchIsAuthorizedWithTokenInputList, 0],
+    ],
+];
+var BatchIsAuthorizedWithTokenInputItem = [
+    3,
+    n0,
+    _BIAWTII,
+    0,
+    [_a, _res, _con],
+    [
+        [() => ActionIdentifier, 0],
+        [() => EntityIdentifier, 0],
+        [() => ContextDefinition, 0],
+    ],
+];
+var BatchIsAuthorizedWithTokenOutput = [
+    3,
+    n0,
+    _BIAWTO,
+    0,
+    [_p, _re],
+    [
+        [() => EntityIdentifier, 0],
+        [() => BatchIsAuthorizedWithTokenOutputList, 0],
+    ],
+];
+var BatchIsAuthorizedWithTokenOutputItem = [
+    3,
+    n0,
+    _BIAWTOI,
+    0,
+    [_req, _de, _dP, _er],
+    [[() => BatchIsAuthorizedWithTokenInputItem, 0], 0, () => DeterminingPolicyList, [() => EvaluationErrorList, 0]],
+];
+var CognitoGroupConfiguration = [3, n0, _CGC, 0, [_gET], [[() => GroupEntityType, 0]]];
+var CognitoGroupConfigurationDetail = [
+    3,
+    n0,
+    _CGCD,
+    0,
+    [_gET],
+    [[() => GroupEntityType, 0]],
+];
+var CognitoGroupConfigurationItem = [
+    3,
+    n0,
+    _CGCI,
+    0,
+    [_gET],
+    [[() => GroupEntityType, 0]],
+];
+var CognitoUserPoolConfiguration = [
+    3,
+    n0,
+    _CUPC,
+    0,
+    [_uPA, _cI, _gC],
+    [0, [() => ClientIds, 0], [() => CognitoGroupConfiguration, 0]],
+];
+var CognitoUserPoolConfigurationDetail = [
+    3,
+    n0,
+    _CUPCD,
+    0,
+    [_uPA, _cI, _i, _gC],
+    [0, [() => ClientIds, 0], 0, [() => CognitoGroupConfigurationDetail, 0]],
+];
+var CognitoUserPoolConfigurationItem = [
+    3,
+    n0,
+    _CUPCI,
+    0,
+    [_uPA, _cI, _i, _gC],
+    [0, [() => ClientIds, 0], 0, [() => CognitoGroupConfigurationItem, 0]],
+];
+var ConflictException = [
+    -3,
+    n0,
+    _CE,
+    {
+        [_e]: _c,
+        [_hE]: 409,
+    },
+    [_m, _reso],
+    [0, () => ResourceConflictList],
+];
+schema.TypeRegistry.for(n0).registerError(ConflictException, ConflictException$1);
+var CreateIdentitySourceInput = [
+    3,
+    n0,
+    _CISI,
+    0,
+    [_cT, _pSI, _conf, _pET],
+    [[0, 4], 0, [() => Configuration, 0], [() => PrincipalEntityType, 0]],
+];
+var CreateIdentitySourceOutput = [3, n0, _CISO, 0, [_cD, _iSI, _lUD, _pSI], [5, 0, 5, 0]];
+var CreatePolicyInput = [
+    3,
+    n0,
+    _CPI,
+    0,
+    [_cT, _pSI, _d],
+    [[0, 4], 0, [() => PolicyDefinition, 0]],
+];
+var CreatePolicyOutput = [
+    3,
+    n0,
+    _CPO,
+    0,
+    [_pSI, _pI, _pT, _p, _res, _ac, _cD, _lUD, _ef],
+    [0, 0, 0, [() => EntityIdentifier, 0], [() => EntityIdentifier, 0], [() => ActionIdentifierList, 0], 5, 5, 0],
+];
+var CreatePolicyStoreInput = [
+    3,
+    n0,
+    _CPSI,
+    0,
+    [_cT, _vS, _des, _dPe, _t],
+    [[0, 4], () => ValidationSettings, [() => PolicyStoreDescription, 0], 0, 128 | 0],
+];
+var CreatePolicyStoreOutput = [3, n0, _CPSO, 0, [_pSI, _ar, _cD, _lUD], [0, 0, 5, 5]];
+var CreatePolicyTemplateInput = [
+    3,
+    n0,
+    _CPTI,
+    0,
+    [_cT, _pSI, _des, _s],
+    [[0, 4], 0, [() => PolicyTemplateDescription, 0], [() => PolicyStatement, 0]],
+];
+var CreatePolicyTemplateOutput = [3, n0, _CPTO, 0, [_pSI, _pTI, _cD, _lUD], [0, 0, 5, 5]];
+var DeleteIdentitySourceInput = [3, n0, _DISI, 0, [_pSI, _iSI], [0, 0]];
+var DeleteIdentitySourceOutput = [3, n0, _DISO, 0, [], []];
+var DeletePolicyInput = [3, n0, _DPI, 0, [_pSI, _pI], [0, 0]];
+var DeletePolicyOutput = [3, n0, _DPO, 0, [], []];
+var DeletePolicyStoreInput = [3, n0, _DPSI, 0, [_pSI], [0]];
+var DeletePolicyStoreOutput = [3, n0, _DPSO, 0, [], []];
+var DeletePolicyTemplateInput = [3, n0, _DPTI, 0, [_pSI, _pTI], [0, 0]];
+var DeletePolicyTemplateOutput = [3, n0, _DPTO, 0, [], []];
+var DeterminingPolicyItem = [3, n0, _DPIe, 0, [_pI], [0]];
+var EntityIdentifier = [
+    3,
+    n0,
+    _EIn,
+    0,
+    [_eT, _eI],
+    [
+        [() => EntityType, 0],
+        [() => EntityId, 0],
+    ],
+];
+var EntityItem = [
+    3,
+    n0,
+    _EInt,
+    0,
+    [_id, _at, _pa, _t],
+    [
+        [() => EntityIdentifier, 0],
+        [() => EntityAttributes, 0],
+        [() => ParentList, 0],
+        [() => EntityCedarTags, 0],
+    ],
+];
+var EvaluationErrorItem = [3, n0, _EEI, 8, [_eD], [0]];
+var GetIdentitySourceInput = [3, n0, _GISI, 0, [_pSI, _iSI], [0, 0]];
+var GetIdentitySourceOutput = [
+    3,
+    n0,
+    _GISO,
+    0,
+    [_cD, _det, _iSI, _lUD, _pSI, _pET, _conf],
+    [5, [() => IdentitySourceDetails, 0], 0, 5, 0, [() => PrincipalEntityType, 0], [() => ConfigurationDetail, 0]],
+];
+var GetPolicyInput = [3, n0, _GPI, 0, [_pSI, _pI], [0, 0]];
+var GetPolicyOutput = [
+    3,
+    n0,
+    _GPO,
+    0,
+    [_pSI, _pI, _pT, _p, _res, _ac, _d, _cD, _lUD, _ef],
+    [
+        0,
+        0,
+        0,
+        [() => EntityIdentifier, 0],
+        [() => EntityIdentifier, 0],
+        [() => ActionIdentifierList, 0],
+        [() => PolicyDefinitionDetail, 0],
+        5,
+        5,
+        0,
+    ],
+];
+var GetPolicyStoreInput = [3, n0, _GPSI, 0, [_pSI, _t], [0, 2]];
+var GetPolicyStoreOutput = [
+    3,
+    n0,
+    _GPSO,
+    0,
+    [_pSI, _ar, _vS, _cD, _lUD, _des, _dPe, _cV, _t],
+    [0, 0, () => ValidationSettings, 5, 5, [() => PolicyStoreDescription, 0], 0, 0, 128 | 0],
+];
+var GetPolicyTemplateInput = [3, n0, _GPTI, 0, [_pSI, _pTI], [0, 0]];
+var GetPolicyTemplateOutput = [
+    3,
+    n0,
+    _GPTO,
+    0,
+    [_pSI, _pTI, _des, _s, _cD, _lUD],
+    [0, 0, [() => PolicyTemplateDescription, 0], [() => PolicyStatement, 0], 5, 5],
+];
+var GetSchemaInput = [3, n0, _GSI, 0, [_pSI], [0]];
+var GetSchemaOutput = [
+    3,
+    n0,
+    _GSO,
+    0,
+    [_pSI, _sc, _cD, _lUD, _n],
+    [0, [() => SchemaJson, 0], 5, 5, [() => NamespaceList, 0]],
+];
+var IdentitySourceDetails = [
+    3,
+    n0,
+    _ISD,
+    0,
+    [_cI, _uPA, _dU, _oII],
+    [[() => ClientIds, 0], 0, 0, 0],
+];
+var IdentitySourceFilter = [3, n0, _ISF, 0, [_pET], [[() => PrincipalEntityType, 0]]];
+var IdentitySourceItem = [
+    3,
+    n0,
+    _ISI,
+    0,
+    [_cD, _det, _iSI, _lUD, _pSI, _pET, _conf],
+    [5, [() => IdentitySourceItemDetails, 0], 0, 5, 0, [() => PrincipalEntityType, 0], [() => ConfigurationItem, 0]],
+];
+var IdentitySourceItemDetails = [
+    3,
+    n0,
+    _ISID,
+    0,
+    [_cI, _uPA, _dU, _oII],
+    [[() => ClientIds, 0], 0, 0, 0],
+];
+var InternalServerException = [
+    -3,
+    n0,
+    _ISE,
+    {
+        [_e]: _se,
+        [_hE]: 500,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InternalServerException, InternalServerException$1);
+var InvalidStateException = [
+    -3,
+    n0,
+    _ISEn,
+    {
+        [_e]: _c,
+        [_hE]: 406,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidStateException, InvalidStateException$1);
+var IsAuthorizedInput = [
+    3,
+    n0,
+    _IAI,
+    0,
+    [_pSI, _p, _a, _res, _con, _en],
+    [
+        0,
+        [() => EntityIdentifier, 0],
+        [() => ActionIdentifier, 0],
+        [() => EntityIdentifier, 0],
+        [() => ContextDefinition, 0],
+        [() => EntitiesDefinition, 0],
+    ],
+];
+var IsAuthorizedOutput = [
+    3,
+    n0,
+    _IAO,
+    0,
+    [_de, _dP, _er],
+    [0, () => DeterminingPolicyList, [() => EvaluationErrorList, 0]],
+];
+var IsAuthorizedWithTokenInput = [
+    3,
+    n0,
+    _IAWTI,
+    0,
+    [_pSI, _iT, _aTc, _a, _res, _con, _en],
+    [
+        0,
+        [() => Token, 0],
+        [() => Token, 0],
+        [() => ActionIdentifier, 0],
+        [() => EntityIdentifier, 0],
+        [() => ContextDefinition, 0],
+        [() => EntitiesDefinition, 0],
+    ],
+];
+var IsAuthorizedWithTokenOutput = [
+    3,
+    n0,
+    _IAWTO,
+    0,
+    [_de, _dP, _er, _p],
+    [0, () => DeterminingPolicyList, [() => EvaluationErrorList, 0], [() => EntityIdentifier, 0]],
+];
+var ListIdentitySourcesInput = [
+    3,
+    n0,
+    _LISI,
+    0,
+    [_pSI, _nT, _mR, _f],
+    [0, 0, 1, [() => IdentitySourceFilters, 0]],
+];
+var ListIdentitySourcesOutput = [
+    3,
+    n0,
+    _LISO,
+    0,
+    [_nT, _iS],
+    [0, [() => IdentitySources, 0]],
+];
+var ListPoliciesInput = [
+    3,
+    n0,
+    _LPI,
+    0,
+    [_pSI, _nT, _mR, _fi],
+    [0, 0, 1, [() => PolicyFilter, 0]],
+];
+var ListPoliciesOutput = [3, n0, _LPO, 0, [_nT, _po], [0, [() => PolicyList, 0]]];
+var ListPolicyStoresInput = [3, n0, _LPSI, 0, [_nT, _mR], [0, 1]];
+var ListPolicyStoresOutput = [
+    3,
+    n0,
+    _LPSO,
+    0,
+    [_nT, _pS],
+    [0, [() => PolicyStoreList, 0]],
+];
+var ListPolicyTemplatesInput = [3, n0, _LPTI, 0, [_pSI, _nT, _mR], [0, 0, 1]];
+var ListPolicyTemplatesOutput = [
+    3,
+    n0,
+    _LPTO,
+    0,
+    [_nT, _pTo],
+    [0, [() => PolicyTemplatesList, 0]],
+];
+var ListTagsForResourceInput = [3, n0, _LTFRI, 0, [_rA], [0]];
+var ListTagsForResourceOutput = [3, n0, _LTFRO, 0, [_t], [128 | 0]];
+var OpenIdConnectAccessTokenConfiguration = [
+    3,
+    n0,
+    _OICATC,
+    0,
+    [_pIC, _au],
+    [[() => Claim, 0], 64 | 0],
+];
+var OpenIdConnectAccessTokenConfigurationDetail = [
+    3,
+    n0,
+    _OICATCD,
+    0,
+    [_pIC, _au],
+    [[() => Claim, 0], 64 | 0],
+];
+var OpenIdConnectAccessTokenConfigurationItem = [
+    3,
+    n0,
+    _OICATCI,
+    0,
+    [_pIC, _au],
+    [[() => Claim, 0], 64 | 0],
+];
+var OpenIdConnectConfiguration = [
+    3,
+    n0,
+    _OICC,
+    0,
+    [_i, _eIP, _gC, _tS],
+    [0, [() => EntityIdPrefix, 0], [() => OpenIdConnectGroupConfiguration, 0], [() => OpenIdConnectTokenSelection, 0]],
+];
+var OpenIdConnectConfigurationDetail = [
+    3,
+    n0,
+    _OICCD,
+    0,
+    [_i, _eIP, _gC, _tS],
+    [
+        0,
+        [() => EntityIdPrefix, 0],
+        [() => OpenIdConnectGroupConfigurationDetail, 0],
+        [() => OpenIdConnectTokenSelectionDetail, 0],
+    ],
+];
+var OpenIdConnectConfigurationItem = [
+    3,
+    n0,
+    _OICCI,
+    0,
+    [_i, _eIP, _gC, _tS],
+    [
+        0,
+        [() => EntityIdPrefix, 0],
+        [() => OpenIdConnectGroupConfigurationItem, 0],
+        [() => OpenIdConnectTokenSelectionItem, 0],
+    ],
+];
+var OpenIdConnectGroupConfiguration = [
+    3,
+    n0,
+    _OICGC,
+    0,
+    [_gCr, _gET],
+    [
+        [() => Claim, 0],
+        [() => GroupEntityType, 0],
+    ],
+];
+var OpenIdConnectGroupConfigurationDetail = [
+    3,
+    n0,
+    _OICGCD,
+    0,
+    [_gCr, _gET],
+    [
+        [() => Claim, 0],
+        [() => GroupEntityType, 0],
+    ],
+];
+var OpenIdConnectGroupConfigurationItem = [
+    3,
+    n0,
+    _OICGCI,
+    0,
+    [_gCr, _gET],
+    [
+        [() => Claim, 0],
+        [() => GroupEntityType, 0],
+    ],
+];
+var OpenIdConnectIdentityTokenConfiguration = [
+    3,
+    n0,
+    _OICITC,
+    0,
+    [_pIC, _cI],
+    [
+        [() => Claim, 0],
+        [() => ClientIds, 0],
+    ],
+];
+var OpenIdConnectIdentityTokenConfigurationDetail = [
+    3,
+    n0,
+    _OICITCD,
+    0,
+    [_pIC, _cI],
+    [
+        [() => Claim, 0],
+        [() => ClientIds, 0],
+    ],
+];
+var OpenIdConnectIdentityTokenConfigurationItem = [
+    3,
+    n0,
+    _OICITCI,
+    0,
+    [_pIC, _cI],
+    [
+        [() => Claim, 0],
+        [() => ClientIds, 0],
+    ],
+];
+var PolicyFilter = [
+    3,
+    n0,
+    _PF,
+    0,
+    [_p, _res, _pT, _pTI],
+    [[() => EntityReference, 0], [() => EntityReference, 0], 0, 0],
+];
+var PolicyItem = [
+    3,
+    n0,
+    _PI,
+    0,
+    [_pSI, _pI, _pT, _p, _res, _ac, _d, _cD, _lUD, _ef],
+    [
+        0,
+        0,
+        0,
+        [() => EntityIdentifier, 0],
+        [() => EntityIdentifier, 0],
+        [() => ActionIdentifierList, 0],
+        [() => PolicyDefinitionItem, 0],
+        5,
+        5,
+        0,
+    ],
+];
+var PolicyStoreItem = [
+    3,
+    n0,
+    _PSI,
+    0,
+    [_pSI, _ar, _cD, _lUD, _des],
+    [0, 0, 5, 5, [() => PolicyStoreDescription, 0]],
+];
+var PolicyTemplateItem = [
+    3,
+    n0,
+    _PTI,
+    0,
+    [_pSI, _pTI, _des, _cD, _lUD],
+    [0, 0, [() => PolicyTemplateDescription, 0], 5, 5],
+];
+var PutSchemaInput = [3, n0, _PSIu, 0, [_pSI, _d], [0, [() => SchemaDefinition, 0]]];
+var PutSchemaOutput = [
+    3,
+    n0,
+    _PSO,
+    0,
+    [_pSI, _n, _cD, _lUD],
+    [0, [() => NamespaceList, 0], 5, 5],
+];
+var ResourceConflict = [3, n0, _RC, 0, [_rI, _rT], [0, 0]];
+var ResourceNotFoundException = [
+    -3,
+    n0,
+    _RNFE,
+    {
+        [_e]: _c,
+        [_hE]: 404,
+    },
+    [_m, _rI, _rT],
+    [0, 0, 0],
+];
+schema.TypeRegistry.for(n0).registerError(ResourceNotFoundException, ResourceNotFoundException$1);
+var ServiceQuotaExceededException = [
+    -3,
+    n0,
+    _SQEE,
+    {
+        [_e]: _c,
+        [_hE]: 402,
+    },
+    [_m, _rI, _rT, _sC, _qC],
+    [0, 0, 0, 0, 0],
+];
+schema.TypeRegistry.for(n0).registerError(ServiceQuotaExceededException, ServiceQuotaExceededException$1);
+var StaticPolicyDefinition = [
+    3,
+    n0,
+    _SPDt,
+    0,
+    [_des, _s],
+    [
+        [() => StaticPolicyDescription, 0],
+        [() => PolicyStatement, 0],
+    ],
+];
+var StaticPolicyDefinitionDetail = [
+    3,
+    n0,
+    _SPDD,
+    0,
+    [_des, _s],
+    [
+        [() => StaticPolicyDescription, 0],
+        [() => PolicyStatement, 0],
+    ],
+];
+var StaticPolicyDefinitionItem = [
+    3,
+    n0,
+    _SPDI,
+    0,
+    [_des],
+    [[() => StaticPolicyDescription, 0]],
+];
+var TagResourceInput = [3, n0, _TRI, 0, [_rA, _t], [0, 128 | 0]];
+var TagResourceOutput = [3, n0, _TRO, 0, [], []];
+var TemplateLinkedPolicyDefinition = [
+    3,
+    n0,
+    _TLPD,
+    0,
+    [_pTI, _p, _res],
+    [0, [() => EntityIdentifier, 0], [() => EntityIdentifier, 0]],
+];
+var TemplateLinkedPolicyDefinitionDetail = [
+    3,
+    n0,
+    _TLPDD,
+    0,
+    [_pTI, _p, _res],
+    [0, [() => EntityIdentifier, 0], [() => EntityIdentifier, 0]],
+];
+var TemplateLinkedPolicyDefinitionItem = [
+    3,
+    n0,
+    _TLPDI,
+    0,
+    [_pTI, _p, _res],
+    [0, [() => EntityIdentifier, 0], [() => EntityIdentifier, 0]],
+];
+var ThrottlingException = [
+    -3,
+    n0,
+    _TE,
+    {
+        [_e]: _c,
+        [_hE]: 429,
+    },
+    [_m, _sC, _qC],
+    [0, 0, 0],
+];
+schema.TypeRegistry.for(n0).registerError(ThrottlingException, ThrottlingException$1);
+var TooManyTagsException = [
+    -3,
+    n0,
+    _TMTE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_m, _rN],
+    [0, 0],
+];
+schema.TypeRegistry.for(n0).registerError(TooManyTagsException, TooManyTagsException$1);
+var UntagResourceInput = [3, n0, _URI, 0, [_rA, _tK], [0, 64 | 0]];
+var UntagResourceOutput = [3, n0, _URO, 0, [], []];
+var UpdateCognitoGroupConfiguration = [
+    3,
+    n0,
+    _UCGC,
+    0,
+    [_gET],
+    [[() => GroupEntityType, 0]],
+];
+var UpdateCognitoUserPoolConfiguration = [
+    3,
+    n0,
+    _UCUPC,
+    0,
+    [_uPA, _cI, _gC],
+    [0, [() => ClientIds, 0], [() => UpdateCognitoGroupConfiguration, 0]],
+];
+var UpdateIdentitySourceInput = [
+    3,
+    n0,
+    _UISI,
+    0,
+    [_pSI, _iSI, _uC, _pET],
+    [0, 0, [() => UpdateConfiguration, 0], [() => PrincipalEntityType, 0]],
+];
+var UpdateIdentitySourceOutput = [3, n0, _UISO, 0, [_cD, _iSI, _lUD, _pSI], [5, 0, 5, 0]];
+var UpdateOpenIdConnectAccessTokenConfiguration = [
+    3,
+    n0,
+    _UOICATC,
+    0,
+    [_pIC, _au],
+    [[() => Claim, 0], 64 | 0],
+];
+var UpdateOpenIdConnectConfiguration = [
+    3,
+    n0,
+    _UOICC,
+    0,
+    [_i, _eIP, _gC, _tS],
+    [
+        0,
+        [() => EntityIdPrefix, 0],
+        [() => UpdateOpenIdConnectGroupConfiguration, 0],
+        [() => UpdateOpenIdConnectTokenSelection, 0],
+    ],
+];
+var UpdateOpenIdConnectGroupConfiguration = [
+    3,
+    n0,
+    _UOICGC,
+    0,
+    [_gCr, _gET],
+    [
+        [() => Claim, 0],
+        [() => GroupEntityType, 0],
+    ],
+];
+var UpdateOpenIdConnectIdentityTokenConfiguration = [
+    3,
+    n0,
+    _UOICITC,
+    0,
+    [_pIC, _cI],
+    [
+        [() => Claim, 0],
+        [() => ClientIds, 0],
+    ],
+];
+var UpdatePolicyInput = [
+    3,
+    n0,
+    _UPI,
+    0,
+    [_pSI, _pI, _d],
+    [0, 0, [() => UpdatePolicyDefinition, 0]],
+];
+var UpdatePolicyOutput = [
+    3,
+    n0,
+    _UPO,
+    0,
+    [_pSI, _pI, _pT, _p, _res, _ac, _cD, _lUD, _ef],
+    [0, 0, 0, [() => EntityIdentifier, 0], [() => EntityIdentifier, 0], [() => ActionIdentifierList, 0], 5, 5, 0],
+];
+var UpdatePolicyStoreInput = [
+    3,
+    n0,
+    _UPSI,
+    0,
+    [_pSI, _vS, _dPe, _des],
+    [0, () => ValidationSettings, 0, [() => PolicyStoreDescription, 0]],
+];
+var UpdatePolicyStoreOutput = [3, n0, _UPSO, 0, [_pSI, _ar, _cD, _lUD], [0, 0, 5, 5]];
+var UpdatePolicyTemplateInput = [
+    3,
+    n0,
+    _UPTI,
+    0,
+    [_pSI, _pTI, _des, _s],
+    [0, 0, [() => PolicyTemplateDescription, 0], [() => PolicyStatement, 0]],
+];
+var UpdatePolicyTemplateOutput = [3, n0, _UPTO, 0, [_pSI, _pTI, _cD, _lUD], [0, 0, 5, 5]];
+var UpdateStaticPolicyDefinition = [
+    3,
+    n0,
+    _USPD,
+    0,
+    [_des, _s],
+    [
+        [() => StaticPolicyDescription, 0],
+        [() => PolicyStatement, 0],
+    ],
+];
+var ValidationException = [
+    -3,
+    n0,
+    _VE,
+    {
+        [_e]: _c,
+    },
+    [_m, _fL],
+    [0, () => ValidationExceptionFieldList],
+];
+schema.TypeRegistry.for(n0).registerError(ValidationException, ValidationException$1);
+var ValidationExceptionField = [3, n0, _VEF, 0, [_pat, _m], [0, 0]];
+var ValidationSettings = [3, n0, _VS, 0, [_mo], [0]];
+var VerifiedPermissionsServiceException = [
+    -3,
+    _sm,
+    "VerifiedPermissionsServiceException",
+    0,
+    [],
+    [],
+];
+schema.TypeRegistry.for(_sm).registerError(VerifiedPermissionsServiceException, VerifiedPermissionsServiceException$1);
+var ActionIdentifierList = [1, n0, _AIL, 0, [() => ActionIdentifier, 0]];
+var BatchGetPolicyErrorList = [1, n0, _BGPEL, 0, () => BatchGetPolicyErrorItem];
+var BatchGetPolicyInputList = [1, n0, _BGPIL, 0, () => BatchGetPolicyInputItem];
+var BatchGetPolicyOutputList = [1, n0, _BGPOL, 0, [() => BatchGetPolicyOutputItem, 0]];
+var BatchIsAuthorizedInputList = [1, n0, _BIAIL, 0, [() => BatchIsAuthorizedInputItem, 0]];
+var BatchIsAuthorizedOutputList = [1, n0, _BIAOL, 0, [() => BatchIsAuthorizedOutputItem, 0]];
+var BatchIsAuthorizedWithTokenInputList = [
+    1,
+    n0,
+    _BIAWTIL,
+    0,
+    [() => BatchIsAuthorizedWithTokenInputItem, 0],
+];
+var BatchIsAuthorizedWithTokenOutputList = [
+    1,
+    n0,
+    _BIAWTOL,
+    0,
+    [() => BatchIsAuthorizedWithTokenOutputItem, 0],
+];
+var CedarTagSetAttribute = [1, n0, _CTSA, 0, [() => CedarTagValue, 0]];
+var ClientIds = [1, n0, _CIl, 0, [() => ClientId, 0]];
+var DeterminingPolicyList = [1, n0, _DPL, 0, () => DeterminingPolicyItem];
+var EntityList = [1, n0, _EL, 0, [() => EntityItem, 0]];
+var EvaluationErrorList = [1, n0, _EEL, 0, [() => EvaluationErrorItem, 0]];
+var IdentitySourceFilters = [1, n0, _ISFd, 0, [() => IdentitySourceFilter, 0]];
+var IdentitySources = [1, n0, _IS, 0, [() => IdentitySourceItem, 0]];
+var NamespaceList = [1, n0, _NL, 0, [() => Namespace, 0]];
+var ParentList = [1, n0, _PL, 0, [() => EntityIdentifier, 0]];
+var PolicyList = [1, n0, _PLo, 0, [() => PolicyItem, 0]];
+var PolicyStoreList = [1, n0, _PSL, 0, [() => PolicyStoreItem, 0]];
+var PolicyTemplatesList = [1, n0, _PTL, 0, [() => PolicyTemplateItem, 0]];
+var ResourceConflictList = [1, n0, _RCL, 0, () => ResourceConflict];
+var SetAttribute = [1, n0, _SAe, 0, [() => AttributeValue, 0]];
+var ValidationExceptionFieldList = [1, n0, _VEFL, 0, () => ValidationExceptionField];
+var CedarTagRecordAttribute = [2, n0, _CTRA, 0, [0, 0], [() => CedarTagValue, 0]];
+var ContextMap = [2, n0, _CM, 8, [0, 0], [() => AttributeValue, 0]];
+var EntityAttributes = [2, n0, _EA, 0, [0, 0], [() => AttributeValue, 0]];
+var EntityCedarTags = [2, n0, _ECT, 0, [0, 0], [() => CedarTagValue, 0]];
+var RecordAttribute = [2, n0, _RA, 0, [0, 0], [() => AttributeValue, 0]];
+var AttributeValue = [
+    3,
+    n0,
+    _AV,
+    0,
+    [_b, _eIn, _l, _st, _set, _rec, _ip, _dec, _da, _du],
+    [
+        [() => BooleanAttribute, 0],
+        [() => EntityIdentifier, 0],
+        [() => LongAttribute, 0],
+        [() => StringAttribute, 0],
+        [() => SetAttribute, 0],
+        [() => RecordAttribute, 0],
+        [() => IpAddr, 0],
+        [() => Decimal, 0],
+        [() => DatetimeAttribute, 0],
+        [() => Duration, 0],
+    ],
+];
+var CedarTagValue = [
+    3,
+    n0,
+    _CTV,
+    0,
+    [_b, _eIn, _l, _st, _set, _rec, _ip, _dec, _da, _du],
+    [
+        [() => BooleanAttribute, 0],
+        [() => EntityIdentifier, 0],
+        [() => LongAttribute, 0],
+        [() => StringAttribute, 0],
+        [() => CedarTagSetAttribute, 0],
+        [() => CedarTagRecordAttribute, 0],
+        [() => IpAddr, 0],
+        [() => Decimal, 0],
+        [() => DatetimeAttribute, 0],
+        [() => Duration, 0],
+    ],
+];
+var Configuration = [
+    3,
+    n0,
+    _Co,
+    0,
+    [_cUPC, _oICC],
+    [
+        [() => CognitoUserPoolConfiguration, 0],
+        [() => OpenIdConnectConfiguration, 0],
+    ],
+];
+var ConfigurationDetail = [
+    3,
+    n0,
+    _CD,
+    0,
+    [_cUPC, _oICC],
+    [
+        [() => CognitoUserPoolConfigurationDetail, 0],
+        [() => OpenIdConnectConfigurationDetail, 0],
+    ],
+];
+var ConfigurationItem = [
+    3,
+    n0,
+    _CIo,
+    0,
+    [_cUPC, _oICC],
+    [
+        [() => CognitoUserPoolConfigurationItem, 0],
+        [() => OpenIdConnectConfigurationItem, 0],
+    ],
+];
+var ContextDefinition = [
+    3,
+    n0,
+    _CDo,
+    0,
+    [_cM, _cJ],
+    [
+        [() => ContextMap, 0],
+        [() => CedarJson, 0],
+    ],
+];
+var EntitiesDefinition = [
+    3,
+    n0,
+    _ED,
+    0,
+    [_eL, _cJ],
+    [
+        [() => EntityList, 0],
+        [() => CedarJson, 0],
+    ],
+];
+var EntityReference = [3, n0, _ER, 0, [_u, _id], [2, [() => EntityIdentifier, 0]]];
+var OpenIdConnectTokenSelection = [
+    3,
+    n0,
+    _OICTS,
+    0,
+    [_aTO, _iTO],
+    [
+        [() => OpenIdConnectAccessTokenConfiguration, 0],
+        [() => OpenIdConnectIdentityTokenConfiguration, 0],
+    ],
+];
+var OpenIdConnectTokenSelectionDetail = [
+    3,
+    n0,
+    _OICTSD,
+    0,
+    [_aTO, _iTO],
+    [
+        [() => OpenIdConnectAccessTokenConfigurationDetail, 0],
+        [() => OpenIdConnectIdentityTokenConfigurationDetail, 0],
+    ],
+];
+var OpenIdConnectTokenSelectionItem = [
+    3,
+    n0,
+    _OICTSI,
+    0,
+    [_aTO, _iTO],
+    [
+        [() => OpenIdConnectAccessTokenConfigurationItem, 0],
+        [() => OpenIdConnectIdentityTokenConfigurationItem, 0],
+    ],
+];
+var PolicyDefinition = [
+    3,
+    n0,
+    _PD,
+    0,
+    [_sta, _tL],
+    [
+        [() => StaticPolicyDefinition, 0],
+        [() => TemplateLinkedPolicyDefinition, 0],
+    ],
+];
+var PolicyDefinitionDetail = [
+    3,
+    n0,
+    _PDD,
+    0,
+    [_sta, _tL],
+    [
+        [() => StaticPolicyDefinitionDetail, 0],
+        [() => TemplateLinkedPolicyDefinitionDetail, 0],
+    ],
+];
+var PolicyDefinitionItem = [
+    3,
+    n0,
+    _PDI,
+    0,
+    [_sta, _tL],
+    [
+        [() => StaticPolicyDefinitionItem, 0],
+        [() => TemplateLinkedPolicyDefinitionItem, 0],
+    ],
+];
+var SchemaDefinition = [3, n0, _SD, 0, [_cJ], [[() => SchemaJson, 0]]];
+var UpdateConfiguration = [
+    3,
+    n0,
+    _UC,
+    0,
+    [_cUPC, _oICC],
+    [
+        [() => UpdateCognitoUserPoolConfiguration, 0],
+        [() => UpdateOpenIdConnectConfiguration, 0],
+    ],
+];
+var UpdateOpenIdConnectTokenSelection = [
+    3,
+    n0,
+    _UOICTS,
+    0,
+    [_aTO, _iTO],
+    [
+        [() => UpdateOpenIdConnectAccessTokenConfiguration, 0],
+        [() => UpdateOpenIdConnectIdentityTokenConfiguration, 0],
+    ],
+];
+var UpdatePolicyDefinition = [
+    3,
+    n0,
+    _UPD,
+    0,
+    [_sta],
+    [[() => UpdateStaticPolicyDefinition, 0]],
+];
+var BatchGetPolicy = [
+    9,
+    n0,
+    _BGP,
+    0,
+    () => BatchGetPolicyInput,
+    () => BatchGetPolicyOutput,
+];
+var BatchIsAuthorized = [
+    9,
+    n0,
+    _BIA,
+    0,
+    () => BatchIsAuthorizedInput,
+    () => BatchIsAuthorizedOutput,
+];
+var BatchIsAuthorizedWithToken = [
+    9,
+    n0,
+    _BIAWT,
+    0,
+    () => BatchIsAuthorizedWithTokenInput,
+    () => BatchIsAuthorizedWithTokenOutput,
+];
+var CreateIdentitySource = [
+    9,
+    n0,
+    _CIS,
+    2,
+    () => CreateIdentitySourceInput,
+    () => CreateIdentitySourceOutput,
+];
+var CreatePolicy = [9, n0, _CP, 2, () => CreatePolicyInput, () => CreatePolicyOutput];
+var CreatePolicyStore = [
+    9,
+    n0,
+    _CPS,
+    2,
+    () => CreatePolicyStoreInput,
+    () => CreatePolicyStoreOutput,
+];
+var CreatePolicyTemplate = [
+    9,
+    n0,
+    _CPT,
+    2,
+    () => CreatePolicyTemplateInput,
+    () => CreatePolicyTemplateOutput,
+];
+var DeleteIdentitySource = [
+    9,
+    n0,
+    _DIS,
+    2,
+    () => DeleteIdentitySourceInput,
+    () => DeleteIdentitySourceOutput,
+];
+var DeletePolicy = [9, n0, _DP, 2, () => DeletePolicyInput, () => DeletePolicyOutput];
+var DeletePolicyStore = [
+    9,
+    n0,
+    _DPS,
+    2,
+    () => DeletePolicyStoreInput,
+    () => DeletePolicyStoreOutput,
+];
+var DeletePolicyTemplate = [
+    9,
+    n0,
+    _DPT,
+    2,
+    () => DeletePolicyTemplateInput,
+    () => DeletePolicyTemplateOutput,
+];
+var GetIdentitySource = [
+    9,
+    n0,
+    _GIS,
+    0,
+    () => GetIdentitySourceInput,
+    () => GetIdentitySourceOutput,
+];
+var GetPolicy = [9, n0, _GP, 0, () => GetPolicyInput, () => GetPolicyOutput];
+var GetPolicyStore = [
+    9,
+    n0,
+    _GPS,
+    0,
+    () => GetPolicyStoreInput,
+    () => GetPolicyStoreOutput,
+];
+var GetPolicyTemplate = [
+    9,
+    n0,
+    _GPT,
+    0,
+    () => GetPolicyTemplateInput,
+    () => GetPolicyTemplateOutput,
+];
+var GetSchema = [9, n0, _GS, 0, () => GetSchemaInput, () => GetSchemaOutput];
+var IsAuthorized = [9, n0, _IAs, 0, () => IsAuthorizedInput, () => IsAuthorizedOutput];
+var IsAuthorizedWithToken = [
+    9,
+    n0,
+    _IAWT,
+    0,
+    () => IsAuthorizedWithTokenInput,
+    () => IsAuthorizedWithTokenOutput,
+];
+var ListIdentitySources = [
+    9,
+    n0,
+    _LIS,
+    0,
+    () => ListIdentitySourcesInput,
+    () => ListIdentitySourcesOutput,
+];
+var ListPolicies = [9, n0, _LP, 0, () => ListPoliciesInput, () => ListPoliciesOutput];
+var ListPolicyStores = [
+    9,
+    n0,
+    _LPS,
+    0,
+    () => ListPolicyStoresInput,
+    () => ListPolicyStoresOutput,
+];
+var ListPolicyTemplates = [
+    9,
+    n0,
+    _LPT,
+    0,
+    () => ListPolicyTemplatesInput,
+    () => ListPolicyTemplatesOutput,
+];
+var ListTagsForResource = [
+    9,
+    n0,
+    _LTFR,
+    0,
+    () => ListTagsForResourceInput,
+    () => ListTagsForResourceOutput,
+];
+var PutSchema = [9, n0, _PSu, 2, () => PutSchemaInput, () => PutSchemaOutput];
+var TagResource = [9, n0, _TR, 0, () => TagResourceInput, () => TagResourceOutput];
+var UntagResource = [9, n0, _UR, 0, () => UntagResourceInput, () => UntagResourceOutput];
+var UpdateIdentitySource = [
+    9,
+    n0,
+    _UIS,
+    2,
+    () => UpdateIdentitySourceInput,
+    () => UpdateIdentitySourceOutput,
+];
+var UpdatePolicy = [9, n0, _UP, 2, () => UpdatePolicyInput, () => UpdatePolicyOutput];
+var UpdatePolicyStore = [
+    9,
+    n0,
+    _UPS,
+    2,
+    () => UpdatePolicyStoreInput,
+    () => UpdatePolicyStoreOutput,
+];
+var UpdatePolicyTemplate = [
+    9,
+    n0,
+    _UPT,
+    2,
+    () => UpdatePolicyTemplateInput,
+    () => UpdatePolicyTemplateOutput,
+];
 
 class BatchGetPolicyCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("VerifiedPermissions", "BatchGetPolicy", {})
     .n("VerifiedPermissionsClient", "BatchGetPolicyCommand")
-    .f(void 0, BatchGetPolicyOutputFilterSensitiveLog)
-    .ser(se_BatchGetPolicyCommand)
-    .de(de_BatchGetPolicyCommand)
+    .sc(BatchGetPolicy)
     .build() {
 }
 
@@ -2380,16 +2136,11 @@ class BatchIsAuthorizedCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("VerifiedPermissions", "BatchIsAuthorized", {})
     .n("VerifiedPermissionsClient", "BatchIsAuthorizedCommand")
-    .f(BatchIsAuthorizedInputFilterSensitiveLog, BatchIsAuthorizedOutputFilterSensitiveLog)
-    .ser(se_BatchIsAuthorizedCommand)
-    .de(de_BatchIsAuthorizedCommand)
+    .sc(BatchIsAuthorized)
     .build() {
 }
 
@@ -2397,16 +2148,11 @@ class BatchIsAuthorizedWithTokenCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("VerifiedPermissions", "BatchIsAuthorizedWithToken", {})
     .n("VerifiedPermissionsClient", "BatchIsAuthorizedWithTokenCommand")
-    .f(BatchIsAuthorizedWithTokenInputFilterSensitiveLog, BatchIsAuthorizedWithTokenOutputFilterSensitiveLog)
-    .ser(se_BatchIsAuthorizedWithTokenCommand)
-    .de(de_BatchIsAuthorizedWithTokenCommand)
+    .sc(BatchIsAuthorizedWithToken)
     .build() {
 }
 
@@ -2414,16 +2160,11 @@ class CreateIdentitySourceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("VerifiedPermissions", "CreateIdentitySource", {})
     .n("VerifiedPermissionsClient", "CreateIdentitySourceCommand")
-    .f(CreateIdentitySourceInputFilterSensitiveLog, void 0)
-    .ser(se_CreateIdentitySourceCommand)
-    .de(de_CreateIdentitySourceCommand)
+    .sc(CreateIdentitySource)
     .build() {
 }
 
@@ -2431,16 +2172,11 @@ class CreatePolicyCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("VerifiedPermissions", "CreatePolicy", {})
     .n("VerifiedPermissionsClient", "CreatePolicyCommand")
-    .f(CreatePolicyInputFilterSensitiveLog, CreatePolicyOutputFilterSensitiveLog)
-    .ser(se_CreatePolicyCommand)
-    .de(de_CreatePolicyCommand)
+    .sc(CreatePolicy)
     .build() {
 }
 
@@ -2448,16 +2184,11 @@ class CreatePolicyStoreCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("VerifiedPermissions", "CreatePolicyStore", {})
     .n("VerifiedPermissionsClient", "CreatePolicyStoreCommand")
-    .f(CreatePolicyStoreInputFilterSensitiveLog, void 0)
-    .ser(se_CreatePolicyStoreCommand)
-    .de(de_CreatePolicyStoreCommand)
+    .sc(CreatePolicyStore)
     .build() {
 }
 
@@ -2465,16 +2196,11 @@ class CreatePolicyTemplateCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("VerifiedPermissions", "CreatePolicyTemplate", {})
     .n("VerifiedPermissionsClient", "CreatePolicyTemplateCommand")
-    .f(CreatePolicyTemplateInputFilterSensitiveLog, void 0)
-    .ser(se_CreatePolicyTemplateCommand)
-    .de(de_CreatePolicyTemplateCommand)
+    .sc(CreatePolicyTemplate)
     .build() {
 }
 
@@ -2482,16 +2208,11 @@ class DeleteIdentitySourceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("VerifiedPermissions", "DeleteIdentitySource", {})
     .n("VerifiedPermissionsClient", "DeleteIdentitySourceCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteIdentitySourceCommand)
-    .de(de_DeleteIdentitySourceCommand)
+    .sc(DeleteIdentitySource)
     .build() {
 }
 
@@ -2499,16 +2220,11 @@ class DeletePolicyCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("VerifiedPermissions", "DeletePolicy", {})
     .n("VerifiedPermissionsClient", "DeletePolicyCommand")
-    .f(void 0, void 0)
-    .ser(se_DeletePolicyCommand)
-    .de(de_DeletePolicyCommand)
+    .sc(DeletePolicy)
     .build() {
 }
 
@@ -2516,16 +2232,11 @@ class DeletePolicyStoreCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("VerifiedPermissions", "DeletePolicyStore", {})
     .n("VerifiedPermissionsClient", "DeletePolicyStoreCommand")
-    .f(void 0, void 0)
-    .ser(se_DeletePolicyStoreCommand)
-    .de(de_DeletePolicyStoreCommand)
+    .sc(DeletePolicyStore)
     .build() {
 }
 
@@ -2533,16 +2244,11 @@ class DeletePolicyTemplateCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("VerifiedPermissions", "DeletePolicyTemplate", {})
     .n("VerifiedPermissionsClient", "DeletePolicyTemplateCommand")
-    .f(void 0, void 0)
-    .ser(se_DeletePolicyTemplateCommand)
-    .de(de_DeletePolicyTemplateCommand)
+    .sc(DeletePolicyTemplate)
     .build() {
 }
 
@@ -2550,16 +2256,11 @@ class GetIdentitySourceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("VerifiedPermissions", "GetIdentitySource", {})
     .n("VerifiedPermissionsClient", "GetIdentitySourceCommand")
-    .f(void 0, GetIdentitySourceOutputFilterSensitiveLog)
-    .ser(se_GetIdentitySourceCommand)
-    .de(de_GetIdentitySourceCommand)
+    .sc(GetIdentitySource)
     .build() {
 }
 
@@ -2567,16 +2268,11 @@ class GetPolicyCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("VerifiedPermissions", "GetPolicy", {})
     .n("VerifiedPermissionsClient", "GetPolicyCommand")
-    .f(void 0, GetPolicyOutputFilterSensitiveLog)
-    .ser(se_GetPolicyCommand)
-    .de(de_GetPolicyCommand)
+    .sc(GetPolicy)
     .build() {
 }
 
@@ -2584,16 +2280,11 @@ class GetPolicyStoreCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("VerifiedPermissions", "GetPolicyStore", {})
     .n("VerifiedPermissionsClient", "GetPolicyStoreCommand")
-    .f(void 0, GetPolicyStoreOutputFilterSensitiveLog)
-    .ser(se_GetPolicyStoreCommand)
-    .de(de_GetPolicyStoreCommand)
+    .sc(GetPolicyStore)
     .build() {
 }
 
@@ -2601,16 +2292,11 @@ class GetPolicyTemplateCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("VerifiedPermissions", "GetPolicyTemplate", {})
     .n("VerifiedPermissionsClient", "GetPolicyTemplateCommand")
-    .f(void 0, GetPolicyTemplateOutputFilterSensitiveLog)
-    .ser(se_GetPolicyTemplateCommand)
-    .de(de_GetPolicyTemplateCommand)
+    .sc(GetPolicyTemplate)
     .build() {
 }
 
@@ -2618,16 +2304,11 @@ class GetSchemaCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("VerifiedPermissions", "GetSchema", {})
     .n("VerifiedPermissionsClient", "GetSchemaCommand")
-    .f(void 0, GetSchemaOutputFilterSensitiveLog)
-    .ser(se_GetSchemaCommand)
-    .de(de_GetSchemaCommand)
+    .sc(GetSchema)
     .build() {
 }
 
@@ -2635,16 +2316,11 @@ class IsAuthorizedCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("VerifiedPermissions", "IsAuthorized", {})
     .n("VerifiedPermissionsClient", "IsAuthorizedCommand")
-    .f(IsAuthorizedInputFilterSensitiveLog, IsAuthorizedOutputFilterSensitiveLog)
-    .ser(se_IsAuthorizedCommand)
-    .de(de_IsAuthorizedCommand)
+    .sc(IsAuthorized)
     .build() {
 }
 
@@ -2652,16 +2328,11 @@ class IsAuthorizedWithTokenCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("VerifiedPermissions", "IsAuthorizedWithToken", {})
     .n("VerifiedPermissionsClient", "IsAuthorizedWithTokenCommand")
-    .f(IsAuthorizedWithTokenInputFilterSensitiveLog, IsAuthorizedWithTokenOutputFilterSensitiveLog)
-    .ser(se_IsAuthorizedWithTokenCommand)
-    .de(de_IsAuthorizedWithTokenCommand)
+    .sc(IsAuthorizedWithToken)
     .build() {
 }
 
@@ -2669,16 +2340,11 @@ class ListIdentitySourcesCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("VerifiedPermissions", "ListIdentitySources", {})
     .n("VerifiedPermissionsClient", "ListIdentitySourcesCommand")
-    .f(ListIdentitySourcesInputFilterSensitiveLog, ListIdentitySourcesOutputFilterSensitiveLog)
-    .ser(se_ListIdentitySourcesCommand)
-    .de(de_ListIdentitySourcesCommand)
+    .sc(ListIdentitySources)
     .build() {
 }
 
@@ -2686,16 +2352,11 @@ class ListPoliciesCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("VerifiedPermissions", "ListPolicies", {})
     .n("VerifiedPermissionsClient", "ListPoliciesCommand")
-    .f(ListPoliciesInputFilterSensitiveLog, ListPoliciesOutputFilterSensitiveLog)
-    .ser(se_ListPoliciesCommand)
-    .de(de_ListPoliciesCommand)
+    .sc(ListPolicies)
     .build() {
 }
 
@@ -2703,16 +2364,11 @@ class ListPolicyStoresCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("VerifiedPermissions", "ListPolicyStores", {})
     .n("VerifiedPermissionsClient", "ListPolicyStoresCommand")
-    .f(void 0, ListPolicyStoresOutputFilterSensitiveLog)
-    .ser(se_ListPolicyStoresCommand)
-    .de(de_ListPolicyStoresCommand)
+    .sc(ListPolicyStores)
     .build() {
 }
 
@@ -2720,16 +2376,11 @@ class ListPolicyTemplatesCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("VerifiedPermissions", "ListPolicyTemplates", {})
     .n("VerifiedPermissionsClient", "ListPolicyTemplatesCommand")
-    .f(void 0, ListPolicyTemplatesOutputFilterSensitiveLog)
-    .ser(se_ListPolicyTemplatesCommand)
-    .de(de_ListPolicyTemplatesCommand)
+    .sc(ListPolicyTemplates)
     .build() {
 }
 
@@ -2737,16 +2388,11 @@ class ListTagsForResourceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("VerifiedPermissions", "ListTagsForResource", {})
     .n("VerifiedPermissionsClient", "ListTagsForResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_ListTagsForResourceCommand)
-    .de(de_ListTagsForResourceCommand)
+    .sc(ListTagsForResource)
     .build() {
 }
 
@@ -2754,16 +2400,11 @@ class PutSchemaCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("VerifiedPermissions", "PutSchema", {})
     .n("VerifiedPermissionsClient", "PutSchemaCommand")
-    .f(PutSchemaInputFilterSensitiveLog, PutSchemaOutputFilterSensitiveLog)
-    .ser(se_PutSchemaCommand)
-    .de(de_PutSchemaCommand)
+    .sc(PutSchema)
     .build() {
 }
 
@@ -2771,16 +2412,11 @@ class TagResourceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("VerifiedPermissions", "TagResource", {})
     .n("VerifiedPermissionsClient", "TagResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_TagResourceCommand)
-    .de(de_TagResourceCommand)
+    .sc(TagResource)
     .build() {
 }
 
@@ -2788,16 +2424,11 @@ class UntagResourceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("VerifiedPermissions", "UntagResource", {})
     .n("VerifiedPermissionsClient", "UntagResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_UntagResourceCommand)
-    .de(de_UntagResourceCommand)
+    .sc(UntagResource)
     .build() {
 }
 
@@ -2805,16 +2436,11 @@ class UpdateIdentitySourceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("VerifiedPermissions", "UpdateIdentitySource", {})
     .n("VerifiedPermissionsClient", "UpdateIdentitySourceCommand")
-    .f(UpdateIdentitySourceInputFilterSensitiveLog, void 0)
-    .ser(se_UpdateIdentitySourceCommand)
-    .de(de_UpdateIdentitySourceCommand)
+    .sc(UpdateIdentitySource)
     .build() {
 }
 
@@ -2822,16 +2448,11 @@ class UpdatePolicyCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("VerifiedPermissions", "UpdatePolicy", {})
     .n("VerifiedPermissionsClient", "UpdatePolicyCommand")
-    .f(UpdatePolicyInputFilterSensitiveLog, UpdatePolicyOutputFilterSensitiveLog)
-    .ser(se_UpdatePolicyCommand)
-    .de(de_UpdatePolicyCommand)
+    .sc(UpdatePolicy)
     .build() {
 }
 
@@ -2839,16 +2460,11 @@ class UpdatePolicyStoreCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("VerifiedPermissions", "UpdatePolicyStore", {})
     .n("VerifiedPermissionsClient", "UpdatePolicyStoreCommand")
-    .f(UpdatePolicyStoreInputFilterSensitiveLog, void 0)
-    .ser(se_UpdatePolicyStoreCommand)
-    .de(de_UpdatePolicyStoreCommand)
+    .sc(UpdatePolicyStore)
     .build() {
 }
 
@@ -2856,16 +2472,11 @@ class UpdatePolicyTemplateCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("VerifiedPermissions", "UpdatePolicyTemplate", {})
     .n("VerifiedPermissionsClient", "UpdatePolicyTemplateCommand")
-    .f(UpdatePolicyTemplateInputFilterSensitiveLog, void 0)
-    .ser(se_UpdatePolicyTemplateCommand)
-    .de(de_UpdatePolicyTemplateCommand)
+    .sc(UpdatePolicyTemplate)
     .build() {
 }
 
@@ -2921,154 +2532,57 @@ Object.defineProperty(exports, "__Client", {
     enumerable: true,
     get: function () { return smithyClient.Client; }
 });
-exports.AccessDeniedException = AccessDeniedException;
-exports.ActionIdentifierFilterSensitiveLog = ActionIdentifierFilterSensitiveLog;
-exports.AttributeValueFilterSensitiveLog = AttributeValueFilterSensitiveLog;
+exports.AccessDeniedException = AccessDeniedException$1;
 exports.BatchGetPolicyCommand = BatchGetPolicyCommand;
 exports.BatchGetPolicyErrorCode = BatchGetPolicyErrorCode;
-exports.BatchGetPolicyOutputFilterSensitiveLog = BatchGetPolicyOutputFilterSensitiveLog;
-exports.BatchGetPolicyOutputItemFilterSensitiveLog = BatchGetPolicyOutputItemFilterSensitiveLog;
 exports.BatchIsAuthorizedCommand = BatchIsAuthorizedCommand;
-exports.BatchIsAuthorizedInputFilterSensitiveLog = BatchIsAuthorizedInputFilterSensitiveLog;
-exports.BatchIsAuthorizedInputItemFilterSensitiveLog = BatchIsAuthorizedInputItemFilterSensitiveLog;
-exports.BatchIsAuthorizedOutputFilterSensitiveLog = BatchIsAuthorizedOutputFilterSensitiveLog;
-exports.BatchIsAuthorizedOutputItemFilterSensitiveLog = BatchIsAuthorizedOutputItemFilterSensitiveLog;
 exports.BatchIsAuthorizedWithTokenCommand = BatchIsAuthorizedWithTokenCommand;
-exports.BatchIsAuthorizedWithTokenInputFilterSensitiveLog = BatchIsAuthorizedWithTokenInputFilterSensitiveLog;
-exports.BatchIsAuthorizedWithTokenInputItemFilterSensitiveLog = BatchIsAuthorizedWithTokenInputItemFilterSensitiveLog;
-exports.BatchIsAuthorizedWithTokenOutputFilterSensitiveLog = BatchIsAuthorizedWithTokenOutputFilterSensitiveLog;
-exports.BatchIsAuthorizedWithTokenOutputItemFilterSensitiveLog = BatchIsAuthorizedWithTokenOutputItemFilterSensitiveLog;
 exports.CedarVersion = CedarVersion;
-exports.CognitoGroupConfigurationDetailFilterSensitiveLog = CognitoGroupConfigurationDetailFilterSensitiveLog;
-exports.CognitoGroupConfigurationFilterSensitiveLog = CognitoGroupConfigurationFilterSensitiveLog;
-exports.CognitoGroupConfigurationItemFilterSensitiveLog = CognitoGroupConfigurationItemFilterSensitiveLog;
-exports.CognitoUserPoolConfigurationDetailFilterSensitiveLog = CognitoUserPoolConfigurationDetailFilterSensitiveLog;
-exports.CognitoUserPoolConfigurationFilterSensitiveLog = CognitoUserPoolConfigurationFilterSensitiveLog;
-exports.CognitoUserPoolConfigurationItemFilterSensitiveLog = CognitoUserPoolConfigurationItemFilterSensitiveLog;
-exports.ConfigurationDetailFilterSensitiveLog = ConfigurationDetailFilterSensitiveLog;
-exports.ConfigurationFilterSensitiveLog = ConfigurationFilterSensitiveLog;
-exports.ConfigurationItemFilterSensitiveLog = ConfigurationItemFilterSensitiveLog;
-exports.ConflictException = ConflictException;
-exports.ContextDefinitionFilterSensitiveLog = ContextDefinitionFilterSensitiveLog;
+exports.ConflictException = ConflictException$1;
 exports.CreateIdentitySourceCommand = CreateIdentitySourceCommand;
-exports.CreateIdentitySourceInputFilterSensitiveLog = CreateIdentitySourceInputFilterSensitiveLog;
 exports.CreatePolicyCommand = CreatePolicyCommand;
-exports.CreatePolicyInputFilterSensitiveLog = CreatePolicyInputFilterSensitiveLog;
-exports.CreatePolicyOutputFilterSensitiveLog = CreatePolicyOutputFilterSensitiveLog;
 exports.CreatePolicyStoreCommand = CreatePolicyStoreCommand;
-exports.CreatePolicyStoreInputFilterSensitiveLog = CreatePolicyStoreInputFilterSensitiveLog;
 exports.CreatePolicyTemplateCommand = CreatePolicyTemplateCommand;
-exports.CreatePolicyTemplateInputFilterSensitiveLog = CreatePolicyTemplateInputFilterSensitiveLog;
 exports.Decision = Decision;
 exports.DeleteIdentitySourceCommand = DeleteIdentitySourceCommand;
 exports.DeletePolicyCommand = DeletePolicyCommand;
 exports.DeletePolicyStoreCommand = DeletePolicyStoreCommand;
 exports.DeletePolicyTemplateCommand = DeletePolicyTemplateCommand;
 exports.DeletionProtection = DeletionProtection;
-exports.EntitiesDefinitionFilterSensitiveLog = EntitiesDefinitionFilterSensitiveLog;
-exports.EntityIdentifierFilterSensitiveLog = EntityIdentifierFilterSensitiveLog;
-exports.EntityItemFilterSensitiveLog = EntityItemFilterSensitiveLog;
-exports.EntityReferenceFilterSensitiveLog = EntityReferenceFilterSensitiveLog;
-exports.EvaluationErrorItemFilterSensitiveLog = EvaluationErrorItemFilterSensitiveLog;
 exports.GetIdentitySourceCommand = GetIdentitySourceCommand;
-exports.GetIdentitySourceOutputFilterSensitiveLog = GetIdentitySourceOutputFilterSensitiveLog;
 exports.GetPolicyCommand = GetPolicyCommand;
-exports.GetPolicyOutputFilterSensitiveLog = GetPolicyOutputFilterSensitiveLog;
 exports.GetPolicyStoreCommand = GetPolicyStoreCommand;
-exports.GetPolicyStoreOutputFilterSensitiveLog = GetPolicyStoreOutputFilterSensitiveLog;
 exports.GetPolicyTemplateCommand = GetPolicyTemplateCommand;
-exports.GetPolicyTemplateOutputFilterSensitiveLog = GetPolicyTemplateOutputFilterSensitiveLog;
 exports.GetSchemaCommand = GetSchemaCommand;
-exports.GetSchemaOutputFilterSensitiveLog = GetSchemaOutputFilterSensitiveLog;
-exports.IdentitySourceDetailsFilterSensitiveLog = IdentitySourceDetailsFilterSensitiveLog;
-exports.IdentitySourceFilterFilterSensitiveLog = IdentitySourceFilterFilterSensitiveLog;
-exports.IdentitySourceItemDetailsFilterSensitiveLog = IdentitySourceItemDetailsFilterSensitiveLog;
-exports.IdentitySourceItemFilterSensitiveLog = IdentitySourceItemFilterSensitiveLog;
-exports.InternalServerException = InternalServerException;
-exports.InvalidStateException = InvalidStateException;
+exports.InternalServerException = InternalServerException$1;
+exports.InvalidStateException = InvalidStateException$1;
 exports.IsAuthorizedCommand = IsAuthorizedCommand;
-exports.IsAuthorizedInputFilterSensitiveLog = IsAuthorizedInputFilterSensitiveLog;
-exports.IsAuthorizedOutputFilterSensitiveLog = IsAuthorizedOutputFilterSensitiveLog;
 exports.IsAuthorizedWithTokenCommand = IsAuthorizedWithTokenCommand;
-exports.IsAuthorizedWithTokenInputFilterSensitiveLog = IsAuthorizedWithTokenInputFilterSensitiveLog;
-exports.IsAuthorizedWithTokenOutputFilterSensitiveLog = IsAuthorizedWithTokenOutputFilterSensitiveLog;
 exports.ListIdentitySourcesCommand = ListIdentitySourcesCommand;
-exports.ListIdentitySourcesInputFilterSensitiveLog = ListIdentitySourcesInputFilterSensitiveLog;
-exports.ListIdentitySourcesOutputFilterSensitiveLog = ListIdentitySourcesOutputFilterSensitiveLog;
 exports.ListPoliciesCommand = ListPoliciesCommand;
-exports.ListPoliciesInputFilterSensitiveLog = ListPoliciesInputFilterSensitiveLog;
-exports.ListPoliciesOutputFilterSensitiveLog = ListPoliciesOutputFilterSensitiveLog;
 exports.ListPolicyStoresCommand = ListPolicyStoresCommand;
-exports.ListPolicyStoresOutputFilterSensitiveLog = ListPolicyStoresOutputFilterSensitiveLog;
 exports.ListPolicyTemplatesCommand = ListPolicyTemplatesCommand;
-exports.ListPolicyTemplatesOutputFilterSensitiveLog = ListPolicyTemplatesOutputFilterSensitiveLog;
 exports.ListTagsForResourceCommand = ListTagsForResourceCommand;
-exports.OpenIdConnectAccessTokenConfigurationDetailFilterSensitiveLog = OpenIdConnectAccessTokenConfigurationDetailFilterSensitiveLog;
-exports.OpenIdConnectAccessTokenConfigurationFilterSensitiveLog = OpenIdConnectAccessTokenConfigurationFilterSensitiveLog;
-exports.OpenIdConnectAccessTokenConfigurationItemFilterSensitiveLog = OpenIdConnectAccessTokenConfigurationItemFilterSensitiveLog;
-exports.OpenIdConnectConfigurationDetailFilterSensitiveLog = OpenIdConnectConfigurationDetailFilterSensitiveLog;
-exports.OpenIdConnectConfigurationFilterSensitiveLog = OpenIdConnectConfigurationFilterSensitiveLog;
-exports.OpenIdConnectConfigurationItemFilterSensitiveLog = OpenIdConnectConfigurationItemFilterSensitiveLog;
-exports.OpenIdConnectGroupConfigurationDetailFilterSensitiveLog = OpenIdConnectGroupConfigurationDetailFilterSensitiveLog;
-exports.OpenIdConnectGroupConfigurationFilterSensitiveLog = OpenIdConnectGroupConfigurationFilterSensitiveLog;
-exports.OpenIdConnectGroupConfigurationItemFilterSensitiveLog = OpenIdConnectGroupConfigurationItemFilterSensitiveLog;
-exports.OpenIdConnectIdentityTokenConfigurationDetailFilterSensitiveLog = OpenIdConnectIdentityTokenConfigurationDetailFilterSensitiveLog;
-exports.OpenIdConnectIdentityTokenConfigurationFilterSensitiveLog = OpenIdConnectIdentityTokenConfigurationFilterSensitiveLog;
-exports.OpenIdConnectIdentityTokenConfigurationItemFilterSensitiveLog = OpenIdConnectIdentityTokenConfigurationItemFilterSensitiveLog;
-exports.OpenIdConnectTokenSelectionDetailFilterSensitiveLog = OpenIdConnectTokenSelectionDetailFilterSensitiveLog;
-exports.OpenIdConnectTokenSelectionFilterSensitiveLog = OpenIdConnectTokenSelectionFilterSensitiveLog;
-exports.OpenIdConnectTokenSelectionItemFilterSensitiveLog = OpenIdConnectTokenSelectionItemFilterSensitiveLog;
 exports.OpenIdIssuer = OpenIdIssuer;
-exports.PolicyDefinitionDetailFilterSensitiveLog = PolicyDefinitionDetailFilterSensitiveLog;
-exports.PolicyDefinitionFilterSensitiveLog = PolicyDefinitionFilterSensitiveLog;
-exports.PolicyDefinitionItemFilterSensitiveLog = PolicyDefinitionItemFilterSensitiveLog;
 exports.PolicyEffect = PolicyEffect;
-exports.PolicyFilterFilterSensitiveLog = PolicyFilterFilterSensitiveLog;
-exports.PolicyItemFilterSensitiveLog = PolicyItemFilterSensitiveLog;
-exports.PolicyStoreItemFilterSensitiveLog = PolicyStoreItemFilterSensitiveLog;
-exports.PolicyTemplateItemFilterSensitiveLog = PolicyTemplateItemFilterSensitiveLog;
 exports.PolicyType = PolicyType;
 exports.PutSchemaCommand = PutSchemaCommand;
-exports.PutSchemaInputFilterSensitiveLog = PutSchemaInputFilterSensitiveLog;
-exports.PutSchemaOutputFilterSensitiveLog = PutSchemaOutputFilterSensitiveLog;
-exports.ResourceNotFoundException = ResourceNotFoundException;
+exports.ResourceNotFoundException = ResourceNotFoundException$1;
 exports.ResourceType = ResourceType;
-exports.SchemaDefinitionFilterSensitiveLog = SchemaDefinitionFilterSensitiveLog;
-exports.ServiceQuotaExceededException = ServiceQuotaExceededException;
-exports.StaticPolicyDefinitionDetailFilterSensitiveLog = StaticPolicyDefinitionDetailFilterSensitiveLog;
-exports.StaticPolicyDefinitionFilterSensitiveLog = StaticPolicyDefinitionFilterSensitiveLog;
-exports.StaticPolicyDefinitionItemFilterSensitiveLog = StaticPolicyDefinitionItemFilterSensitiveLog;
+exports.ServiceQuotaExceededException = ServiceQuotaExceededException$1;
 exports.TagResourceCommand = TagResourceCommand;
-exports.TemplateLinkedPolicyDefinitionDetailFilterSensitiveLog = TemplateLinkedPolicyDefinitionDetailFilterSensitiveLog;
-exports.TemplateLinkedPolicyDefinitionFilterSensitiveLog = TemplateLinkedPolicyDefinitionFilterSensitiveLog;
-exports.TemplateLinkedPolicyDefinitionItemFilterSensitiveLog = TemplateLinkedPolicyDefinitionItemFilterSensitiveLog;
-exports.ThrottlingException = ThrottlingException;
-exports.TooManyTagsException = TooManyTagsException;
+exports.ThrottlingException = ThrottlingException$1;
+exports.TooManyTagsException = TooManyTagsException$1;
 exports.UntagResourceCommand = UntagResourceCommand;
-exports.UpdateCognitoGroupConfigurationFilterSensitiveLog = UpdateCognitoGroupConfigurationFilterSensitiveLog;
-exports.UpdateCognitoUserPoolConfigurationFilterSensitiveLog = UpdateCognitoUserPoolConfigurationFilterSensitiveLog;
-exports.UpdateConfigurationFilterSensitiveLog = UpdateConfigurationFilterSensitiveLog;
 exports.UpdateIdentitySourceCommand = UpdateIdentitySourceCommand;
-exports.UpdateIdentitySourceInputFilterSensitiveLog = UpdateIdentitySourceInputFilterSensitiveLog;
-exports.UpdateOpenIdConnectAccessTokenConfigurationFilterSensitiveLog = UpdateOpenIdConnectAccessTokenConfigurationFilterSensitiveLog;
-exports.UpdateOpenIdConnectConfigurationFilterSensitiveLog = UpdateOpenIdConnectConfigurationFilterSensitiveLog;
-exports.UpdateOpenIdConnectGroupConfigurationFilterSensitiveLog = UpdateOpenIdConnectGroupConfigurationFilterSensitiveLog;
-exports.UpdateOpenIdConnectIdentityTokenConfigurationFilterSensitiveLog = UpdateOpenIdConnectIdentityTokenConfigurationFilterSensitiveLog;
-exports.UpdateOpenIdConnectTokenSelectionFilterSensitiveLog = UpdateOpenIdConnectTokenSelectionFilterSensitiveLog;
 exports.UpdatePolicyCommand = UpdatePolicyCommand;
-exports.UpdatePolicyDefinitionFilterSensitiveLog = UpdatePolicyDefinitionFilterSensitiveLog;
-exports.UpdatePolicyInputFilterSensitiveLog = UpdatePolicyInputFilterSensitiveLog;
-exports.UpdatePolicyOutputFilterSensitiveLog = UpdatePolicyOutputFilterSensitiveLog;
 exports.UpdatePolicyStoreCommand = UpdatePolicyStoreCommand;
-exports.UpdatePolicyStoreInputFilterSensitiveLog = UpdatePolicyStoreInputFilterSensitiveLog;
 exports.UpdatePolicyTemplateCommand = UpdatePolicyTemplateCommand;
-exports.UpdatePolicyTemplateInputFilterSensitiveLog = UpdatePolicyTemplateInputFilterSensitiveLog;
-exports.UpdateStaticPolicyDefinitionFilterSensitiveLog = UpdateStaticPolicyDefinitionFilterSensitiveLog;
-exports.ValidationException = ValidationException;
+exports.ValidationException = ValidationException$1;
 exports.ValidationMode = ValidationMode;
 exports.VerifiedPermissions = VerifiedPermissions;
 exports.VerifiedPermissionsClient = VerifiedPermissionsClient;
-exports.VerifiedPermissionsServiceException = VerifiedPermissionsServiceException;
+exports.VerifiedPermissionsServiceException = VerifiedPermissionsServiceException$1;
 exports.paginateListIdentitySources = paginateListIdentitySources;
 exports.paginateListPolicies = paginateListPolicies;
 exports.paginateListPolicyStores = paginateListPolicyStores;