@aws/lsp-codewhisperer 0.0.58 → 0.0.60

package/node_modules/@amzn/codewhisperer-streaming/dist-es/models/models_0.js

@@ -0,0 +1,1006 @@
+import { CodeWhispererStreamingServiceException as __BaseException } from "./CodeWhispererStreamingServiceException";
+import { SENSITIVE_STRING, } from "@smithy/smithy-client";
+export const AccessDeniedExceptionReason = {
+    UNAUTHORIZED_CUSTOMIZATION_RESOURCE_ACCESS: "UNAUTHORIZED_CUSTOMIZATION_RESOURCE_ACCESS",
+    UNAUTHORIZED_WORKSPACE_CONTEXT_FEATURE_ACCESS: "UNAUTHORIZED_WORKSPACE_CONTEXT_FEATURE_ACCESS",
+};
+export class AccessDeniedException extends __BaseException {
+    name = "AccessDeniedException";
+    $fault = "client";
+    reason;
+    constructor(opts) {
+        super({
+            name: "AccessDeniedException",
+            $fault: "client",
+            ...opts
+        });
+        Object.setPrototypeOf(this, AccessDeniedException.prototype);
+        this.reason = opts.reason;
+    }
+}
+export const AdditionalContentEntryFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.name && { name: SENSITIVE_STRING
+    }),
+    ...(obj.description && { description: SENSITIVE_STRING
+    }),
+    ...(obj.innerContext && { innerContext: SENSITIVE_STRING
+    }),
+});
+export const InternalServerExceptionReason = {
+    MODEL_TEMPORARILY_UNAVAILABLE: "MODEL_TEMPORARILY_UNAVAILABLE",
+};
+export class InternalServerException extends __BaseException {
+    name = "InternalServerException";
+    $fault = "server";
+    $retryable = {};
+    reason;
+    constructor(opts) {
+        super({
+            name: "InternalServerException",
+            $fault: "server",
+            ...opts
+        });
+        Object.setPrototypeOf(this, InternalServerException.prototype);
+        this.reason = opts.reason;
+    }
+}
+export class ResourceNotFoundException extends __BaseException {
+    name = "ResourceNotFoundException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ResourceNotFoundException",
+            $fault: "client",
+            ...opts
+        });
+        Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
+    }
+}
+export const ThrottlingExceptionReason = {
+    MONTHLY_REQUEST_COUNT: "MONTHLY_REQUEST_COUNT",
+};
+export class ThrottlingException extends __BaseException {
+    name = "ThrottlingException";
+    $fault = "client";
+    $retryable = {
+        throttling: true,
+    };
+    reason;
+    constructor(opts) {
+        super({
+            name: "ThrottlingException",
+            $fault: "client",
+            ...opts
+        });
+        Object.setPrototypeOf(this, ThrottlingException.prototype);
+        this.reason = opts.reason;
+    }
+}
+export const ValidationExceptionReason = {
+    CONTENT_LENGTH_EXCEEDS_THRESHOLD: "CONTENT_LENGTH_EXCEEDS_THRESHOLD",
+    INVALID_CONVERSATION_ID: "INVALID_CONVERSATION_ID",
+    INVALID_KMS_GRANT: "INVALID_KMS_GRANT",
+};
+export class ValidationException extends __BaseException {
+    name = "ValidationException";
+    $fault = "client";
+    reason;
+    constructor(opts) {
+        super({
+            name: "ValidationException",
+            $fault: "client",
+            ...opts
+        });
+        Object.setPrototypeOf(this, ValidationException.prototype);
+        this.reason = opts.reason;
+    }
+}
+export const AppStudioStateFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.namespace && { namespace: SENSITIVE_STRING
+    }),
+    ...(obj.propertyName && { propertyName: SENSITIVE_STRING
+    }),
+    ...(obj.propertyValue && { propertyValue: SENSITIVE_STRING
+    }),
+    ...(obj.propertyContext && { propertyContext: SENSITIVE_STRING
+    }),
+});
+export const AssistantResponseEventFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.content && { content: SENSITIVE_STRING
+    }),
+});
+export const UserIntent = {
+    APPLY_COMMON_BEST_PRACTICES: "APPLY_COMMON_BEST_PRACTICES",
+    CITE_SOURCES: "CITE_SOURCES",
+    CODE_GENERATION: "CODE_GENERATION",
+    EXPLAIN_CODE_SELECTION: "EXPLAIN_CODE_SELECTION",
+    EXPLAIN_LINE_BY_LINE: "EXPLAIN_LINE_BY_LINE",
+    GENERATE_CLOUDFORMATION_TEMPLATE: "GENERATE_CLOUDFORMATION_TEMPLATE",
+    GENERATE_UNIT_TESTS: "GENERATE_UNIT_TESTS",
+    IMPROVE_CODE: "IMPROVE_CODE",
+    SHOW_EXAMPLES: "SHOW_EXAMPLES",
+    SUGGEST_ALTERNATE_IMPLEMENTATION: "SUGGEST_ALTERNATE_IMPLEMENTATION",
+};
+export const FollowupPromptFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.content && { content: SENSITIVE_STRING
+    }),
+});
+export const SupplementaryWebLinkFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.url && { url: SENSITIVE_STRING
+    }),
+    ...(obj.title && { title: SENSITIVE_STRING
+    }),
+    ...(obj.snippet && { snippet: SENSITIVE_STRING
+    }),
+});
+export const ToolUseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.name && { name: SENSITIVE_STRING
+    }),
+    ...(obj.input && { input: SENSITIVE_STRING
+    }),
+});
+export const AssistantResponseMessageFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.content && { content: SENSITIVE_STRING
+    }),
+    ...(obj.supplementaryWebLinks && { supplementaryWebLinks: obj.supplementaryWebLinks.map(item => SupplementaryWebLinkFilterSensitiveLog(item))
+    }),
+    ...(obj.followupPrompt && { followupPrompt: FollowupPromptFilterSensitiveLog(obj.followupPrompt)
+    }),
+    ...(obj.toolUses && { toolUses: obj.toolUses.map(item => ToolUseFilterSensitiveLog(item))
+    }),
+});
+export const ConflictExceptionReason = {
+    CUSTOMER_KMS_KEY_DISABLED: "CUSTOMER_KMS_KEY_DISABLED",
+    CUSTOMER_KMS_KEY_INVALID_KEY_POLICY: "CUSTOMER_KMS_KEY_INVALID_KEY_POLICY",
+    MISMATCHED_KMS_KEY: "MISMATCHED_KMS_KEY",
+};
+export class ConflictException extends __BaseException {
+    name = "ConflictException";
+    $fault = "client";
+    reason;
+    constructor(opts) {
+        super({
+            name: "ConflictException",
+            $fault: "client",
+            ...opts
+        });
+        Object.setPrototypeOf(this, ConflictException.prototype);
+        this.reason = opts.reason;
+    }
+}
+export const ContentChecksumType = {
+    SHA_256: "SHA_256",
+};
+export const BinaryMetadataEventFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const BinaryPayloadEventFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.bytes && { bytes: SENSITIVE_STRING
+    }),
+});
+export const ImageFormat = {
+    GIF: "gif",
+    JPEG: "jpeg",
+    PNG: "png",
+    WEBP: "webp",
+};
+export var ImageSource;
+(function (ImageSource) {
+    ImageSource.visit = (value, visitor) => {
+        if (value.bytes !== undefined)
+            return visitor.bytes(value.bytes);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(ImageSource || (ImageSource = {}));
+export const ImageSourceFilterSensitiveLog = (obj) => {
+    if (obj.bytes !== undefined)
+        return { bytes: obj.bytes
+        };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: 'UNKNOWN' };
+};
+export const ImageBlockFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.source && { source: SENSITIVE_STRING
+    }),
+});
+export const Origin = {
+    AI_EDITOR: "AI_EDITOR",
+    CHATBOT: "CHATBOT",
+    CLI: "CLI",
+    CONSOLE: "CONSOLE",
+    DOCUMENTATION: "DOCUMENTATION",
+    GITLAB: "GITLAB",
+    IDE: "IDE",
+    MARKETING: "MARKETING",
+    MD: "MD",
+    MD_IDE: "MD_IDE",
+    MOBILE: "MOBILE",
+    OPENSEARCH_DASHBOARD: "OPENSEARCH_DASHBOARD",
+    Q_DEV_BEXT: "Q_DEV_BEXT",
+    SAGE_MAKER: "SAGE_MAKER",
+    SERVICE_INTERNAL: "SERVICE_INTERNAL",
+    UNIFIED_SEARCH: "UNIFIED_SEARCH",
+    UNKNOWN: "UNKNOWN",
+};
+export const ConsoleStateFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.consoleUrl && { consoleUrl: SENSITIVE_STRING
+    }),
+    ...(obj.taskName && { taskName: SENSITIVE_STRING
+    }),
+});
+export const DiagnosticSeverity = {
+    ERROR: "ERROR",
+    HINT: "HINT",
+    INFORMATION: "INFORMATION",
+    WARNING: "WARNING",
+};
+export const RuntimeDiagnosticFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.source && { source: SENSITIVE_STRING
+    }),
+    ...(obj.message && { message: SENSITIVE_STRING
+    }),
+});
+export const CodeDescriptionFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.href && { href: SENSITIVE_STRING
+    }),
+});
+export const SymbolType = {
+    DECLARATION: "DECLARATION",
+    USAGE: "USAGE",
+};
+export const TextDocumentFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.relativeFilePath && { relativeFilePath: SENSITIVE_STRING
+    }),
+    ...(obj.text && { text: SENSITIVE_STRING
+    }),
+});
+export const DiagnosticLocationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.uri && { uri: SENSITIVE_STRING
+    }),
+});
+export const DiagnosticRelatedInformationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.location && { location: DiagnosticLocationFilterSensitiveLog(obj.location)
+    }),
+    ...(obj.message && { message: SENSITIVE_STRING
+    }),
+});
+export const DiagnosticTag = {
+    DEPRECATED: "DEPRECATED",
+    UNNECESSARY: "UNNECESSARY",
+};
+export const TextDocumentDiagnosticFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.document && { document: TextDocumentFilterSensitiveLog(obj.document)
+    }),
+    ...(obj.source && { source: SENSITIVE_STRING
+    }),
+    ...(obj.message && { message: SENSITIVE_STRING
+    }),
+    ...(obj.code && { code: SENSITIVE_STRING
+    }),
+    ...(obj.codeDescription && { codeDescription: CodeDescriptionFilterSensitiveLog(obj.codeDescription)
+    }),
+    ...(obj.relatedInformation && { relatedInformation: obj.relatedInformation.map(item => DiagnosticRelatedInformationFilterSensitiveLog(item))
+    }),
+    ...(obj.data && { data: SENSITIVE_STRING
+    }),
+});
+export var Diagnostic;
+(function (Diagnostic) {
+    Diagnostic.visit = (value, visitor) => {
+        if (value.textDocumentDiagnostic !== undefined)
+            return visitor.textDocumentDiagnostic(value.textDocumentDiagnostic);
+        if (value.runtimeDiagnostic !== undefined)
+            return visitor.runtimeDiagnostic(value.runtimeDiagnostic);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(Diagnostic || (Diagnostic = {}));
+export const DiagnosticFilterSensitiveLog = (obj) => {
+    if (obj.textDocumentDiagnostic !== undefined)
+        return { textDocumentDiagnostic: TextDocumentDiagnosticFilterSensitiveLog(obj.textDocumentDiagnostic)
+        };
+    if (obj.runtimeDiagnostic !== undefined)
+        return { runtimeDiagnostic: RuntimeDiagnosticFilterSensitiveLog(obj.runtimeDiagnostic)
+        };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: 'UNKNOWN' };
+};
+export var CursorState;
+(function (CursorState) {
+    CursorState.visit = (value, visitor) => {
+        if (value.position !== undefined)
+            return visitor.position(value.position);
+        if (value.range !== undefined)
+            return visitor.range(value.range);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(CursorState || (CursorState = {}));
+export const ContentType = {
+    CODE: "CODE",
+    FILE: "FILE",
+    PROMPT: "PROMPT",
+    WORKSPACE: "WORKSPACE",
+};
+export const RelevantTextDocumentFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.relativeFilePath && { relativeFilePath: SENSITIVE_STRING
+    }),
+    ...(obj.text && { text: SENSITIVE_STRING
+    }),
+});
+export const EditorStateFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.document && { document: TextDocumentFilterSensitiveLog(obj.document)
+    }),
+    ...(obj.cursorState && { cursorState: obj.cursorState
+    }),
+    ...(obj.relevantDocuments && { relevantDocuments: obj.relevantDocuments.map(item => RelevantTextDocumentFilterSensitiveLog(item))
+    }),
+    ...(obj.workspaceFolders && { workspaceFolders: SENSITIVE_STRING
+    }),
+});
+export const EnvironmentVariableFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.key && { key: SENSITIVE_STRING
+    }),
+    ...(obj.value && { value: SENSITIVE_STRING
+    }),
+});
+export const EnvStateFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.currentWorkingDirectory && { currentWorkingDirectory: SENSITIVE_STRING
+    }),
+    ...(obj.environmentVariables && { environmentVariables: obj.environmentVariables.map(item => EnvironmentVariableFilterSensitiveLog(item))
+    }),
+});
+export const GitStateFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.status && { status: SENSITIVE_STRING
+    }),
+});
+export const ShellHistoryEntryFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.command && { command: SENSITIVE_STRING
+    }),
+    ...(obj.directory && { directory: SENSITIVE_STRING
+    }),
+    ...(obj.stdout && { stdout: SENSITIVE_STRING
+    }),
+    ...(obj.stderr && { stderr: SENSITIVE_STRING
+    }),
+});
+export const ShellStateFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.shellHistory && { shellHistory: obj.shellHistory.map(item => ShellHistoryEntryFilterSensitiveLog(item))
+    }),
+});
+export var ToolResultContentBlock;
+(function (ToolResultContentBlock) {
+    ToolResultContentBlock.visit = (value, visitor) => {
+        if (value.text !== undefined)
+            return visitor.text(value.text);
+        if (value.json !== undefined)
+            return visitor.json(value.json);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(ToolResultContentBlock || (ToolResultContentBlock = {}));
+export const ToolResultContentBlockFilterSensitiveLog = (obj) => {
+    if (obj.text !== undefined)
+        return { text: SENSITIVE_STRING
+        };
+    if (obj.json !== undefined)
+        return { json: SENSITIVE_STRING
+        };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: 'UNKNOWN' };
+};
+export const ToolResultStatus = {
+    ERROR: "error",
+    SUCCESS: "success",
+};
+export const ToolResultFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.content && { content: obj.content.map(item => ToolResultContentBlockFilterSensitiveLog(item))
+    }),
+});
+export const ToolInputSchemaFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.json && { json: SENSITIVE_STRING
+    }),
+});
+export const ToolSpecificationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.inputSchema && { inputSchema: ToolInputSchemaFilterSensitiveLog(obj.inputSchema)
+    }),
+    ...(obj.name && { name: SENSITIVE_STRING
+    }),
+    ...(obj.description && { description: SENSITIVE_STRING
+    }),
+});
+export var Tool;
+(function (Tool) {
+    Tool.visit = (value, visitor) => {
+        if (value.toolSpecification !== undefined)
+            return visitor.toolSpecification(value.toolSpecification);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(Tool || (Tool = {}));
+export const ToolFilterSensitiveLog = (obj) => {
+    if (obj.toolSpecification !== undefined)
+        return { toolSpecification: ToolSpecificationFilterSensitiveLog(obj.toolSpecification)
+        };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: 'UNKNOWN' };
+};
+export const UserInputMessageContextFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.editorState && { editorState: EditorStateFilterSensitiveLog(obj.editorState)
+    }),
+    ...(obj.shellState && { shellState: ShellStateFilterSensitiveLog(obj.shellState)
+    }),
+    ...(obj.gitState && { gitState: GitStateFilterSensitiveLog(obj.gitState)
+    }),
+    ...(obj.envState && { envState: EnvStateFilterSensitiveLog(obj.envState)
+    }),
+    ...(obj.appStudioContext && { appStudioContext: AppStudioStateFilterSensitiveLog(obj.appStudioContext)
+    }),
+    ...(obj.diagnostic && { diagnostic: DiagnosticFilterSensitiveLog(obj.diagnostic)
+    }),
+    ...(obj.consoleState && { consoleState: ConsoleStateFilterSensitiveLog(obj.consoleState)
+    }),
+    ...(obj.additionalContext && { additionalContext: obj.additionalContext.map(item => AdditionalContentEntryFilterSensitiveLog(item))
+    }),
+    ...(obj.toolResults && { toolResults: obj.toolResults.map(item => ToolResultFilterSensitiveLog(item))
+    }),
+    ...(obj.tools && { tools: obj.tools.map(item => ToolFilterSensitiveLog(item))
+    }),
+});
+export const UserInputMessageFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.content && { content: SENSITIVE_STRING
+    }),
+    ...(obj.userInputMessageContext && { userInputMessageContext: UserInputMessageContextFilterSensitiveLog(obj.userInputMessageContext)
+    }),
+    ...(obj.images && { images: obj.images.map(item => ImageBlockFilterSensitiveLog(item))
+    }),
+});
+export var ChatMessage;
+(function (ChatMessage) {
+    ChatMessage.visit = (value, visitor) => {
+        if (value.userInputMessage !== undefined)
+            return visitor.userInputMessage(value.userInputMessage);
+        if (value.assistantResponseMessage !== undefined)
+            return visitor.assistantResponseMessage(value.assistantResponseMessage);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(ChatMessage || (ChatMessage = {}));
+export const ChatMessageFilterSensitiveLog = (obj) => {
+    if (obj.userInputMessage !== undefined)
+        return { userInputMessage: UserInputMessageFilterSensitiveLog(obj.userInputMessage)
+        };
+    if (obj.assistantResponseMessage !== undefined)
+        return { assistantResponseMessage: AssistantResponseMessageFilterSensitiveLog(obj.assistantResponseMessage)
+        };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: 'UNKNOWN' };
+};
+export var CitationTarget;
+(function (CitationTarget) {
+    CitationTarget.visit = (value, visitor) => {
+        if (value.location !== undefined)
+            return visitor.location(value.location);
+        if (value.range !== undefined)
+            return visitor.range(value.range);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(CitationTarget || (CitationTarget = {}));
+export const CitationEventFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.target && { target: obj.target
+    }),
+    ...(obj.citationText && { citationText: SENSITIVE_STRING
+    }),
+    ...(obj.citationLink && { citationLink: SENSITIVE_STRING
+    }),
+});
+export const CodeEventFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.content && { content: SENSITIVE_STRING
+    }),
+});
+export const FollowupPromptEventFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.followupPrompt && { followupPrompt: FollowupPromptFilterSensitiveLog(obj.followupPrompt)
+    }),
+});
+export const IntentType = {
+    DEEPLINKS: "DEEPLINKS",
+    GLUE_SENSEI: "GLUE_SENSEI",
+    RESOURCE_DATA: "RESOURCE_DATA",
+    SUPPORT: "SUPPORT",
+};
+export var IntentDataType;
+(function (IntentDataType) {
+    IntentDataType.visit = (value, visitor) => {
+        if (value.string !== undefined)
+            return visitor.string(value.string);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(IntentDataType || (IntentDataType = {}));
+export const IntentsEventFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.intents && { intents: SENSITIVE_STRING
+    }),
+});
+export const CloudWatchTroubleshootingLinkFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.label && { label: SENSITIVE_STRING
+    }),
+    ...(obj.investigationPayload && { investigationPayload: SENSITIVE_STRING
+    }),
+    ...(obj.defaultText && { defaultText: SENSITIVE_STRING
+    }),
+});
+export const ModuleLinkFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.cloudWatchTroubleshootingLink && { cloudWatchTroubleshootingLink: CloudWatchTroubleshootingLinkFilterSensitiveLog(obj.cloudWatchTroubleshootingLink)
+    }),
+});
+export const WebLinkFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.label && { label: SENSITIVE_STRING
+    }),
+    ...(obj.url && { url: SENSITIVE_STRING
+    }),
+});
+export const ActionFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.webLink && { webLink: WebLinkFilterSensitiveLog(obj.webLink)
+    }),
+    ...(obj.moduleLink && { moduleLink: ModuleLinkFilterSensitiveLog(obj.moduleLink)
+    }),
+});
+export const TextFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.content && { content: SENSITIVE_STRING
+    }),
+});
+export const AlertComponentFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.text && { text: TextFilterSensitiveLog(obj.text)
+    }),
+});
+export const AlertType = {
+    ERROR: "ERROR",
+    INFO: "INFO",
+    WARNING: "WARNING",
+};
+export const AlertFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.content && { content: obj.content.map(item => AlertComponentFilterSensitiveLog(item))
+    }),
+});
+export const InfrastructureUpdateTransitionFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.currentState && { currentState: SENSITIVE_STRING
+    }),
+    ...(obj.nextState && { nextState: SENSITIVE_STRING
+    }),
+});
+export const InfrastructureUpdateFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.transition && { transition: InfrastructureUpdateTransitionFilterSensitiveLog(obj.transition)
+    }),
+});
+export const StepComponentFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.text && { text: TextFilterSensitiveLog(obj.text)
+    }),
+});
+export const StepState = {
+    FAILED: "FAILED",
+    IN_PROGRESS: "IN_PROGRESS",
+    LOADING: "LOADING",
+    PAUSED: "PAUSED",
+    PENDING: "PENDING",
+    STOPPED: "STOPPED",
+    SUCCEEDED: "SUCCEEDED",
+};
+export const StepFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.label && { label: SENSITIVE_STRING
+    }),
+    ...(obj.content && { content: obj.content.map(item => StepComponentFilterSensitiveLog(item))
+    }),
+});
+export const ProgressComponentFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.step && { step: StepFilterSensitiveLog(obj.step)
+    }),
+});
+export const ProgressFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.content && { content: obj.content.map(item => ProgressComponentFilterSensitiveLog(item))
+    }),
+});
+export const ResourceFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.title && { title: SENSITIVE_STRING
+    }),
+    ...(obj.link && { link: SENSITIVE_STRING
+    }),
+    ...(obj.description && { description: SENSITIVE_STRING
+    }),
+    ...(obj.type && { type: SENSITIVE_STRING
+    }),
+    ...(obj.ARN && { ARN: SENSITIVE_STRING
+    }),
+    ...(obj.resourceJsonString && { resourceJsonString: SENSITIVE_STRING
+    }),
+});
+export const ResourceListFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.action && { action: ActionFilterSensitiveLog(obj.action)
+    }),
+    ...(obj.items && { items: obj.items.map(item => ResourceFilterSensitiveLog(item))
+    }),
+});
+export const SectionComponentFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.text && { text: TextFilterSensitiveLog(obj.text)
+    }),
+    ...(obj.alert && { alert: AlertFilterSensitiveLog(obj.alert)
+    }),
+    ...(obj.resource && { resource: ResourceFilterSensitiveLog(obj.resource)
+    }),
+    ...(obj.resourceList && { resourceList: ResourceListFilterSensitiveLog(obj.resourceList)
+    }),
+});
+export const SectionFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.title && { title: SENSITIVE_STRING
+    }),
+    ...(obj.content && { content: obj.content.map(item => SectionComponentFilterSensitiveLog(item))
+    }),
+    ...(obj.action && { action: ActionFilterSensitiveLog(obj.action)
+    }),
+});
+export const SuggestionFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.value && { value: SENSITIVE_STRING
+    }),
+});
+export const SuggestionsFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.items && { items: obj.items.map(item => SuggestionFilterSensitiveLog(item))
+    }),
+});
+export const TaskActionConfirmationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.content && { content: SENSITIVE_STRING
+    }),
+});
+export const TaskActionNoteType = {
+    INFO: "INFO",
+    WARNING: "WARNING",
+};
+export const TaskActionNoteFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.content && { content: SENSITIVE_STRING
+    }),
+});
+export const TaskActionFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.label && { label: SENSITIVE_STRING
+    }),
+    ...(obj.note && { note: TaskActionNoteFilterSensitiveLog(obj.note)
+    }),
+    ...(obj.payload && { payload: SENSITIVE_STRING
+    }),
+    ...(obj.confirmation && { confirmation: TaskActionConfirmationFilterSensitiveLog(obj.confirmation)
+    }),
+});
+export const TaskComponentFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.text && { text: TextFilterSensitiveLog(obj.text)
+    }),
+    ...(obj.infrastructureUpdate && { infrastructureUpdate: InfrastructureUpdateFilterSensitiveLog(obj.infrastructureUpdate)
+    }),
+    ...(obj.alert && { alert: AlertFilterSensitiveLog(obj.alert)
+    }),
+    ...(obj.progress && { progress: ProgressFilterSensitiveLog(obj.progress)
+    }),
+});
+export const TaskOverviewFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.label && { label: SENSITIVE_STRING
+    }),
+    ...(obj.description && { description: SENSITIVE_STRING
+    }),
+});
+export const TaskDetailsFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.overview && { overview: TaskOverviewFilterSensitiveLog(obj.overview)
+    }),
+    ...(obj.content && { content: obj.content.map(item => TaskComponentFilterSensitiveLog(item))
+    }),
+    ...(obj.actions && { actions: obj.actions.map(item => TaskActionFilterSensitiveLog(item))
+    }),
+});
+export const InteractionComponentFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.text && { text: TextFilterSensitiveLog(obj.text)
+    }),
+    ...(obj.alert && { alert: AlertFilterSensitiveLog(obj.alert)
+    }),
+    ...(obj.infrastructureUpdate && { infrastructureUpdate: InfrastructureUpdateFilterSensitiveLog(obj.infrastructureUpdate)
+    }),
+    ...(obj.progress && { progress: ProgressFilterSensitiveLog(obj.progress)
+    }),
+    ...(obj.step && { step: StepFilterSensitiveLog(obj.step)
+    }),
+    ...(obj.taskDetails && { taskDetails: TaskDetailsFilterSensitiveLog(obj.taskDetails)
+    }),
+    ...(obj.suggestions && { suggestions: SuggestionsFilterSensitiveLog(obj.suggestions)
+    }),
+    ...(obj.section && { section: SectionFilterSensitiveLog(obj.section)
+    }),
+    ...(obj.resource && { resource: ResourceFilterSensitiveLog(obj.resource)
+    }),
+    ...(obj.resourceList && { resourceList: ResourceListFilterSensitiveLog(obj.resourceList)
+    }),
+    ...(obj.action && { action: ActionFilterSensitiveLog(obj.action)
+    }),
+});
+export const InteractionComponentEntryFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.interactionComponent && { interactionComponent: InteractionComponentFilterSensitiveLog(obj.interactionComponent)
+    }),
+});
+export const InteractionComponentsEventFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.interactionComponentEntries && { interactionComponentEntries: obj.interactionComponentEntries.map(item => InteractionComponentEntryFilterSensitiveLog(item))
+    }),
+});
+export const InvalidStateReason = {
+    INVALID_TASK_ASSIST_PLAN: "INVALID_TASK_ASSIST_PLAN",
+};
+export const SupplementaryWebLinksEventFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.supplementaryWebLinks && { supplementaryWebLinks: obj.supplementaryWebLinks.map(item => SupplementaryWebLinkFilterSensitiveLog(item))
+    }),
+});
+export const ToolResultEventFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.toolResult && { toolResult: ToolResultFilterSensitiveLog(obj.toolResult)
+    }),
+});
+export const ToolUseEventFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.name && { name: SENSITIVE_STRING
+    }),
+    ...(obj.input && { input: SENSITIVE_STRING
+    }),
+});
+export var ChatResponseStream;
+(function (ChatResponseStream) {
+    ChatResponseStream.visit = (value, visitor) => {
+        if (value.messageMetadataEvent !== undefined)
+            return visitor.messageMetadataEvent(value.messageMetadataEvent);
+        if (value.assistantResponseEvent !== undefined)
+            return visitor.assistantResponseEvent(value.assistantResponseEvent);
+        if (value.dryRunSucceedEvent !== undefined)
+            return visitor.dryRunSucceedEvent(value.dryRunSucceedEvent);
+        if (value.codeReferenceEvent !== undefined)
+            return visitor.codeReferenceEvent(value.codeReferenceEvent);
+        if (value.supplementaryWebLinksEvent !== undefined)
+            return visitor.supplementaryWebLinksEvent(value.supplementaryWebLinksEvent);
+        if (value.followupPromptEvent !== undefined)
+            return visitor.followupPromptEvent(value.followupPromptEvent);
+        if (value.codeEvent !== undefined)
+            return visitor.codeEvent(value.codeEvent);
+        if (value.intentsEvent !== undefined)
+            return visitor.intentsEvent(value.intentsEvent);
+        if (value.interactionComponentsEvent !== undefined)
+            return visitor.interactionComponentsEvent(value.interactionComponentsEvent);
+        if (value.toolUseEvent !== undefined)
+            return visitor.toolUseEvent(value.toolUseEvent);
+        if (value.toolResultEvent !== undefined)
+            return visitor.toolResultEvent(value.toolResultEvent);
+        if (value.citationEvent !== undefined)
+            return visitor.citationEvent(value.citationEvent);
+        if (value.invalidStateEvent !== undefined)
+            return visitor.invalidStateEvent(value.invalidStateEvent);
+        if (value.error !== undefined)
+            return visitor.error(value.error);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(ChatResponseStream || (ChatResponseStream = {}));
+export const ChatResponseStreamFilterSensitiveLog = (obj) => {
+    if (obj.messageMetadataEvent !== undefined)
+        return { messageMetadataEvent: obj.messageMetadataEvent
+        };
+    if (obj.assistantResponseEvent !== undefined)
+        return { assistantResponseEvent: AssistantResponseEventFilterSensitiveLog(obj.assistantResponseEvent)
+        };
+    if (obj.dryRunSucceedEvent !== undefined)
+        return { dryRunSucceedEvent: obj.dryRunSucceedEvent
+        };
+    if (obj.codeReferenceEvent !== undefined)
+        return { codeReferenceEvent: obj.codeReferenceEvent
+        };
+    if (obj.supplementaryWebLinksEvent !== undefined)
+        return { supplementaryWebLinksEvent: SupplementaryWebLinksEventFilterSensitiveLog(obj.supplementaryWebLinksEvent)
+        };
+    if (obj.followupPromptEvent !== undefined)
+        return { followupPromptEvent: FollowupPromptEventFilterSensitiveLog(obj.followupPromptEvent)
+        };
+    if (obj.codeEvent !== undefined)
+        return { codeEvent: CodeEventFilterSensitiveLog(obj.codeEvent)
+        };
+    if (obj.intentsEvent !== undefined)
+        return { intentsEvent: IntentsEventFilterSensitiveLog(obj.intentsEvent)
+        };
+    if (obj.interactionComponentsEvent !== undefined)
+        return { interactionComponentsEvent: InteractionComponentsEventFilterSensitiveLog(obj.interactionComponentsEvent)
+        };
+    if (obj.toolUseEvent !== undefined)
+        return { toolUseEvent: ToolUseEventFilterSensitiveLog(obj.toolUseEvent)
+        };
+    if (obj.toolResultEvent !== undefined)
+        return { toolResultEvent: ToolResultEventFilterSensitiveLog(obj.toolResultEvent)
+        };
+    if (obj.citationEvent !== undefined)
+        return { citationEvent: CitationEventFilterSensitiveLog(obj.citationEvent)
+        };
+    if (obj.invalidStateEvent !== undefined)
+        return { invalidStateEvent: obj.invalidStateEvent
+        };
+    if (obj.error !== undefined)
+        return { error: obj.error
+        };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: 'UNKNOWN' };
+};
+export const ChatTriggerType = {
+    DIAGNOSTIC: "DIAGNOSTIC",
+    INLINE_CHAT: "INLINE_CHAT",
+    MANUAL: "MANUAL",
+};
+export const ContextTruncationScheme = {
+    ANALYSIS: "ANALYSIS",
+    GUMBY: "GUMBY",
+};
+export const ConversationStateFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.history && { history: obj.history.map(item => ChatMessageFilterSensitiveLog(item))
+    }),
+    ...(obj.currentMessage && { currentMessage: ChatMessageFilterSensitiveLog(obj.currentMessage)
+    }),
+});
+export class DryRunOperationException extends __BaseException {
+    name = "DryRunOperationException";
+    $fault = "client";
+    responseCode;
+    constructor(opts) {
+        super({
+            name: "DryRunOperationException",
+            $fault: "client",
+            ...opts
+        });
+        Object.setPrototypeOf(this, DryRunOperationException.prototype);
+        this.responseCode = opts.responseCode;
+    }
+}
+export const TransformationDownloadArtifactType = {
+    CLIENT_INSTRUCTIONS: "ClientInstructions",
+    GENERATED_CODE: "GeneratedCode",
+    LOGS: "Logs",
+};
+export var ExportContext;
+(function (ExportContext) {
+    ExportContext.visit = (value, visitor) => {
+        if (value.transformationExportContext !== undefined)
+            return visitor.transformationExportContext(value.transformationExportContext);
+        if (value.unitTestGenerationExportContext !== undefined)
+            return visitor.unitTestGenerationExportContext(value.unitTestGenerationExportContext);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(ExportContext || (ExportContext = {}));
+export const ExportIntent = {
+    TASK_ASSIST: "TASK_ASSIST",
+    TRANSFORMATION: "TRANSFORMATION",
+    UNIT_TESTS: "UNIT_TESTS",
+};
+export var ResultArchiveStream;
+(function (ResultArchiveStream) {
+    ResultArchiveStream.visit = (value, visitor) => {
+        if (value.binaryMetadataEvent !== undefined)
+            return visitor.binaryMetadataEvent(value.binaryMetadataEvent);
+        if (value.binaryPayloadEvent !== undefined)
+            return visitor.binaryPayloadEvent(value.binaryPayloadEvent);
+        if (value.internalServerException !== undefined)
+            return visitor.internalServerException(value.internalServerException);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(ResultArchiveStream || (ResultArchiveStream = {}));
+export const ResultArchiveStreamFilterSensitiveLog = (obj) => {
+    if (obj.binaryMetadataEvent !== undefined)
+        return { binaryMetadataEvent: SENSITIVE_STRING
+        };
+    if (obj.binaryPayloadEvent !== undefined)
+        return { binaryPayloadEvent: SENSITIVE_STRING
+        };
+    if (obj.internalServerException !== undefined)
+        return { internalServerException: obj.internalServerException
+        };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: 'UNKNOWN' };
+};
+export const ServiceQuotaExceededExceptionReason = {
+    CONVERSATION_LIMIT_EXCEEDED: "CONVERSATION_LIMIT_EXCEEDED",
+};
+export class ServiceQuotaExceededException extends __BaseException {
+    name = "ServiceQuotaExceededException";
+    $fault = "client";
+    reason;
+    constructor(opts) {
+        super({
+            name: "ServiceQuotaExceededException",
+            $fault: "client",
+            ...opts
+        });
+        Object.setPrototypeOf(this, ServiceQuotaExceededException.prototype);
+        this.reason = opts.reason;
+    }
+}
+export const GenerateAssistantResponseRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.conversationState && { conversationState: ConversationStateFilterSensitiveLog(obj.conversationState)
+    }),
+});
+export const GenerateAssistantResponseResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.generateAssistantResponseResponse && { generateAssistantResponseResponse: 'STREAMING_CONTENT'
+    }),
+});
+export const ExportResultArchiveResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.body && { body: 'STREAMING_CONTENT'
+    }),
+});
+export const SendMessageRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.conversationState && { conversationState: ConversationStateFilterSensitiveLog(obj.conversationState)
+    }),
+});
+export const SendMessageResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.sendMessageResponse && { sendMessageResponse: 'STREAMING_CONTENT'
+    }),
+});
+export const GenerateTaskAssistPlanRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.conversationState && { conversationState: ConversationStateFilterSensitiveLog(obj.conversationState)
+    }),
+});
+export const GenerateTaskAssistPlanResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.planningResponseStream && { planningResponseStream: 'STREAMING_CONTENT'
+    }),
+});