@aws/lsp-codewhisperer 0.0.84 → 0.0.86

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

@@ -0,0 +1,1429 @@
+import { CodeWhispererRuntimeServiceException as __BaseException } from "./CodeWhispererRuntimeServiceException";
+import { SENSITIVE_STRING, } from "@smithy/smithy-client";
+export const AccessDeniedExceptionReason = {
+    FEATURE_NOT_SUPPORTED: "FEATURE_NOT_SUPPORTED",
+    TEMPORARILY_SUSPENDED: "TEMPORARILY_SUSPENDED",
+    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 FunctionalityName = {
+    Analysis: "ANALYSIS",
+    ChatCustomization: "CHAT_CUSTOMIZATION",
+    Completions: "COMPLETIONS",
+    Conversations: "CONVERSATIONS",
+    FeatureDevelopment: "FEATURE_DEVELOPMENT",
+    TaskAssist: "TASK_ASSIST",
+    Transformations: "TRANSFORMATIONS",
+    TransformationsWebApp: "TRANSFORMATIONS_WEBAPP",
+};
+export const AdditionalContentEntryFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.name && { name: SENSITIVE_STRING
+    }),
+    ...(obj.description && { description: SENSITIVE_STRING
+    }),
+    ...(obj.innerContext && { innerContext: SENSITIVE_STRING
+    }),
+});
+export const AgenticChatEventStatus = {
+    Cancelled: "CANCELLED",
+    Failed: "FAILED",
+    Succeeded: "SUCCEEDED",
+};
+export const AgentTaskType = {
+    SPEC_TASK: "spectask",
+    VIBE: "vibe",
+};
+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 = {
+    DAILY_REQUEST_COUNT: "DAILY_REQUEST_COUNT",
+    INSUFFICIENT_MODEL_CAPACITY: "INSUFFICIENT_MODEL_CAPACITY",
+    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 ArtifactType = {
+    BUILT_JARS: "BuiltJars",
+    SOURCE_CODE: "SourceCode",
+};
+export const CachePointType = {
+    DEFAULT: "default",
+};
+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 ReasoningTextFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.text && { text: SENSITIVE_STRING
+    }),
+    ...(obj.signature && { signature: SENSITIVE_STRING
+    }),
+});
+export var ReasoningContent;
+(function (ReasoningContent) {
+    ReasoningContent.visit = (value, visitor) => {
+        if (value.reasoningText !== undefined)
+            return visitor.reasoningText(value.reasoningText);
+        if (value.redactedContent !== undefined)
+            return visitor.redactedContent(value.redactedContent);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(ReasoningContent || (ReasoningContent = {}));
+export const ReasoningContentFilterSensitiveLog = (obj) => {
+    if (obj.reasoningText !== undefined)
+        return { reasoningText: SENSITIVE_STRING
+        };
+    if (obj.redactedContent !== undefined)
+        return { redactedContent: obj.redactedContent
+        };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: 'UNKNOWN' };
+};
+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))
+    }),
+    ...(obj.reasoningContent && { reasoningContent: SENSITIVE_STRING
+    }),
+});
+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 OptInFeatureToggle = {
+    OFF: "OFF",
+    ON: "ON",
+};
+export const OverageStatus = {
+    DISABLED: "DISABLED",
+    ENABLED: "ENABLED",
+};
+export const RecommendationsWithReferencesPreference = {
+    ALLOW: "ALLOW",
+    BLOCK: "BLOCK",
+};
+export const ResourcePolicyEffect = {
+    ALLOW: "ALLOW",
+    DENY: "DENY",
+};
+export var IdentityDetails;
+(function (IdentityDetails) {
+    IdentityDetails.visit = (value, visitor) => {
+        if (value.ssoIdentityDetails !== undefined)
+            return visitor.ssoIdentityDetails(value.ssoIdentityDetails);
+        if (value.externalIdentityDetails !== undefined)
+            return visitor.externalIdentityDetails(value.externalIdentityDetails);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(IdentityDetails || (IdentityDetails = {}));
+export const ProfileType = {
+    CODEWHISPERER: "CODEWHISPERER",
+    Q_DEVELOPER: "Q_DEVELOPER",
+};
+export const ProfileStatus = {
+    ACTIVE: "ACTIVE",
+    CREATE_FAILED: "CREATE_FAILED",
+    CREATING: "CREATING",
+    DELETE_FAILED: "DELETE_FAILED",
+    DELETING: "DELETING",
+    UPDATE_FAILED: "UPDATE_FAILED",
+    UPDATING: "UPDATING",
+};
+export const FileContextFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.leftFileContent && { leftFileContent: SENSITIVE_STRING
+    }),
+    ...(obj.rightFileContent && { rightFileContent: SENSITIVE_STRING
+    }),
+    ...(obj.filename && { filename: SENSITIVE_STRING
+    }),
+    ...(obj.fileUri && { fileUri: SENSITIVE_STRING
+    }),
+});
+export var SupplementalContextMetadata;
+(function (SupplementalContextMetadata) {
+    SupplementalContextMetadata.visit = (value, visitor) => {
+        if (value.previousEditorStateMetadata !== undefined)
+            return visitor.previousEditorStateMetadata(value.previousEditorStateMetadata);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(SupplementalContextMetadata || (SupplementalContextMetadata = {}));
+export const SupplementalContextType = {
+    PREVIOUS_EDITOR_STATE: "PreviousEditorState",
+    WORKSPACE_CONTEXT: "WorkspaceContext",
+};
+export const SupplementalContextFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.filePath && { filePath: SENSITIVE_STRING
+    }),
+    ...(obj.content && { content: SENSITIVE_STRING
+    }),
+    ...(obj.metadata && { metadata: obj.metadata
+    }),
+});
+export const ImportFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.statement && { statement: SENSITIVE_STRING
+    }),
+});
+export const ContentChecksumType = {
+    SHA_256: "SHA_256",
+};
+export const ChangeLogGranularityType = {
+    BUSINESS: "BUSINESS",
+    STANDARD: "STANDARD",
+};
+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",
+    INLINE_CHAT: "INLINE_CHAT",
+    MARKETING: "MARKETING",
+    MD: "MD",
+    MD_CE: "MD_CE",
+    MD_IDE: "MD_IDE",
+    MOBILE: "MOBILE",
+    OPENSEARCH_DASHBOARD: "OPENSEARCH_DASHBOARD",
+    Q_DEV_BEXT: "Q_DEV_BEXT",
+    SAGE_MAKER: "SAGE_MAKER",
+    SERVICE_INTERNAL: "SERVICE_INTERNAL",
+    SM_AI_STUDIO_IDE: "SM_AI_STUDIO_IDE",
+    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);
+        if (value.cachePoint !== undefined)
+            return visitor.cachePoint(value.cachePoint);
+        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.cachePoint !== undefined)
+        return { cachePoint: obj.cachePoint
+        };
+    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 const IdeDiagnosticType = {
+    BEST_PRACTICE: "BEST_PRACTICE",
+    OTHER: "OTHER",
+    REFERENCE_ERROR: "REFERENCE_ERROR",
+    SECURITY: "SECURITY",
+    SYNTAX_ERROR: "SYNTAX_ERROR",
+    TYPE_ERROR: "TYPE_ERROR",
+};
+export const IdeDiagnosticFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.source && { source: SENSITIVE_STRING
+    }),
+});
+export const ChatMessageInteractionType = {
+    AGENTIC_CODE_ACCEPTED: "AGENTIC_CODE_ACCEPTED",
+    CLICK_BODY_LINK: "CLICK_BODY_LINK",
+    CLICK_FOLLOW_UP: "CLICK_FOLLOW_UP",
+    CLICK_LINK: "CLICK_LINK",
+    COPY: "COPY",
+    COPY_SNIPPET: "COPY_SNIPPET",
+    DOWNVOTE: "DOWNVOTE",
+    HOVER_REFERENCE: "HOVER_REFERENCE",
+    INSERT_AT_CURSOR: "INSERT_AT_CURSOR",
+    UPVOTE: "UPVOTE",
+};
+export const ChatInteractWithMessageEventFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.addedIdeDiagnostics && { addedIdeDiagnostics: obj.addedIdeDiagnostics.map(item => IdeDiagnosticFilterSensitiveLog(item))
+    }),
+    ...(obj.removedIdeDiagnostics && { removedIdeDiagnostics: obj.removedIdeDiagnostics.map(item => IdeDiagnosticFilterSensitiveLog(item))
+    }),
+});
+export const ChatTriggerType = {
+    DIAGNOSTIC: "DIAGNOSTIC",
+    INLINE_CHAT: "INLINE_CHAT",
+    MANUAL: "MANUAL",
+};
+export const CodeAnalysisFindingsSchema = {
+    CODEANALYSIS_FINDINGS_V1_0: "codeanalysis/findings/1.0",
+};
+export const CodeAnalysisScope = {
+    Agentic: "AGENTIC",
+    File: "FILE",
+    Project: "PROJECT",
+};
+export const CodeAnalysisStatus = {
+    COMPLETED: "Completed",
+    FAILED: "Failed",
+    PENDING: "Pending",
+};
+export const CodeFixJobStatus = {
+    FAILED: "Failed",
+    IN_PROGRESS: "InProgress",
+    SUCCEEDED: "Succeeded",
+};
+export const CodeGenerationWorkflowStage = {
+    INITIAL: "InitialCodeGeneration",
+    REFINEMENT: "CodeRefinement",
+};
+export const CodeGenerationWorkflowStatus = {
+    COMPLETE: "Complete",
+    FAILED: "Failed",
+    IN_PROGRESS: "InProgress",
+};
+export const CodeScanRemediationsEventType = {
+    CODESCAN_ISSUE_APPLY_FIX: "CODESCAN_ISSUE_APPLY_FIX",
+    CODESCAN_ISSUE_HOVER: "CODESCAN_ISSUE_HOVER",
+    CODESCAN_ISSUE_VIEW_DETAILS: "CODESCAN_ISSUE_VIEW_DETAILS",
+};
+export const CompletionFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.content && { content: SENSITIVE_STRING
+    }),
+    ...(obj.mostRelevantMissingImports && { mostRelevantMissingImports: obj.mostRelevantMissingImports.map(item => ImportFilterSensitiveLog(item))
+    }),
+});
+export const CompletionType = {
+    Block: "BLOCK",
+    Line: "LINE",
+};
+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 const TransformationUploadArtifactType = {
+    CLIENT_BUILD_RESULT: "ClientBuildResult",
+    DEPENDENCIES: "Dependencies",
+};
+export const WorkspaceContextUploadContextFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.relativePath && { relativePath: SENSITIVE_STRING
+    }),
+});
+export var UploadContext;
+(function (UploadContext) {
+    UploadContext.visit = (value, visitor) => {
+        if (value.taskAssistPlanningUploadContext !== undefined)
+            return visitor.taskAssistPlanningUploadContext(value.taskAssistPlanningUploadContext);
+        if (value.transformationUploadContext !== undefined)
+            return visitor.transformationUploadContext(value.transformationUploadContext);
+        if (value.codeAnalysisUploadContext !== undefined)
+            return visitor.codeAnalysisUploadContext(value.codeAnalysisUploadContext);
+        if (value.codeFixUploadContext !== undefined)
+            return visitor.codeFixUploadContext(value.codeFixUploadContext);
+        if (value.workspaceContextUploadContext !== undefined)
+            return visitor.workspaceContextUploadContext(value.workspaceContextUploadContext);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(UploadContext || (UploadContext = {}));
+export const UploadContextFilterSensitiveLog = (obj) => {
+    if (obj.taskAssistPlanningUploadContext !== undefined)
+        return { taskAssistPlanningUploadContext: obj.taskAssistPlanningUploadContext
+        };
+    if (obj.transformationUploadContext !== undefined)
+        return { transformationUploadContext: obj.transformationUploadContext
+        };
+    if (obj.codeAnalysisUploadContext !== undefined)
+        return { codeAnalysisUploadContext: obj.codeAnalysisUploadContext
+        };
+    if (obj.codeFixUploadContext !== undefined)
+        return { codeFixUploadContext: obj.codeFixUploadContext
+        };
+    if (obj.workspaceContextUploadContext !== undefined)
+        return { workspaceContextUploadContext: WorkspaceContextUploadContextFilterSensitiveLog(obj.workspaceContextUploadContext)
+        };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: 'UNKNOWN' };
+};
+export const UploadIntent = {
+    AGENTIC_CODE_REVIEW: "AGENTIC_CODE_REVIEW",
+    AUTOMATIC_FILE_SECURITY_SCAN: "AUTOMATIC_FILE_SECURITY_SCAN",
+    CODE_FIX_GENERATION: "CODE_FIX_GENERATION",
+    FULL_PROJECT_SECURITY_SCAN: "FULL_PROJECT_SECURITY_SCAN",
+    TASK_ASSIST_PLANNING: "TASK_ASSIST_PLANNING",
+    TRANSFORMATION: "TRANSFORMATION",
+    UNIT_TESTS_GENERATION: "UNIT_TESTS_GENERATION",
+    WORKSPACE_CONTEXT: "WORKSPACE_CONTEXT",
+};
+export const CreateUploadUrlRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.contentMd5 && { contentMd5: SENSITIVE_STRING
+    }),
+    ...(obj.contentChecksum && { contentChecksum: SENSITIVE_STRING
+    }),
+    ...(obj.uploadContext && { uploadContext: UploadContextFilterSensitiveLog(obj.uploadContext)
+    }),
+});
+export const CreateUploadUrlResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.uploadUrl && { uploadUrl: SENSITIVE_STRING
+    }),
+    ...(obj.requestHeaders && { requestHeaders: SENSITIVE_STRING
+    }),
+});
+export const DocFolderLevel = {
+    ENTIRE_WORKSPACE: "ENTIRE_WORKSPACE",
+    SUB_FOLDER: "SUB_FOLDER",
+};
+export const DocInteractionType = {
+    EDIT_README: "EDIT_README",
+    GENERATE_README: "GENERATE_README",
+    UPDATE_README: "UPDATE_README",
+};
+export const DocUserDecision = {
+    ACCEPT: "ACCEPT",
+    REJECT: "REJECT",
+};
+export const DocumentationType = {
+    CHANGE_LOG: "CHANGE_LOG",
+    README: "README",
+};
+export const DocumentationIntentContextFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.scope && { scope: SENSITIVE_STRING
+    }),
+});
+export const EditFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.content && { content: SENSITIVE_STRING
+    }),
+});
+export const TransformationDownloadArtifactType = {
+    CLIENT_INSTRUCTIONS: "ClientInstructions",
+    GENERATED_CODE: "GeneratedCode",
+    LOGS: "Logs",
+};
+export var FeatureValue;
+(function (FeatureValue) {
+    FeatureValue.visit = (value, visitor) => {
+        if (value.boolValue !== undefined)
+            return visitor.boolValue(value.boolValue);
+        if (value.doubleValue !== undefined)
+            return visitor.doubleValue(value.doubleValue);
+        if (value.longValue !== undefined)
+            return visitor.longValue(value.longValue);
+        if (value.stringValue !== undefined)
+            return visitor.stringValue(value.stringValue);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(FeatureValue || (FeatureValue = {}));
+export const OptOutPreference = {
+    OptIn: "OPTIN",
+    OptOut: "OPTOUT",
+};
+export const PredictionType = {
+    COMPLETIONS: "COMPLETIONS",
+    EDITS: "EDITS",
+};
+export const IdeCategory = {
+    CLI: "CLI",
+    Eclipse: "ECLIPSE",
+    JetBrains: "JETBRAINS",
+    JupyterMD: "JUPYTER_MD",
+    JupyterSM: "JUPYTER_SM",
+    VSCode: "VSCODE",
+    VisualStudio: "VISUAL_STUDIO",
+};
+export const OperatingSystem = {
+    Linux: "LINUX",
+    Mac: "MAC",
+    Windows: "WINDOWS",
+};
+export const GenerateCompletionsRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.fileContext && { fileContext: FileContextFilterSensitiveLog(obj.fileContext)
+    }),
+    ...(obj.editorState && { editorState: EditorStateFilterSensitiveLog(obj.editorState)
+    }),
+    ...(obj.nextToken && { nextToken: SENSITIVE_STRING
+    }),
+    ...(obj.supplementalContexts && { supplementalContexts: obj.supplementalContexts.map(item => SupplementalContextFilterSensitiveLog(item))
+    }),
+});
+export var Prediction;
+(function (Prediction) {
+    Prediction.visit = (value, visitor) => {
+        if (value.completion !== undefined)
+            return visitor.completion(value.completion);
+        if (value.edit !== undefined)
+            return visitor.edit(value.edit);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(Prediction || (Prediction = {}));
+export const PredictionFilterSensitiveLog = (obj) => {
+    if (obj.completion !== undefined)
+        return { completion: CompletionFilterSensitiveLog(obj.completion)
+        };
+    if (obj.edit !== undefined)
+        return { edit: EditFilterSensitiveLog(obj.edit)
+        };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: 'UNKNOWN' };
+};
+export const GenerateCompletionsResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.predictions && { predictions: obj.predictions.map(item => PredictionFilterSensitiveLog(item))
+    }),
+    ...(obj.completions && { completions: obj.completions.map(item => CompletionFilterSensitiveLog(item))
+    }),
+    ...(obj.nextToken && { nextToken: SENSITIVE_STRING
+    }),
+});
+export const GetCodeAnalysisResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.errorMessage && { errorMessage: SENSITIVE_STRING
+    }),
+});
+export const SuggestedFixFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.codeDiff && { codeDiff: SENSITIVE_STRING
+    }),
+    ...(obj.description && { description: SENSITIVE_STRING
+    }),
+});
+export const GetCodeFixJobResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.suggestedFix && { suggestedFix: SuggestedFixFilterSensitiveLog(obj.suggestedFix)
+    }),
+});
+export const InlineChatUserDecision = {
+    ACCEPT: "ACCEPT",
+    DISMISS: "DISMISS",
+    REJECT: "REJECT",
+};
+export const Intent = {
+    DEV: "DEV",
+    DOC: "DOC",
+};
+export var IntentContext;
+(function (IntentContext) {
+    IntentContext.visit = (value, visitor) => {
+        if (value.documentation !== undefined)
+            return visitor.documentation(value.documentation);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(IntentContext || (IntentContext = {}));
+export const IntentContextFilterSensitiveLog = (obj) => {
+    if (obj.documentation !== undefined)
+        return { documentation: DocumentationIntentContextFilterSensitiveLog(obj.documentation)
+        };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: 'UNKNOWN' };
+};
+export const ListCodeAnalysisFindingsResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.codeAnalysisFindings && { codeAnalysisFindings: SENSITIVE_STRING
+    }),
+});
+export const TargetFileInfoFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.filePath && { filePath: SENSITIVE_STRING
+    }),
+    ...(obj.testFilePath && { testFilePath: SENSITIVE_STRING
+    }),
+    ...(obj.fileSummary && { fileSummary: SENSITIVE_STRING
+    }),
+    ...(obj.filePlan && { filePlan: SENSITIVE_STRING
+    }),
+});
+export const PackageInfoFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.executionCommand && { executionCommand: SENSITIVE_STRING
+    }),
+    ...(obj.buildCommand && { buildCommand: SENSITIVE_STRING
+    }),
+    ...(obj.packageSummary && { packageSummary: SENSITIVE_STRING
+    }),
+    ...(obj.packagePlan && { packagePlan: SENSITIVE_STRING
+    }),
+    ...(obj.targetFileInfoList && { targetFileInfoList: obj.targetFileInfoList.map(item => TargetFileInfoFilterSensitiveLog(item))
+    }),
+});
+export const TransformationProgressUpdateStatus = {
+    AWAITING_CLIENT_ACTION: "AWAITING_CLIENT_ACTION",
+    COMPLETED: "COMPLETED",
+    FAILED: "FAILED",
+    IN_PROGRESS: "IN_PROGRESS",
+    PAUSED: "PAUSED",
+    SKIPPED: "SKIPPED",
+};
+export const TerminalUserInteractionEventType = {
+    CODEWHISPERER_TERMINAL_COMPLETION_INSERTED: "CODEWHISPERER_TERMINAL_COMPLETION_INSERTED",
+    CODEWHISPERER_TERMINAL_TRANSLATION_ACTION: "CODEWHISPERER_TERMINAL_TRANSLATION_ACTION",
+};
+export const SuggestionState = {
+    Accept: "ACCEPT",
+    Discard: "DISCARD",
+    Empty: "EMPTY",
+    Merge: "MERGE",
+    Reject: "REJECT",
+};
+export const SuggestionType = {
+    Completions: "COMPLETIONS",
+    Edits: "EDITS",
+};
+export const UserTriggerDecisionEventFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.addedIdeDiagnostics && { addedIdeDiagnostics: obj.addedIdeDiagnostics.map(item => IdeDiagnosticFilterSensitiveLog(item))
+    }),
+    ...(obj.removedIdeDiagnostics && { removedIdeDiagnostics: obj.removedIdeDiagnostics.map(item => IdeDiagnosticFilterSensitiveLog(item))
+    }),
+});
+export var TelemetryEvent;
+(function (TelemetryEvent) {
+    TelemetryEvent.visit = (value, visitor) => {
+        if (value.userTriggerDecisionEvent !== undefined)
+            return visitor.userTriggerDecisionEvent(value.userTriggerDecisionEvent);
+        if (value.codeCoverageEvent !== undefined)
+            return visitor.codeCoverageEvent(value.codeCoverageEvent);
+        if (value.userModificationEvent !== undefined)
+            return visitor.userModificationEvent(value.userModificationEvent);
+        if (value.codeScanEvent !== undefined)
+            return visitor.codeScanEvent(value.codeScanEvent);
+        if (value.codeScanSucceededEvent !== undefined)
+            return visitor.codeScanSucceededEvent(value.codeScanSucceededEvent);
+        if (value.codeScanFailedEvent !== undefined)
+            return visitor.codeScanFailedEvent(value.codeScanFailedEvent);
+        if (value.codeScanRemediationsEvent !== undefined)
+            return visitor.codeScanRemediationsEvent(value.codeScanRemediationsEvent);
+        if (value.codeFixGenerationEvent !== undefined)
+            return visitor.codeFixGenerationEvent(value.codeFixGenerationEvent);
+        if (value.codeFixAcceptanceEvent !== undefined)
+            return visitor.codeFixAcceptanceEvent(value.codeFixAcceptanceEvent);
+        if (value.metricData !== undefined)
+            return visitor.metricData(value.metricData);
+        if (value.chatAddMessageEvent !== undefined)
+            return visitor.chatAddMessageEvent(value.chatAddMessageEvent);
+        if (value.chatInteractWithMessageEvent !== undefined)
+            return visitor.chatInteractWithMessageEvent(value.chatInteractWithMessageEvent);
+        if (value.chatUserModificationEvent !== undefined)
+            return visitor.chatUserModificationEvent(value.chatUserModificationEvent);
+        if (value.terminalUserInteractionEvent !== undefined)
+            return visitor.terminalUserInteractionEvent(value.terminalUserInteractionEvent);
+        if (value.featureDevEvent !== undefined)
+            return visitor.featureDevEvent(value.featureDevEvent);
+        if (value.featureDevCodeGenerationEvent !== undefined)
+            return visitor.featureDevCodeGenerationEvent(value.featureDevCodeGenerationEvent);
+        if (value.featureDevCodeAcceptanceEvent !== undefined)
+            return visitor.featureDevCodeAcceptanceEvent(value.featureDevCodeAcceptanceEvent);
+        if (value.inlineChatEvent !== undefined)
+            return visitor.inlineChatEvent(value.inlineChatEvent);
+        if (value.transformEvent !== undefined)
+            return visitor.transformEvent(value.transformEvent);
+        if (value.docGenerationEvent !== undefined)
+            return visitor.docGenerationEvent(value.docGenerationEvent);
+        if (value.docV2GenerationEvent !== undefined)
+            return visitor.docV2GenerationEvent(value.docV2GenerationEvent);
+        if (value.docV2AcceptanceEvent !== undefined)
+            return visitor.docV2AcceptanceEvent(value.docV2AcceptanceEvent);
+        if (value.testGenerationEvent !== undefined)
+            return visitor.testGenerationEvent(value.testGenerationEvent);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(TelemetryEvent || (TelemetryEvent = {}));
+export const TelemetryEventFilterSensitiveLog = (obj) => {
+    if (obj.userTriggerDecisionEvent !== undefined)
+        return { userTriggerDecisionEvent: UserTriggerDecisionEventFilterSensitiveLog(obj.userTriggerDecisionEvent)
+        };
+    if (obj.codeCoverageEvent !== undefined)
+        return { codeCoverageEvent: obj.codeCoverageEvent
+        };
+    if (obj.userModificationEvent !== undefined)
+        return { userModificationEvent: obj.userModificationEvent
+        };
+    if (obj.codeScanEvent !== undefined)
+        return { codeScanEvent: obj.codeScanEvent
+        };
+    if (obj.codeScanSucceededEvent !== undefined)
+        return { codeScanSucceededEvent: obj.codeScanSucceededEvent
+        };
+    if (obj.codeScanFailedEvent !== undefined)
+        return { codeScanFailedEvent: obj.codeScanFailedEvent
+        };
+    if (obj.codeScanRemediationsEvent !== undefined)
+        return { codeScanRemediationsEvent: obj.codeScanRemediationsEvent
+        };
+    if (obj.codeFixGenerationEvent !== undefined)
+        return { codeFixGenerationEvent: obj.codeFixGenerationEvent
+        };
+    if (obj.codeFixAcceptanceEvent !== undefined)
+        return { codeFixAcceptanceEvent: obj.codeFixAcceptanceEvent
+        };
+    if (obj.metricData !== undefined)
+        return { metricData: obj.metricData
+        };
+    if (obj.chatAddMessageEvent !== undefined)
+        return { chatAddMessageEvent: obj.chatAddMessageEvent
+        };
+    if (obj.chatInteractWithMessageEvent !== undefined)
+        return { chatInteractWithMessageEvent: ChatInteractWithMessageEventFilterSensitiveLog(obj.chatInteractWithMessageEvent)
+        };
+    if (obj.chatUserModificationEvent !== undefined)
+        return { chatUserModificationEvent: obj.chatUserModificationEvent
+        };
+    if (obj.terminalUserInteractionEvent !== undefined)
+        return { terminalUserInteractionEvent: obj.terminalUserInteractionEvent
+        };
+    if (obj.featureDevEvent !== undefined)
+        return { featureDevEvent: obj.featureDevEvent
+        };
+    if (obj.featureDevCodeGenerationEvent !== undefined)
+        return { featureDevCodeGenerationEvent: obj.featureDevCodeGenerationEvent
+        };
+    if (obj.featureDevCodeAcceptanceEvent !== undefined)
+        return { featureDevCodeAcceptanceEvent: obj.featureDevCodeAcceptanceEvent
+        };
+    if (obj.inlineChatEvent !== undefined)
+        return { inlineChatEvent: obj.inlineChatEvent
+        };
+    if (obj.transformEvent !== undefined)
+        return { transformEvent: obj.transformEvent
+        };
+    if (obj.docGenerationEvent !== undefined)
+        return { docGenerationEvent: obj.docGenerationEvent
+        };
+    if (obj.docV2GenerationEvent !== undefined)
+        return { docV2GenerationEvent: obj.docV2GenerationEvent
+        };
+    if (obj.docV2AcceptanceEvent !== undefined)
+        return { docV2AcceptanceEvent: obj.docV2AcceptanceEvent
+        };
+    if (obj.testGenerationEvent !== undefined)
+        return { testGenerationEvent: obj.testGenerationEvent
+        };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: 'UNKNOWN' };
+};
+export const SendTelemetryEventRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.telemetryEvent && { telemetryEvent: TelemetryEventFilterSensitiveLog(obj.telemetryEvent)
+    }),
+});
+export const ServiceQuotaExceededExceptionReason = {
+    CONVERSATION_LIMIT_EXCEEDED: "CONVERSATION_LIMIT_EXCEEDED",
+    MONTHLY_REQUEST_COUNT: "MONTHLY_REQUEST_COUNT",
+    OVERAGE_REQUEST_LIMIT_EXCEEDED: "OVERAGE_REQUEST_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 StartCodeAnalysisResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.errorMessage && { errorMessage: SENSITIVE_STRING
+    }),
+});
+export const StartCodeFixJobRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.description && { description: SENSITIVE_STRING
+    }),
+});
+export const TargetCodeFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.relativeTargetPath && { relativeTargetPath: SENSITIVE_STRING
+    }),
+});
+export const TaskAssistPlanStepAction = {
+    CREATE: "CREATE",
+    DELETE: "DELETE",
+    MODIFY: "MODIFY",
+    UNKNOWN: "UNKNOWN",
+};
+export const TestGenerationJobStatus = {
+    COMPLETED: "COMPLETED",
+    FAILED: "FAILED",
+    IN_PROGRESS: "IN_PROGRESS",
+};
+export const TestGenerationJobFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.shortAnswer && { shortAnswer: SENSITIVE_STRING
+    }),
+    ...(obj.jobSummary && { jobSummary: SENSITIVE_STRING
+    }),
+    ...(obj.jobPlan && { jobPlan: SENSITIVE_STRING
+    }),
+    ...(obj.packageInfoList && { packageInfoList: obj.packageInfoList.map(item => PackageInfoFilterSensitiveLog(item))
+    }),
+});
+export const TransformationDotNetRuntimeEnv = {
+    NET_5_0: "NET_5_0",
+    NET_6_0: "NET_6_0",
+    NET_7_0: "NET_7_0",
+    NET_8_0: "NET_8_0",
+    NET_9_0: "NET_9_0",
+    NET_STANDARD_2_0: "NET_STANDARD_2_0",
+};
+export const TransformationJavaRuntimeEnv = {
+    JVM_11: "JVM_11",
+    JVM_17: "JVM_17",
+    JVM_21: "JVM_21",
+    JVM_8: "JVM_8",
+};
+export const TransformationStatus = {
+    ACCEPTED: "ACCEPTED",
+    COMPLETED: "COMPLETED",
+    CREATED: "CREATED",
+    FAILED: "FAILED",
+    PARTIALLY_COMPLETED: "PARTIALLY_COMPLETED",
+    PAUSED: "PAUSED",
+    PLANNED: "PLANNED",
+    PLANNING: "PLANNING",
+    PREPARED: "PREPARED",
+    PREPARING: "PREPARING",
+    REJECTED: "REJECTED",
+    RESUMED: "RESUMED",
+    STARTED: "STARTED",
+    STOPPED: "STOPPED",
+    STOPPING: "STOPPING",
+    TRANSFORMED: "TRANSFORMED",
+    TRANSFORMING: "TRANSFORMING",
+};
+export const TransformationLanguage = {
+    COBOL: "COBOL",
+    C_SHARP: "C_SHARP",
+    JAVA_11: "JAVA_11",
+    JAVA_17: "JAVA_17",
+    JAVA_21: "JAVA_21",
+    JAVA_8: "JAVA_8",
+    JCL: "JCL",
+    PL_I: "PL_I",
+};
+export const TransformationOperatingSystemFamily = {
+    LINUX: "LINUX",
+    WINDOWS: "WINDOWS",
+};
+export const TransformationMainframeRuntimeEnv = {
+    MAINFRAME: "MAINFRAME",
+};
+export var TransformationRuntimeEnv;
+(function (TransformationRuntimeEnv) {
+    TransformationRuntimeEnv.visit = (value, visitor) => {
+        if (value.java !== undefined)
+            return visitor.java(value.java);
+        if (value.dotNet !== undefined)
+            return visitor.dotNet(value.dotNet);
+        if (value.mainframe !== undefined)
+            return visitor.mainframe(value.mainframe);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(TransformationRuntimeEnv || (TransformationRuntimeEnv = {}));
+export var TransformationProjectArtifactDescriptor;
+(function (TransformationProjectArtifactDescriptor) {
+    TransformationProjectArtifactDescriptor.visit = (value, visitor) => {
+        if (value.sourceCodeArtifact !== undefined)
+            return visitor.sourceCodeArtifact(value.sourceCodeArtifact);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(TransformationProjectArtifactDescriptor || (TransformationProjectArtifactDescriptor = {}));
+export const TransformationType = {
+    DOCUMENT_GENERATION: "DOCUMENT_GENERATION",
+    LANGUAGE_UPGRADE: "LANGUAGE_UPGRADE",
+};
+export const TransformationStepStatus = {
+    COMPLETED: "COMPLETED",
+    CREATED: "CREATED",
+    FAILED: "FAILED",
+    PARTIALLY_COMPLETED: "PARTIALLY_COMPLETED",
+    PAUSED: "PAUSED",
+    SKIPPED: "SKIPPED",
+    STOPPED: "STOPPED",
+};
+export const TransformationUserActionStatus = {
+    COMPLETED: "COMPLETED",
+    REJECTED: "REJECTED",
+};
+export const UsageLimitType = {
+    AGENTIC_REQUEST: "AGENTIC_REQUEST",
+    AI_EDITOR: "AI_EDITOR",
+    CODE_COMPLETIONS: "CODE_COMPLETIONS",
+    TRANSFORM: "TRANSFORM",
+};
+export const UsageLimitUpdateRequestStatus = {
+    APPROVED: "APPROVED",
+    PENDING_REVIEW: "PENDING_REVIEW",
+    REJECTED: "REJECTED",
+};
+export const UserInfoFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.email && { email: SENSITIVE_STRING
+    }),
+});
+export const EventFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.eventBlob && { eventBlob: SENSITIVE_STRING
+    }),
+});
+export const ListEventsResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.events && { events: obj.events.map(item => EventFilterSensitiveLog(item))
+    }),
+});
+export const ModelProvider = {
+    DEFAULT: "DEFAULT",
+};
+export const InputType = {
+    IMAGE: "IMAGE",
+    TEXT: "TEXT",
+};
+export const CreateUserMemoryEntryInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.memoryEntryString && { memoryEntryString: SENSITIVE_STRING
+    }),
+});
+export const MemoryStatus = {
+    DECRYPTION_FAILURE: "DECRYPTION_FAILURE",
+    VALID: "VALID",
+};
+export const MemoryEntryMetadataFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.attributes && { attributes: Object.entries(obj.attributes).reduce((acc, [key, value]) => (acc[key] =
+            SENSITIVE_STRING
+            ,
+                acc), {})
+    }),
+});
+export const MemoryEntryFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.memoryEntryString && { memoryEntryString: SENSITIVE_STRING
+    }),
+    ...(obj.metadata && { metadata: MemoryEntryMetadataFilterSensitiveLog(obj.metadata)
+    }),
+});
+export const CreateUserMemoryEntryOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.memoryEntry && { memoryEntry: MemoryEntryFilterSensitiveLog(obj.memoryEntry)
+    }),
+});
+export const ListUserMemoryEntriesOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.memoryEntries && { memoryEntries: obj.memoryEntries.map(item => MemoryEntryFilterSensitiveLog(item))
+    }),
+});
+export const SubscriptionProvider = {
+    AWS_ACCOUNT: "AWS_ACCOUNT",
+    STRIPE: "STRIPE",
+};
+export const SubscriptionType = {
+    Q_DEVELOPER_STANDALONE: "Q_DEVELOPER_STANDALONE",
+    Q_DEVELOPER_STANDALONE_FREE: "Q_DEVELOPER_STANDALONE_FREE",
+    Q_DEVELOPER_STANDALONE_POWER: "Q_DEVELOPER_STANDALONE_POWER",
+    Q_DEVELOPER_STANDALONE_PRO: "Q_DEVELOPER_STANDALONE_PRO",
+    Q_DEVELOPER_STANDALONE_PRO_PLUS: "Q_DEVELOPER_STANDALONE_PRO_PLUS",
+};
+export const SubscriptionStatus = {
+    ACTIVE: "ACTIVE",
+    INACTIVE: "INACTIVE",
+};
+export const SubscriptionName = {
+    KIRO_FREE: "KIRO_FREE",
+    KIRO_POWER: "KIRO_POWER",
+    KIRO_PRO: "KIRO_PRO",
+    KIRO_PRO_PLUS: "KIRO_PRO_PLUS",
+};
+export const Currency = {
+    USD: "USD",
+};
+export const GetTestGenerationResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.testGenerationJob && { testGenerationJob: TestGenerationJobFilterSensitiveLog(obj.testGenerationJob)
+    }),
+});
+export const StartTestGenerationRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.targetCodeList && { targetCodeList: obj.targetCodeList.map(item => TargetCodeFilterSensitiveLog(item))
+    }),
+    ...(obj.userInput && { userInput: SENSITIVE_STRING
+    }),
+});
+export const StartTestGenerationResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.testGenerationJob && { testGenerationJob: TestGenerationJobFilterSensitiveLog(obj.testGenerationJob)
+    }),
+});
+export const ResourceType = {
+    AGENTIC_REQUEST: "AGENTIC_REQUEST",
+    CREDIT: "CREDIT",
+    SPEC: "SPEC",
+    VIBE: "VIBE",
+};
+export const OverageCapability = {
+    OVERAGE_CAPABLE: "OVERAGE_CAPABLE",
+    OVERAGE_INCAPABLE: "OVERAGE_INCAPABLE",
+};
+export const SubscriptionManagementTarget = {
+    MANAGE: "MANAGE",
+    PURCHASE: "PURCHASE",
+};
+export const UpgradeCapability = {
+    UPGRADE_CAPABLE: "UPGRADE_CAPABLE",
+    UPGRADE_INCAPABLE: "UPGRADE_INCAPABLE",
+};
+export const FreeTrialStatus = {
+    ACTIVE: "ACTIVE",
+    EXPIRED: "EXPIRED",
+};
+export const GetUsageLimitsResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.userInfo && { userInfo: UserInfoFilterSensitiveLog(obj.userInfo)
+    }),
+});
+export class UpdateUsageLimitQuotaExceededException extends __BaseException {
+    name = "UpdateUsageLimitQuotaExceededException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "UpdateUsageLimitQuotaExceededException",
+            $fault: "client",
+            ...opts
+        });
+        Object.setPrototypeOf(this, UpdateUsageLimitQuotaExceededException.prototype);
+    }
+}
+export const GetTaskAssistCodeGenerationResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.codeGenerationStatusDetail && { codeGenerationStatusDetail: SENSITIVE_STRING
+    }),
+});