import * as HttpClient from "effect/unstable/http/HttpClient";
import * as S from "effect/Schema";
import * as stream from "effect/Stream";
import * as API from "../client/api.ts";
import type { Credentials } from "../credentials.ts";
import type { CommonErrors } from "../errors.ts";
import type { Region } from "../region.ts";
export type InstanceId = string;
export type UUID = string;
export type AppVersion = number;
export type QAppsTimestamp = Date;
export type Filename = string;
export type Title = string;
export type Description = string;
export type Placeholder = string;
export type Default = string;
export type Prompt = string;
export type DocumentAttributeKey = string;
export type DocumentAttributeStringValue = string;
export type PlatoString = string;
export type PluginId = string;
export type ActionIdentifier = string;
export type FormInputCardMetadataSchema = unknown;
export type InitialPrompt = string;
export type AppArn = string;
export type SessionName = string;
export type SessionSharingEnabled = boolean;
export type SessionSharingAcceptResponses = boolean;
export type SessionSharingRevealCards = boolean;
export type PageLimit = number;
export type PaginationToken = string;
export type UserId = string;
export type AmazonResourceName = string;
export type TagKey = string;
export type TagValue = string;
export interface AssociateLibraryItemReviewInput {
    instanceId: string;
    libraryItemId: string;
}
export declare const AssociateLibraryItemReviewInput: S.Schema<AssociateLibraryItemReviewInput>;
export interface AssociateLibraryItemReviewResponse {
}
export declare const AssociateLibraryItemReviewResponse: S.Schema<AssociateLibraryItemReviewResponse>;
export interface AssociateQAppWithUserInput {
    instanceId: string;
    appId: string;
}
export declare const AssociateQAppWithUserInput: S.Schema<AssociateQAppWithUserInput>;
export interface AssociateQAppWithUserResponse {
}
export declare const AssociateQAppWithUserResponse: S.Schema<AssociateQAppWithUserResponse>;
export interface BatchCreateCategoryInputCategory {
    id?: string;
    title: string;
    color?: string;
}
export declare const BatchCreateCategoryInputCategory: S.Schema<BatchCreateCategoryInputCategory>;
export type BatchCreateCategoryInputCategoryList = BatchCreateCategoryInputCategory[];
export declare const BatchCreateCategoryInputCategoryList: S.$Array<S.Schema<BatchCreateCategoryInputCategory>>;
export interface BatchCreateCategoryInput {
    instanceId: string;
    categories: BatchCreateCategoryInputCategory[];
}
export declare const BatchCreateCategoryInput: S.Schema<BatchCreateCategoryInput>;
export interface BatchCreateCategoryResponse {
}
export declare const BatchCreateCategoryResponse: S.Schema<BatchCreateCategoryResponse>;
export type DeleteCategoryInputList = string[];
export declare const DeleteCategoryInputList: S.$Array<S.String>;
export interface BatchDeleteCategoryInput {
    instanceId: string;
    categories: string[];
}
export declare const BatchDeleteCategoryInput: S.Schema<BatchDeleteCategoryInput>;
export interface BatchDeleteCategoryResponse {
}
export declare const BatchDeleteCategoryResponse: S.Schema<BatchDeleteCategoryResponse>;
export interface CategoryInput {
    id: string;
    title: string;
    color?: string;
}
export declare const CategoryInput: S.Schema<CategoryInput>;
export type CategoryListInput = CategoryInput[];
export declare const CategoryListInput: S.$Array<S.Schema<CategoryInput>>;
export interface BatchUpdateCategoryInput {
    instanceId: string;
    categories: CategoryInput[];
}
export declare const BatchUpdateCategoryInput: S.Schema<BatchUpdateCategoryInput>;
export interface BatchUpdateCategoryResponse {
}
export declare const BatchUpdateCategoryResponse: S.Schema<BatchUpdateCategoryResponse>;
export type CategoryIdList = string[];
export declare const CategoryIdList: S.$Array<S.String>;
export interface CreateLibraryItemInput {
    instanceId: string;
    appId: string;
    appVersion: number;
    categories: string[];
}
export declare const CreateLibraryItemInput: S.Schema<CreateLibraryItemInput>;
export interface CreateLibraryItemOutput {
    libraryItemId: string;
    status: string;
    createdAt: Date;
    createdBy: string;
    updatedAt?: Date;
    updatedBy?: string;
    ratingCount: number;
    isVerified?: boolean;
}
export declare const CreateLibraryItemOutput: S.Schema<CreateLibraryItemOutput>;
export type DocumentScope = "APPLICATION" | "SESSION" | (string & {});
export declare const DocumentScope: S.String;
export interface CreatePresignedUrlInput {
    instanceId: string;
    cardId: string;
    appId: string;
    fileContentsSha256: string;
    fileName: string;
    scope: DocumentScope;
    sessionId?: string;
}
export declare const CreatePresignedUrlInput: S.Schema<CreatePresignedUrlInput>;
export type PresignedUrlFields = {
    [key: string]: string | undefined;
};
export declare const PresignedUrlFields: S.$Record<S.String, S.optional<S.String>>;
export interface CreatePresignedUrlOutput {
    fileId: string;
    presignedUrl: string;
    presignedUrlFields: {
        [key: string]: string | undefined;
    };
    presignedUrlExpiration: Date;
}
export declare const CreatePresignedUrlOutput: S.Schema<CreatePresignedUrlOutput>;
export type CardType = "text-input" | "q-query" | "file-upload" | "q-plugin" | "form-input" | (string & {});
export declare const CardType: S.String;
export interface TextInputCardInput {
    title: string;
    id: string;
    type: CardType;
    placeholder?: string;
    defaultValue?: string;
}
export declare const TextInputCardInput: S.Schema<TextInputCardInput>;
export type CardOutputSource = "approved-sources" | "llm" | (string & {});
export declare const CardOutputSource: S.String;
export type AttributeFilters = AttributeFilter[];
export declare const AttributeFilters: S.Schema<AttributeFilters>;
export type DocumentAttributeStringListValue = string[];
export declare const DocumentAttributeStringListValue: S.$Array<S.String>;
export type DocumentAttributeValue = {
    stringValue: string;
    stringListValue?: never;
    longValue?: never;
    dateValue?: never;
} | {
    stringValue?: never;
    stringListValue: string[];
    longValue?: never;
    dateValue?: never;
} | {
    stringValue?: never;
    stringListValue?: never;
    longValue: number;
    dateValue?: never;
} | {
    stringValue?: never;
    stringListValue?: never;
    longValue?: never;
    dateValue: Date;
};
export declare const DocumentAttributeValue: S.Union<readonly [S.Struct<{
    readonly stringValue: S.String;
}>, S.Struct<{
    readonly stringListValue: S.$Array<S.String>;
}>, S.Struct<{
    readonly longValue: S.Number;
}>, S.Struct<{
    readonly dateValue: S.Date;
}>]>;
export interface DocumentAttribute {
    name: string;
    value: DocumentAttributeValue;
}
export declare const DocumentAttribute: S.Schema<DocumentAttribute>;
export interface AttributeFilter {
    andAllFilters?: AttributeFilter[];
    orAllFilters?: AttributeFilter[];
    notFilter?: AttributeFilter;
    equalsTo?: DocumentAttribute;
    containsAll?: DocumentAttribute;
    containsAny?: DocumentAttribute;
    greaterThan?: DocumentAttribute;
    greaterThanOrEquals?: DocumentAttribute;
    lessThan?: DocumentAttribute;
    lessThanOrEquals?: DocumentAttribute;
}
export declare const AttributeFilter: S.Schema<AttributeFilter>;
export interface QQueryCardInput {
    title: string;
    id: string;
    type: CardType;
    prompt: string;
    outputSource?: CardOutputSource;
    attributeFilter?: AttributeFilter;
}
export declare const QQueryCardInput: S.Schema<QQueryCardInput>;
export interface QPluginCardInput {
    title: string;
    id: string;
    type: CardType;
    prompt: string;
    pluginId: string;
    actionIdentifier?: string;
}
export declare const QPluginCardInput: S.Schema<QPluginCardInput>;
export interface FileUploadCardInput {
    title: string;
    id: string;
    type: CardType;
    filename?: string;
    fileId?: string;
    allowOverride?: boolean;
}
export declare const FileUploadCardInput: S.Schema<FileUploadCardInput>;
export interface FormInputCardMetadata {
    schema: any;
}
export declare const FormInputCardMetadata: S.Schema<FormInputCardMetadata>;
export type InputCardComputeMode = "append" | "replace" | (string & {});
export declare const InputCardComputeMode: S.String;
export interface FormInputCardInput {
    title: string;
    id: string;
    type: CardType;
    metadata: FormInputCardMetadata;
    computeMode?: InputCardComputeMode;
}
export declare const FormInputCardInput: S.Schema<FormInputCardInput>;
export type CardInput = {
    textInput: TextInputCardInput;
    qQuery?: never;
    qPlugin?: never;
    fileUpload?: never;
    formInput?: never;
} | {
    textInput?: never;
    qQuery: QQueryCardInput;
    qPlugin?: never;
    fileUpload?: never;
    formInput?: never;
} | {
    textInput?: never;
    qQuery?: never;
    qPlugin: QPluginCardInput;
    fileUpload?: never;
    formInput?: never;
} | {
    textInput?: never;
    qQuery?: never;
    qPlugin?: never;
    fileUpload: FileUploadCardInput;
    formInput?: never;
} | {
    textInput?: never;
    qQuery?: never;
    qPlugin?: never;
    fileUpload?: never;
    formInput: FormInputCardInput;
};
export declare const CardInput: S.Union<readonly [S.Struct<{
    readonly textInput: S.Schema<TextInputCardInput>;
}>, S.Struct<{
    readonly qQuery: S.Schema<QQueryCardInput>;
}>, S.Struct<{
    readonly qPlugin: S.Schema<QPluginCardInput>;
}>, S.Struct<{
    readonly fileUpload: S.Schema<FileUploadCardInput>;
}>, S.Struct<{
    readonly formInput: S.Schema<FormInputCardInput>;
}>]>;
export type CardList = CardInput[];
export declare const CardList: S.$Array<S.Union<readonly [S.Struct<{
    readonly textInput: S.Schema<TextInputCardInput>;
}>, S.Struct<{
    readonly qQuery: S.Schema<QQueryCardInput>;
}>, S.Struct<{
    readonly qPlugin: S.Schema<QPluginCardInput>;
}>, S.Struct<{
    readonly fileUpload: S.Schema<FileUploadCardInput>;
}>, S.Struct<{
    readonly formInput: S.Schema<FormInputCardInput>;
}>]>>;
export interface AppDefinitionInput {
    cards: CardInput[];
    initialPrompt?: string;
}
export declare const AppDefinitionInput: S.Schema<AppDefinitionInput>;
export type TagMap = {
    [key: string]: string | undefined;
};
export declare const TagMap: S.$Record<S.String, S.optional<S.String>>;
export interface CreateQAppInput {
    instanceId: string;
    title: string;
    description?: string;
    appDefinition: AppDefinitionInput;
    tags?: {
        [key: string]: string | undefined;
    };
}
export declare const CreateQAppInput: S.Schema<CreateQAppInput>;
export type AppStatus = "PUBLISHED" | "DRAFT" | "DELETED" | (string & {});
export declare const AppStatus: S.String;
export type AppRequiredCapability = "FileUpload" | "CreatorMode" | "RetrievalMode" | "PluginMode" | (string & {});
export declare const AppRequiredCapability: S.String;
export type AppRequiredCapabilities = AppRequiredCapability[];
export declare const AppRequiredCapabilities: S.$Array<S.String>;
export interface CreateQAppOutput {
    appId: string;
    appArn: string;
    title: string;
    description?: string;
    initialPrompt?: string;
    appVersion: number;
    status: AppStatus;
    createdAt: Date;
    createdBy: string;
    updatedAt: Date;
    updatedBy: string;
    requiredCapabilities?: AppRequiredCapability[];
}
export declare const CreateQAppOutput: S.Schema<CreateQAppOutput>;
export interface DeleteLibraryItemInput {
    instanceId: string;
    libraryItemId: string;
}
export declare const DeleteLibraryItemInput: S.Schema<DeleteLibraryItemInput>;
export interface DeleteLibraryItemResponse {
}
export declare const DeleteLibraryItemResponse: S.Schema<DeleteLibraryItemResponse>;
export interface DeleteQAppInput {
    instanceId: string;
    appId: string;
}
export declare const DeleteQAppInput: S.Schema<DeleteQAppInput>;
export interface DeleteQAppResponse {
}
export declare const DeleteQAppResponse: S.Schema<DeleteQAppResponse>;
export interface DescribeQAppPermissionsInput {
    instanceId: string;
    appId: string;
}
export declare const DescribeQAppPermissionsInput: S.Schema<DescribeQAppPermissionsInput>;
export type Action = "read" | "write" | (string & {});
export declare const Action: S.String;
export type UserType = "owner" | "user" | (string & {});
export declare const UserType: S.String;
export interface PrincipalOutput {
    userId?: string;
    userType?: UserType;
    email?: string;
}
export declare const PrincipalOutput: S.Schema<PrincipalOutput>;
export interface PermissionOutput {
    action: Action;
    principal: PrincipalOutput;
}
export declare const PermissionOutput: S.Schema<PermissionOutput>;
export type PermissionsOutputList = PermissionOutput[];
export declare const PermissionsOutputList: S.$Array<S.Schema<PermissionOutput>>;
export interface DescribeQAppPermissionsOutput {
    resourceArn?: string;
    appId?: string;
    permissions?: PermissionOutput[];
}
export declare const DescribeQAppPermissionsOutput: S.Schema<DescribeQAppPermissionsOutput>;
export interface DisassociateLibraryItemReviewInput {
    instanceId: string;
    libraryItemId: string;
}
export declare const DisassociateLibraryItemReviewInput: S.Schema<DisassociateLibraryItemReviewInput>;
export interface DisassociateLibraryItemReviewResponse {
}
export declare const DisassociateLibraryItemReviewResponse: S.Schema<DisassociateLibraryItemReviewResponse>;
export interface DisassociateQAppFromUserInput {
    instanceId: string;
    appId: string;
}
export declare const DisassociateQAppFromUserInput: S.Schema<DisassociateQAppFromUserInput>;
export interface DisassociateQAppFromUserResponse {
}
export declare const DisassociateQAppFromUserResponse: S.Schema<DisassociateQAppFromUserResponse>;
export interface ExportQAppSessionDataInput {
    instanceId: string;
    sessionId: string;
}
export declare const ExportQAppSessionDataInput: S.Schema<ExportQAppSessionDataInput>;
export interface ExportQAppSessionDataOutput {
    csvFileLink: string;
    expiresAt: Date;
    sessionArn: string;
}
export declare const ExportQAppSessionDataOutput: S.Schema<ExportQAppSessionDataOutput>;
export interface GetLibraryItemInput {
    instanceId: string;
    libraryItemId: string;
    appId?: string;
}
export declare const GetLibraryItemInput: S.Schema<GetLibraryItemInput>;
export interface Category {
    id: string;
    title: string;
    color?: string;
    appCount?: number;
}
export declare const Category: S.Schema<Category>;
export type CategoryList = Category[];
export declare const CategoryList: S.$Array<S.Schema<Category>>;
export interface GetLibraryItemOutput {
    libraryItemId: string;
    appId: string;
    appVersion: number;
    categories: Category[];
    status: string;
    createdAt: Date;
    createdBy: string;
    updatedAt?: Date;
    updatedBy?: string;
    ratingCount: number;
    isRatedByUser?: boolean;
    userCount?: number;
    isVerified?: boolean;
}
export declare const GetLibraryItemOutput: S.Schema<GetLibraryItemOutput>;
export interface GetQAppInput {
    instanceId: string;
    appId: string;
    appVersion?: number;
}
export declare const GetQAppInput: S.Schema<GetQAppInput>;
export type DependencyList = string[];
export declare const DependencyList: S.$Array<S.String>;
export interface TextInputCard {
    id: string;
    title: string;
    dependencies: string[];
    type: CardType;
    placeholder?: string;
    defaultValue?: string;
}
export declare const TextInputCard: S.Schema<TextInputCard>;
export type MemoryReferenceList = string[];
export declare const MemoryReferenceList: S.$Array<S.String>;
export interface QQueryCard {
    id: string;
    title: string;
    dependencies: string[];
    type: CardType;
    prompt: string;
    outputSource: CardOutputSource;
    attributeFilter?: AttributeFilter;
    memoryReferences?: string[];
}
export declare const QQueryCard: S.Schema<QQueryCard>;
export type PluginType = "SERVICE_NOW" | "SALESFORCE" | "JIRA" | "ZENDESK" | "CUSTOM" | "ASANA" | "ATLASSIAN_CONFLUENCE" | "GOOGLE_CALENDAR" | "JIRA_CLOUD" | "MICROSOFT_EXCHANGE" | "MICROSOFT_TEAMS" | "PAGERDUTY_ADVANCE" | "SALESFORCE_CRM" | "SERVICENOW_NOW_PLATFORM" | "SMARTSHEET" | "ZENDESK_SUITE" | (string & {});
export declare const PluginType: S.String;
export interface QPluginCard {
    id: string;
    title: string;
    dependencies: string[];
    type: CardType;
    prompt: string;
    pluginType: PluginType;
    pluginId: string;
    actionIdentifier?: string;
}
export declare const QPluginCard: S.Schema<QPluginCard>;
export interface FileUploadCard {
    id: string;
    title: string;
    dependencies: string[];
    type: CardType;
    filename?: string;
    fileId?: string;
    allowOverride?: boolean;
}
export declare const FileUploadCard: S.Schema<FileUploadCard>;
export interface FormInputCard {
    id: string;
    title: string;
    dependencies: string[];
    type: CardType;
    metadata: FormInputCardMetadata;
    computeMode?: InputCardComputeMode;
}
export declare const FormInputCard: S.Schema<FormInputCard>;
export type Card = {
    textInput: TextInputCard;
    qQuery?: never;
    qPlugin?: never;
    fileUpload?: never;
    formInput?: never;
} | {
    textInput?: never;
    qQuery: QQueryCard;
    qPlugin?: never;
    fileUpload?: never;
    formInput?: never;
} | {
    textInput?: never;
    qQuery?: never;
    qPlugin: QPluginCard;
    fileUpload?: never;
    formInput?: never;
} | {
    textInput?: never;
    qQuery?: never;
    qPlugin?: never;
    fileUpload: FileUploadCard;
    formInput?: never;
} | {
    textInput?: never;
    qQuery?: never;
    qPlugin?: never;
    fileUpload?: never;
    formInput: FormInputCard;
};
export declare const Card: S.Union<readonly [S.Struct<{
    readonly textInput: S.Schema<TextInputCard>;
}>, S.Struct<{
    readonly qQuery: S.Schema<QQueryCard>;
}>, S.Struct<{
    readonly qPlugin: S.Schema<QPluginCard>;
}>, S.Struct<{
    readonly fileUpload: S.Schema<FileUploadCard>;
}>, S.Struct<{
    readonly formInput: S.Schema<FormInputCard>;
}>]>;
export type CardModelList = Card[];
export declare const CardModelList: S.$Array<S.Union<readonly [S.Struct<{
    readonly textInput: S.Schema<TextInputCard>;
}>, S.Struct<{
    readonly qQuery: S.Schema<QQueryCard>;
}>, S.Struct<{
    readonly qPlugin: S.Schema<QPluginCard>;
}>, S.Struct<{
    readonly fileUpload: S.Schema<FileUploadCard>;
}>, S.Struct<{
    readonly formInput: S.Schema<FormInputCard>;
}>]>>;
export interface AppDefinition {
    appDefinitionVersion: string;
    cards: Card[];
    canEdit?: boolean;
}
export declare const AppDefinition: S.Schema<AppDefinition>;
export interface GetQAppOutput {
    appId: string;
    appArn: string;
    title: string;
    description?: string;
    initialPrompt?: string;
    appVersion: number;
    status: AppStatus;
    createdAt: Date;
    createdBy: string;
    updatedAt: Date;
    updatedBy: string;
    requiredCapabilities?: AppRequiredCapability[];
    appDefinition: AppDefinition;
}
export declare const GetQAppOutput: S.Schema<GetQAppOutput>;
export interface GetQAppSessionInput {
    instanceId: string;
    sessionId: string;
}
export declare const GetQAppSessionInput: S.Schema<GetQAppSessionInput>;
export type ExecutionStatus = "IN_PROGRESS" | "WAITING" | "COMPLETED" | "ERROR" | (string & {});
export declare const ExecutionStatus: S.String;
export interface Submission {
    value?: any;
    submissionId?: string;
    timestamp?: Date;
}
export declare const Submission: S.Schema<Submission>;
export type SubmissionList = Submission[];
export declare const SubmissionList: S.$Array<S.Schema<Submission>>;
export interface CardStatus {
    currentState: ExecutionStatus;
    currentValue: string;
    submissions?: Submission[];
}
export declare const CardStatus: S.Schema<CardStatus>;
export type CardStatusMap = {
    [key: string]: CardStatus | undefined;
};
export declare const CardStatusMap: S.$Record<S.String, S.optional<S.Schema<CardStatus>>>;
export interface GetQAppSessionOutput {
    sessionId: string;
    sessionArn: string;
    sessionName?: string;
    appVersion?: number;
    latestPublishedAppVersion?: number;
    status: ExecutionStatus;
    cardStatus: {
        [key: string]: CardStatus | undefined;
    };
    userIsHost?: boolean;
}
export declare const GetQAppSessionOutput: S.Schema<GetQAppSessionOutput>;
export interface GetQAppSessionMetadataInput {
    instanceId: string;
    sessionId: string;
}
export declare const GetQAppSessionMetadataInput: S.Schema<GetQAppSessionMetadataInput>;
export interface SessionSharingConfiguration {
    enabled: boolean;
    acceptResponses?: boolean;
    revealCards?: boolean;
}
export declare const SessionSharingConfiguration: S.Schema<SessionSharingConfiguration>;
export interface GetQAppSessionMetadataOutput {
    sessionId: string;
    sessionArn: string;
    sessionName?: string;
    sharingConfiguration: SessionSharingConfiguration;
    sessionOwner?: boolean;
}
export declare const GetQAppSessionMetadataOutput: S.Schema<GetQAppSessionMetadataOutput>;
export interface ImportDocumentInput {
    instanceId: string;
    cardId: string;
    appId: string;
    fileContentsBase64: string;
    fileName: string;
    scope: DocumentScope;
    sessionId?: string;
}
export declare const ImportDocumentInput: S.Schema<ImportDocumentInput>;
export interface ImportDocumentOutput {
    fileId?: string;
}
export declare const ImportDocumentOutput: S.Schema<ImportDocumentOutput>;
export interface ListCategoriesInput {
    instanceId: string;
}
export declare const ListCategoriesInput: S.Schema<ListCategoriesInput>;
export type CategoriesList = Category[];
export declare const CategoriesList: S.$Array<S.Schema<Category>>;
export interface ListCategoriesOutput {
    categories?: Category[];
}
export declare const ListCategoriesOutput: S.Schema<ListCategoriesOutput>;
export interface ListLibraryItemsInput {
    instanceId: string;
    limit?: number;
    nextToken?: string;
    categoryId?: string;
}
export declare const ListLibraryItemsInput: S.Schema<ListLibraryItemsInput>;
export interface LibraryItemMember {
    libraryItemId: string;
    appId: string;
    appVersion: number;
    categories: Category[];
    status: string;
    createdAt: Date;
    createdBy: string;
    updatedAt?: Date;
    updatedBy?: string;
    ratingCount: number;
    isRatedByUser?: boolean;
    userCount?: number;
    isVerified?: boolean;
}
export declare const LibraryItemMember: S.Schema<LibraryItemMember>;
export type LibraryItemList = LibraryItemMember[];
export declare const LibraryItemList: S.$Array<S.Schema<LibraryItemMember>>;
export interface ListLibraryItemsOutput {
    libraryItems?: LibraryItemMember[];
    nextToken?: string;
}
export declare const ListLibraryItemsOutput: S.Schema<ListLibraryItemsOutput>;
export interface ListQAppsInput {
    instanceId: string;
    limit?: number;
    nextToken?: string;
}
export declare const ListQAppsInput: S.Schema<ListQAppsInput>;
export interface UserAppItem {
    appId: string;
    appArn: string;
    title: string;
    description?: string;
    createdAt: Date;
    canEdit?: boolean;
    status?: string;
    isVerified?: boolean;
}
export declare const UserAppItem: S.Schema<UserAppItem>;
export type UserAppsList = UserAppItem[];
export declare const UserAppsList: S.$Array<S.Schema<UserAppItem>>;
export interface ListQAppsOutput {
    apps: UserAppItem[];
    nextToken?: string;
}
export declare const ListQAppsOutput: S.Schema<ListQAppsOutput>;
export interface ListQAppSessionDataInput {
    instanceId: string;
    sessionId: string;
}
export declare const ListQAppSessionDataInput: S.Schema<ListQAppSessionDataInput>;
export interface User {
    userId?: string;
}
export declare const User: S.Schema<User>;
export interface QAppSessionData {
    cardId: string;
    value?: any;
    user: User;
    submissionId?: string;
    timestamp?: Date;
}
export declare const QAppSessionData: S.Schema<QAppSessionData>;
export type QAppSessionDataList = QAppSessionData[];
export declare const QAppSessionDataList: S.$Array<S.Schema<QAppSessionData>>;
export interface ListQAppSessionDataOutput {
    sessionId: string;
    sessionArn: string;
    sessionData?: QAppSessionData[];
    nextToken?: string;
}
export declare const ListQAppSessionDataOutput: S.Schema<ListQAppSessionDataOutput>;
export interface ListTagsForResourceRequest {
    resourceARN: string;
}
export declare const ListTagsForResourceRequest: S.Schema<ListTagsForResourceRequest>;
export type Tags = {
    [key: string]: string | undefined;
};
export declare const Tags: S.$Record<S.String, S.optional<S.String>>;
export interface ListTagsForResourceResponse {
    tags?: {
        [key: string]: string | undefined;
    };
}
export declare const ListTagsForResourceResponse: S.Schema<ListTagsForResourceResponse>;
export type Sender = "USER" | "SYSTEM" | (string & {});
export declare const Sender: S.String;
export interface ConversationMessage {
    body: string;
    type: Sender;
}
export declare const ConversationMessage: S.Schema<ConversationMessage>;
export type MessageList = ConversationMessage[];
export declare const MessageList: S.$Array<S.Schema<ConversationMessage>>;
export type PredictQAppInputOptions = {
    conversation: ConversationMessage[];
    problemStatement?: never;
} | {
    conversation?: never;
    problemStatement: string;
};
export declare const PredictQAppInputOptions: S.Union<readonly [S.Struct<{
    readonly conversation: S.$Array<S.Schema<ConversationMessage>>;
}>, S.Struct<{
    readonly problemStatement: S.String;
}>]>;
export interface PredictQAppInput {
    instanceId: string;
    options?: PredictQAppInputOptions;
}
export declare const PredictQAppInput: S.Schema<PredictQAppInput>;
export interface PredictAppDefinition {
    title: string;
    description?: string;
    appDefinition: AppDefinitionInput;
}
export declare const PredictAppDefinition: S.Schema<PredictAppDefinition>;
export interface PredictQAppOutput {
    app: PredictAppDefinition;
    problemStatement: string;
}
export declare const PredictQAppOutput: S.Schema<PredictQAppOutput>;
export type SubmissionMutationKind = "edit" | "delete" | "add" | (string & {});
export declare const SubmissionMutationKind: S.String;
export interface SubmissionMutation {
    submissionId: string;
    mutationType: SubmissionMutationKind;
}
export declare const SubmissionMutation: S.Schema<SubmissionMutation>;
export interface CardValue {
    cardId: string;
    value: string;
    submissionMutation?: SubmissionMutation;
}
export declare const CardValue: S.Schema<CardValue>;
export type CardValueList = CardValue[];
export declare const CardValueList: S.$Array<S.Schema<CardValue>>;
export interface StartQAppSessionInput {
    instanceId: string;
    appId: string;
    appVersion: number;
    initialValues?: CardValue[];
    sessionId?: string;
    tags?: {
        [key: string]: string | undefined;
    };
}
export declare const StartQAppSessionInput: S.Schema<StartQAppSessionInput>;
export interface StartQAppSessionOutput {
    sessionId: string;
    sessionArn: string;
}
export declare const StartQAppSessionOutput: S.Schema<StartQAppSessionOutput>;
export interface StopQAppSessionInput {
    instanceId: string;
    sessionId: string;
}
export declare const StopQAppSessionInput: S.Schema<StopQAppSessionInput>;
export interface StopQAppSessionResponse {
}
export declare const StopQAppSessionResponse: S.Schema<StopQAppSessionResponse>;
export interface TagResourceRequest {
    resourceARN: string;
    tags: {
        [key: string]: string | undefined;
    };
}
export declare const TagResourceRequest: S.Schema<TagResourceRequest>;
export interface TagResourceResponse {
}
export declare const TagResourceResponse: S.Schema<TagResourceResponse>;
export type TagKeys = string[];
export declare const TagKeys: S.$Array<S.String>;
export interface UntagResourceRequest {
    resourceARN: string;
    tagKeys: string[];
}
export declare const UntagResourceRequest: S.Schema<UntagResourceRequest>;
export interface UntagResourceResponse {
}
export declare const UntagResourceResponse: S.Schema<UntagResourceResponse>;
export type LibraryItemStatus = "PUBLISHED" | "DISABLED" | (string & {});
export declare const LibraryItemStatus: S.String;
export interface UpdateLibraryItemInput {
    instanceId: string;
    libraryItemId: string;
    status?: LibraryItemStatus;
    categories?: string[];
}
export declare const UpdateLibraryItemInput: S.Schema<UpdateLibraryItemInput>;
export interface UpdateLibraryItemOutput {
    libraryItemId: string;
    appId: string;
    appVersion: number;
    categories: Category[];
    status: string;
    createdAt: Date;
    createdBy: string;
    updatedAt?: Date;
    updatedBy?: string;
    ratingCount: number;
    isRatedByUser?: boolean;
    userCount?: number;
    isVerified?: boolean;
}
export declare const UpdateLibraryItemOutput: S.Schema<UpdateLibraryItemOutput>;
export interface UpdateLibraryItemMetadataInput {
    instanceId: string;
    libraryItemId: string;
    isVerified?: boolean;
}
export declare const UpdateLibraryItemMetadataInput: S.Schema<UpdateLibraryItemMetadataInput>;
export interface UpdateLibraryItemMetadataResponse {
}
export declare const UpdateLibraryItemMetadataResponse: S.Schema<UpdateLibraryItemMetadataResponse>;
export interface UpdateQAppInput {
    instanceId: string;
    appId: string;
    title?: string;
    description?: string;
    appDefinition?: AppDefinitionInput;
}
export declare const UpdateQAppInput: S.Schema<UpdateQAppInput>;
export interface UpdateQAppOutput {
    appId: string;
    appArn: string;
    title: string;
    description?: string;
    initialPrompt?: string;
    appVersion: number;
    status: AppStatus;
    createdAt: Date;
    createdBy: string;
    updatedAt: Date;
    updatedBy: string;
    requiredCapabilities?: AppRequiredCapability[];
}
export declare const UpdateQAppOutput: S.Schema<UpdateQAppOutput>;
export interface PermissionInput {
    action: Action;
    principal: string;
}
export declare const PermissionInput: S.Schema<PermissionInput>;
export type PermissionsInputList = PermissionInput[];
export declare const PermissionsInputList: S.$Array<S.Schema<PermissionInput>>;
export interface UpdateQAppPermissionsInput {
    instanceId: string;
    appId: string;
    grantPermissions?: PermissionInput[];
    revokePermissions?: PermissionInput[];
}
export declare const UpdateQAppPermissionsInput: S.Schema<UpdateQAppPermissionsInput>;
export interface UpdateQAppPermissionsOutput {
    resourceArn?: string;
    appId?: string;
    permissions?: PermissionOutput[];
}
export declare const UpdateQAppPermissionsOutput: S.Schema<UpdateQAppPermissionsOutput>;
export interface UpdateQAppSessionInput {
    instanceId: string;
    sessionId: string;
    values?: CardValue[];
}
export declare const UpdateQAppSessionInput: S.Schema<UpdateQAppSessionInput>;
export interface UpdateQAppSessionOutput {
    sessionId: string;
    sessionArn: string;
}
export declare const UpdateQAppSessionOutput: S.Schema<UpdateQAppSessionOutput>;
export interface UpdateQAppSessionMetadataInput {
    instanceId: string;
    sessionId: string;
    sessionName?: string;
    sharingConfiguration: SessionSharingConfiguration;
}
export declare const UpdateQAppSessionMetadataInput: S.Schema<UpdateQAppSessionMetadataInput>;
export interface UpdateQAppSessionMetadataOutput {
    sessionId: string;
    sessionArn: string;
    sessionName?: string;
    sharingConfiguration: SessionSharingConfiguration;
}
export declare const UpdateQAppSessionMetadataOutput: S.Schema<UpdateQAppSessionMetadataOutput>;
declare const AccessDeniedException_base: S.Class<AccessDeniedException, S.TaggedStruct<"AccessDeniedException", {
    readonly message: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        AuthError: true;
    };
});
export declare class AccessDeniedException extends AccessDeniedException_base {
}
declare const ConflictException_base: S.Class<ConflictException, S.TaggedStruct<"ConflictException", {
    readonly message: S.String;
    readonly resourceId: S.String;
    readonly resourceType: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ConflictError: true;
    };
});
export declare class ConflictException extends ConflictException_base {
}
declare const InternalServerException_base: S.Class<InternalServerException, S.TaggedStruct<"InternalServerException", {
    readonly message: S.String;
    readonly retryAfterSeconds: S.optional<S.Number>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ServerError: true;
    };
}) & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        RetryableError: true;
    };
});
export declare class InternalServerException extends InternalServerException_base {
}
declare const ResourceNotFoundException_base: S.Class<ResourceNotFoundException, S.TaggedStruct<"ResourceNotFoundException", {
    readonly message: S.String;
    readonly resourceId: S.String;
    readonly resourceType: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class ResourceNotFoundException extends ResourceNotFoundException_base {
}
declare const ServiceQuotaExceededException_base: S.Class<ServiceQuotaExceededException, S.TaggedStruct<"ServiceQuotaExceededException", {
    readonly message: S.String;
    readonly resourceId: S.String;
    readonly resourceType: S.String;
    readonly serviceCode: S.String;
    readonly quotaCode: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        QuotaError: true;
    };
});
export declare class ServiceQuotaExceededException extends ServiceQuotaExceededException_base {
}
declare const ThrottlingException_base: S.Class<ThrottlingException, S.TaggedStruct<"ThrottlingException", {
    readonly message: S.String;
    readonly serviceCode: S.String;
    readonly quotaCode: S.String;
    readonly retryAfterSeconds: S.optional<S.Number>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ThrottlingError: true;
    };
}) & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        RetryableError: true;
    };
});
export declare class ThrottlingException extends ThrottlingException_base {
}
declare const UnauthorizedException_base: S.Class<UnauthorizedException, S.TaggedStruct<"UnauthorizedException", {
    readonly message: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        AuthError: true;
    };
});
export declare class UnauthorizedException extends UnauthorizedException_base {
}
declare const ValidationException_base: S.Class<ValidationException, S.TaggedStruct<"ValidationException", {
    readonly message: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class ValidationException extends ValidationException_base {
}
declare const ContentTooLargeException_base: S.Class<ContentTooLargeException, S.TaggedStruct<"ContentTooLargeException", {
    readonly message: S.String;
    readonly resourceId: S.String;
    readonly resourceType: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class ContentTooLargeException extends ContentTooLargeException_base {
}
export type AssociateLibraryItemReviewError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ServiceQuotaExceededException | ThrottlingException | UnauthorizedException | ValidationException | CommonErrors;
/**
 * Associates a rating or review for a library item with the user submitting the request. This increments the rating count for the specified library item.
 */
export declare const associateLibraryItemReview: API.OperationMethod<AssociateLibraryItemReviewInput, AssociateLibraryItemReviewResponse, AssociateLibraryItemReviewError, Credentials | Region | HttpClient.HttpClient>;
export type AssociateQAppWithUserError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ServiceQuotaExceededException | ThrottlingException | UnauthorizedException | ValidationException | CommonErrors;
/**
 * This operation creates a link between the user's identity calling the operation and a specific Q App. This is useful to mark the Q App as a *favorite* for the user if the user doesn't own the Amazon Q App so they can still run it and see it in their inventory of Q Apps.
 */
export declare const associateQAppWithUser: API.OperationMethod<AssociateQAppWithUserInput, AssociateQAppWithUserResponse, AssociateQAppWithUserError, Credentials | Region | HttpClient.HttpClient>;
export type BatchCreateCategoryError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ThrottlingException | UnauthorizedException | ValidationException | CommonErrors;
/**
 * Creates Categories for the Amazon Q Business application environment instance. Web experience users use Categories to tag and filter library items. For more information, see Custom labels for Amazon Q Apps.
 */
export declare const batchCreateCategory: API.OperationMethod<BatchCreateCategoryInput, BatchCreateCategoryResponse, BatchCreateCategoryError, Credentials | Region | HttpClient.HttpClient>;
export type BatchDeleteCategoryError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ThrottlingException | UnauthorizedException | ValidationException | CommonErrors;
/**
 * Deletes Categories for the Amazon Q Business application environment instance. Web experience users use Categories to tag and filter library items. For more information, see Custom labels for Amazon Q Apps.
 */
export declare const batchDeleteCategory: API.OperationMethod<BatchDeleteCategoryInput, BatchDeleteCategoryResponse, BatchDeleteCategoryError, Credentials | Region | HttpClient.HttpClient>;
export type BatchUpdateCategoryError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ThrottlingException | UnauthorizedException | ValidationException | CommonErrors;
/**
 * Updates Categories for the Amazon Q Business application environment instance. Web experience users use Categories to tag and filter library items. For more information, see Custom labels for Amazon Q Apps.
 */
export declare const batchUpdateCategory: API.OperationMethod<BatchUpdateCategoryInput, BatchUpdateCategoryResponse, BatchUpdateCategoryError, Credentials | Region | HttpClient.HttpClient>;
export type CreateLibraryItemError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ServiceQuotaExceededException | ThrottlingException | UnauthorizedException | ValidationException | CommonErrors;
/**
 * Creates a new library item for an Amazon Q App, allowing it to be discovered and used by other allowed users.
 */
export declare const createLibraryItem: API.OperationMethod<CreateLibraryItemInput, CreateLibraryItemOutput, CreateLibraryItemError, Credentials | Region | HttpClient.HttpClient>;
export type CreatePresignedUrlError = AccessDeniedException | InternalServerException | ThrottlingException | UnauthorizedException | ValidationException | CommonErrors;
/**
 * Creates a presigned URL for an S3 POST operation to upload a file. You can use this URL to set a default file for a `FileUploadCard` in a Q App definition or to provide a file for a single Q App run. The `scope` parameter determines how the file will be used, either at the app definition level or the app session level.
 *
 * The IAM permissions are derived from the `qapps:ImportDocument` action. For more information on the IAM policy for Amazon Q Apps, see IAM permissions for using Amazon Q Apps.
 */
export declare const createPresignedUrl: API.OperationMethod<CreatePresignedUrlInput, CreatePresignedUrlOutput, CreatePresignedUrlError, Credentials | Region | HttpClient.HttpClient>;
export type CreateQAppError = AccessDeniedException | ConflictException | ContentTooLargeException | InternalServerException | ServiceQuotaExceededException | ThrottlingException | UnauthorizedException | ValidationException | CommonErrors;
/**
 * Creates a new Amazon Q App based on the provided definition. The Q App definition specifies the cards and flow of the Q App. This operation also calculates the dependencies between the cards by inspecting the references in the prompts.
 */
export declare const createQApp: API.OperationMethod<CreateQAppInput, CreateQAppOutput, CreateQAppError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteLibraryItemError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ServiceQuotaExceededException | ThrottlingException | UnauthorizedException | ValidationException | CommonErrors;
/**
 * Deletes a library item for an Amazon Q App, removing it from the library so it can no longer be discovered or used by other users.
 */
export declare const deleteLibraryItem: API.OperationMethod<DeleteLibraryItemInput, DeleteLibraryItemResponse, DeleteLibraryItemError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteQAppError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | UnauthorizedException | ValidationException | CommonErrors;
/**
 * Deletes an Amazon Q App owned by the user. If the Q App was previously published to the library, it is also removed from the library.
 */
export declare const deleteQApp: API.OperationMethod<DeleteQAppInput, DeleteQAppResponse, DeleteQAppError, Credentials | Region | HttpClient.HttpClient>;
export type DescribeQAppPermissionsError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | UnauthorizedException | ValidationException | CommonErrors;
/**
 * Describes read permissions for a Amazon Q App in Amazon Q Business application environment instance.
 */
export declare const describeQAppPermissions: API.OperationMethod<DescribeQAppPermissionsInput, DescribeQAppPermissionsOutput, DescribeQAppPermissionsError, Credentials | Region | HttpClient.HttpClient>;
export type DisassociateLibraryItemReviewError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ServiceQuotaExceededException | ThrottlingException | UnauthorizedException | ValidationException | CommonErrors;
/**
 * Removes a rating or review previously submitted by the user for a library item.
 */
export declare const disassociateLibraryItemReview: API.OperationMethod<DisassociateLibraryItemReviewInput, DisassociateLibraryItemReviewResponse, DisassociateLibraryItemReviewError, Credentials | Region | HttpClient.HttpClient>;
export type DisassociateQAppFromUserError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | UnauthorizedException | ValidationException | CommonErrors;
/**
 * Disassociates a Q App from a user removing the user's access to run the Q App.
 */
export declare const disassociateQAppFromUser: API.OperationMethod<DisassociateQAppFromUserInput, DisassociateQAppFromUserResponse, DisassociateQAppFromUserError, Credentials | Region | HttpClient.HttpClient>;
export type ExportQAppSessionDataError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ServiceQuotaExceededException | ThrottlingException | UnauthorizedException | ValidationException | CommonErrors;
/**
 * Exports the collected data of a Q App data collection session.
 */
export declare const exportQAppSessionData: API.OperationMethod<ExportQAppSessionDataInput, ExportQAppSessionDataOutput, ExportQAppSessionDataError, Credentials | Region | HttpClient.HttpClient>;
export type GetLibraryItemError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | UnauthorizedException | ValidationException | CommonErrors;
/**
 * Retrieves details about a library item for an Amazon Q App, including its metadata, categories, ratings, and usage statistics.
 */
export declare const getLibraryItem: API.OperationMethod<GetLibraryItemInput, GetLibraryItemOutput, GetLibraryItemError, Credentials | Region | HttpClient.HttpClient>;
export type GetQAppError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | UnauthorizedException | ValidationException | CommonErrors;
/**
 * Retrieves the full details of an Q App, including its definition specifying the cards and flow.
 */
export declare const getQApp: API.OperationMethod<GetQAppInput, GetQAppOutput, GetQAppError, Credentials | Region | HttpClient.HttpClient>;
export type GetQAppSessionError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ServiceQuotaExceededException | ThrottlingException | UnauthorizedException | ValidationException | CommonErrors;
/**
 * Retrieves the current state and results for an active session of an Amazon Q App.
 */
export declare const getQAppSession: API.OperationMethod<GetQAppSessionInput, GetQAppSessionOutput, GetQAppSessionError, Credentials | Region | HttpClient.HttpClient>;
export type GetQAppSessionMetadataError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ServiceQuotaExceededException | ThrottlingException | UnauthorizedException | ValidationException | CommonErrors;
/**
 * Retrieves the current configuration of a Q App session.
 */
export declare const getQAppSessionMetadata: API.OperationMethod<GetQAppSessionMetadataInput, GetQAppSessionMetadataOutput, GetQAppSessionMetadataError, Credentials | Region | HttpClient.HttpClient>;
export type ImportDocumentError = AccessDeniedException | ContentTooLargeException | InternalServerException | ResourceNotFoundException | ServiceQuotaExceededException | ThrottlingException | UnauthorizedException | ValidationException | CommonErrors;
/**
 * Uploads a file that can then be used either as a default in a `FileUploadCard` from Q App definition or as a file that is used inside a single Q App run. The purpose of the document is determined by a scope parameter that indicates whether it is at the app definition level or at the app session level.
 */
export declare const importDocument: API.OperationMethod<ImportDocumentInput, ImportDocumentOutput, ImportDocumentError, Credentials | Region | HttpClient.HttpClient>;
export type ListCategoriesError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | UnauthorizedException | ValidationException | CommonErrors;
/**
 * Lists the categories of a Amazon Q Business application environment instance. For more information, see Custom labels for Amazon Q Apps.
 */
export declare const listCategories: API.OperationMethod<ListCategoriesInput, ListCategoriesOutput, ListCategoriesError, Credentials | Region | HttpClient.HttpClient>;
export type ListLibraryItemsError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | UnauthorizedException | ValidationException | CommonErrors;
/**
 * Lists the library items for Amazon Q Apps that are published and available for users in your Amazon Web Services account.
 */
export declare const listLibraryItems: API.OperationMethod<ListLibraryItemsInput, ListLibraryItemsOutput, ListLibraryItemsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListLibraryItemsInput) => stream.Stream<ListLibraryItemsOutput, ListLibraryItemsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListLibraryItemsInput) => stream.Stream<LibraryItemMember, ListLibraryItemsError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListQAppsError = AccessDeniedException | InternalServerException | ThrottlingException | UnauthorizedException | ValidationException | CommonErrors;
/**
 * Lists the Amazon Q Apps owned by or associated with the user either because they created it or because they used it from the library in the past. The user identity is extracted from the credentials used to invoke this operation..
 */
export declare const listQApps: API.OperationMethod<ListQAppsInput, ListQAppsOutput, ListQAppsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListQAppsInput) => stream.Stream<ListQAppsOutput, ListQAppsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListQAppsInput) => stream.Stream<UserAppItem, ListQAppsError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListQAppSessionDataError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ServiceQuotaExceededException | ThrottlingException | UnauthorizedException | ValidationException | CommonErrors;
/**
 * Lists the collected data of a Q App data collection session.
 */
export declare const listQAppSessionData: API.OperationMethod<ListQAppSessionDataInput, ListQAppSessionDataOutput, ListQAppSessionDataError, Credentials | Region | HttpClient.HttpClient>;
export type ListTagsForResourceError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Lists the tags associated with an Amazon Q Apps resource.
 */
export declare const listTagsForResource: API.OperationMethod<ListTagsForResourceRequest, ListTagsForResourceResponse, ListTagsForResourceError, Credentials | Region | HttpClient.HttpClient>;
export type PredictQAppError = AccessDeniedException | InternalServerException | ThrottlingException | UnauthorizedException | ValidationException | CommonErrors;
/**
 * Generates an Amazon Q App definition based on either a conversation or a problem statement provided as input.The resulting app definition can be used to call `CreateQApp`. This API doesn't create Amazon Q Apps directly.
 */
export declare const predictQApp: API.OperationMethod<PredictQAppInput, PredictQAppOutput, PredictQAppError, Credentials | Region | HttpClient.HttpClient>;
export type StartQAppSessionError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ServiceQuotaExceededException | ThrottlingException | UnauthorizedException | ValidationException | CommonErrors;
/**
 * Starts a new session for an Amazon Q App, allowing inputs to be provided and the app to be run.
 *
 * Each Q App session will be condensed into a single conversation in the web experience.
 */
export declare const startQAppSession: API.OperationMethod<StartQAppSessionInput, StartQAppSessionOutput, StartQAppSessionError, Credentials | Region | HttpClient.HttpClient>;
export type StopQAppSessionError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ServiceQuotaExceededException | ThrottlingException | UnauthorizedException | ValidationException | CommonErrors;
/**
 * Stops an active session for an Amazon Q App.This deletes all data related to the session and makes it invalid for future uses. The results of the session will be persisted as part of the conversation.
 */
export declare const stopQAppSession: API.OperationMethod<StopQAppSessionInput, StopQAppSessionResponse, StopQAppSessionError, Credentials | Region | HttpClient.HttpClient>;
export type TagResourceError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Associates tags with an Amazon Q Apps resource.
 */
export declare const tagResource: API.OperationMethod<TagResourceRequest, TagResourceResponse, TagResourceError, Credentials | Region | HttpClient.HttpClient>;
export type UntagResourceError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Disassociates tags from an Amazon Q Apps resource.
 */
export declare const untagResource: API.OperationMethod<UntagResourceRequest, UntagResourceResponse, UntagResourceError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateLibraryItemError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ThrottlingException | UnauthorizedException | ValidationException | CommonErrors;
/**
 * Updates the library item for an Amazon Q App.
 */
export declare const updateLibraryItem: API.OperationMethod<UpdateLibraryItemInput, UpdateLibraryItemOutput, UpdateLibraryItemError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateLibraryItemMetadataError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ThrottlingException | UnauthorizedException | ValidationException | CommonErrors;
/**
 * Updates the verification status of a library item for an Amazon Q App.
 */
export declare const updateLibraryItemMetadata: API.OperationMethod<UpdateLibraryItemMetadataInput, UpdateLibraryItemMetadataResponse, UpdateLibraryItemMetadataError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateQAppError = AccessDeniedException | ContentTooLargeException | InternalServerException | ResourceNotFoundException | ThrottlingException | UnauthorizedException | ValidationException | CommonErrors;
/**
 * Updates an existing Amazon Q App, allowing modifications to its title, description, and definition.
 */
export declare const updateQApp: API.OperationMethod<UpdateQAppInput, UpdateQAppOutput, UpdateQAppError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateQAppPermissionsError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | UnauthorizedException | ValidationException | CommonErrors;
/**
 * Updates read permissions for a Amazon Q App in Amazon Q Business application environment instance.
 */
export declare const updateQAppPermissions: API.OperationMethod<UpdateQAppPermissionsInput, UpdateQAppPermissionsOutput, UpdateQAppPermissionsError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateQAppSessionError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ServiceQuotaExceededException | ThrottlingException | UnauthorizedException | ValidationException | CommonErrors;
/**
 * Updates the session for a given Q App `sessionId`. This is only valid when at least one card of the session is in the `WAITING` state. Data for each `WAITING` card can be provided as input. If inputs are not provided, the call will be accepted but session will not move forward. Inputs for cards that are not in the `WAITING` status will be ignored.
 */
export declare const updateQAppSession: API.OperationMethod<UpdateQAppSessionInput, UpdateQAppSessionOutput, UpdateQAppSessionError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateQAppSessionMetadataError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ServiceQuotaExceededException | ThrottlingException | UnauthorizedException | ValidationException | CommonErrors;
/**
 * Updates the configuration metadata of a session for a given Q App `sessionId`.
 */
export declare const updateQAppSessionMetadata: API.OperationMethod<UpdateQAppSessionMetadataInput, UpdateQAppSessionMetadataOutput, UpdateQAppSessionMetadataError, Credentials | Region | HttpClient.HttpClient>;
export {};
//# sourceMappingURL=qapps.d.ts.map