@aws-sdk/client-verifiedpermissions 3.395.0 → 3.398.0

package/dist-es/commands/UpdateIdentitySourceCommand.js

@@ -1,6 +1,7 @@
 import { getEndpointPlugin } from "@smithy/middleware-endpoint";
 import { getSerdePlugin } from "@smithy/middleware-serde";
 import { Command as $Command } from "@smithy/smithy-client";
+import { UpdateIdentitySourceInputFilterSensitiveLog, } from "../models/models_0";
 import { de_UpdateIdentitySourceCommand, se_UpdateIdentitySourceCommand } from "../protocols/Aws_json1_0";
 export { $Command };
 export class UpdateIdentitySourceCommand extends $Command {
@@ -27,7 +28,7 @@ export class UpdateIdentitySourceCommand extends $Command {
             logger,
             clientName,
             commandName,
-            inputFilterSensitiveLog: (_) => _,
+            inputFilterSensitiveLog: UpdateIdentitySourceInputFilterSensitiveLog,
             outputFilterSensitiveLog: (_) => _,
         };
         const { requestHandler } = configuration;

package/dist-es/commands/UpdatePolicyCommand.js

@@ -1,6 +1,7 @@
 import { getEndpointPlugin } from "@smithy/middleware-endpoint";
 import { getSerdePlugin } from "@smithy/middleware-serde";
 import { Command as $Command } from "@smithy/smithy-client";
+import { UpdatePolicyInputFilterSensitiveLog, UpdatePolicyOutputFilterSensitiveLog, } from "../models/models_0";
 import { de_UpdatePolicyCommand, se_UpdatePolicyCommand } from "../protocols/Aws_json1_0";
 export { $Command };
 export class UpdatePolicyCommand extends $Command {
@@ -27,8 +28,8 @@ export class UpdatePolicyCommand extends $Command {
             logger,
             clientName,
             commandName,
-            inputFilterSensitiveLog: (_) => _,
-            outputFilterSensitiveLog: (_) => _,
+            inputFilterSensitiveLog: UpdatePolicyInputFilterSensitiveLog,
+            outputFilterSensitiveLog: UpdatePolicyOutputFilterSensitiveLog,
         };
         const { requestHandler } = configuration;
         return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);

package/dist-es/commands/UpdatePolicyTemplateCommand.js

@@ -1,6 +1,7 @@
 import { getEndpointPlugin } from "@smithy/middleware-endpoint";
 import { getSerdePlugin } from "@smithy/middleware-serde";
 import { Command as $Command } from "@smithy/smithy-client";
+import { UpdatePolicyTemplateInputFilterSensitiveLog, } from "../models/models_0";
 import { de_UpdatePolicyTemplateCommand, se_UpdatePolicyTemplateCommand } from "../protocols/Aws_json1_0";
 export { $Command };
 export class UpdatePolicyTemplateCommand extends $Command {
@@ -27,7 +28,7 @@ export class UpdatePolicyTemplateCommand extends $Command {
             logger,
             clientName,
             commandName,
-            inputFilterSensitiveLog: (_) => _,
+            inputFilterSensitiveLog: UpdatePolicyTemplateInputFilterSensitiveLog,
             outputFilterSensitiveLog: (_) => _,
         };
         const { requestHandler } = configuration;

package/dist-es/models/models_0.js

@@ -1,3 +1,4 @@
+import { SENSITIVE_STRING } from "@smithy/smithy-client";
 import { VerifiedPermissionsServiceException as __BaseException } from "./VerifiedPermissionsServiceException";
 export class AccessDeniedException extends __BaseException {
     constructor(opts) {
@@ -225,3 +226,307 @@ export var EntitiesDefinition;
         return visitor._(value.$unknown[0], value.$unknown[1]);
     };
 })(EntitiesDefinition || (EntitiesDefinition = {}));
+export const ActionIdentifierFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.actionType && { actionType: SENSITIVE_STRING }),
+    ...(obj.actionId && { actionId: SENSITIVE_STRING }),
+});
+export const EntityIdentifierFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.entityType && { entityType: SENSITIVE_STRING }),
+    ...(obj.entityId && { entityId: SENSITIVE_STRING }),
+});
+export const CognitoUserPoolConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.clientIds && { clientIds: SENSITIVE_STRING }),
+});
+export const ConfigurationFilterSensitiveLog = (obj) => {
+    if (obj.cognitoUserPoolConfiguration !== undefined)
+        return {
+            cognitoUserPoolConfiguration: CognitoUserPoolConfigurationFilterSensitiveLog(obj.cognitoUserPoolConfiguration),
+        };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const CreateIdentitySourceInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.configuration && { configuration: ConfigurationFilterSensitiveLog(obj.configuration) }),
+    ...(obj.principalEntityType && { principalEntityType: SENSITIVE_STRING }),
+});
+export const StaticPolicyDefinitionFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.description && { description: SENSITIVE_STRING }),
+    ...(obj.statement && { statement: SENSITIVE_STRING }),
+});
+export const TemplateLinkedPolicyDefinitionFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.principal && { principal: EntityIdentifierFilterSensitiveLog(obj.principal) }),
+    ...(obj.resource && { resource: EntityIdentifierFilterSensitiveLog(obj.resource) }),
+});
+export 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" };
+};
+export const CreatePolicyInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.definition && { definition: PolicyDefinitionFilterSensitiveLog(obj.definition) }),
+});
+export const CreatePolicyOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.principal && { principal: EntityIdentifierFilterSensitiveLog(obj.principal) }),
+    ...(obj.resource && { resource: EntityIdentifierFilterSensitiveLog(obj.resource) }),
+});
+export const CreatePolicyTemplateInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.description && { description: SENSITIVE_STRING }),
+    ...(obj.statement && { statement: SENSITIVE_STRING }),
+});
+export 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" };
+};
+export const EvaluationErrorItemFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const IdentitySourceDetailsFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.clientIds && { clientIds: SENSITIVE_STRING }),
+});
+export const GetIdentitySourceOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.details && { details: IdentitySourceDetailsFilterSensitiveLog(obj.details) }),
+    ...(obj.principalEntityType && { principalEntityType: SENSITIVE_STRING }),
+});
+export const StaticPolicyDefinitionDetailFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.description && { description: SENSITIVE_STRING }),
+    ...(obj.statement && { statement: SENSITIVE_STRING }),
+});
+export const TemplateLinkedPolicyDefinitionDetailFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.principal && { principal: EntityIdentifierFilterSensitiveLog(obj.principal) }),
+    ...(obj.resource && { resource: EntityIdentifierFilterSensitiveLog(obj.resource) }),
+});
+export 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" };
+};
+export const GetPolicyOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.principal && { principal: EntityIdentifierFilterSensitiveLog(obj.principal) }),
+    ...(obj.resource && { resource: EntityIdentifierFilterSensitiveLog(obj.resource) }),
+    ...(obj.definition && { definition: PolicyDefinitionDetailFilterSensitiveLog(obj.definition) }),
+});
+export const GetPolicyTemplateOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.description && { description: SENSITIVE_STRING }),
+    ...(obj.statement && { statement: SENSITIVE_STRING }),
+});
+export const GetSchemaOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.schema && { schema: SENSITIVE_STRING }),
+});
+export const IdentitySourceFilterFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.principalEntityType && { principalEntityType: SENSITIVE_STRING }),
+});
+export const ListIdentitySourcesInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.filters && { filters: obj.filters.map((item) => IdentitySourceFilterFilterSensitiveLog(item)) }),
+});
+export const IdentitySourceItemDetailsFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.clientIds && { clientIds: SENSITIVE_STRING }),
+});
+export const IdentitySourceItemFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.details && { details: IdentitySourceItemDetailsFilterSensitiveLog(obj.details) }),
+    ...(obj.principalEntityType && { principalEntityType: SENSITIVE_STRING }),
+});
+export const ListIdentitySourcesOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.identitySources && {
+        identitySources: obj.identitySources.map((item) => IdentitySourceItemFilterSensitiveLog(item)),
+    }),
+});
+export const UpdateCognitoUserPoolConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.clientIds && { clientIds: SENSITIVE_STRING }),
+});
+export const UpdateConfigurationFilterSensitiveLog = (obj) => {
+    if (obj.cognitoUserPoolConfiguration !== undefined)
+        return {
+            cognitoUserPoolConfiguration: UpdateCognitoUserPoolConfigurationFilterSensitiveLog(obj.cognitoUserPoolConfiguration),
+        };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const UpdateIdentitySourceInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.updateConfiguration && {
+        updateConfiguration: UpdateConfigurationFilterSensitiveLog(obj.updateConfiguration),
+    }),
+    ...(obj.principalEntityType && { principalEntityType: SENSITIVE_STRING }),
+});
+export const IsAuthorizedOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.errors && { errors: SENSITIVE_STRING }),
+});
+export const IsAuthorizedWithTokenOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.errors && { errors: SENSITIVE_STRING }),
+});
+export const PolicyFilterFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.principal && { principal: EntityReferenceFilterSensitiveLog(obj.principal) }),
+    ...(obj.resource && { resource: EntityReferenceFilterSensitiveLog(obj.resource) }),
+});
+export const ListPoliciesInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.filter && { filter: PolicyFilterFilterSensitiveLog(obj.filter) }),
+});
+export const StaticPolicyDefinitionItemFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.description && { description: SENSITIVE_STRING }),
+});
+export const TemplateLinkedPolicyDefinitionItemFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.principal && { principal: EntityIdentifierFilterSensitiveLog(obj.principal) }),
+    ...(obj.resource && { resource: EntityIdentifierFilterSensitiveLog(obj.resource) }),
+});
+export 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" };
+};
+export const PolicyItemFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.principal && { principal: EntityIdentifierFilterSensitiveLog(obj.principal) }),
+    ...(obj.resource && { resource: EntityIdentifierFilterSensitiveLog(obj.resource) }),
+    ...(obj.definition && { definition: PolicyDefinitionItemFilterSensitiveLog(obj.definition) }),
+});
+export const ListPoliciesOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.policies && { policies: obj.policies.map((item) => PolicyItemFilterSensitiveLog(item)) }),
+});
+export const PolicyTemplateItemFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.description && { description: SENSITIVE_STRING }),
+});
+export const ListPolicyTemplatesOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.policyTemplates && {
+        policyTemplates: obj.policyTemplates.map((item) => PolicyTemplateItemFilterSensitiveLog(item)),
+    }),
+});
+export const UpdateStaticPolicyDefinitionFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.description && { description: SENSITIVE_STRING }),
+    ...(obj.statement && { statement: SENSITIVE_STRING }),
+});
+export const UpdatePolicyDefinitionFilterSensitiveLog = (obj) => {
+    if (obj.static !== undefined)
+        return { static: UpdateStaticPolicyDefinitionFilterSensitiveLog(obj.static) };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const UpdatePolicyInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.definition && { definition: UpdatePolicyDefinitionFilterSensitiveLog(obj.definition) }),
+});
+export const UpdatePolicyOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.principal && { principal: EntityIdentifierFilterSensitiveLog(obj.principal) }),
+    ...(obj.resource && { resource: EntityIdentifierFilterSensitiveLog(obj.resource) }),
+});
+export const UpdatePolicyTemplateInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.description && { description: SENSITIVE_STRING }),
+    ...(obj.statement && { statement: SENSITIVE_STRING }),
+});
+export const SchemaDefinitionFilterSensitiveLog = (obj) => {
+    if (obj.cedarJson !== undefined)
+        return { cedarJson: SENSITIVE_STRING };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const PutSchemaInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.definition && { definition: SchemaDefinitionFilterSensitiveLog(obj.definition) }),
+});
+export const PutSchemaOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.namespaces && { namespaces: SENSITIVE_STRING }),
+});
+export const AttributeValueFilterSensitiveLog = (obj) => {
+    if (obj.boolean !== undefined)
+        return { boolean: SENSITIVE_STRING };
+    if (obj.entityIdentifier !== undefined)
+        return { entityIdentifier: EntityIdentifierFilterSensitiveLog(obj.entityIdentifier) };
+    if (obj.long !== undefined)
+        return { long: SENSITIVE_STRING };
+    if (obj.string !== undefined)
+        return { string: 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.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const ContextDefinitionFilterSensitiveLog = (obj) => {
+    if (obj.contextMap !== undefined)
+        return {
+            contextMap: Object.entries(obj.contextMap).reduce((acc, [key, value]) => ((acc[key] = AttributeValueFilterSensitiveLog(value)), acc), {}),
+        };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export 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)) }),
+});
+export const EntitiesDefinitionFilterSensitiveLog = (obj) => {
+    if (obj.entityList !== undefined)
+        return { entityList: obj.entityList.map((item) => EntityItemFilterSensitiveLog(item)) };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export 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) }),
+});
+export const IsAuthorizedWithTokenInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.identityToken && { identityToken: SENSITIVE_STRING }),
+    ...(obj.accessToken && { accessToken: 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) }),
+});

package/dist-es/runtimeExtensions.js

@@ -1,12 +1,12 @@
-import { getDefaultClientConfiguration, resolveDefaultRuntimeConfig } from "@smithy/types";
+import { getDefaultExtensionConfiguration, resolveDefaultRuntimeConfig } from "@smithy/smithy-client";
 const asPartial = (t) => t;
 export const resolveRuntimeExtensions = (runtimeConfig, extensions) => {
-    const clientConfiguration = {
-        ...asPartial(getDefaultClientConfiguration(runtimeConfig)),
+    const extensionConfiguration = {
+        ...asPartial(getDefaultExtensionConfiguration(runtimeConfig)),
     };
-    extensions.forEach((extension) => extension.configureClient(clientConfiguration));
+    extensions.forEach((extension) => extension.configure(extensionConfiguration));
     return {
         ...runtimeConfig,
-        ...resolveDefaultRuntimeConfig(clientConfiguration),
+        ...resolveDefaultRuntimeConfig(extensionConfiguration),
     };
 };

package/dist-types/commands/IsAuthorizedWithTokenCommand.d.ts

@@ -24,11 +24,25 @@ export interface IsAuthorizedWithTokenCommandOutput extends IsAuthorizedWithToke
 /**
  * @public
  * <p>Makes an authorization decision about a service request described in the parameters.
- *             The principal in this request comes from an external identity source. The information in the
- *             parameters can also define additional context that Verified Permissions can include in the evaluation.
- *             The request is evaluated against all matching policies in the specified policy store. The result
- *             of the decision is either <code>Allow</code> or <code>Deny</code>, along with a list of
- *             the policies that resulted in the decision.</p>
+ *             The principal in this request comes from an external identity source in the form of an identity
+ *             token formatted as a <a href="https://wikipedia.org/wiki/JSON_Web_Token">JSON web
+ *                 token (JWT)</a>. The information in the parameters can also define additional
+ *             context that Verified Permissions can include in the evaluation. The request is evaluated against all
+ *             matching policies in the specified policy store. The result of the decision is either
+ *                 <code>Allow</code> or <code>Deny</code>, along with a list of the policies that
+ *             resulted in the decision.</p>
+ *          <important>
+ *             <p>If you specify the <code>identityToken</code> parameter, then this operation
+ *                 derives the principal from that token. You must not also include that principal in
+ *                 the <code>entities</code> parameter or the operation fails and reports a conflict
+ *                 between the two entity sources.</p>
+ *             <p>If you provide only an <code>accessToken</code>, then you can include the entity
+ *                 as part of the <code>entities</code> parameter to provide additional
+ *                 attributes.</p>
+ *          </important>
+ *          <p>At this time, Verified Permissions accepts tokens from only Amazon Cognito.</p>
+ *          <p>Verified Permissions validates each token that is specified in a request by checking its expiration
+ *             date and its signature.</p>
  *          <important>
  *             <p>If you delete a Amazon Cognito user pool or user, tokens from that deleted pool or that deleted user continue to be usable until they expire.</p>
  *          </important>

package/dist-types/commands/UpdatePolicyCommand.d.ts

@@ -27,9 +27,46 @@ export interface UpdatePolicyCommandOutput extends UpdatePolicyOutput, __Metadat
  *             the <a href="https://docs.aws.amazon.com/verifiedpermissions/latest/apireference/API_UpdatePolicyInput.html#amazonverifiedpermissions-UpdatePolicy-request-UpdatePolicyDefinition">UpdatePolicyDefinition</a> parameter. You can directly update only static policies. To
  *             change a template-linked policy, you must update the template instead, using <a href="https://docs.aws.amazon.com/verifiedpermissions/latest/apireference/API_UpdatePolicyTemplate.html">UpdatePolicyTemplate</a>.</p>
  *          <note>
- *             <p>If policy validation is enabled in the policy store, then updating a static policy causes Verified Permissions to
- *                 validate the policy against the schema in the policy store. If the updated static policy doesn't pass
- *                 validation, the operation fails and the update isn't stored.</p>
+ *             <ul>
+ *                <li>
+ *                   <p>If policy validation is enabled in the policy store, then updating a static policy causes
+ *                         Verified Permissions to validate the policy against the schema in the policy store. If the updated
+ *                         static policy doesn't pass validation, the operation fails and the update isn't
+ *                         stored.</p>
+ *                </li>
+ *                <li>
+ *                   <p>When you edit a static policy, You can change only certain elements of a static
+ *                         policy:</p>
+ *                   <ul>
+ *                      <li>
+ *                         <p>The action referenced by the policy. </p>
+ *                      </li>
+ *                      <li>
+ *                         <p>A condition clause, such as when and unless. </p>
+ *                      </li>
+ *                   </ul>
+ *                   <p>You can't change these elements of a static policy: </p>
+ *                   <ul>
+ *                      <li>
+ *                         <p>Changing a policy from a static policy to a template-linked
+ *                                 policy. </p>
+ *                      </li>
+ *                      <li>
+ *                         <p>Changing the effect of a static policy from permit or forbid.
+ *                             </p>
+ *                      </li>
+ *                      <li>
+ *                         <p>The principal referenced by a static policy. </p>
+ *                      </li>
+ *                      <li>
+ *                         <p>The resource referenced by a static policy. </p>
+ *                      </li>
+ *                   </ul>
+ *                </li>
+ *                <li>
+ *                   <p>To update a template-linked policy, you must update the template instead. </p>
+ *                </li>
+ *             </ul>
  *          </note>
  * @example
  * Use a bare-bones client and the command you need to make an API call.

package/dist-types/extensionConfiguration.d.ts

@@ -0,0 +1,6 @@
+import { DefaultExtensionConfiguration } from "@smithy/types";
+/**
+ * @internal
+ */
+export interface VerifiedPermissionsExtensionConfiguration extends DefaultExtensionConfiguration {
+}