@aws-sdk/client-bedrock-agentcore-control 3.847.0

package/dist-es/models/models_0.js

@@ -0,0 +1,1104 @@
+import { SENSITIVE_STRING } from "@smithy/smithy-client";
+import { BedrockAgentCoreControlServiceException as __BaseException } from "./BedrockAgentCoreControlServiceException";
+export class AccessDeniedException extends __BaseException {
+    name = "AccessDeniedException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "AccessDeniedException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, AccessDeniedException.prototype);
+    }
+}
+export const AgentStatus = {
+    CREATE_FAILED: "CREATE_FAILED",
+    CREATING: "CREATING",
+    DELETING: "DELETING",
+    READY: "READY",
+    UPDATE_FAILED: "UPDATE_FAILED",
+    UPDATING: "UPDATING",
+};
+export var AgentArtifact;
+(function (AgentArtifact) {
+    AgentArtifact.visit = (value, visitor) => {
+        if (value.containerConfiguration !== undefined)
+            return visitor.containerConfiguration(value.containerConfiguration);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(AgentArtifact || (AgentArtifact = {}));
+export const AgentEndpointStatus = {
+    CREATE_FAILED: "CREATE_FAILED",
+    CREATING: "CREATING",
+    DELETING: "DELETING",
+    READY: "READY",
+    UPDATE_FAILED: "UPDATE_FAILED",
+    UPDATING: "UPDATING",
+};
+export class ConflictException extends __BaseException {
+    name = "ConflictException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ConflictException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ConflictException.prototype);
+    }
+}
+export class InternalServerException extends __BaseException {
+    name = "InternalServerException";
+    $fault = "server";
+    constructor(opts) {
+        super({
+            name: "InternalServerException",
+            $fault: "server",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InternalServerException.prototype);
+    }
+}
+export class ResourceNotFoundException extends __BaseException {
+    name = "ResourceNotFoundException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ResourceNotFoundException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
+    }
+}
+export class ServiceQuotaExceededException extends __BaseException {
+    name = "ServiceQuotaExceededException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ServiceQuotaExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ServiceQuotaExceededException.prototype);
+    }
+}
+export class ThrottlingException extends __BaseException {
+    name = "ThrottlingException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ThrottlingException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ThrottlingException.prototype);
+    }
+}
+export const ValidationExceptionReason = {
+    CANNOT_PARSE: "CannotParse",
+    FIELD_VALIDATION_FAILED: "FieldValidationFailed",
+    IDEMPOTENT_PARAMETER_MISMATCH_EXCEPTION: "IdempotentParameterMismatchException",
+    RESOURCE_CONFLICT: "ResourceConflict",
+    ROOT_EVENT_IN_OTHER_SESSION: "EventInOtherSession",
+};
+export class ValidationException extends __BaseException {
+    name = "ValidationException";
+    $fault = "client";
+    reason;
+    fieldList;
+    constructor(opts) {
+        super({
+            name: "ValidationException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ValidationException.prototype);
+        this.reason = opts.reason;
+        this.fieldList = opts.fieldList;
+    }
+}
+export var AuthorizerConfiguration;
+(function (AuthorizerConfiguration) {
+    AuthorizerConfiguration.visit = (value, visitor) => {
+        if (value.customJWTAuthorizer !== undefined)
+            return visitor.customJWTAuthorizer(value.customJWTAuthorizer);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(AuthorizerConfiguration || (AuthorizerConfiguration = {}));
+export const NetworkMode = {
+    PUBLIC: "PUBLIC",
+};
+export const ServerProtocol = {
+    HTTP: "HTTP",
+    MCP: "MCP",
+};
+export class DecryptionFailure extends __BaseException {
+    name = "DecryptionFailure";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "DecryptionFailure",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, DecryptionFailure.prototype);
+    }
+}
+export class EncryptionFailure extends __BaseException {
+    name = "EncryptionFailure";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "EncryptionFailure",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, EncryptionFailure.prototype);
+    }
+}
+export class ResourceLimitExceededException extends __BaseException {
+    name = "ResourceLimitExceededException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ResourceLimitExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ResourceLimitExceededException.prototype);
+    }
+}
+export class UnauthorizedException extends __BaseException {
+    name = "UnauthorizedException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "UnauthorizedException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, UnauthorizedException.prototype);
+    }
+}
+export const BrowserNetworkMode = {
+    PUBLIC: "PUBLIC",
+};
+export const BrowserStatus = {
+    CREATE_FAILED: "CREATE_FAILED",
+    CREATING: "CREATING",
+    DELETED: "DELETED",
+    DELETE_FAILED: "DELETE_FAILED",
+    DELETING: "DELETING",
+    READY: "READY",
+};
+export const ResourceType = {
+    CUSTOM: "CUSTOM",
+    SYSTEM: "SYSTEM",
+};
+export const CodeInterpreterNetworkMode = {
+    PUBLIC: "PUBLIC",
+    SANDBOX: "SANDBOX",
+};
+export const CodeInterpreterStatus = {
+    CREATE_FAILED: "CREATE_FAILED",
+    CREATING: "CREATING",
+    DELETED: "DELETED",
+    DELETE_FAILED: "DELETE_FAILED",
+    DELETING: "DELETING",
+    READY: "READY",
+};
+export const AuthorizerType = {
+    CUSTOM_JWT: "CUSTOM_JWT",
+};
+export const ExceptionLevel = {
+    DEBUG: "DEBUG",
+};
+export const SearchType = {
+    SEMANTIC: "SEMANTIC",
+};
+export var GatewayProtocolConfiguration;
+(function (GatewayProtocolConfiguration) {
+    GatewayProtocolConfiguration.visit = (value, visitor) => {
+        if (value.mcp !== undefined)
+            return visitor.mcp(value.mcp);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(GatewayProtocolConfiguration || (GatewayProtocolConfiguration = {}));
+export const GatewayProtocolType = {
+    MCP: "MCP",
+};
+export const GatewayStatus = {
+    CREATING: "CREATING",
+    DELETING: "DELETING",
+    FAILED: "FAILED",
+    READY: "READY",
+    UPDATE_UNSUCCESSFUL: "UPDATE_UNSUCCESSFUL",
+    UPDATING: "UPDATING",
+};
+export const ApiKeyCredentialLocation = {
+    HEADER: "HEADER",
+    QUERY_PARAMETER: "QUERY_PARAMETER",
+};
+export var CredentialProvider;
+(function (CredentialProvider) {
+    CredentialProvider.visit = (value, visitor) => {
+        if (value.oauthCredentialProvider !== undefined)
+            return visitor.oauthCredentialProvider(value.oauthCredentialProvider);
+        if (value.apiKeyCredentialProvider !== undefined)
+            return visitor.apiKeyCredentialProvider(value.apiKeyCredentialProvider);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(CredentialProvider || (CredentialProvider = {}));
+export const CredentialProviderType = {
+    API_KEY: "API_KEY",
+    GATEWAY_IAM_ROLE: "GATEWAY_IAM_ROLE",
+    OAUTH: "OAUTH",
+};
+export const SchemaType = {
+    ARRAY: "array",
+    BOOLEAN: "boolean",
+    INTEGER: "integer",
+    NUMBER: "number",
+    OBJECT: "object",
+    STRING: "string",
+};
+export var ApiSchemaConfiguration;
+(function (ApiSchemaConfiguration) {
+    ApiSchemaConfiguration.visit = (value, visitor) => {
+        if (value.s3 !== undefined)
+            return visitor.s3(value.s3);
+        if (value.inlinePayload !== undefined)
+            return visitor.inlinePayload(value.inlinePayload);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(ApiSchemaConfiguration || (ApiSchemaConfiguration = {}));
+export const TargetStatus = {
+    CREATING: "CREATING",
+    DELETING: "DELETING",
+    FAILED: "FAILED",
+    READY: "READY",
+    UPDATE_UNSUCCESSFUL: "UPDATE_UNSUCCESSFUL",
+    UPDATING: "UPDATING",
+};
+export const KeyType = {
+    CustomerManagedKey: "CustomerManagedKey",
+    ServiceManagedKey: "ServiceManagedKey",
+};
+export var CustomConfigurationInput;
+(function (CustomConfigurationInput) {
+    CustomConfigurationInput.visit = (value, visitor) => {
+        if (value.semanticOverride !== undefined)
+            return visitor.semanticOverride(value.semanticOverride);
+        if (value.summaryOverride !== undefined)
+            return visitor.summaryOverride(value.summaryOverride);
+        if (value.userPreferenceOverride !== undefined)
+            return visitor.userPreferenceOverride(value.userPreferenceOverride);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(CustomConfigurationInput || (CustomConfigurationInput = {}));
+export var MemoryStrategyInput;
+(function (MemoryStrategyInput) {
+    MemoryStrategyInput.visit = (value, visitor) => {
+        if (value.semanticMemoryStrategy !== undefined)
+            return visitor.semanticMemoryStrategy(value.semanticMemoryStrategy);
+        if (value.summaryMemoryStrategy !== undefined)
+            return visitor.summaryMemoryStrategy(value.summaryMemoryStrategy);
+        if (value.userPreferenceMemoryStrategy !== undefined)
+            return visitor.userPreferenceMemoryStrategy(value.userPreferenceMemoryStrategy);
+        if (value.customMemoryStrategy !== undefined)
+            return visitor.customMemoryStrategy(value.customMemoryStrategy);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(MemoryStrategyInput || (MemoryStrategyInput = {}));
+export const MemoryStatus = {
+    ACTIVE: "ACTIVE",
+    CREATING: "CREATING",
+    DELETING: "DELETING",
+    FAILED: "FAILED",
+};
+export var CustomConsolidationConfiguration;
+(function (CustomConsolidationConfiguration) {
+    CustomConsolidationConfiguration.visit = (value, visitor) => {
+        if (value.semanticConsolidationOverride !== undefined)
+            return visitor.semanticConsolidationOverride(value.semanticConsolidationOverride);
+        if (value.summaryConsolidationOverride !== undefined)
+            return visitor.summaryConsolidationOverride(value.summaryConsolidationOverride);
+        if (value.userPreferenceConsolidationOverride !== undefined)
+            return visitor.userPreferenceConsolidationOverride(value.userPreferenceConsolidationOverride);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(CustomConsolidationConfiguration || (CustomConsolidationConfiguration = {}));
+export var ConsolidationConfiguration;
+(function (ConsolidationConfiguration) {
+    ConsolidationConfiguration.visit = (value, visitor) => {
+        if (value.customConsolidationConfiguration !== undefined)
+            return visitor.customConsolidationConfiguration(value.customConsolidationConfiguration);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(ConsolidationConfiguration || (ConsolidationConfiguration = {}));
+export var CustomExtractionConfiguration;
+(function (CustomExtractionConfiguration) {
+    CustomExtractionConfiguration.visit = (value, visitor) => {
+        if (value.semanticExtractionOverride !== undefined)
+            return visitor.semanticExtractionOverride(value.semanticExtractionOverride);
+        if (value.userPreferenceExtractionOverride !== undefined)
+            return visitor.userPreferenceExtractionOverride(value.userPreferenceExtractionOverride);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(CustomExtractionConfiguration || (CustomExtractionConfiguration = {}));
+export var ExtractionConfiguration;
+(function (ExtractionConfiguration) {
+    ExtractionConfiguration.visit = (value, visitor) => {
+        if (value.customExtractionConfiguration !== undefined)
+            return visitor.customExtractionConfiguration(value.customExtractionConfiguration);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(ExtractionConfiguration || (ExtractionConfiguration = {}));
+export const OverrideType = {
+    SEMANTIC_OVERRIDE: "SEMANTIC_OVERRIDE",
+    SUMMARY_OVERRIDE: "SUMMARY_OVERRIDE",
+    USER_PREFERENCE_OVERRIDE: "USER_PREFERENCE_OVERRIDE",
+};
+export const MemoryStrategyStatus = {
+    ACTIVE: "ACTIVE",
+    CREATING: "CREATING",
+    DELETING: "DELETING",
+    FAILED: "FAILED",
+};
+export const MemoryStrategyType = {
+    CUSTOM: "CUSTOM",
+    SEMANTIC: "SEMANTIC",
+    SUMMARIZATION: "SUMMARIZATION",
+    USER_PREFERENCE: "USER_PREFERENCE",
+};
+export class ServiceException extends __BaseException {
+    name = "ServiceException";
+    $fault = "server";
+    $retryable = {};
+    constructor(opts) {
+        super({
+            name: "ServiceException",
+            $fault: "server",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ServiceException.prototype);
+    }
+}
+export class ThrottledException extends __BaseException {
+    name = "ThrottledException";
+    $fault = "client";
+    $retryable = {};
+    constructor(opts) {
+        super({
+            name: "ThrottledException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ThrottledException.prototype);
+    }
+}
+export var CustomConsolidationConfigurationInput;
+(function (CustomConsolidationConfigurationInput) {
+    CustomConsolidationConfigurationInput.visit = (value, visitor) => {
+        if (value.semanticConsolidationOverride !== undefined)
+            return visitor.semanticConsolidationOverride(value.semanticConsolidationOverride);
+        if (value.summaryConsolidationOverride !== undefined)
+            return visitor.summaryConsolidationOverride(value.summaryConsolidationOverride);
+        if (value.userPreferenceConsolidationOverride !== undefined)
+            return visitor.userPreferenceConsolidationOverride(value.userPreferenceConsolidationOverride);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(CustomConsolidationConfigurationInput || (CustomConsolidationConfigurationInput = {}));
+export var ModifyConsolidationConfiguration;
+(function (ModifyConsolidationConfiguration) {
+    ModifyConsolidationConfiguration.visit = (value, visitor) => {
+        if (value.customConsolidationConfiguration !== undefined)
+            return visitor.customConsolidationConfiguration(value.customConsolidationConfiguration);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(ModifyConsolidationConfiguration || (ModifyConsolidationConfiguration = {}));
+export var CustomExtractionConfigurationInput;
+(function (CustomExtractionConfigurationInput) {
+    CustomExtractionConfigurationInput.visit = (value, visitor) => {
+        if (value.semanticExtractionOverride !== undefined)
+            return visitor.semanticExtractionOverride(value.semanticExtractionOverride);
+        if (value.userPreferenceExtractionOverride !== undefined)
+            return visitor.userPreferenceExtractionOverride(value.userPreferenceExtractionOverride);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(CustomExtractionConfigurationInput || (CustomExtractionConfigurationInput = {}));
+export var ModifyExtractionConfiguration;
+(function (ModifyExtractionConfiguration) {
+    ModifyExtractionConfiguration.visit = (value, visitor) => {
+        if (value.customExtractionConfiguration !== undefined)
+            return visitor.customExtractionConfiguration(value.customExtractionConfiguration);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(ModifyExtractionConfiguration || (ModifyExtractionConfiguration = {}));
+export const CredentialProviderVendorType = {
+    CustomOauth2: "CustomOauth2",
+    GithubOauth2: "GithubOauth2",
+    GoogleOauth2: "GoogleOauth2",
+    MicrosoftOauth2: "MicrosoftOauth2",
+    SalesforceOauth2: "SalesforceOauth2",
+    SlackOauth2: "SlackOauth2",
+};
+export var Oauth2Discovery;
+(function (Oauth2Discovery) {
+    Oauth2Discovery.visit = (value, visitor) => {
+        if (value.discoveryUrl !== undefined)
+            return visitor.discoveryUrl(value.discoveryUrl);
+        if (value.authorizationServerMetadata !== undefined)
+            return visitor.authorizationServerMetadata(value.authorizationServerMetadata);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(Oauth2Discovery || (Oauth2Discovery = {}));
+export var Oauth2ProviderConfigInput;
+(function (Oauth2ProviderConfigInput) {
+    Oauth2ProviderConfigInput.visit = (value, visitor) => {
+        if (value.customOauth2ProviderConfig !== undefined)
+            return visitor.customOauth2ProviderConfig(value.customOauth2ProviderConfig);
+        if (value.googleOauth2ProviderConfig !== undefined)
+            return visitor.googleOauth2ProviderConfig(value.googleOauth2ProviderConfig);
+        if (value.githubOauth2ProviderConfig !== undefined)
+            return visitor.githubOauth2ProviderConfig(value.githubOauth2ProviderConfig);
+        if (value.slackOauth2ProviderConfig !== undefined)
+            return visitor.slackOauth2ProviderConfig(value.slackOauth2ProviderConfig);
+        if (value.salesforceOauth2ProviderConfig !== undefined)
+            return visitor.salesforceOauth2ProviderConfig(value.salesforceOauth2ProviderConfig);
+        if (value.microsoftOauth2ProviderConfig !== undefined)
+            return visitor.microsoftOauth2ProviderConfig(value.microsoftOauth2ProviderConfig);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(Oauth2ProviderConfigInput || (Oauth2ProviderConfigInput = {}));
+export var Oauth2ProviderConfigOutput;
+(function (Oauth2ProviderConfigOutput) {
+    Oauth2ProviderConfigOutput.visit = (value, visitor) => {
+        if (value.customOauth2ProviderConfig !== undefined)
+            return visitor.customOauth2ProviderConfig(value.customOauth2ProviderConfig);
+        if (value.googleOauth2ProviderConfig !== undefined)
+            return visitor.googleOauth2ProviderConfig(value.googleOauth2ProviderConfig);
+        if (value.githubOauth2ProviderConfig !== undefined)
+            return visitor.githubOauth2ProviderConfig(value.githubOauth2ProviderConfig);
+        if (value.slackOauth2ProviderConfig !== undefined)
+            return visitor.slackOauth2ProviderConfig(value.slackOauth2ProviderConfig);
+        if (value.salesforceOauth2ProviderConfig !== undefined)
+            return visitor.salesforceOauth2ProviderConfig(value.salesforceOauth2ProviderConfig);
+        if (value.microsoftOauth2ProviderConfig !== undefined)
+            return visitor.microsoftOauth2ProviderConfig(value.microsoftOauth2ProviderConfig);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(Oauth2ProviderConfigOutput || (Oauth2ProviderConfigOutput = {}));
+export class ConcurrentModificationException extends __BaseException {
+    name = "ConcurrentModificationException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ConcurrentModificationException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ConcurrentModificationException.prototype);
+    }
+}
+export var ToolSchema;
+(function (ToolSchema) {
+    ToolSchema.visit = (value, visitor) => {
+        if (value.s3 !== undefined)
+            return visitor.s3(value.s3);
+        if (value.inlinePayload !== undefined)
+            return visitor.inlinePayload(value.inlinePayload);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(ToolSchema || (ToolSchema = {}));
+export var McpTargetConfiguration;
+(function (McpTargetConfiguration) {
+    McpTargetConfiguration.visit = (value, visitor) => {
+        if (value.openApiSchema !== undefined)
+            return visitor.openApiSchema(value.openApiSchema);
+        if (value.smithyModel !== undefined)
+            return visitor.smithyModel(value.smithyModel);
+        if (value.lambda !== undefined)
+            return visitor.lambda(value.lambda);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(McpTargetConfiguration || (McpTargetConfiguration = {}));
+export var TargetConfiguration;
+(function (TargetConfiguration) {
+    TargetConfiguration.visit = (value, visitor) => {
+        if (value.mcp !== undefined)
+            return visitor.mcp(value.mcp);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(TargetConfiguration || (TargetConfiguration = {}));
+export const AgentFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.description && { description: SENSITIVE_STRING }),
+});
+export const AgentEndpointFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.name && { name: SENSITIVE_STRING }),
+});
+export const CreateAgentRuntimeEndpointRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.name && { name: SENSITIVE_STRING }),
+});
+export const DeleteAgentRuntimeEndpointRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.endpointName && { endpointName: SENSITIVE_STRING }),
+});
+export const GetAgentRuntimeEndpointRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.endpointName && { endpointName: SENSITIVE_STRING }),
+});
+export const GetAgentRuntimeEndpointResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.name && { name: SENSITIVE_STRING }),
+});
+export const ListAgentRuntimeEndpointsResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.runtimeEndpoints && {
+        runtimeEndpoints: obj.runtimeEndpoints.map((item) => AgentEndpointFilterSensitiveLog(item)),
+    }),
+});
+export const UpdateAgentRuntimeEndpointRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.endpointName && { endpointName: SENSITIVE_STRING }),
+});
+export const CreateAgentRuntimeRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.description && { description: SENSITIVE_STRING }),
+    ...(obj.agentRuntimeArtifact && { agentRuntimeArtifact: obj.agentRuntimeArtifact }),
+    ...(obj.environmentVariables && { environmentVariables: SENSITIVE_STRING }),
+    ...(obj.authorizerConfiguration && { authorizerConfiguration: obj.authorizerConfiguration }),
+});
+export const GetAgentRuntimeResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.description && { description: SENSITIVE_STRING }),
+    ...(obj.agentRuntimeArtifact && { agentRuntimeArtifact: obj.agentRuntimeArtifact }),
+    ...(obj.environmentVariables && { environmentVariables: SENSITIVE_STRING }),
+    ...(obj.authorizerConfiguration && { authorizerConfiguration: obj.authorizerConfiguration }),
+});
+export const ListAgentRuntimesResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.agentRuntimes && { agentRuntimes: obj.agentRuntimes.map((item) => AgentFilterSensitiveLog(item)) }),
+});
+export const ListAgentRuntimeVersionsResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.agentRuntimes && { agentRuntimes: obj.agentRuntimes.map((item) => AgentFilterSensitiveLog(item)) }),
+});
+export const UpdateAgentRuntimeRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.description && { description: SENSITIVE_STRING }),
+    ...(obj.agentRuntimeArtifact && { agentRuntimeArtifact: obj.agentRuntimeArtifact }),
+    ...(obj.environmentVariables && { environmentVariables: SENSITIVE_STRING }),
+    ...(obj.authorizerConfiguration && { authorizerConfiguration: obj.authorizerConfiguration }),
+});
+export const CreateApiKeyCredentialProviderRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.apiKey && { apiKey: SENSITIVE_STRING }),
+});
+export const UpdateApiKeyCredentialProviderRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.apiKey && { apiKey: SENSITIVE_STRING }),
+});
+export const CreateBrowserRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.description && { description: SENSITIVE_STRING }),
+});
+export const GetBrowserResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.description && { description: SENSITIVE_STRING }),
+});
+export const BrowserSummaryFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.description && { description: SENSITIVE_STRING }),
+});
+export const ListBrowsersResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.browserSummaries && {
+        browserSummaries: obj.browserSummaries.map((item) => BrowserSummaryFilterSensitiveLog(item)),
+    }),
+});
+export const CreateCodeInterpreterRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.description && { description: SENSITIVE_STRING }),
+});
+export const GetCodeInterpreterResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.description && { description: SENSITIVE_STRING }),
+});
+export const CodeInterpreterSummaryFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.description && { description: SENSITIVE_STRING }),
+});
+export const ListCodeInterpretersResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.codeInterpreterSummaries && {
+        codeInterpreterSummaries: obj.codeInterpreterSummaries.map((item) => CodeInterpreterSummaryFilterSensitiveLog(item)),
+    }),
+});
+export const CreateGatewayRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.name && { name: SENSITIVE_STRING }),
+    ...(obj.description && { description: SENSITIVE_STRING }),
+    ...(obj.protocolConfiguration && { protocolConfiguration: obj.protocolConfiguration }),
+    ...(obj.authorizerConfiguration && { authorizerConfiguration: obj.authorizerConfiguration }),
+});
+export const CreateGatewayResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.name && { name: SENSITIVE_STRING }),
+    ...(obj.description && { description: SENSITIVE_STRING }),
+    ...(obj.protocolConfiguration && { protocolConfiguration: obj.protocolConfiguration }),
+    ...(obj.authorizerConfiguration && { authorizerConfiguration: obj.authorizerConfiguration }),
+});
+export const GetGatewayResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.name && { name: SENSITIVE_STRING }),
+    ...(obj.description && { description: SENSITIVE_STRING }),
+    ...(obj.protocolConfiguration && { protocolConfiguration: obj.protocolConfiguration }),
+    ...(obj.authorizerConfiguration && { authorizerConfiguration: obj.authorizerConfiguration }),
+});
+export const GatewaySummaryFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.name && { name: SENSITIVE_STRING }),
+    ...(obj.description && { description: SENSITIVE_STRING }),
+});
+export const ListGatewaysResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.items && { items: obj.items.map((item) => GatewaySummaryFilterSensitiveLog(item)) }),
+});
+export const UpdateGatewayRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.name && { name: SENSITIVE_STRING }),
+    ...(obj.description && { description: SENSITIVE_STRING }),
+    ...(obj.protocolConfiguration && { protocolConfiguration: obj.protocolConfiguration }),
+    ...(obj.authorizerConfiguration && { authorizerConfiguration: obj.authorizerConfiguration }),
+});
+export const UpdateGatewayResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.name && { name: SENSITIVE_STRING }),
+    ...(obj.description && { description: SENSITIVE_STRING }),
+    ...(obj.protocolConfiguration && { protocolConfiguration: obj.protocolConfiguration }),
+    ...(obj.authorizerConfiguration && { authorizerConfiguration: obj.authorizerConfiguration }),
+});
+export const OAuthCredentialProviderFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.customParameters && { customParameters: SENSITIVE_STRING }),
+});
+export const CredentialProviderFilterSensitiveLog = (obj) => {
+    if (obj.oauthCredentialProvider !== undefined)
+        return { oauthCredentialProvider: OAuthCredentialProviderFilterSensitiveLog(obj.oauthCredentialProvider) };
+    if (obj.apiKeyCredentialProvider !== undefined)
+        return { apiKeyCredentialProvider: obj.apiKeyCredentialProvider };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const CredentialProviderConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.credentialProvider && { credentialProvider: CredentialProviderFilterSensitiveLog(obj.credentialProvider) }),
+});
+export const ApiSchemaConfigurationFilterSensitiveLog = (obj) => {
+    if (obj.s3 !== undefined)
+        return { s3: obj.s3 };
+    if (obj.inlinePayload !== undefined)
+        return { inlinePayload: SENSITIVE_STRING };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const TargetSummaryFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.name && { name: SENSITIVE_STRING }),
+    ...(obj.description && { description: SENSITIVE_STRING }),
+});
+export const ListGatewayTargetsResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.items && { items: obj.items.map((item) => TargetSummaryFilterSensitiveLog(item)) }),
+});
+export const SemanticOverrideConsolidationConfigurationInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.appendToPrompt && { appendToPrompt: SENSITIVE_STRING }),
+});
+export const SemanticOverrideExtractionConfigurationInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.appendToPrompt && { appendToPrompt: SENSITIVE_STRING }),
+});
+export const SemanticOverrideConfigurationInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.extraction && { extraction: SemanticOverrideExtractionConfigurationInputFilterSensitiveLog(obj.extraction) }),
+    ...(obj.consolidation && {
+        consolidation: SemanticOverrideConsolidationConfigurationInputFilterSensitiveLog(obj.consolidation),
+    }),
+});
+export const SummaryOverrideConsolidationConfigurationInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.appendToPrompt && { appendToPrompt: SENSITIVE_STRING }),
+});
+export const SummaryOverrideConfigurationInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.consolidation && {
+        consolidation: SummaryOverrideConsolidationConfigurationInputFilterSensitiveLog(obj.consolidation),
+    }),
+});
+export const UserPreferenceOverrideConsolidationConfigurationInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.appendToPrompt && { appendToPrompt: SENSITIVE_STRING }),
+});
+export const UserPreferenceOverrideExtractionConfigurationInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.appendToPrompt && { appendToPrompt: SENSITIVE_STRING }),
+});
+export const UserPreferenceOverrideConfigurationInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.extraction && {
+        extraction: UserPreferenceOverrideExtractionConfigurationInputFilterSensitiveLog(obj.extraction),
+    }),
+    ...(obj.consolidation && {
+        consolidation: UserPreferenceOverrideConsolidationConfigurationInputFilterSensitiveLog(obj.consolidation),
+    }),
+});
+export const CustomConfigurationInputFilterSensitiveLog = (obj) => {
+    if (obj.semanticOverride !== undefined)
+        return { semanticOverride: SemanticOverrideConfigurationInputFilterSensitiveLog(obj.semanticOverride) };
+    if (obj.summaryOverride !== undefined)
+        return { summaryOverride: SummaryOverrideConfigurationInputFilterSensitiveLog(obj.summaryOverride) };
+    if (obj.userPreferenceOverride !== undefined)
+        return {
+            userPreferenceOverride: UserPreferenceOverrideConfigurationInputFilterSensitiveLog(obj.userPreferenceOverride),
+        };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const CustomMemoryStrategyInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.description && { description: SENSITIVE_STRING }),
+    ...(obj.configuration && { configuration: CustomConfigurationInputFilterSensitiveLog(obj.configuration) }),
+});
+export const SemanticMemoryStrategyInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.description && { description: SENSITIVE_STRING }),
+});
+export const SummaryMemoryStrategyInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.description && { description: SENSITIVE_STRING }),
+});
+export const UserPreferenceMemoryStrategyInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.description && { description: SENSITIVE_STRING }),
+});
+export const MemoryStrategyInputFilterSensitiveLog = (obj) => {
+    if (obj.semanticMemoryStrategy !== undefined)
+        return { semanticMemoryStrategy: SemanticMemoryStrategyInputFilterSensitiveLog(obj.semanticMemoryStrategy) };
+    if (obj.summaryMemoryStrategy !== undefined)
+        return { summaryMemoryStrategy: SummaryMemoryStrategyInputFilterSensitiveLog(obj.summaryMemoryStrategy) };
+    if (obj.userPreferenceMemoryStrategy !== undefined)
+        return {
+            userPreferenceMemoryStrategy: UserPreferenceMemoryStrategyInputFilterSensitiveLog(obj.userPreferenceMemoryStrategy),
+        };
+    if (obj.customMemoryStrategy !== undefined)
+        return { customMemoryStrategy: CustomMemoryStrategyInputFilterSensitiveLog(obj.customMemoryStrategy) };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const CreateMemoryInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.description && { description: SENSITIVE_STRING }),
+    ...(obj.memoryStrategies && {
+        memoryStrategies: obj.memoryStrategies.map((item) => MemoryStrategyInputFilterSensitiveLog(item)),
+    }),
+});
+export const SemanticConsolidationOverrideFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.appendToPrompt && { appendToPrompt: SENSITIVE_STRING }),
+});
+export const SummaryConsolidationOverrideFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.appendToPrompt && { appendToPrompt: SENSITIVE_STRING }),
+});
+export const UserPreferenceConsolidationOverrideFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.appendToPrompt && { appendToPrompt: SENSITIVE_STRING }),
+});
+export const CustomConsolidationConfigurationFilterSensitiveLog = (obj) => {
+    if (obj.semanticConsolidationOverride !== undefined)
+        return {
+            semanticConsolidationOverride: SemanticConsolidationOverrideFilterSensitiveLog(obj.semanticConsolidationOverride),
+        };
+    if (obj.summaryConsolidationOverride !== undefined)
+        return {
+            summaryConsolidationOverride: SummaryConsolidationOverrideFilterSensitiveLog(obj.summaryConsolidationOverride),
+        };
+    if (obj.userPreferenceConsolidationOverride !== undefined)
+        return {
+            userPreferenceConsolidationOverride: UserPreferenceConsolidationOverrideFilterSensitiveLog(obj.userPreferenceConsolidationOverride),
+        };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const ConsolidationConfigurationFilterSensitiveLog = (obj) => {
+    if (obj.customConsolidationConfiguration !== undefined)
+        return {
+            customConsolidationConfiguration: CustomConsolidationConfigurationFilterSensitiveLog(obj.customConsolidationConfiguration),
+        };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const SemanticExtractionOverrideFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.appendToPrompt && { appendToPrompt: SENSITIVE_STRING }),
+});
+export const UserPreferenceExtractionOverrideFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.appendToPrompt && { appendToPrompt: SENSITIVE_STRING }),
+});
+export const CustomExtractionConfigurationFilterSensitiveLog = (obj) => {
+    if (obj.semanticExtractionOverride !== undefined)
+        return { semanticExtractionOverride: SemanticExtractionOverrideFilterSensitiveLog(obj.semanticExtractionOverride) };
+    if (obj.userPreferenceExtractionOverride !== undefined)
+        return {
+            userPreferenceExtractionOverride: UserPreferenceExtractionOverrideFilterSensitiveLog(obj.userPreferenceExtractionOverride),
+        };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const ExtractionConfigurationFilterSensitiveLog = (obj) => {
+    if (obj.customExtractionConfiguration !== undefined)
+        return {
+            customExtractionConfiguration: CustomExtractionConfigurationFilterSensitiveLog(obj.customExtractionConfiguration),
+        };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const StrategyConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.extraction && { extraction: ExtractionConfigurationFilterSensitiveLog(obj.extraction) }),
+    ...(obj.consolidation && { consolidation: ConsolidationConfigurationFilterSensitiveLog(obj.consolidation) }),
+});
+export const MemoryStrategyFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.description && { description: SENSITIVE_STRING }),
+    ...(obj.configuration && { configuration: StrategyConfigurationFilterSensitiveLog(obj.configuration) }),
+});
+export const MemoryFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.description && { description: SENSITIVE_STRING }),
+    ...(obj.strategies && { strategies: obj.strategies.map((item) => MemoryStrategyFilterSensitiveLog(item)) }),
+});
+export const CreateMemoryOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.memory && { memory: MemoryFilterSensitiveLog(obj.memory) }),
+});
+export const GetMemoryOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.memory && { memory: MemoryFilterSensitiveLog(obj.memory) }),
+});
+export const CustomConsolidationConfigurationInputFilterSensitiveLog = (obj) => {
+    if (obj.semanticConsolidationOverride !== undefined)
+        return {
+            semanticConsolidationOverride: SemanticOverrideConsolidationConfigurationInputFilterSensitiveLog(obj.semanticConsolidationOverride),
+        };
+    if (obj.summaryConsolidationOverride !== undefined)
+        return {
+            summaryConsolidationOverride: SummaryOverrideConsolidationConfigurationInputFilterSensitiveLog(obj.summaryConsolidationOverride),
+        };
+    if (obj.userPreferenceConsolidationOverride !== undefined)
+        return {
+            userPreferenceConsolidationOverride: UserPreferenceOverrideConsolidationConfigurationInputFilterSensitiveLog(obj.userPreferenceConsolidationOverride),
+        };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const ModifyConsolidationConfigurationFilterSensitiveLog = (obj) => {
+    if (obj.customConsolidationConfiguration !== undefined)
+        return {
+            customConsolidationConfiguration: CustomConsolidationConfigurationInputFilterSensitiveLog(obj.customConsolidationConfiguration),
+        };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const CustomExtractionConfigurationInputFilterSensitiveLog = (obj) => {
+    if (obj.semanticExtractionOverride !== undefined)
+        return {
+            semanticExtractionOverride: SemanticOverrideExtractionConfigurationInputFilterSensitiveLog(obj.semanticExtractionOverride),
+        };
+    if (obj.userPreferenceExtractionOverride !== undefined)
+        return {
+            userPreferenceExtractionOverride: UserPreferenceOverrideExtractionConfigurationInputFilterSensitiveLog(obj.userPreferenceExtractionOverride),
+        };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const ModifyExtractionConfigurationFilterSensitiveLog = (obj) => {
+    if (obj.customExtractionConfiguration !== undefined)
+        return {
+            customExtractionConfiguration: CustomExtractionConfigurationInputFilterSensitiveLog(obj.customExtractionConfiguration),
+        };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const ModifyStrategyConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.extraction && { extraction: ModifyExtractionConfigurationFilterSensitiveLog(obj.extraction) }),
+    ...(obj.consolidation && { consolidation: ModifyConsolidationConfigurationFilterSensitiveLog(obj.consolidation) }),
+});
+export const ModifyMemoryStrategyInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.description && { description: SENSITIVE_STRING }),
+    ...(obj.configuration && { configuration: ModifyStrategyConfigurationFilterSensitiveLog(obj.configuration) }),
+});
+export const ModifyMemoryStrategiesFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.addMemoryStrategies && {
+        addMemoryStrategies: obj.addMemoryStrategies.map((item) => MemoryStrategyInputFilterSensitiveLog(item)),
+    }),
+    ...(obj.modifyMemoryStrategies && {
+        modifyMemoryStrategies: obj.modifyMemoryStrategies.map((item) => ModifyMemoryStrategyInputFilterSensitiveLog(item)),
+    }),
+});
+export const UpdateMemoryInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.description && { description: SENSITIVE_STRING }),
+    ...(obj.memoryStrategies && { memoryStrategies: ModifyMemoryStrategiesFilterSensitiveLog(obj.memoryStrategies) }),
+});
+export const UpdateMemoryOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.memory && { memory: MemoryFilterSensitiveLog(obj.memory) }),
+});
+export const CustomOauth2ProviderConfigInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.oauthDiscovery && { oauthDiscovery: obj.oauthDiscovery }),
+    ...(obj.clientSecret && { clientSecret: SENSITIVE_STRING }),
+});
+export const GithubOauth2ProviderConfigInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.clientSecret && { clientSecret: SENSITIVE_STRING }),
+});
+export const GoogleOauth2ProviderConfigInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.clientSecret && { clientSecret: SENSITIVE_STRING }),
+});
+export const MicrosoftOauth2ProviderConfigInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.clientSecret && { clientSecret: SENSITIVE_STRING }),
+});
+export const SalesforceOauth2ProviderConfigInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.clientSecret && { clientSecret: SENSITIVE_STRING }),
+});
+export const SlackOauth2ProviderConfigInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.clientSecret && { clientSecret: SENSITIVE_STRING }),
+});
+export const Oauth2ProviderConfigInputFilterSensitiveLog = (obj) => {
+    if (obj.customOauth2ProviderConfig !== undefined)
+        return {
+            customOauth2ProviderConfig: CustomOauth2ProviderConfigInputFilterSensitiveLog(obj.customOauth2ProviderConfig),
+        };
+    if (obj.googleOauth2ProviderConfig !== undefined)
+        return {
+            googleOauth2ProviderConfig: GoogleOauth2ProviderConfigInputFilterSensitiveLog(obj.googleOauth2ProviderConfig),
+        };
+    if (obj.githubOauth2ProviderConfig !== undefined)
+        return {
+            githubOauth2ProviderConfig: GithubOauth2ProviderConfigInputFilterSensitiveLog(obj.githubOauth2ProviderConfig),
+        };
+    if (obj.slackOauth2ProviderConfig !== undefined)
+        return {
+            slackOauth2ProviderConfig: SlackOauth2ProviderConfigInputFilterSensitiveLog(obj.slackOauth2ProviderConfig),
+        };
+    if (obj.salesforceOauth2ProviderConfig !== undefined)
+        return {
+            salesforceOauth2ProviderConfig: SalesforceOauth2ProviderConfigInputFilterSensitiveLog(obj.salesforceOauth2ProviderConfig),
+        };
+    if (obj.microsoftOauth2ProviderConfig !== undefined)
+        return {
+            microsoftOauth2ProviderConfig: MicrosoftOauth2ProviderConfigInputFilterSensitiveLog(obj.microsoftOauth2ProviderConfig),
+        };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const CreateOauth2CredentialProviderRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.oauth2ProviderConfigInput && {
+        oauth2ProviderConfigInput: Oauth2ProviderConfigInputFilterSensitiveLog(obj.oauth2ProviderConfigInput),
+    }),
+});
+export const UpdateOauth2CredentialProviderRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.oauth2ProviderConfigInput && {
+        oauth2ProviderConfigInput: Oauth2ProviderConfigInputFilterSensitiveLog(obj.oauth2ProviderConfigInput),
+    }),
+});
+export const McpTargetConfigurationFilterSensitiveLog = (obj) => {
+    if (obj.openApiSchema !== undefined)
+        return { openApiSchema: ApiSchemaConfigurationFilterSensitiveLog(obj.openApiSchema) };
+    if (obj.smithyModel !== undefined)
+        return { smithyModel: ApiSchemaConfigurationFilterSensitiveLog(obj.smithyModel) };
+    if (obj.lambda !== undefined)
+        return { lambda: obj.lambda };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const TargetConfigurationFilterSensitiveLog = (obj) => {
+    if (obj.mcp !== undefined)
+        return { mcp: McpTargetConfigurationFilterSensitiveLog(obj.mcp) };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const CreateGatewayTargetRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.name && { name: SENSITIVE_STRING }),
+    ...(obj.description && { description: SENSITIVE_STRING }),
+    ...(obj.targetConfiguration && {
+        targetConfiguration: TargetConfigurationFilterSensitiveLog(obj.targetConfiguration),
+    }),
+    ...(obj.credentialProviderConfigurations && {
+        credentialProviderConfigurations: obj.credentialProviderConfigurations.map((item) => CredentialProviderConfigurationFilterSensitiveLog(item)),
+    }),
+});
+export const CreateGatewayTargetResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.name && { name: SENSITIVE_STRING }),
+    ...(obj.description && { description: SENSITIVE_STRING }),
+    ...(obj.targetConfiguration && {
+        targetConfiguration: TargetConfigurationFilterSensitiveLog(obj.targetConfiguration),
+    }),
+    ...(obj.credentialProviderConfigurations && {
+        credentialProviderConfigurations: obj.credentialProviderConfigurations.map((item) => CredentialProviderConfigurationFilterSensitiveLog(item)),
+    }),
+});
+export const GetGatewayTargetResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.name && { name: SENSITIVE_STRING }),
+    ...(obj.description && { description: SENSITIVE_STRING }),
+    ...(obj.targetConfiguration && {
+        targetConfiguration: TargetConfigurationFilterSensitiveLog(obj.targetConfiguration),
+    }),
+    ...(obj.credentialProviderConfigurations && {
+        credentialProviderConfigurations: obj.credentialProviderConfigurations.map((item) => CredentialProviderConfigurationFilterSensitiveLog(item)),
+    }),
+});
+export const UpdateGatewayTargetRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.name && { name: SENSITIVE_STRING }),
+    ...(obj.description && { description: SENSITIVE_STRING }),
+    ...(obj.targetConfiguration && {
+        targetConfiguration: TargetConfigurationFilterSensitiveLog(obj.targetConfiguration),
+    }),
+    ...(obj.credentialProviderConfigurations && {
+        credentialProviderConfigurations: obj.credentialProviderConfigurations.map((item) => CredentialProviderConfigurationFilterSensitiveLog(item)),
+    }),
+});
+export const UpdateGatewayTargetResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.name && { name: SENSITIVE_STRING }),
+    ...(obj.description && { description: SENSITIVE_STRING }),
+    ...(obj.targetConfiguration && {
+        targetConfiguration: TargetConfigurationFilterSensitiveLog(obj.targetConfiguration),
+    }),
+    ...(obj.credentialProviderConfigurations && {
+        credentialProviderConfigurations: obj.credentialProviderConfigurations.map((item) => CredentialProviderConfigurationFilterSensitiveLog(item)),
+    }),
+});