export declare type Maybe<T> = T | null;
export declare type InputMaybe<T> = Maybe<T>;
export declare type Exact<T extends {
    [key: string]: unknown;
}> = {
    [K in keyof T]: T[K];
};
export declare type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
    [SubKey in K]?: Maybe<T[SubKey]>;
};
export declare type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
    [SubKey in K]: Maybe<T[SubKey]>;
};
/** All built-in and custom scalars, mapped to their actual values */
export declare type Scalars = {
    ID: string;
    String: string;
    Boolean: boolean;
    Int: number;
    Float: number;
    /** A date string, such as 2007-12-03, compliant with the `full-date` format outlined in section 5.6 of the RFC 3339 profile of the ISO 8601 standard for representation of dates and times using the Gregorian calendar. */
    Date: string;
    /** A date-time string at UTC, such as 2007-12-03T10:15:30Z, compliant with the `date-time` format outlined in section 5.6 of the RFC 3339 profile of the ISO 8601 standard for representation of dates and times using the Gregorian calendar. */
    DateTime: string;
    /** A time string at UTC, such as 10:15:30Z, compliant with the `full-time` format outlined in section 5.6 of the RFC 3339profile of the ISO 8601 standard for representation of dates and times using the Gregorian calendar. */
    Time: string;
};
/**
 * In the case that this has been made by an API
 * there are the fields to render on the UI
 */
export declare type ApiIntegration = {
    __typename?: 'APIIntegration';
    /** Display description of this integration, equivalent to a user title. */
    displayDescription?: Maybe<Scalars['String']>;
    /** Display name of this integration, equivalent to a user name. */
    displayName?: Maybe<Scalars['String']>;
    /** Avatar of this integration. */
    logoURL?: Maybe<Scalars['String']>;
};
/** Information about the company that you're writing to. */
export declare type Account = {
    __typename?: 'Account';
    /** Data about the hosted client portal. */
    clientPortal: ClientPortal;
    /** Name of the Account. */
    name: Scalars['String'];
    /** Slug ID of this account. */
    slug: Scalars['String'];
    /** Website of the Account. */
    website: Scalars['String'];
};
/** Describes an attachment that may be attached to a message. */
export declare type Attachment = {
    __typename?: 'Attachment';
    /** ID of the attachment */
    _id: Scalars['ID'];
    /** Extension of this attachment */
    extension: Scalars['String'];
    /** Name of the attachment */
    fileName: Scalars['String'];
    /** If true, this attachment has not been used on the app and it may be deleted. */
    pending: Scalars['Boolean'];
    /** Size (in bytes) of this file */
    size?: Maybe<Scalars['Float']>;
    /** If this attachment has been created, use this signed url to upload his content. */
    uploadUrl?: Maybe<Scalars['String']>;
    /** This boolean returns if the file has been already uploaded to s3. */
    uploaded: Scalars['Boolean'];
    /** URL to download this attachment */
    url?: Maybe<Scalars['String']>;
};
/** Input for updating visitor attributes */
export declare type AttributesInput = {
    /** Attributes to set */
    attributes: Array<InputMaybe<VisitorAttributeCategoryInput>>;
};
/** Generic response of authentication type */
export declare type AuthenticateResult = {
    __typename?: 'AuthenticateResult';
    /** Will always be true, fails it throws error. */
    ok: Scalars['Boolean'];
};
/** Input to initiate the authenticate flow. */
export declare type AuthenticatedVisitorInput = {
    /** Attributes to set on this request */
    attributes?: InputMaybe<Array<InputMaybe<VisitorAttributeCategoryInput>>>;
    /** This token will be sent to the customer webhook to validate user credentials. */
    token: Scalars['String'];
};
/** Describes the current type of authentication for a visitor. */
export declare enum AuthenticationType {
    /**
     * Secure authentication via webhook, the customer service has been able
     * to validate the identity of the visitor.
     */
    Authenticated = "authenticated",
    /** User has been authenticated via the client apis. */
    ClientAuth = "clientAuth",
    /** User is a guest and has provided their name and email */
    Guest = "guest",
    /**
     * Not authenticated, neither as guest nor as a visitor.
     * You will not be able to operate a conversation but can inspect knowledge base or other
     * static resurces.
     */
    Unauthenticated = "unauthenticated"
}
export declare type BlockElement = CodeElement | HeadingElement | IframeElement | ImageElement | OrderedListElement | ParagraphElement | QuoteElement | UnorderedListElement;
export declare type ClientPortal = {
    __typename?: 'ClientPortal';
    /**
     * Checks if the knowledge base setting is enabled on
     * the portal page
     */
    knowledgeBaseEnabled?: Maybe<Scalars['Boolean']>;
    /**
     * Checks if the status page setting is enabled on
     * the portal page
     */
    statusPageEnabled?: Maybe<Scalars['Boolean']>;
};
/** Represents a block of code on the rich text editor. */
export declare type CodeElement = {
    __typename?: 'CodeElement';
    /** Id of item. */
    _id: Scalars['ID'];
    /** Content on this code element */
    children: Array<InlineTextElement>;
    /** Reference of the type, on this case, it will be 'code'. */
    type: Scalars['String'];
};
/** A Conversation, pretty self-explanatory. */
export declare type Conversation = {
    __typename?: 'Conversation';
    /** Identifier of this conversation */
    _id: Scalars['ID'];
    /** Account where this docs belongs. */
    accountId: Scalars['ID'];
    /** True if the last message was sent by an operator. */
    answered: Scalars['Boolean'];
    /** Creation of this conversation. */
    createdAt: Scalars['DateTime'];
    /** True if this conversation is closed. */
    done: Scalars['Boolean'];
    /** Last item publicly sent. */
    lastItem?: Maybe<ConversationItem>;
    /** Message thread */
    messages: Array<ConversationItem>;
    /** Visitor (the widget user) of the chat. */
    visitor: Visitor;
};
/** A Conversation, pretty self-explanatory. */
export declare type ConversationMessagesArgs = {
    after?: InputMaybe<Scalars['ID']>;
};
/**
 * Default content card, used to display rich information in the UI, and also by
 * our unfurl service to preview links.
 */
export declare type ConversationCard = {
    __typename?: 'ConversationCard';
    /**
     * Used to display a small icon on the header of the card,
     * in the case of unfurl, it display the favicon of the previewed page.
     */
    appIcon?: Maybe<Scalars['String']>;
    /**
     * Used to display a small title on the header of the card,
     * in case of unfurl, it displays the <title> tag of the previewed page.
     */
    appTitle?: Maybe<Scalars['String']>;
    /** Describes who created this card. */
    createdBy: ConversationCardSender;
    /** Text describing the content of the card. */
    description?: Maybe<Scalars['String']>;
    /** Image to display in the card, it is optional. */
    image?: Maybe<Scalars['String']>;
    /** Optional clickable link on this card. */
    link?: Maybe<Scalars['String']>;
    /**
     * Title to display on the card, if this card also has a link, this title
     * becomes an anchor tag to such link.
     */
    title?: Maybe<Scalars['String']>;
    /** Describes the type of card to be shown. */
    type: ConversationCardType;
};
/** Describes who created this card */
export declare enum ConversationCardSender {
    /** This card has been created by an API Integration call. */
    Api = "api",
    /** This card has been created by an automation hook */
    Hook = "hook",
    /** This card has been created by a trigger (TBD). */
    Trigger = "trigger",
    /** This card has been created by the unfurl service. */
    Unfurl = "unfurl"
}
/** Describes how this card is going to be shown. */
export declare enum ConversationCardType {
    /** This card is going to be shown as a default content card. */
    Card = "card",
    /** This card is going to be shown as a unfurl. */
    Unfurl = "unfurl"
}
/** This is the main content of the conversation. */
export declare type ConversationContent = {
    __typename?: 'ConversationContent';
    /** Contains the main content of the rich message. */
    message: Array<ParagraphElement>;
    /** Non-rich representation of this message. */
    messageString?: Maybe<Scalars['String']>;
    /** Type of the message received, for widget, only "message" is allowed. */
    type: ConversationContentType;
};
/** This is the main content of the conversation */
export declare type ConversationContentInput = {
    /** Contains the main content of the rich message. */
    message: Array<ConversationContentMessageInput>;
};
export declare type ConversationContentMessageChildrenInput = {
    /**
     * For: Text.
     * Describes if is bold class applied to this text.
     */
    bold?: InputMaybe<Scalars['Boolean']>;
    /**
     * For: Link.
     * Children text to be contained on this link.
     */
    children?: InputMaybe<Array<ConversationContentMessageChildrenInput>>;
    /**
     * For: Text.
     * Describes if is italic class applied to this text.
     */
    italic?: InputMaybe<Scalars['Boolean']>;
    /**
     * For: Text.
     * Text to be displayed.
     */
    text?: InputMaybe<Scalars['String']>;
    /** If is no text, may have a type */
    type?: InputMaybe<ConversationContentMessageChildrenType>;
    /**
     * For: Text.
     * Describes if is underline class applied to this text.
     */
    underline?: InputMaybe<Scalars['Boolean']>;
    /**
     * For: Link.
     * URL (href) of the said link.
     */
    url?: InputMaybe<Scalars['String']>;
};
/** Extra (non-text) content types */
export declare enum ConversationContentMessageChildrenType {
    /** Render this element as a link. */
    Link = "link"
}
/** Describes a message that is shown as a bubble of text on the UI. */
export declare type ConversationContentMessageInput = {
    /** Content of this paragraph. */
    children: Array<ConversationContentMessageChildrenInput>;
    /** Block Type of this paragraph, for now, only paragraphs are supported. */
    type: ConversationContentMessageType;
};
/** Root type of content */
export declare enum ConversationContentMessageType {
    /** Display a paragraph. */
    Paragraph = "paragraph"
}
/**
 * Type of message received, widget will only display "message"
 * since other types are private and not show client-side
 */
export declare enum ConversationContentType {
    /** Received a message */
    Message = "message"
}
/**
 * Conversation items are the unit of our conversations, describing each message shared,
 * it may contain cards, message and/or attachments.
 */
export declare type ConversationItem = {
    __typename?: 'ConversationItem';
    /** Identifier of this message. */
    _id: Scalars['ID'];
    /** List of file attachments that this message may have. */
    attachments: Array<Attachment>;
    /** Buttons that this item may have */
    buttons: Array<ConversationItemButton>;
    /** A card that may be linked on this conversation item. */
    card?: Maybe<ConversationCard>;
    /** Content of this message. */
    content: ConversationContent;
    /** ID of the conversation where this message belongs. */
    conversationId: Scalars['ID'];
    /** Stamp of this message creation. */
    createdAt: Scalars['DateTime'];
    /** Describes who sent this message. */
    sender: Sender;
    /** Describes the type of who sent this message. */
    senderType: ConversationSenderType;
};
export declare type ConversationItemButton = {
    __typename?: 'ConversationItemButton';
    /** ID of this button. */
    _id: Scalars['ID'];
    /** Which type of action this button causes. */
    action_type: ConversationItemButtonActionType;
    /** If this button triggers an broadcast an event, here's the event name. */
    event_name?: Maybe<Scalars['String']>;
    /** Optional content for the event. */
    event_payload?: Maybe<Scalars['String']>;
    /** If this widget opens a link, here's the link target. */
    target?: Maybe<ConversationItemButtonTarget>;
    /** Button of the text. */
    text: Scalars['String'];
    /** Type of this button */
    type: ConversationItemButtonType;
    /** If this widget opens a link, here's the link URL. */
    url?: Maybe<Scalars['String']>;
};
export declare enum ConversationItemButtonActionType {
    /** This button will execute an internal action. */
    Callback = "CALLBACK",
    /** This button will open a link. */
    Link = "LINK",
    /** This button will broadcast an event on the widget caller. */
    WidgetEvent = "WIDGET_EVENT"
}
export declare enum ConversationItemButtonTarget {
    /** Opens the linked document in a new window or tab */
    Blank = "_blank",
    /** Opens the linked document in the same frame as it was clicked (this is default) */
    Self = "_self"
}
export declare enum ConversationItemButtonType {
    /** This button looks like a primary action. */
    Primary = "PRIMARY",
    /** This button looks like a secondary action. */
    Secondary = "SECONDARY"
}
/**
 * Conversation items are the unit of our conversations, describing each message shared,
 * it may contain cards, message and/or attachments.
 */
export declare type ConversationItemInput = {
    /** List of file attachments that this message may have. */
    attachments?: InputMaybe<Array<Scalars['ID']>>;
    /** Content of this message. */
    content: ConversationContentInput;
};
/** Describes the type of who sent this message. */
export declare enum ConversationSenderType {
    /** This message was sent via an API Integration. */
    Api = "api",
    /** This message has been generated by an automation hook. */
    Hook = "hook",
    /** This message was sent by an Operator (aka App User, Dashboard User, Member User). */
    Operator = "operator",
    /** This message was sent by an Visitor (aka Wiget User, aka Customer). */
    Visitor = "visitor"
}
/** Returns a conversation update. */
export declare type ConversationUpdate = {
    __typename?: 'ConversationUpdate';
    /** Updates conversation */
    conversation: Conversation;
    /** Messages in that conversation. */
    messages: Array<ConversationItem>;
    /**
     * True if triggers the conversation sound and overview.
     * False if just updates the chat without any user interaction.
     */
    userInteraction: Scalars['Boolean'];
};
export declare enum ErrorCodes {
    BadRequest = "BAD_REQUEST",
    NotAllowed = "NOT_ALLOWED",
    NotFound = "NOT_FOUND",
    UnauthenticatedUser = "UNAUTHENTICATED_USER"
}
export declare type GenericResponse = {
    __typename?: 'GenericResponse';
    ok?: Maybe<Scalars['Boolean']>;
};
/** Input for logging a user as a guest */
export declare type GuestInput = {
    /** Email of the visitor */
    email: Scalars['String'];
    /** Name of the visitor */
    name: Scalars['String'];
};
/** Configuration about the background of the widget. */
export declare type HeadingBackground = {
    __typename?: 'HeadingBackground';
    /** Background color as CSS color, image URL or whatever. */
    background: Scalars['String'];
    /** Hexa of the background color selected. */
    color: Scalars['String'];
};
/** Represents a heading on the rich text editor. */
export declare type HeadingElement = {
    __typename?: 'HeadingElement';
    /** Id of item. */
    _id: Scalars['ID'];
    /** Content on this heading */
    children: Array<InlineTextElement>;
    /** Heading type */
    heading: Scalars['String'];
    /** Reference of the type, on this case is 'heading'. */
    type: Scalars['String'];
};
/** Represents an embeddable frame on the rich text editor. */
export declare type IframeElement = {
    __typename?: 'IframeElement';
    /** Id of item. */
    _id: Scalars['ID'];
    /** Should be always empty but required by the text editor. */
    children: Array<InlineTextElement>;
    /** Reference of the type, on this case, it will be 'iframe'. */
    type: Scalars['String'];
    /** URL of the frame associated with this element. */
    url: Scalars['String'];
};
/** Represents an image on the rich text editor. */
export declare type ImageElement = {
    __typename?: 'ImageElement';
    /** Id of item. */
    _id: Scalars['ID'];
    /** Should be always empty but required by the text editor. */
    children: Array<InlineTextElement>;
    /** ID of the attachment associated with this element. */
    id: Scalars['String'];
    /** Reference of the type, on this case, it will be 'img'. */
    type: Scalars['String'];
    /** URL of the attachment associated with this element. */
    url: Scalars['String'];
};
/** An inbox is a internal group that holds operator and conversations. */
export declare type Inbox = {
    __typename?: 'Inbox';
    /** Inbox ID */
    _id: Scalars['ID'];
    /** Users assigned to this inbox. */
    users: Array<MemberUser>;
    /**
     * Work schedule of this inbox, for presentation
     * purposes.
     */
    workWeek: WorkWeek;
};
/** A paragraph may have different type of children, those are defined here. */
export declare type InlineElement = InlineLinkElement | InlineTextElement;
/** Chunk of text displayed as a link (anchor tag). */
export declare type InlineLinkElement = {
    __typename?: 'InlineLinkElement';
    /** Id of item. */
    _id: Scalars['ID'];
    /** Text to be displayed on this link. */
    children?: Maybe<Array<InlineTextElement>>;
    /** Reference of the type, on this case, it will be 'link'. */
    type: Scalars['String'];
    /** URL (href) of the said link. */
    url: Scalars['String'];
};
/** Chunk of text displayed as plain text. */
export declare type InlineTextElement = {
    __typename?: 'InlineTextElement';
    /** Id of item. */
    _id: Scalars['ID'];
    /** Describes if is bold class applied to this text. */
    bold?: Maybe<Scalars['Boolean']>;
    /** Describes if is italic class applied to this text. */
    italic?: Maybe<Scalars['Boolean']>;
    /** Text to be displayed. */
    text: Scalars['String'];
    /** Describes if is underline class applied to this text. */
    underline?: Maybe<Scalars['Boolean']>;
};
export declare type KnowledgeBase = {
    __typename?: 'KnowledgeBase';
    /** ID of this knowledge base instance. */
    _id: Scalars['ID'];
    articles: Array<KnowledgeBaseArticle>;
    /** Categories of articles available in this knowledge base instance. */
    categories?: Maybe<Array<Maybe<KnowledgeBaseCategory>>>;
    /** Find a category by ID. */
    category?: Maybe<KnowledgeBaseCategory>;
    /** List of pinned articles */
    pinned: Array<KnowledgeBaseArticle>;
};
export declare type KnowledgeBaseArticlesArgs = {
    search: Scalars['String'];
};
export declare type KnowledgeBaseCategoryArgs = {
    id: Scalars['ID'];
};
export declare type KnowledgeBaseArticle = {
    __typename?: 'KnowledgeBaseArticle';
    /** ID of this knowledge base article. */
    _id: Scalars['ID'];
    /** Article ID */
    articleId: Scalars['ID'];
    /** Category of this article. */
    categoryId: Scalars['ID'];
    /** Content of this article. */
    content: Array<KnowledgeBaseArticleVersionContent>;
    /** Member who created this article. */
    createdBy: MemberUser;
    /** ID of the member who created this article. */
    createdById: Scalars['ID'];
    /** Member who published this article. */
    publishedBy: MemberUser;
    /** ID of the member who published this article. */
    publishedById: Scalars['ID'];
    /** Article Subtitle. */
    subtitle?: Maybe<Array<Maybe<LocalizedString>>>;
    /** Article Title. */
    title: Array<LocalizedString>;
};
export declare type KnowledgeBaseArticleVersionContent = {
    __typename?: 'KnowledgeBaseArticleVersionContent';
    /** Language of this content of the article. */
    language: Scalars['String'];
    /** Content on the specified language. */
    value: Array<BlockElement>;
};
export declare type KnowledgeBaseCategory = {
    __typename?: 'KnowledgeBaseCategory';
    /** ID of this category */
    _id: Scalars['ID'];
    /** Return an article on this category */
    article?: Maybe<KnowledgeBaseArticle>;
    /** Returns articles for this category. */
    articles: Array<KnowledgeBaseArticle>;
    /** Timestamp of creation */
    createdAt: Scalars['DateTime'];
    /** Logo to show for this category. */
    logoURL?: Maybe<Scalars['String']>;
    /** Category Subtitle. */
    subtitle?: Maybe<Array<Maybe<LocalizedString>>>;
    /** Category Title. */
    title?: Maybe<Array<Maybe<LocalizedString>>>;
};
export declare type KnowledgeBaseCategoryArticleArgs = {
    id: Scalars['ID'];
};
/** Represents a item within a list. */
export declare type ListElement = {
    __typename?: 'ListElement';
    /** Id of item. */
    _id: Scalars['ID'];
    /** Text to be displayed on this list item. */
    children?: Maybe<Array<InlineTextElement>>;
    /** Reference of the type, on this case it will be 'li'. */
    type: Scalars['String'];
};
/** A localized string is a string that only applies to a specific language variant. */
export declare type LocalizedString = {
    __typename?: 'LocalizedString';
    /** Describes the language-variant for this string. */
    language: Scalars['String'];
    /** Describes the actual value of this string. */
    value: Scalars['String'];
};
/** A localized string is a string that only applies to a specific language variant. */
export declare type LocalizedStringInput = {
    /** Describes the language-variant for this string. */
    language: Scalars['String'];
    /** Describes the actual value of this string. */
    value: Scalars['String'];
};
/**
 * A member is an operator of the platform, representing the company
 * that you're writing to.
 */
export declare type MemberUser = {
    __typename?: 'MemberUser';
    /** The unique identifier for the member. */
    _id: Scalars['ID'];
    /** User First Name. */
    firstName: Scalars['String'];
    /** User Last Name. */
    lastName: Scalars['String'];
    /** User Avatar logo */
    logoURL?: Maybe<Scalars['String']>;
    /** Computed name of the user (lastname + firstname). */
    name?: Maybe<Scalars['String']>;
};
export declare type Mutation = {
    __typename?: 'Mutation';
    /** This will set the user type, based on a token that the user app has to resolve. */
    AuthenticateUser?: Maybe<AuthenticateResult>;
    /** Marks attachment as uploaded */
    CompleteAttachment: Attachment;
    /** Executes a button callback on the conversation item. */
    ConversationButtonCallback: GenericResponse;
    /** Creates an attachment for be used later on the app. */
    CreateAttachment: Attachment;
    /** Creates a new conversation. */
    CreateConversation: Conversation;
    /** Deletes an attachment (only if was not used). */
    DeleteAttachment: GenericResponse;
    /** Post a new message. */
    PostConversationItem: ConversationItem;
    /** Removes a preview from a message (only if you had sent such message). */
    RemoveUnfURLCard: ConversationItem;
    /**
     * This will set the user data as GUEST, only available if the authentication method
     * is flagged as "allowGuests"
     */
    SetGuest?: Maybe<Visitor>;
    /**
     * This will set the user data, only available if the authentication method of
     * the integration is "client side".
     */
    SetUser?: Maybe<Visitor>;
    /** Set data attributes for an user */
    SetUserAttributes?: Maybe<Visitor>;
};
export declare type MutationAuthenticateUserArgs = {
    data: AuthenticatedVisitorInput;
};
export declare type MutationCompleteAttachmentArgs = {
    id: Scalars['ID'];
};
export declare type MutationConversationButtonCallbackArgs = {
    buttonId: Scalars['ID'];
    conversationId: Scalars['ID'];
};
export declare type MutationCreateAttachmentArgs = {
    fileName: Scalars['String'];
};
export declare type MutationDeleteAttachmentArgs = {
    id: Scalars['ID'];
};
export declare type MutationPostConversationItemArgs = {
    conversationId: Scalars['ID'];
    data: ConversationItemInput;
};
export declare type MutationRemoveUnfUrlCardArgs = {
    id: Scalars['ID'];
};
export declare type MutationSetGuestArgs = {
    data: GuestInput;
};
export declare type MutationSetUserArgs = {
    data: VisitorInput;
};
export declare type MutationSetUserAttributesArgs = {
    data: AttributesInput;
};
export declare type OrderedListElement = {
    __typename?: 'OrderedListElement';
    /** Id of item. */
    _id: Scalars['ID'];
    /** List elements on this list. */
    children: Array<ListElement>;
    /** Reference of the type, on this case, it will be 'ol'. */
    type: Scalars['String'];
};
export declare type PageInfo = {
    __typename?: 'PageInfo';
    end?: Maybe<Scalars['String']>;
    hasNext?: Maybe<Scalars['Boolean']>;
    start?: Maybe<Scalars['String']>;
};
/** Represents a paragraph on the rich text editor. */
export declare type ParagraphElement = {
    __typename?: 'ParagraphElement';
    /** Id of item. */
    _id: Scalars['ID'];
    /** Content on this paragraph. */
    children: Array<InlineElement>;
    /** Reference of the type, on this case, it will be 'paragraph'. */
    type: Scalars['String'];
};
/** Query data returning useful information to render the widget */
export declare type Profile = {
    __typename?: 'Profile';
    /** Account Data */
    account?: Maybe<Account>;
    /** Flag to see if the widget integration allows guest users */
    allowGuests: Scalars['Boolean'];
    /** Widget background color */
    background: HeadingBackground;
    /** Color of the bubble */
    fabColor: Scalars['String'];
    /** Logo to show on the fab of the widget */
    fabLogoURL?: Maybe<Scalars['String']>;
    /** Widget foreground color */
    foreground: Scalars['String'];
    /** Color used on the header text of the widget. */
    headerTextColor: Scalars['String'];
    /** Inbox of this widget. */
    inbox: Inbox;
    knowledgeBase?: Maybe<KnowledgeBase>;
    /** Logo to show on the header of the widget */
    logoURL?: Maybe<Scalars['String']>;
    /** Color of the notification ripple */
    notificationColor: Scalars['String'];
    statusPage?: Maybe<StatusPage>;
    /** Subtitle appearing in the widget */
    subtitle: Array<LocalizedString>;
    /** Title appearing in the widget */
    title: Array<LocalizedString>;
    /** User Visitor Data */
    visitor?: Maybe<Visitor>;
};
export declare type Query = {
    __typename?: 'Query';
    /** Retrieves your conversation by id */
    Conversation?: Maybe<Conversation>;
    /** Retrieves your conversations */
    Conversations?: Maybe<Array<Maybe<Conversation>>>;
    /** Returns the Widget Profile. */
    Profile?: Maybe<Profile>;
};
export declare type QueryConversationArgs = {
    id: Scalars['ID'];
};
export declare type QueryConversationsArgs = {
    after?: InputMaybe<Scalars['ID']>;
};
/** Represents a quote on the rich text editor. */
export declare type QuoteElement = {
    __typename?: 'QuoteElement';
    /** Id of item. */
    _id: Scalars['ID'];
    /** Content on this quote element */
    children: Array<InlineTextElement>;
    /** Reference of the type, on this case, it will be 'blockquote'. */
    type: Scalars['String'];
};
export declare type S3Upload = {
    __typename?: 'S3Upload';
    url: Scalars['String'];
};
/** Describes who sent this message. */
export declare type Sender = ApiIntegration | MemberUser | Visitor;
export declare type StatusPage = {
    __typename?: 'StatusPage';
    /** Groups on this statuspage. */
    componentGroups: Array<Maybe<StatusPageComponentGroup>>;
    /** Components of this statuspage. */
    components: Array<StatusPageComponent>;
    summary?: Maybe<StatusPageSummary>;
};
export declare type StatusPageComponent = {
    __typename?: 'StatusPageComponent';
    /** Identifier of this component. */
    _id: Scalars['ID'];
    /** Timestamp of creation. */
    createdAt: Scalars['DateTime'];
    /** Descriptive text to be displayed for this component. */
    description?: Maybe<Array<LocalizedString>>;
    /** Display mode of this component. */
    displayMode: StatusPageComponentDisplayMode;
    eventsHistory: Array<StatusPageComponentEventHistoryDate>;
    /** Group of this component. */
    groupId?: Maybe<Scalars['ID']>;
    /** Name to be displayed for this component. */
    name: Array<LocalizedString>;
};
export declare type StatusPageComponentEventsHistoryArgs = {
    days?: InputMaybe<Scalars['Int']>;
};
export declare enum StatusPageComponentDisplayMode {
    /** A 90 days history will be displayed. */
    History = "HISTORY",
    /** It will be hidden from the list of components. */
    None = "NONE",
    /** Only the current status will be displayed. */
    Status = "STATUS"
}
export declare type StatusPageComponentEventHistoryDate = {
    __typename?: 'StatusPageComponentEventHistoryDate';
    date: Scalars['DateTime'];
    events: Array<StatusPageEvent>;
};
export declare type StatusPageComponentGroup = {
    __typename?: 'StatusPageComponentGroup';
    /** Identifier of this component group. */
    _id: Scalars['ID'];
    /** Timestamp of creation. */
    createdAt: Scalars['DateTime'];
    /** Name to be displayed for this component group. */
    name: Array<LocalizedString>;
};
export declare type StatusPageEvent = {
    __typename?: 'StatusPageEvent';
    /** Identifier of this component. */
    _id: Scalars['ID'];
    /** IDs of the components affected by this event. */
    affectedComponentIds: Array<Scalars['ID']>;
    /** Timestamp of creation. */
    createdAt: Scalars['DateTime'];
    /** Descriptive text to be displayed for this event. */
    description?: Maybe<Array<LocalizedString>>;
    /** Timestamp of when this event ended. */
    finishedAt?: Maybe<Scalars['DateTime']>;
    /** Updates to this event. */
    historyItems: Array<StatusPageEventHistoryItem>;
    /** Impact of this event */
    impact: StatusPageEventImpact;
    /** True if this event is a maintenance event, otherwise is an incident event. */
    maintenance: Scalars['Boolean'];
    /** True if this event is a ongoing. */
    ongoing: Scalars['Boolean'];
    /** Timestamp of when this event started. */
    startedAt: Scalars['DateTime'];
    /** Return latest status. */
    status: StatusPageEventHistoryItemStatus;
    /** Title of this event. */
    title: Array<LocalizedString>;
};
export declare type StatusPageEventHistoryItem = {
    __typename?: 'StatusPageEventHistoryItem';
    /** ID of this incident history item. */
    _id: Scalars['ID'];
    /** Components affected by this incident. */
    affectedComponents: Array<StatusPageEventHistoryItemAffectedComponent>;
    /** Date of this item creation */
    createdAt: Scalars['DateTime'];
    /** Date of where this event ocurred. */
    eventDate: Scalars['DateTime'];
    /** Message describing the update. */
    message?: Maybe<Array<LocalizedString>>;
    /** The current status of the incident. */
    status: StatusPageEventHistoryItemStatus;
};
export declare type StatusPageEventHistoryItemAffectedComponent = {
    __typename?: 'StatusPageEventHistoryItemAffectedComponent';
    /** Component which is affected by this event. */
    componentId: Scalars['ID'];
    /** Status of the affected component. */
    componentStatus: StatusPageEventHistoryItemComponentStatus;
};
export declare enum StatusPageEventHistoryItemComponentStatus {
    /** The component has a degraded performance. */
    Degraded = "DEGRADED",
    /** This component is totally out of service. */
    MajorOutage = "MAJOR_OUTAGE",
    /** This component is still operational. */
    Operational = "OPERATIONAL",
    /** This component is partially out of service. */
    PartialOutage = "PARTIAL_OUTAGE",
    /** This component is out of service because of a scheduled maintenance. */
    UnderMaintenance = "UNDER_MAINTENANCE"
}
export declare enum StatusPageEventHistoryItemStatus {
    /** **On incidents:** The incident has been identified and a remediation is in progress. */
    Identified = "IDENTIFIED",
    /** **On incidents:** A fix has been dispatched and operations is monitoring the component vitals. */
    Monitoring = "MONITORING",
    /**
     * **On incidents:** this means that the incident has been acknowledged (investigating).
     * **On maintenances:** this means that the maintenance is actually ongoing.
     */
    Ongoing = "ONGOING",
    /**
     * **On incidents:** The incident has been resolved.
     * **On maintenances:** The maintenance has been finished.
     */
    Resolved = "RESOLVED"
}
export declare enum StatusPageEventImpact {
    /** This event caused a critical impact. */
    Critical = "CRITICAL",
    /** This event caused a major impact. */
    Major = "MAJOR",
    /** This event caused a partial (or minor) impact. */
    Minor = "MINOR",
    /** This event caused no impact. */
    None = "NONE"
}
export declare type StatusPageSummary = {
    __typename?: 'StatusPageSummary';
    /** Summary of the last 7 days of the status page. */
    last7d: Scalars['Float'];
    /** Summary of the last 24 hours of the status page. */
    last24h: Scalars['Float'];
    /** Summary of the last 30 days of the status page. */
    last30d: Scalars['Float'];
    /** Summary of the last 90 days of the status page. */
    last90d: Scalars['Float'];
};
export declare type Subscription = {
    __typename?: 'Subscription';
    /** Triggered when a conversation change is received or a new conversation arrives. */
    OnConversation: ConversationUpdate;
    /** Notify when your data has been updated. */
    OnVisitorUpdate: Visitor;
};
export declare type UnorderedListElement = {
    __typename?: 'UnorderedListElement';
    /** Id of item. */
    _id: Scalars['ID'];
    /** List elements on this list. */
    children: Array<ListElement>;
    /** Reference of the type, on this case, it will be 'ul'. */
    type: Scalars['String'];
};
/** Represents the user using the widget */
export declare type Visitor = {
    __typename?: 'Visitor';
    /** Identifier of this visitor */
    _id: Scalars['ID'];
    /** Attributes set to the current visitor. */
    attributes?: Maybe<Array<Maybe<VisitorAttributeCategory>>>;
    /** Email of the visitor */
    email?: Maybe<Scalars['String']>;
    /** Image of the visitor */
    image?: Maybe<Scalars['String']>;
    /** Name of the visitor */
    name?: Maybe<Scalars['String']>;
    /** Authentication Type of the visitor. */
    type: AuthenticationType;
};
/** Type of a single attribute shown on the UI */
export declare type VisitorAttribute = {
    __typename?: 'VisitorAttribute';
    /** Name of the attribute */
    name: Scalars['String'];
    /** Type of the attribute */
    type: VisitorAttributeType;
    /** Value of the attribute */
    value: Scalars['String'];
};
/** A AttributeCategory is a group of attributes */
export declare type VisitorAttributeCategory = {
    __typename?: 'VisitorAttributeCategory';
    /** Attributes contained in this group */
    attributes?: Maybe<Array<Maybe<VisitorAttribute>>>;
    /** Name of the group */
    name: Scalars['String'];
};
/** A AttributeCategory is a group of attributes */
export declare type VisitorAttributeCategoryInput = {
    /** Attributes contained in this group */
    attributes?: InputMaybe<Array<InputMaybe<VisitorAttributeInput>>>;
    /** Name of the group */
    name: Scalars['String'];
};
/** Type of a single attribute shown on the UI */
export declare type VisitorAttributeInput = {
    /** Name of the attribute */
    name: Scalars['String'];
    /** Type of the attribute */
    type: VisitorAttributeType;
    /** Value of the attribute */
    value: Scalars['String'];
};
/** The Atrribute Type controls how the attribute shows on the UI */
export declare enum VisitorAttributeType {
    /** Will render as a link */
    Link = "link",
    /** Will render as a text */
    Text = "text"
}
/** Input to authenticate the user client-side. */
export declare type VisitorInput = {
    /** Attributes to set on this request */
    attributes?: InputMaybe<Array<InputMaybe<VisitorAttributeCategoryInput>>>;
    /** Email of the visitor */
    email: Scalars['String'];
    /** Image of the visitor. */
    image?: InputMaybe<Scalars['String']>;
    /** Name of the visitor */
    name: Scalars['String'];
};
/** A Unit of work explaining which hours the company operates on such day */
export declare type WorkHourRule = {
    __typename?: 'WorkHourRule';
    /** Starting hour of the shift. */
    from: Scalars['Time'];
    /** Ending hour of the shift. */
    to: Scalars['Time'];
};
/** Represents a workable week. */
export declare type WorkWeek = {
    __typename?: 'WorkWeek';
    /** Friday work rules */
    friday: Array<WorkHourRule>;
    /** Ugh, mondays! */
    monday: Array<WorkHourRule>;
    /** Saturday work rules */
    saturday: Array<WorkHourRule>;
    /** Sunday work rules */
    sunday: Array<WorkHourRule>;
    /** Thursday work rules */
    thursday: Array<WorkHourRule>;
    /** Timezone of the workweek */
    timezone: Scalars['String'];
    /** Tuesday work rules */
    tuesday: Array<WorkHourRule>;
    /** Wednesday work rules */
    wednesday: Array<WorkHourRule>;
};
