@aws/lsp-codewhisperer 0.0.94 → 0.0.96

package/node_modules/@amazon/elastic-gumby-frontend-client/dist-es/models/models_0.d.ts

@@ -0,0 +1,1289 @@
+import { ElasticGumbyFrontendServiceException as __BaseException } from "./ElasticGumbyFrontendServiceException";
+import { ExceptionOptionType as __ExceptionOptionType } from "@smithy/smithy-client";
+import { DocumentType as __DocumentType } from "@smithy/types";
+export declare const AccountConnectionStatus: {
+    readonly ACTIVE: "ACTIVE";
+    readonly PENDING: "PENDING";
+    readonly REJECTED: "REJECTED";
+};
+export type AccountConnectionStatus = typeof AccountConnectionStatus[keyof typeof AccountConnectionStatus];
+export interface AwsAccountConnection {
+    status?: AccountConnectionStatus;
+    createdDate?: Date;
+    expirationDate?: Date;
+    accountId?: string;
+    roleArn?: string;
+    connectionToken?: string;
+}
+export type AccountConnection = AccountConnection.AwsAccountConnectionMember | AccountConnection.$UnknownMember;
+export declare namespace AccountConnection {
+    interface AwsAccountConnectionMember {
+        awsAccountConnection: AwsAccountConnection;
+        $unknown?: never;
+    }
+    interface $UnknownMember {
+        awsAccountConnection?: never;
+        $unknown: [string, any];
+    }
+    interface Visitor<T> {
+        awsAccountConnection: (value: AwsAccountConnection) => T;
+        _: (name: string, value: any) => T;
+    }
+    const visit: <T>(value: AccountConnection, visitor: Visitor<T>) => T;
+}
+export interface AwsAccountConnectionRequest {
+    awsAccountId?: string;
+}
+export type AccountConnectionRequest = AccountConnectionRequest.AwsAccountConnectionRequestMember | AccountConnectionRequest.$UnknownMember;
+export declare namespace AccountConnectionRequest {
+    interface AwsAccountConnectionRequestMember {
+        awsAccountConnectionRequest: AwsAccountConnectionRequest;
+        $unknown?: never;
+    }
+    interface $UnknownMember {
+        awsAccountConnectionRequest?: never;
+        $unknown: [string, any];
+    }
+    interface Visitor<T> {
+        awsAccountConnectionRequest: (value: AwsAccountConnectionRequest) => T;
+        _: (name: string, value: any) => T;
+    }
+    const visit: <T>(value: AccountConnectionRequest, visitor: Visitor<T>) => T;
+}
+export declare const Action: {
+    readonly APPROVE: "APPROVE";
+    readonly REJECT: "REJECT";
+};
+export type Action = typeof Action[keyof typeof Action];
+export declare const ActionType: {
+    readonly INVOKE: "INVOKE";
+    readonly SELECT: "SELECT";
+};
+export type ActionType = typeof ActionType[keyof typeof ActionType];
+export declare const AllowedStatus: {
+    readonly ALLOWED: "ALLOWED";
+    readonly DENIED: "DENIED";
+};
+export type AllowedStatus = typeof AllowedStatus[keyof typeof AllowedStatus];
+export declare const CategoryType: {
+    readonly CUSTOMER_OUTPUT: "CUSTOMER_OUTPUT";
+    readonly HITL_FROM_USER: "HITL_FROM_USER";
+    readonly CUSTOMER_INPUT: "CUSTOMER_INPUT";
+    readonly PLAN_STEP_SUMMARY: "PLAN_STEP_SUMMARY";
+};
+export type CategoryType = typeof CategoryType[keyof typeof CategoryType];
+export declare const FileType: {
+    readonly JSON: "JSON";
+    readonly ZIP: "ZIP";
+};
+export type FileType = typeof FileType[keyof typeof FileType];
+export interface ArtifactType {
+    categoryType: CategoryType | undefined;
+    fileType: FileType | undefined;
+    schemaType?: string;
+}
+export interface Artifact {
+    jobId?: string;
+    artifactId: string | undefined;
+    artifactType: ArtifactType | undefined;
+    artifactCreatedTimestamp: Date | undefined;
+    planStepId?: string;
+    artifactExpiryTimestamp: Date | undefined;
+}
+export type ArtifactReference = ArtifactReference.ArtifactIdMember | ArtifactReference.ArtifactTypeMember | ArtifactReference.$UnknownMember;
+export declare namespace ArtifactReference {
+    interface ArtifactTypeMember {
+        artifactType: ArtifactType;
+        artifactId?: never;
+        $unknown?: never;
+    }
+    interface ArtifactIdMember {
+        artifactType?: never;
+        artifactId: string;
+        $unknown?: never;
+    }
+    interface $UnknownMember {
+        artifactType?: never;
+        artifactId?: never;
+        $unknown: [string, any];
+    }
+    interface Visitor<T> {
+        artifactType: (value: ArtifactType) => T;
+        artifactId: (value: string) => T;
+        _: (name: string, value: any) => T;
+    }
+    const visit: <T>(value: ArtifactReference, visitor: Visitor<T>) => T;
+}
+export interface BatchGetMessageRequest {
+    messageIds: (string)[] | undefined;
+    workspaceId?: string;
+}
+export interface BatchGetMessageError {
+    messageId: string | undefined;
+    errorCode: string | undefined;
+    errorMessage: string | undefined;
+}
+export declare const BatchGetMessageErrorFilterSensitiveLog: (obj: BatchGetMessageError) => any;
+export declare const InvokedStatus: {
+    readonly INVOKED: "INVOKED";
+    readonly NOT_INVOKED: "NOT_INVOKED";
+};
+export type InvokedStatus = typeof InvokedStatus[keyof typeof InvokedStatus];
+export interface Option {
+    label?: string;
+    value?: string;
+}
+export declare const OptionFilterSensitiveLog: (obj: Option) => any;
+export interface InteractionResult {
+    interactionId?: string;
+    selectedOption?: Option;
+    invokedStatus?: InvokedStatus;
+}
+export declare const InteractionResultFilterSensitiveLog: (obj: InteractionResult) => any;
+export interface InteractionResults {
+    interactionResults?: (InteractionResult)[];
+    interactionOriginId?: string;
+}
+export declare const InteractionResultsFilterSensitiveLog: (obj: InteractionResults) => any;
+export interface InvokeApi {
+    operationName?: string;
+    operationParams?: Record<string, string>;
+    label?: string;
+}
+export interface InvokeInteractionData {
+    invokeApi?: InvokeApi;
+}
+export interface SelectInteractionData {
+    options?: (Option)[];
+}
+export declare const SelectInteractionDataFilterSensitiveLog: (obj: SelectInteractionData) => any;
+export interface InteractionData {
+    selectInteractionData?: SelectInteractionData;
+    invokeInteractionData?: InvokeInteractionData;
+}
+export declare const InteractionDataFilterSensitiveLog: (obj: InteractionData) => any;
+export declare const Target: {
+    readonly AGENT: "AGENT";
+    readonly JOB: "JOB";
+    readonly JOB_OBJECTIVE: "JOB_OBJECTIVE";
+};
+export type Target = typeof Target[keyof typeof Target];
+export interface Interaction {
+    interactionId?: string;
+    actionType?: ActionType;
+    target?: Target;
+    data?: InteractionData;
+}
+export declare const InteractionFilterSensitiveLog: (obj: Interaction) => any;
+export declare const MessageOrigin: {
+    readonly SYSTEM: "SYSTEM";
+    readonly USER: "USER";
+};
+export type MessageOrigin = typeof MessageOrigin[keyof typeof MessageOrigin];
+export declare const FocusState: {
+    readonly ACTIVE: "ACTIVE";
+    readonly INACTIVE: "INACTIVE";
+    readonly UNKNOWN: "UNKNOWN";
+};
+export type FocusState = typeof FocusState[keyof typeof FocusState];
+export interface ConnectorMetadata {
+    connectorId?: string;
+    focusState?: FocusState;
+}
+export interface ChatArtifactMetadata {
+    artifactId?: string;
+}
+export interface ChatHitlTaskMetadata {
+    hitlTaskId?: string;
+    focusState?: FocusState;
+}
+export interface ChatWorklogStepMetadata {
+    stepId?: string;
+    focusState?: FocusState;
+}
+export interface ChatJobMetadata {
+    jobId?: string;
+    focusState?: FocusState;
+    hitl?: ChatHitlTaskMetadata;
+    artifact?: ChatArtifactMetadata;
+    worklog?: ChatWorklogStepMetadata;
+}
+export interface WorkspaceMetadata {
+    workspaceId?: string;
+    connectors?: (ConnectorMetadata)[];
+    jobs?: (ChatJobMetadata)[];
+}
+export interface ResourcesOnScreen {
+    workspace?: WorkspaceMetadata;
+}
+export interface Metadata {
+    resourcesOnScreen?: ResourcesOnScreen;
+}
+export declare const MessageType: {
+    readonly ERROR: "ERROR";
+    readonly FINAL_RESPONSE: "FINAL_RESPONSE";
+    readonly THINKING: "THINKING";
+};
+export type MessageType = typeof MessageType[keyof typeof MessageType];
+export interface ProcessingInfo {
+    messageType?: MessageType;
+}
+export interface Message {
+    messageId: string | undefined;
+    messageOrigin: MessageOrigin | undefined;
+    createdAt: Date | undefined;
+    text?: string;
+    parentMessageId?: string;
+    interactions?: (Interaction)[];
+    interactionResults?: InteractionResults;
+    metadata?: Metadata;
+    processingInfo?: ProcessingInfo;
+}
+export declare const MessageFilterSensitiveLog: (obj: Message) => any;
+export interface BatchGetMessageResponse {
+    messages: (Message)[] | undefined;
+    errors: (BatchGetMessageError)[] | undefined;
+}
+export declare const BatchGetMessageResponseFilterSensitiveLog: (obj: BatchGetMessageResponse) => any;
+export declare const AccessDeniedReason: {
+    readonly INVALID_SESSION: "INVALID_SESSION";
+    readonly MISSING_SUBSCRIPTION: "MISSING_SUBSCRIPTION";
+    readonly NOT_ALLOWLISTED: "NOT_ALLOWLISTED";
+    readonly UNAUTHORIZED: "UNAUTHORIZED";
+};
+export type AccessDeniedReason = typeof AccessDeniedReason[keyof typeof AccessDeniedReason];
+export declare class AccessDeniedException extends __BaseException {
+    readonly name: "AccessDeniedException";
+    readonly $fault: "client";
+    reason?: AccessDeniedReason;
+    constructor(opts: __ExceptionOptionType<AccessDeniedException, __BaseException>);
+}
+export declare class ConflictException extends __BaseException {
+    readonly name: "ConflictException";
+    readonly $fault: "client";
+    constructor(opts: __ExceptionOptionType<ConflictException, __BaseException>);
+}
+export declare class DryRunOperationException extends __BaseException {
+    readonly name: "DryRunOperationException";
+    readonly $fault: "client";
+    constructor(opts: __ExceptionOptionType<DryRunOperationException, __BaseException>);
+}
+export declare class InternalServerException extends __BaseException {
+    readonly name: "InternalServerException";
+    readonly $fault: "server";
+    constructor(opts: __ExceptionOptionType<InternalServerException, __BaseException>);
+}
+export declare class ResourceNotFoundException extends __BaseException {
+    readonly name: "ResourceNotFoundException";
+    readonly $fault: "client";
+    constructor(opts: __ExceptionOptionType<ResourceNotFoundException, __BaseException>);
+}
+export declare class ThrottlingException extends __BaseException {
+    readonly name: "ThrottlingException";
+    readonly $fault: "client";
+    constructor(opts: __ExceptionOptionType<ThrottlingException, __BaseException>);
+}
+export declare class ValidationException extends __BaseException {
+    readonly name: "ValidationException";
+    readonly $fault: "client";
+    constructor(opts: __ExceptionOptionType<ValidationException, __BaseException>);
+}
+export interface BatchGetUserDetailsRequest {
+    userIdList: (string)[] | undefined;
+}
+export declare const ErrorReason: {
+    readonly NOT_FOUND: "NOT_FOUND";
+    readonly NOT_SUBSCRIBED: "NOT_SUBSCRIBED";
+};
+export type ErrorReason = typeof ErrorReason[keyof typeof ErrorReason];
+export interface FailedUserSummary {
+    userId?: string;
+    errorReason?: ErrorReason;
+}
+export interface UserDetails {
+    userId: string | undefined;
+    userName?: string;
+    displayName?: string;
+    familyName?: string;
+    givenName?: string;
+    nickName?: string;
+    email?: string;
+}
+export declare const UserDetailsFilterSensitiveLog: (obj: UserDetails) => any;
+export interface BatchGetUserDetailsResponse {
+    successfulUserDetails: (UserDetails)[] | undefined;
+    failedUserDetails: (FailedUserSummary)[] | undefined;
+}
+export declare const BatchGetUserDetailsResponseFilterSensitiveLog: (obj: BatchGetUserDetailsResponse) => any;
+export declare const BlockingType: {
+    readonly BLOCKING: "BLOCKING";
+    readonly NON_BLOCKING: "NON_BLOCKING";
+};
+export type BlockingType = typeof BlockingType[keyof typeof BlockingType];
+export interface CampaignContext {
+    campaignName: string | undefined;
+}
+export declare const ChatFeedbackReason: {
+    readonly HARMFUL: "Harmful";
+    readonly NOT_ACCURATE: "Not accurate";
+    readonly NOT_USEFUL_OR_INCOMPLETE: "Not useful or incomplete";
+    readonly OTHER: "Something else";
+};
+export type ChatFeedbackReason = typeof ChatFeedbackReason[keyof typeof ChatFeedbackReason];
+export declare const ChatFeedbackType: {
+    readonly NEGATIVE: "NEGATIVE";
+    readonly POSITIVE: "POSITIVE";
+};
+export type ChatFeedbackType = typeof ChatFeedbackType[keyof typeof ChatFeedbackType];
+export interface ChatFeedbackMetadata {
+    hitlTaskId?: string;
+    jobStepId?: string;
+    jobId?: string;
+    messageId: string | undefined;
+}
+export interface ChatFeedback {
+    feedbackType: ChatFeedbackType | undefined;
+    feedbackReasons?: (ChatFeedbackReason)[];
+    feedback?: string;
+    metadata: ChatFeedbackMetadata | undefined;
+}
+export declare const ChatFeedbackFilterSensitiveLog: (obj: ChatFeedback) => any;
+export interface CompleteArtifactUploadRequest {
+    workspaceId: string | undefined;
+    jobId: string | undefined;
+    artifactId: string | undefined;
+}
+export interface CompleteArtifactUploadResponse {
+    artifact: Artifact | undefined;
+}
+export interface ConnectorSummaryData {
+    connectorId?: string;
+    connectorName?: string;
+    description?: string;
+    connectorType?: string;
+    targetRegions?: (string)[];
+}
+export declare const ConnectorSummaryDataFilterSensitiveLog: (obj: ConnectorSummaryData) => any;
+export type ContentDigest = ContentDigest.Sha256Member | ContentDigest.$UnknownMember;
+export declare namespace ContentDigest {
+    interface Sha256Member {
+        Sha256: string;
+        $unknown?: never;
+    }
+    interface $UnknownMember {
+        Sha256?: never;
+        $unknown: [string, any];
+    }
+    interface Visitor<T> {
+        Sha256: (value: string) => T;
+        _: (name: string, value: any) => T;
+    }
+    const visit: <T>(value: ContentDigest, visitor: Visitor<T>) => T;
+}
+export interface CreateArtifactDownloadUrlRequest {
+    workspaceId: string | undefined;
+    jobId: string | undefined;
+    artifactId: string | undefined;
+}
+export interface CreateArtifactDownloadUrlResponse {
+    s3PreSignedUrl: string | undefined;
+    s3UrlExpiryTimestamp: Date | undefined;
+    artifactType: ArtifactType | undefined;
+    requestHeaders: Record<string, (string)[]> | undefined;
+}
+export declare const CreateArtifactDownloadUrlResponseFilterSensitiveLog: (obj: CreateArtifactDownloadUrlResponse) => any;
+export interface CreateArtifactUploadUrlRequest {
+    workspaceId: string | undefined;
+    jobId: string | undefined;
+    contentDigest: ContentDigest | undefined;
+    artifactReference: ArtifactReference | undefined;
+    planStepId?: string;
+}
+export interface CreateArtifactUploadUrlResponse {
+    s3PreSignedUrl: string | undefined;
+    s3UrlExpiryTimestamp: Date | undefined;
+    artifactId: string | undefined;
+    requestHeaders: Record<string, (string)[]> | undefined;
+}
+export declare const CreateArtifactUploadUrlResponseFilterSensitiveLog: (obj: CreateArtifactUploadUrlResponse) => any;
+export interface CreateAssetDownloadUrlRequest {
+    workspaceId: string | undefined;
+    jobId: string | undefined;
+    connectorId: string | undefined;
+    assetKey: string | undefined;
+}
+export interface CreateAssetDownloadUrlResponse {
+    s3PreSignedUrl: string | undefined;
+    s3UrlExpiryTimestamp: Date | undefined;
+    requestHeaders: Record<string, (string)[]> | undefined;
+}
+export declare const CreateAssetDownloadUrlResponseFilterSensitiveLog: (obj: CreateAssetDownloadUrlResponse) => any;
+export interface CreateConnectorRequest {
+    workspaceId: string | undefined;
+    connectorName: string | undefined;
+    description?: string;
+    connectorType: string | undefined;
+    accountConnectionRequest: AccountConnectionRequest | undefined;
+    configuration: Record<string, string> | undefined;
+    idempotencyToken?: string;
+    targetRegions?: (string)[];
+}
+export declare const CreateConnectorRequestFilterSensitiveLog: (obj: CreateConnectorRequest) => any;
+export interface CreateConnectorResponse {
+    connectorId?: string;
+    workspaceId?: string;
+    connectorName?: string;
+    description?: string;
+    connectorType?: string;
+    accountConnection?: AccountConnection;
+    configuration?: Record<string, string>;
+    targetRegions?: (string)[];
+}
+export interface JobTypeContext {
+    jobType: string | undefined;
+}
+export declare const DashboardScope: {
+    readonly CAMPAIGN: "CAMPAIGN";
+    readonly JOB_TYPE: "JOB_TYPE";
+};
+export type DashboardScope = typeof DashboardScope[keyof typeof DashboardScope];
+export interface SummaryConfiguration {
+    scope?: DashboardScope;
+    campaignContext?: CampaignContext;
+    jobTypeContext?: JobTypeContext;
+}
+export declare const DashboardViewType: {
+    readonly SUMMARY: "SUMMARY";
+    readonly TOPOLOGY: "TOPOLOGY";
+};
+export type DashboardViewType = typeof DashboardViewType[keyof typeof DashboardViewType];
+export interface DashboardViewConfiguration {
+    type?: DashboardViewType;
+    summaryConfiguration?: SummaryConfiguration;
+}
+export interface CreateDashboardRequest {
+    configuration?: DashboardViewConfiguration;
+}
+export interface CreateDashboardResponse {
+    dashboardId: string | undefined;
+}
+export declare const GlobalFeedbackType: {
+    readonly BUG: "Bug";
+    readonly CHAT_EFFICACY: "Chat efficacy";
+    readonly FEATURE_REQUEST: "Feature request";
+    readonly JOB_EFFICACY: "Job efficacy";
+    readonly OTHER: "Something else";
+};
+export type GlobalFeedbackType = typeof GlobalFeedbackType[keyof typeof GlobalFeedbackType];
+export interface GlobalFeedbackMetadata {
+    hitlTaskId?: string;
+    jobStepId?: string;
+    jobId?: string;
+}
+export interface GlobalFeedback {
+    feedbackType: GlobalFeedbackType | undefined;
+    feedback: string | undefined;
+    metadata?: GlobalFeedbackMetadata;
+}
+export declare const GlobalFeedbackFilterSensitiveLog: (obj: GlobalFeedback) => any;
+export type JobFeedbackAnswerType = JobFeedbackAnswerType.RatingResponseMember | JobFeedbackAnswerType.TextResponseMember | JobFeedbackAnswerType.$UnknownMember;
+export declare namespace JobFeedbackAnswerType {
+    interface TextResponseMember {
+        textResponse: string;
+        ratingResponse?: never;
+        $unknown?: never;
+    }
+    interface RatingResponseMember {
+        textResponse?: never;
+        ratingResponse: number;
+        $unknown?: never;
+    }
+    interface $UnknownMember {
+        textResponse?: never;
+        ratingResponse?: never;
+        $unknown: [string, any];
+    }
+    interface Visitor<T> {
+        textResponse: (value: string) => T;
+        ratingResponse: (value: number) => T;
+        _: (name: string, value: any) => T;
+    }
+    const visit: <T>(value: JobFeedbackAnswerType, visitor: Visitor<T>) => T;
+}
+export declare const JobFeedbackAnswerTypeFilterSensitiveLog: (obj: JobFeedbackAnswerType) => any;
+export interface JobFeedbackAnswer {
+    questionId: string | undefined;
+    answer: JobFeedbackAnswerType | undefined;
+}
+export declare const JobFeedbackAnswerFilterSensitiveLog: (obj: JobFeedbackAnswer) => any;
+export declare const JobStatus: {
+    readonly ASSESSING: "ASSESSING";
+    readonly AWAITING_HUMAN_INPUT: "AWAITING_HUMAN_INPUT";
+    readonly COMPLETED: "COMPLETED";
+    readonly CREATED: "CREATED";
+    readonly EXECUTING: "EXECUTING";
+    readonly FAILED: "FAILED";
+    readonly PLANNED: "PLANNED";
+    readonly PLANNING: "PLANNING";
+    readonly STARTING: "STARTING";
+    readonly STOPPED: "STOPPED";
+    readonly STOPPING: "STOPPING";
+};
+export type JobStatus = typeof JobStatus[keyof typeof JobStatus];
+export interface JobFeedbackMetadata {
+    hitlTaskId?: string;
+    jobStepId?: string;
+    jobId?: string;
+    jobStatus: JobStatus | undefined;
+}
+export interface JobFeedback {
+    feedback: (JobFeedbackAnswer)[] | undefined;
+    metadata: JobFeedbackMetadata | undefined;
+}
+export declare const JobFeedbackFilterSensitiveLog: (obj: JobFeedback) => any;
+export type Feedback = Feedback.ChatFeedbackMember | Feedback.GlobalFeedbackMember | Feedback.JobFeedbackMember | Feedback.$UnknownMember;
+export declare namespace Feedback {
+    interface GlobalFeedbackMember {
+        globalFeedback: GlobalFeedback;
+        chatFeedback?: never;
+        jobFeedback?: never;
+        $unknown?: never;
+    }
+    interface ChatFeedbackMember {
+        globalFeedback?: never;
+        chatFeedback: ChatFeedback;
+        jobFeedback?: never;
+        $unknown?: never;
+    }
+    interface JobFeedbackMember {
+        globalFeedback?: never;
+        chatFeedback?: never;
+        jobFeedback: JobFeedback;
+        $unknown?: never;
+    }
+    interface $UnknownMember {
+        globalFeedback?: never;
+        chatFeedback?: never;
+        jobFeedback?: never;
+        $unknown: [string, any];
+    }
+    interface Visitor<T> {
+        globalFeedback: (value: GlobalFeedback) => T;
+        chatFeedback: (value: ChatFeedback) => T;
+        jobFeedback: (value: JobFeedback) => T;
+        _: (name: string, value: any) => T;
+    }
+    const visit: <T>(value: Feedback, visitor: Visitor<T>) => T;
+}
+export declare const FeedbackFilterSensitiveLog: (obj: Feedback) => any;
+export interface CreateFeedbackRequest {
+    workspaceId: string | undefined;
+    feedback: Feedback | undefined;
+}
+export declare const CreateFeedbackRequestFilterSensitiveLog: (obj: CreateFeedbackRequest) => any;
+export interface CreateFeedbackResponse {
+}
+export declare const JobType: {
+    readonly CX_UI_COMPONENT_TESTING: "CX_UI_COMPONENT_TESTING";
+    readonly DOT_NET: "DOT_NET";
+    readonly DYNAMIC_SHOWCASE: "DYNAMIC_SHOWCASE";
+    readonly DYNAMIC_SHOWCASE_AGENTCORE_TESTING: "DYNAMIC_SHOWCASE_AGENTCORE_TESTING";
+    readonly EXTERNAL_CAPGEMINI: "EXTERNAL_CAPGEMINI";
+    readonly EXTERNAL_WAVICLE: "EXTERNAL_WAVICLE";
+    readonly JAVA_UPGRADE: "JAVA_UPGRADE";
+    readonly MAINFRAME: "MAINFRAME";
+    readonly MAINFRAME_MIGRATION_ACCENTURE_KB: "MAINFRAME_MIGRATION_ACCENTURE_KB";
+    readonly MAINFRAME_MODERNIZATION_ACCENTURE: "MAINFRAME_MODERNIZATION_ACCENTURE";
+    readonly MIGRATION_ASSESSMENT: "MIGRATION_ASSESSMENT";
+    readonly PROSERVE_CMF: "PROSERVE_CMF";
+    readonly VMWARE: "VMWARE";
+    readonly VMWARE_V2: "VMWARE_V2";
+    readonly WAVE_PLANNING: "WAVE_PLANNING";
+    readonly WINDOWS_DATABASE: "WINDOWS_DATABASE";
+};
+export type JobType = typeof JobType[keyof typeof JobType];
+export interface CreateJobRequest {
+    workspaceId: string | undefined;
+    objective: string | undefined;
+    jobType: JobType | undefined;
+    jobName: string | undefined;
+    intent: string | undefined;
+    idempotencyToken?: string;
+}
+export declare const CreateJobRequestFilterSensitiveLog: (obj: CreateJobRequest) => any;
+export interface CreateJobResponse {
+    jobId: string | undefined;
+    status: JobStatus | undefined;
+}
+export interface CreateSessionRequest {
+    loginQueryParameters: Record<string, string> | undefined;
+}
+export declare const CreateSessionRequestFilterSensitiveLog: (obj: CreateSessionRequest) => any;
+export interface CreateSessionResponse {
+    userId: string | undefined;
+    state?: string;
+}
+export declare const CreateSessionResponseFilterSensitiveLog: (obj: CreateSessionResponse) => any;
+export interface CreateWorkspaceRequest {
+    name?: string;
+    description?: string;
+    idempotencyToken?: string;
+}
+export declare const CreateWorkspaceRequestFilterSensitiveLog: (obj: CreateWorkspaceRequest) => any;
+export interface Workspace {
+    id: string | undefined;
+    name: string | undefined;
+    description: string | undefined;
+    region: string | undefined;
+    accountId: string | undefined;
+}
+export declare const WorkspaceFilterSensitiveLog: (obj: Workspace) => any;
+export interface CreateWorkspaceResponse {
+    workspace: Workspace | undefined;
+}
+export declare const CreateWorkspaceResponseFilterSensitiveLog: (obj: CreateWorkspaceResponse) => any;
+export declare const DashboardStatus: {
+    readonly COMPLETE: "COMPLETE";
+    readonly ERROR: "ERROR";
+    readonly PENDING: "PENDING";
+};
+export type DashboardStatus = typeof DashboardStatus[keyof typeof DashboardStatus];
+export interface DeleteConnectorRequest {
+    workspaceId: string | undefined;
+    connectorId: string | undefined;
+}
+export interface DeleteConnectorResponse {
+    workspaceId?: string;
+    connectorId?: string;
+}
+export interface DeleteJobRequest {
+    workspaceId: string | undefined;
+    jobId: string | undefined;
+}
+export interface DeleteJobResponse {
+    workspaceId: string | undefined;
+    jobId: string | undefined;
+}
+export interface DeleteSelfRoleMappingsRequest {
+    workspaceId: string | undefined;
+}
+export interface DeleteSelfRoleMappingsResponse {
+    workspaceId: string | undefined;
+}
+export interface DeleteUserRoleMappingsRequest {
+    workspaceId: string | undefined;
+    userId: string | undefined;
+}
+export interface DeleteUserRoleMappingsResponse {
+    workspaceId: string | undefined;
+    userId: string | undefined;
+}
+export interface DeleteWorkspaceRequest {
+    id: string | undefined;
+}
+export interface DeleteWorkspaceResponse {
+    id: string | undefined;
+}
+export interface DetectIsAllowedForOperationRequest {
+    workspaceId: string | undefined;
+    operationName: string | undefined;
+}
+export interface DetectIsAllowedForOperationResponse {
+    allowed: AllowedStatus | undefined;
+}
+export interface GetConnectorRequest {
+    workspaceId: string | undefined;
+    connectorId: string | undefined;
+}
+export interface GetConnectorResponse {
+    connectorId?: string;
+    connectorName?: string;
+    description?: string;
+    userId?: string;
+    connectorType?: string;
+    accountConnection?: AccountConnection;
+    connectorConfiguration?: Record<string, string>;
+    targetRegions?: (string)[];
+    sourceAccount?: string;
+}
+export declare const GetConnectorResponseFilterSensitiveLog: (obj: GetConnectorResponse) => any;
+export interface GetDashboardRequest {
+    dashboardId: string | undefined;
+}
+export interface GetDashboardResponse {
+    data?: __DocumentType;
+    status: DashboardStatus | undefined;
+}
+export interface GetFeedbackQuestionsRequest {
+    workspaceId: string | undefined;
+    jobId: string | undefined;
+}
+export declare const FeedbackAnswerType: {
+    readonly RATING: "RATING";
+    readonly TEXT: "TEXT";
+};
+export type FeedbackAnswerType = typeof FeedbackAnswerType[keyof typeof FeedbackAnswerType];
+export interface FeedbackQuestion {
+    questionId?: string;
+    questionText?: string;
+    answerType?: FeedbackAnswerType;
+    isRequired?: boolean;
+}
+export interface GetFeedbackQuestionsResponse {
+    questions?: (FeedbackQuestion)[];
+}
+export interface GetHitlTaskRequest {
+    workspaceId: string | undefined;
+    jobId: string | undefined;
+    taskId: string | undefined;
+}
+export interface HitlTaskArtifact {
+    artifactId?: string;
+}
+export interface JobMetadata {
+    jobId: string | undefined;
+    workspaceId: string | undefined;
+}
+export declare const Severity: {
+    readonly CRITICAL: "CRITICAL";
+    readonly STANDARD: "STANDARD";
+};
+export type Severity = typeof Severity[keyof typeof Severity];
+export declare const HitlTaskStatus: {
+    readonly AWAITING_APPROVAL: "AWAITING_APPROVAL";
+    readonly AWAITING_HUMAN_INPUT: "AWAITING_HUMAN_INPUT";
+    readonly CANCELLED: "CANCELLED";
+    readonly CLOSED: "CLOSED";
+    readonly CLOSED_PENDING_NEXT_TASK: "CLOSED_PENDING_NEXT_TASK";
+    readonly CREATED: "CREATED";
+    readonly DELIVERED: "DELIVERED";
+    readonly IN_PROGRESS: "IN_PROGRESS";
+    readonly SUBMITTED: "SUBMITTED";
+};
+export type HitlTaskStatus = typeof HitlTaskStatus[keyof typeof HitlTaskStatus];
+export declare const HitlTaskType: {
+    readonly DASHBOARD: "DASHBOARD";
+    readonly NORMAL: "NORMAL";
+};
+export type HitlTaskType = typeof HitlTaskType[keyof typeof HitlTaskType];
+export interface HitlTask {
+    taskId: string | undefined;
+    jobMetadata: JobMetadata | undefined;
+    title: string | undefined;
+    description?: string;
+    uxComponentId: string | undefined;
+    createdAt: Date | undefined;
+    updatedAt?: Date;
+    completedAt?: Date;
+    status: HitlTaskStatus | undefined;
+    agentInstanceId: string | undefined;
+    severity: Severity | undefined;
+    taskType: HitlTaskType | undefined;
+    blockingType?: BlockingType;
+    agentArtifact?: HitlTaskArtifact;
+    humanArtifact?: HitlTaskArtifact;
+    planStepId?: string;
+    tag?: string;
+    expiredAt?: Date;
+    updatedBy?: string;
+    submittedBy?: string;
+}
+export interface GetHitlTaskResponse {
+    task?: HitlTask;
+}
+export interface GetJobRequest {
+    workspaceId: string | undefined;
+    jobId: string | undefined;
+    includeObjective?: boolean;
+}
+export interface StatusDetails {
+    status: JobStatus | undefined;
+    failureReason?: string;
+}
+export declare const StatusDetailsFilterSensitiveLog: (obj: StatusDetails) => any;
+export interface JobInfo {
+    workspaceId?: string;
+    jobId?: string;
+    statusDetails?: StatusDetails;
+    creationTime?: Date;
+    startExecutionTime?: Date;
+    endExecutionTime?: Date;
+    objective?: string;
+    jobName?: string;
+    intent?: string;
+    restartable?: boolean;
+    agentFeatures?: Record<string, string>;
+    clientSource?: string;
+}
+export declare const JobInfoFilterSensitiveLog: (obj: JobInfo) => any;
+export interface GetJobResponse {
+    job?: JobInfo;
+}
+export declare const GetJobResponseFilterSensitiveLog: (obj: GetJobResponse) => any;
+export interface GetLoginRedirectUriRequest {
+    callbackRedirectUri: string | undefined;
+    state?: string;
+}
+export declare const GetLoginRedirectUriRequestFilterSensitiveLog: (obj: GetLoginRedirectUriRequest) => any;
+export interface GetLoginRedirectUriResponse {
+    ssoRedirectUri: string | undefined;
+}
+export interface GetUserDetailsRequest {
+    userId: string | undefined;
+}
+export interface GetUserDetailsResponse {
+    userDetails: UserDetails | undefined;
+}
+export declare const GetUserDetailsResponseFilterSensitiveLog: (obj: GetUserDetailsResponse) => any;
+export interface GetUserPreferencesRequest {
+}
+export declare const NotificationStatus: {
+    readonly DISABLED: "DISABLED";
+    readonly ENABLED: "ENABLED";
+};
+export type NotificationStatus = typeof NotificationStatus[keyof typeof NotificationStatus];
+export interface NotificationSettings {
+    workspaceInvitation: NotificationStatus | undefined;
+    hitlBlocked: NotificationStatus | undefined;
+    jobCompleted: NotificationStatus | undefined;
+}
+export interface GetUserPreferencesResponse {
+    notificationSettings: NotificationSettings | undefined;
+}
+export interface GetWorkspaceRequest {
+    id: string | undefined;
+}
+export interface GetWorkspaceResponse {
+    workspace: Workspace | undefined;
+}
+export declare const GetWorkspaceResponseFilterSensitiveLog: (obj: GetWorkspaceResponse) => any;
+export interface JobFilter {
+    jobId: string | undefined;
+    planStepId?: string;
+    categoryType?: CategoryType;
+}
+export interface ListArtifactsRequest {
+    workspaceId: string | undefined;
+    jobFilter?: JobFilter;
+    nextToken?: string;
+}
+export interface ListArtifactsResponse {
+    artifacts: (Artifact)[] | undefined;
+    nextToken?: string;
+}
+export interface ListAvailableProfilesRequest {
+    nextToken?: string;
+    maxResults?: number;
+}
+export interface IdentityDetails {
+    instanceArn: string | undefined;
+    applicationArn: string | undefined;
+    ssoRegion: string | undefined;
+}
+export declare const EnabledState: {
+    readonly DISABLED: "DISABLED";
+    readonly ENABLED: "ENABLED";
+};
+export type EnabledState = typeof EnabledState[keyof typeof EnabledState];
+export interface ProfilePreferences {
+    crossRegionKnowledge: EnabledState | undefined;
+}
+export declare const ProfileStatus: {
+    readonly ACTIVE: "ACTIVE";
+    readonly CREATE_FAILED: "CREATE_FAILED";
+    readonly CREATING: "CREATING";
+    readonly DELETE_FAILED: "DELETE_FAILED";
+    readonly DELETING: "DELETING";
+    readonly UPDATE_FAILED: "UPDATE_FAILED";
+    readonly UPDATING: "UPDATING";
+};
+export type ProfileStatus = typeof ProfileStatus[keyof typeof ProfileStatus];
+export interface Profile {
+    arn: string | undefined;
+    profileName: string | undefined;
+    tenantId: string | undefined;
+    accountId: string | undefined;
+    updatedAt: number | undefined;
+    createdAt: number | undefined;
+    applicationUrl?: string;
+    identityDetails?: IdentityDetails;
+    customerKmsArn?: string;
+    status?: ProfileStatus;
+    preferences?: ProfilePreferences;
+}
+export interface ListAvailableProfilesResponse {
+    profiles?: (Profile)[];
+    nextToken?: string;
+}
+export interface ListConnectorsRequest {
+    workspaceId: string | undefined;
+    requesterAgentInvocationId?: string;
+    nextToken?: string;
+}
+export interface ListConnectorsResponse {
+    connectors?: (ConnectorSummaryData)[];
+    nextToken?: string;
+}
+export declare const ListConnectorsResponseFilterSensitiveLog: (obj: ListConnectorsResponse) => any;
+export interface HitlTaskFilter {
+    taskStatuses?: (HitlTaskStatus)[];
+    blockingType?: BlockingType;
+    planStepId?: string;
+    tag?: string;
+}
+export interface ListHitlTasksRequest {
+    workspaceId: string | undefined;
+    jobId: string | undefined;
+    taskType: HitlTaskType | undefined;
+    taskFilter?: HitlTaskFilter;
+    nextToken?: string;
+    maxResults?: number;
+}
+export interface ListHitlTasksResponse {
+    hitlTasks?: (HitlTask)[];
+    nextToken?: string;
+}
+export interface ListJobPlanStepsRequest {
+    workspaceId: string | undefined;
+    jobId: string | undefined;
+    parentStepId?: string;
+    maxResults?: number;
+    nextToken?: string;
+}
+export declare const PlanStepStatus: {
+    readonly FAILED: "FAILED";
+    readonly IN_PROGRESS: "IN_PROGRESS";
+    readonly NOT_STARTED: "NOT_STARTED";
+    readonly PENDING_HUMAN_INPUT: "PENDING_HUMAN_INPUT";
+    readonly SUCCEEDED: "SUCCEEDED";
+};
+export type PlanStepStatus = typeof PlanStepStatus[keyof typeof PlanStepStatus];
+export interface JobPlanStep {
+    stepId: string | undefined;
+    parentStepId: string | undefined;
+    stepName: string | undefined;
+    description: string | undefined;
+    score: number | undefined;
+    startTime?: Date;
+    endTime?: Date;
+    status?: PlanStepStatus;
+}
+export interface ListJobPlanStepsResponse {
+    steps?: (JobPlanStep)[];
+    nextToken?: string;
+}
+export interface ListJobsRequest {
+    workspaceId: string | undefined;
+    nextToken?: string;
+}
+export interface ListJobEntry {
+    jobInfo?: JobInfo;
+    userId?: string;
+}
+export declare const ListJobEntryFilterSensitiveLog: (obj: ListJobEntry) => any;
+export interface ListJobsResponse {
+    nextToken?: string;
+    jobList?: (ListJobEntry)[];
+}
+export declare const ListJobsResponseFilterSensitiveLog: (obj: ListJobsResponse) => any;
+export interface ListMessagesRequest {
+    startTimestamp?: Date;
+    nextToken?: string;
+    maxResults?: number;
+    metadata?: Metadata;
+}
+export interface ListMessagesResponse {
+    messageIds?: (string)[];
+    nextToken?: string;
+}
+export interface ListPlanUpdatesRequest {
+    workspaceId: string | undefined;
+    jobId: string | undefined;
+    timestamp: number | undefined;
+    planVersion: string | undefined;
+    nextToken?: string;
+}
+export interface PlanStepUpdateEntry {
+    stepId: string | undefined;
+    parentStepId: string | undefined;
+    stepName: string | undefined;
+    description: string | undefined;
+    score: number | undefined;
+    startTime?: Date;
+    endTime?: Date;
+    status?: PlanStepStatus;
+    deleted?: boolean;
+}
+export interface ListPlanUpdatesResponse {
+    steps?: (PlanStepUpdateEntry)[];
+    nextToken?: string;
+}
+export interface SuggestionMetadata {
+    workspaceId?: string;
+    jobId?: string;
+    artifactId?: string;
+    taskId?: string;
+    stepId?: string;
+    connectorId?: string;
+}
+export declare const SuggestionScope: {
+    readonly ARTIFACT: "ARTIFACT";
+    readonly CONNECTOR: "CONNECTOR";
+    readonly JOB: "JOB";
+    readonly STEP: "STEP";
+    readonly TASK: "TASK";
+    readonly WORKSPACE: "WORKSPACE";
+};
+export type SuggestionScope = typeof SuggestionScope[keyof typeof SuggestionScope];
+export interface ListSuggestionsRequest {
+    scope: SuggestionScope | undefined;
+    metadata?: SuggestionMetadata;
+    limit?: number;
+}
+export interface Suggestion {
+    label: string | undefined;
+    value: string | undefined;
+    category?: string;
+}
+export interface ListSuggestionsResponse {
+    suggestions: (Suggestion)[] | undefined;
+}
+export declare const RoleName: {
+    readonly ADMIN: "ADMIN";
+    readonly APPROVER: "APPROVER";
+    readonly CONTRIBUTOR: "CONTRIBUTOR";
+    readonly READ_ONLY: "READ_ONLY";
+};
+export type RoleName = typeof RoleName[keyof typeof RoleName];
+export interface ListUserRoleMappingsRequest {
+    workspaceId: string | undefined;
+    maxResults?: number;
+    nextToken?: string;
+    roleFilters?: (RoleName)[];
+}
+export interface Role {
+    name: RoleName | undefined;
+}
+export interface User {
+    roles: (Role)[] | undefined;
+    userId: string | undefined;
+}
+export interface ListUserRoleMappingsResponse {
+    items: (User)[] | undefined;
+    nextToken?: string;
+}
+export interface TimeFilter {
+    startTime?: Date;
+    endTime?: Date;
+}
+export interface StepIdFilter {
+    stepId: string | undefined;
+    timeFilter?: TimeFilter;
+}
+export type WorklogFilter = WorklogFilter.StepIdFilterMember | WorklogFilter.TimeFilterMember | WorklogFilter.$UnknownMember;
+export declare namespace WorklogFilter {
+    interface StepIdFilterMember {
+        stepIdFilter: StepIdFilter;
+        timeFilter?: never;
+        $unknown?: never;
+    }
+    interface TimeFilterMember {
+        stepIdFilter?: never;
+        timeFilter: TimeFilter;
+        $unknown?: never;
+    }
+    interface $UnknownMember {
+        stepIdFilter?: never;
+        timeFilter?: never;
+        $unknown: [string, any];
+    }
+    interface Visitor<T> {
+        stepIdFilter: (value: StepIdFilter) => T;
+        timeFilter: (value: TimeFilter) => T;
+        _: (name: string, value: any) => T;
+    }
+    const visit: <T>(value: WorklogFilter, visitor: Visitor<T>) => T;
+}
+export interface ListWorklogsRequest {
+    workspaceId: string | undefined;
+    jobId: string | undefined;
+    worklogFilter?: WorklogFilter;
+    nextToken?: string;
+}
+export declare const WorklogType: {
+    readonly AGENT: "AGENT";
+    readonly HITL: "HITL";
+    readonly JOB_MANAGER: "JOB_MANAGER";
+};
+export type WorklogType = typeof WorklogType[keyof typeof WorklogType];
+export interface Worklog {
+    jobMetadata: JobMetadata | undefined;
+    timestamp: Date | undefined;
+    worklogType: WorklogType | undefined;
+    description?: string;
+    attributeMap?: Record<string, string>;
+}
+export interface ListWorklogsResponse {
+    worklogs?: (Worklog)[];
+    outputToken?: string;
+}
+export interface ListWorkspacesRequest {
+    maxResults?: number;
+    nextToken?: string;
+}
+export interface ListWorkspacesResponse {
+    items: (Workspace)[] | undefined;
+    nextToken?: string;
+}
+export declare const ListWorkspacesResponseFilterSensitiveLog: (obj: ListWorkspacesResponse) => any;
+export interface PutUserPreferencesRequest {
+    notificationSettings: NotificationSettings | undefined;
+}
+export interface PutUserPreferencesResponse {
+    notificationSettings: NotificationSettings | undefined;
+}
+export interface PutUserRoleMappingsRequest {
+    workspaceId: string | undefined;
+    userId: string | undefined;
+    roles: (RoleName)[] | undefined;
+}
+export interface PutUserRoleMappingsResponse {
+    workspaceId: string | undefined;
+    userId: string | undefined;
+    roles: (Role)[] | undefined;
+}
+export interface RevokeSessionRequest {
+}
+export interface RevokeSessionResponse {
+    ssoRedirectUri: string | undefined;
+}
+export declare const UserSearchKey: {
+    readonly EMAIL_ADDRESS: "EMAIL_ADDRESS";
+    readonly USERNAME: "USERNAME";
+};
+export type UserSearchKey = typeof UserSearchKey[keyof typeof UserSearchKey];
+export interface SearchUsersRequest {
+    searchTerm: string | undefined;
+    searchKey: UserSearchKey | undefined;
+    maxResults?: number;
+    nextToken?: string;
+}
+export declare const SearchUsersRequestFilterSensitiveLog: (obj: SearchUsersRequest) => any;
+export interface SearchUsersResponse {
+    users: (UserDetails)[] | undefined;
+    nextToken?: string;
+}
+export declare const SearchUsersResponseFilterSensitiveLog: (obj: SearchUsersResponse) => any;
+export declare const TypeaheadUserSearchKey: {
+    readonly USERNAME_OR_EMAIL_ADDRESS: "USERNAME_OR_EMAIL_ADDRESS";
+};
+export type TypeaheadUserSearchKey = typeof TypeaheadUserSearchKey[keyof typeof TypeaheadUserSearchKey];
+export interface SearchUsersTypeaheadRequest {
+    searchTerm: string | undefined;
+    searchKey: TypeaheadUserSearchKey | undefined;
+}
+export declare const SearchUsersTypeaheadRequestFilterSensitiveLog: (obj: SearchUsersTypeaheadRequest) => any;
+export interface SearchUsersTypeaheadResponse {
+    users: (UserDetails)[] | undefined;
+}
+export declare const SearchUsersTypeaheadResponseFilterSensitiveLog: (obj: SearchUsersTypeaheadResponse) => any;
+export interface SendMessageRequest {
+    text?: string;
+    interactions?: (Interaction)[];
+    interactionResults?: InteractionResults;
+    metadata?: Metadata;
+    idempotencyToken?: string;
+}
+export declare const SendMessageRequestFilterSensitiveLog: (obj: SendMessageRequest) => any;
+export interface SendMessageResponse {
+    message?: Message;
+}
+export declare const SendMessageResponseFilterSensitiveLog: (obj: SendMessageResponse) => any;
+export interface StartJobRequest {
+    workspaceId: string | undefined;
+    jobId: string | undefined;
+    idempotencyToken?: string;
+}
+export interface StartJobResponse {
+    status?: JobStatus;
+}
+export interface StopJobRequest {
+    workspaceId: string | undefined;
+    jobId: string | undefined;
+    idempotencyToken?: string;
+}
+export interface StopJobResponse {
+    status?: JobStatus;
+}
+export interface SubmitCriticalHitlTaskRequest {
+    workspaceId: string | undefined;
+    jobId: string | undefined;
+    taskId: string | undefined;
+    action: Action | undefined;
+    humanArtifact?: HitlTaskArtifact;
+    idempotencyToken?: string;
+}
+export interface SubmitCriticalHitlTaskResponse {
+    status?: HitlTaskStatus;
+}
+export interface SubmitStandardHitlTaskRequest {
+    workspaceId: string | undefined;
+    jobId: string | undefined;
+    taskId: string | undefined;
+    action: Action | undefined;
+    humanArtifact?: HitlTaskArtifact;
+    idempotencyToken?: string;
+}
+export interface SubmitStandardHitlTaskResponse {
+    status?: HitlTaskStatus;
+}
+export interface TestReleaseTraitPreProdRequest {
+}
+export interface TestReleaseTraitPreProdResponse {
+}
+export interface TestReleaseTraitProdRequest {
+}
+export interface TestReleaseTraitProdResponse {
+}
+export declare const PostUpdateAction: {
+    readonly SEND_FOR_APPROVAL: "SEND_FOR_APPROVAL";
+    readonly TRANSIT_TO_IN_PROGRESS: "TRANSIT_TO_IN_PROGRESS";
+};
+export type PostUpdateAction = typeof PostUpdateAction[keyof typeof PostUpdateAction];
+export interface UpdateHitlTaskRequest {
+    workspaceId: string | undefined;
+    jobId: string | undefined;
+    taskId: string | undefined;
+    humanArtifact?: HitlTaskArtifact;
+    postUpdateAction?: PostUpdateAction;
+    idempotencyToken?: string;
+}
+export interface UpdateHitlTaskResponse {
+    status?: HitlTaskStatus;
+}
+export interface UpdateJobRequest {
+    workspaceId: string | undefined;
+    jobId: string | undefined;
+    objective?: string;
+    jobName?: string;
+    idempotencyToken?: string;
+}
+export declare const UpdateJobRequestFilterSensitiveLog: (obj: UpdateJobRequest) => any;
+export interface UpdateJobResponse {
+}
+export interface UpdateWorkspaceRequest {
+    id: string | undefined;
+    name?: string;
+    description?: string;
+    idempotencyToken?: string;
+}
+export declare const UpdateWorkspaceRequestFilterSensitiveLog: (obj: UpdateWorkspaceRequest) => any;
+export interface UpdateWorkspaceResponse {
+    workspace: Workspace | undefined;
+}
+export declare const UpdateWorkspaceResponseFilterSensitiveLog: (obj: UpdateWorkspaceResponse) => any;
+export interface VerifySessionRequest {
+}
+export interface VerifySessionResponse {
+    userId: string | undefined;
+}