1891 lines
87 KiB
TypeScript
1891 lines
87 KiB
TypeScript
import gql from 'graphql-tag';
|
|
import * as VueApolloComposable from '@vue/apollo-composable';
|
|
import type * as VueCompositionApi from 'vue';
|
|
export type Maybe<T> = T | null;
|
|
export type InputMaybe<T> = Maybe<T>;
|
|
export type Exact<T extends { [key: string]: unknown }> = { [K in keyof T]: T[K] };
|
|
export type MakeOptional<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]?: Maybe<T[SubKey]> };
|
|
export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]: Maybe<T[SubKey]> };
|
|
export type MakeEmpty<T extends { [key: string]: unknown }, K extends keyof T> = { [_ in K]?: never };
|
|
export type Incremental<T> = T | { [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never };
|
|
export type ReactiveFunction<TParam> = () => TParam;
|
|
/** All built-in and custom scalars, mapped to their actual values */
|
|
export type Scalars = {
|
|
ID: { input: string; output: string; }
|
|
String: { input: string; output: string; }
|
|
Boolean: { input: boolean; output: boolean; }
|
|
Int: { input: number; output: number; }
|
|
Float: { input: number; output: number; }
|
|
};
|
|
|
|
export type ArchiveCalendarEventInput = {
|
|
archiveNote?: InputMaybe<Scalars['String']['input']>;
|
|
id: Scalars['ID']['input'];
|
|
};
|
|
|
|
export type CalendarDateRange = {
|
|
from?: InputMaybe<Scalars['String']['input']>;
|
|
to?: InputMaybe<Scalars['String']['input']>;
|
|
};
|
|
|
|
export type CalendarEvent = {
|
|
__typename?: 'CalendarEvent';
|
|
archiveNote: Scalars['String']['output'];
|
|
archivedAt: Scalars['String']['output'];
|
|
contact: Scalars['String']['output'];
|
|
createdAt: Scalars['String']['output'];
|
|
end: Scalars['String']['output'];
|
|
id: Scalars['ID']['output'];
|
|
isArchived: Scalars['Boolean']['output'];
|
|
note: Scalars['String']['output'];
|
|
start: Scalars['String']['output'];
|
|
title: Scalars['String']['output'];
|
|
};
|
|
|
|
export type ClientTimelineItem = {
|
|
__typename?: 'ClientTimelineItem';
|
|
calendarEvent?: Maybe<CalendarEvent>;
|
|
contactId: Scalars['String']['output'];
|
|
contentId: Scalars['String']['output'];
|
|
contentType: Scalars['String']['output'];
|
|
datetime: Scalars['String']['output'];
|
|
document?: Maybe<WorkspaceDocument>;
|
|
id: Scalars['ID']['output'];
|
|
message?: Maybe<CommItem>;
|
|
recommendation?: Maybe<FeedCard>;
|
|
};
|
|
|
|
export type CommItem = {
|
|
__typename?: 'CommItem';
|
|
at: Scalars['String']['output'];
|
|
audioUrl: Scalars['String']['output'];
|
|
channel: Scalars['String']['output'];
|
|
contact: Scalars['String']['output'];
|
|
contactId: Scalars['String']['output'];
|
|
contactInboxId: Scalars['String']['output'];
|
|
deliveryStatus?: Maybe<Scalars['String']['output']>;
|
|
direction: Scalars['String']['output'];
|
|
duration: Scalars['String']['output'];
|
|
id: Scalars['ID']['output'];
|
|
kind: Scalars['String']['output'];
|
|
sourceExternalId: Scalars['String']['output'];
|
|
sourceTitle: Scalars['String']['output'];
|
|
text: Scalars['String']['output'];
|
|
transcript: Array<Scalars['String']['output']>;
|
|
waveform: Array<Scalars['Float']['output']>;
|
|
};
|
|
|
|
export type CommPin = {
|
|
__typename?: 'CommPin';
|
|
contact: Scalars['String']['output'];
|
|
id: Scalars['ID']['output'];
|
|
text: Scalars['String']['output'];
|
|
};
|
|
|
|
export type Contact = {
|
|
__typename?: 'Contact';
|
|
avatar: Scalars['String']['output'];
|
|
channels: Array<Scalars['String']['output']>;
|
|
description: Scalars['String']['output'];
|
|
hasUnread: Scalars['Boolean']['output'];
|
|
id: Scalars['ID']['output'];
|
|
lastContactAt: Scalars['String']['output'];
|
|
lastMessageChannel: Scalars['String']['output'];
|
|
lastMessageText: Scalars['String']['output'];
|
|
name: Scalars['String']['output'];
|
|
};
|
|
|
|
export type ContactInbox = {
|
|
__typename?: 'ContactInbox';
|
|
channel: Scalars['String']['output'];
|
|
contactId: Scalars['String']['output'];
|
|
contactName: Scalars['String']['output'];
|
|
id: Scalars['ID']['output'];
|
|
isHidden: Scalars['Boolean']['output'];
|
|
lastMessageAt: Scalars['String']['output'];
|
|
sourceExternalId: Scalars['String']['output'];
|
|
title: Scalars['String']['output'];
|
|
updatedAt: Scalars['String']['output'];
|
|
};
|
|
|
|
export type Conversation = {
|
|
__typename?: 'Conversation';
|
|
createdAt: Scalars['String']['output'];
|
|
id: Scalars['ID']['output'];
|
|
lastMessageAt?: Maybe<Scalars['String']['output']>;
|
|
lastMessageText?: Maybe<Scalars['String']['output']>;
|
|
title: Scalars['String']['output'];
|
|
updatedAt: Scalars['String']['output'];
|
|
};
|
|
|
|
export type CreateCalendarEventInput = {
|
|
archiveNote?: InputMaybe<Scalars['String']['input']>;
|
|
archived?: InputMaybe<Scalars['Boolean']['input']>;
|
|
contact?: InputMaybe<Scalars['String']['input']>;
|
|
end?: InputMaybe<Scalars['String']['input']>;
|
|
note?: InputMaybe<Scalars['String']['input']>;
|
|
start: Scalars['String']['input'];
|
|
title: Scalars['String']['input'];
|
|
};
|
|
|
|
export type CreateCommunicationInput = {
|
|
at?: InputMaybe<Scalars['String']['input']>;
|
|
audioUrl?: InputMaybe<Scalars['String']['input']>;
|
|
channel?: InputMaybe<Scalars['String']['input']>;
|
|
contact: Scalars['String']['input'];
|
|
direction?: InputMaybe<Scalars['String']['input']>;
|
|
durationSec?: InputMaybe<Scalars['Int']['input']>;
|
|
kind?: InputMaybe<Scalars['String']['input']>;
|
|
text?: InputMaybe<Scalars['String']['input']>;
|
|
transcript?: InputMaybe<Array<Scalars['String']['input']>>;
|
|
};
|
|
|
|
export type CreateDealInput = {
|
|
amount?: InputMaybe<Scalars['Int']['input']>;
|
|
contactId: Scalars['ID']['input'];
|
|
nextStep?: InputMaybe<Scalars['String']['input']>;
|
|
paidAmount?: InputMaybe<Scalars['Int']['input']>;
|
|
stage?: InputMaybe<Scalars['String']['input']>;
|
|
summary?: InputMaybe<Scalars['String']['input']>;
|
|
title: Scalars['String']['input'];
|
|
};
|
|
|
|
export type CreateWorkspaceDocumentInput = {
|
|
body?: InputMaybe<Scalars['String']['input']>;
|
|
owner?: InputMaybe<Scalars['String']['input']>;
|
|
scope: Scalars['String']['input'];
|
|
summary: Scalars['String']['input'];
|
|
title: Scalars['String']['input'];
|
|
};
|
|
|
|
export type Deal = {
|
|
__typename?: 'Deal';
|
|
amount: Scalars['String']['output'];
|
|
contact: Scalars['String']['output'];
|
|
currentStepId: Scalars['String']['output'];
|
|
id: Scalars['ID']['output'];
|
|
nextStep: Scalars['String']['output'];
|
|
paidAmount: Scalars['String']['output'];
|
|
stage: Scalars['String']['output'];
|
|
steps: Array<DealStep>;
|
|
summary: Scalars['String']['output'];
|
|
title: Scalars['String']['output'];
|
|
};
|
|
|
|
export type DealStep = {
|
|
__typename?: 'DealStep';
|
|
completedAt: Scalars['String']['output'];
|
|
description: Scalars['String']['output'];
|
|
dueAt: Scalars['String']['output'];
|
|
id: Scalars['ID']['output'];
|
|
order: Scalars['Int']['output'];
|
|
status: Scalars['String']['output'];
|
|
title: Scalars['String']['output'];
|
|
};
|
|
|
|
export type FeedCard = {
|
|
__typename?: 'FeedCard';
|
|
at: Scalars['String']['output'];
|
|
contact: Scalars['String']['output'];
|
|
decision: Scalars['String']['output'];
|
|
decisionNote: Scalars['String']['output'];
|
|
id: Scalars['ID']['output'];
|
|
proposal: FeedProposal;
|
|
text: Scalars['String']['output'];
|
|
};
|
|
|
|
export type FeedProposal = {
|
|
__typename?: 'FeedProposal';
|
|
details: Array<Scalars['String']['output']>;
|
|
key: Scalars['String']['output'];
|
|
title: Scalars['String']['output'];
|
|
};
|
|
|
|
export type MePayload = {
|
|
__typename?: 'MePayload';
|
|
conversation: Conversation;
|
|
team: MeTeam;
|
|
user: MeUser;
|
|
};
|
|
|
|
export type MeTeam = {
|
|
__typename?: 'MeTeam';
|
|
id: Scalars['ID']['output'];
|
|
name: Scalars['String']['output'];
|
|
};
|
|
|
|
export type MeUser = {
|
|
__typename?: 'MeUser';
|
|
id: Scalars['ID']['output'];
|
|
name: Scalars['String']['output'];
|
|
phone: Scalars['String']['output'];
|
|
};
|
|
|
|
export type Mutation = {
|
|
__typename?: 'Mutation';
|
|
archiveCalendarEvent: CalendarEvent;
|
|
archiveChatConversation: MutationResult;
|
|
confirmLatestChangeSet: MutationResult;
|
|
createCalendarEvent: CalendarEvent;
|
|
createChatConversation: Conversation;
|
|
createCommunication: MutationWithIdResult;
|
|
createDeal: Deal;
|
|
createWorkspaceDocument: WorkspaceDocument;
|
|
deleteWorkspaceDocument: MutationWithIdResult;
|
|
logPilotNote: MutationResult;
|
|
login: MutationResult;
|
|
logout: MutationResult;
|
|
markThreadRead: MutationResult;
|
|
rollbackChangeSetItems: MutationResult;
|
|
rollbackLatestChangeSet: MutationResult;
|
|
selectChatConversation: MutationResult;
|
|
sendPilotMessage: MutationResult;
|
|
setContactInboxHidden: MutationResult;
|
|
toggleContactPin: PinToggleResult;
|
|
updateCommunicationTranscript: MutationWithIdResult;
|
|
updateDeal: Deal;
|
|
updateFeedDecision: MutationWithIdResult;
|
|
};
|
|
|
|
|
|
export type MutationarchiveCalendarEventArgs = {
|
|
input: ArchiveCalendarEventInput;
|
|
};
|
|
|
|
|
|
export type MutationarchiveChatConversationArgs = {
|
|
id: Scalars['ID']['input'];
|
|
};
|
|
|
|
|
|
export type MutationcreateCalendarEventArgs = {
|
|
input: CreateCalendarEventInput;
|
|
};
|
|
|
|
|
|
export type MutationcreateChatConversationArgs = {
|
|
title?: InputMaybe<Scalars['String']['input']>;
|
|
};
|
|
|
|
|
|
export type MutationcreateCommunicationArgs = {
|
|
input: CreateCommunicationInput;
|
|
};
|
|
|
|
|
|
export type MutationcreateDealArgs = {
|
|
input: CreateDealInput;
|
|
};
|
|
|
|
|
|
export type MutationcreateWorkspaceDocumentArgs = {
|
|
input: CreateWorkspaceDocumentInput;
|
|
};
|
|
|
|
|
|
export type MutationdeleteWorkspaceDocumentArgs = {
|
|
id: Scalars['ID']['input'];
|
|
};
|
|
|
|
|
|
export type MutationlogPilotNoteArgs = {
|
|
text: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type MutationloginArgs = {
|
|
password: Scalars['String']['input'];
|
|
phone: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type MutationmarkThreadReadArgs = {
|
|
contactId: Scalars['ID']['input'];
|
|
};
|
|
|
|
|
|
export type MutationrollbackChangeSetItemsArgs = {
|
|
changeSetId: Scalars['ID']['input'];
|
|
itemIds: Array<Scalars['ID']['input']>;
|
|
};
|
|
|
|
|
|
export type MutationselectChatConversationArgs = {
|
|
id: Scalars['ID']['input'];
|
|
};
|
|
|
|
|
|
export type MutationsendPilotMessageArgs = {
|
|
text: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type MutationsetContactInboxHiddenArgs = {
|
|
hidden: Scalars['Boolean']['input'];
|
|
inboxId: Scalars['ID']['input'];
|
|
};
|
|
|
|
|
|
export type MutationtoggleContactPinArgs = {
|
|
contact: Scalars['String']['input'];
|
|
text: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type MutationupdateCommunicationTranscriptArgs = {
|
|
id: Scalars['ID']['input'];
|
|
transcript: Array<Scalars['String']['input']>;
|
|
};
|
|
|
|
|
|
export type MutationupdateDealArgs = {
|
|
input: UpdateDealInput;
|
|
};
|
|
|
|
|
|
export type MutationupdateFeedDecisionArgs = {
|
|
decision: Scalars['String']['input'];
|
|
decisionNote?: InputMaybe<Scalars['String']['input']>;
|
|
id: Scalars['ID']['input'];
|
|
};
|
|
|
|
export type MutationResult = {
|
|
__typename?: 'MutationResult';
|
|
ok: Scalars['Boolean']['output'];
|
|
};
|
|
|
|
export type MutationWithIdResult = {
|
|
__typename?: 'MutationWithIdResult';
|
|
id: Scalars['ID']['output'];
|
|
ok: Scalars['Boolean']['output'];
|
|
};
|
|
|
|
export type PilotChangeItem = {
|
|
__typename?: 'PilotChangeItem';
|
|
action: Scalars['String']['output'];
|
|
after: Scalars['String']['output'];
|
|
before: Scalars['String']['output'];
|
|
entity: Scalars['String']['output'];
|
|
entityId?: Maybe<Scalars['String']['output']>;
|
|
id: Scalars['ID']['output'];
|
|
rolledBack: Scalars['Boolean']['output'];
|
|
title: Scalars['String']['output'];
|
|
};
|
|
|
|
export type PilotMessage = {
|
|
__typename?: 'PilotMessage';
|
|
changeItems: Array<PilotChangeItem>;
|
|
changeSetId?: Maybe<Scalars['String']['output']>;
|
|
changeStatus?: Maybe<Scalars['String']['output']>;
|
|
changeSummary?: Maybe<Scalars['String']['output']>;
|
|
createdAt: Scalars['String']['output'];
|
|
eventType?: Maybe<Scalars['String']['output']>;
|
|
id: Scalars['ID']['output'];
|
|
messageKind?: Maybe<Scalars['String']['output']>;
|
|
phase?: Maybe<Scalars['String']['output']>;
|
|
requestId?: Maybe<Scalars['String']['output']>;
|
|
role: Scalars['String']['output'];
|
|
text: Scalars['String']['output'];
|
|
thinking: Array<Scalars['String']['output']>;
|
|
toolRuns: Array<PilotToolRun>;
|
|
tools: Array<Scalars['String']['output']>;
|
|
transient?: Maybe<Scalars['Boolean']['output']>;
|
|
};
|
|
|
|
export type PilotToolRun = {
|
|
__typename?: 'PilotToolRun';
|
|
at: Scalars['String']['output'];
|
|
input: Scalars['String']['output'];
|
|
name: Scalars['String']['output'];
|
|
output: Scalars['String']['output'];
|
|
status: Scalars['String']['output'];
|
|
};
|
|
|
|
export type PinToggleResult = {
|
|
__typename?: 'PinToggleResult';
|
|
ok: Scalars['Boolean']['output'];
|
|
pinned: Scalars['Boolean']['output'];
|
|
};
|
|
|
|
export type Query = {
|
|
__typename?: 'Query';
|
|
calendar: Array<CalendarEvent>;
|
|
chatConversations: Array<Conversation>;
|
|
chatMessages: Array<PilotMessage>;
|
|
communications: Array<CommItem>;
|
|
contactInboxes: Array<ContactInbox>;
|
|
contacts: Array<Contact>;
|
|
deals: Array<Deal>;
|
|
documents: Array<WorkspaceDocument>;
|
|
feed: Array<FeedCard>;
|
|
getClientTimeline: Array<ClientTimelineItem>;
|
|
me: MePayload;
|
|
pins: Array<CommPin>;
|
|
};
|
|
|
|
|
|
export type QuerycalendarArgs = {
|
|
dateRange?: InputMaybe<CalendarDateRange>;
|
|
};
|
|
|
|
|
|
export type QuerygetClientTimelineArgs = {
|
|
contactId: Scalars['ID']['input'];
|
|
limit?: InputMaybe<Scalars['Int']['input']>;
|
|
};
|
|
|
|
export type UpdateDealInput = {
|
|
amount?: InputMaybe<Scalars['Int']['input']>;
|
|
id: Scalars['ID']['input'];
|
|
paidAmount?: InputMaybe<Scalars['Int']['input']>;
|
|
stage?: InputMaybe<Scalars['String']['input']>;
|
|
};
|
|
|
|
export type WorkspaceDocument = {
|
|
__typename?: 'WorkspaceDocument';
|
|
body: Scalars['String']['output'];
|
|
id: Scalars['ID']['output'];
|
|
owner: Scalars['String']['output'];
|
|
scope: Scalars['String']['output'];
|
|
summary: Scalars['String']['output'];
|
|
title: Scalars['String']['output'];
|
|
type: Scalars['String']['output'];
|
|
updatedAt: Scalars['String']['output'];
|
|
};
|
|
|
|
export type ArchiveCalendarEventMutationMutationVariables = Exact<{
|
|
input: ArchiveCalendarEventInput;
|
|
}>;
|
|
|
|
|
|
export type ArchiveCalendarEventMutationMutation = { __typename?: 'Mutation', archiveCalendarEvent: { __typename?: 'CalendarEvent', id: string, title: string, start: string, end: string, contact: string, note: string, isArchived: boolean, createdAt: string, archiveNote: string, archivedAt: string } };
|
|
|
|
export type ArchiveChatConversationMutationMutationVariables = Exact<{
|
|
id: Scalars['ID']['input'];
|
|
}>;
|
|
|
|
|
|
export type ArchiveChatConversationMutationMutation = { __typename?: 'Mutation', archiveChatConversation: { __typename?: 'MutationResult', ok: boolean } };
|
|
|
|
export type CalendarQueryQueryVariables = Exact<{
|
|
from?: InputMaybe<Scalars['String']['input']>;
|
|
to?: InputMaybe<Scalars['String']['input']>;
|
|
}>;
|
|
|
|
|
|
export type CalendarQueryQuery = { __typename?: 'Query', calendar: Array<{ __typename?: 'CalendarEvent', id: string, title: string, start: string, end: string, contact: string, note: string, isArchived: boolean, createdAt: string, archiveNote: string, archivedAt: string }> };
|
|
|
|
export type ChatConversationsQueryQueryVariables = Exact<{ [key: string]: never; }>;
|
|
|
|
|
|
export type ChatConversationsQueryQuery = { __typename?: 'Query', chatConversations: Array<{ __typename?: 'Conversation', id: string, title: string, createdAt: string, updatedAt: string, lastMessageAt?: string | null, lastMessageText?: string | null }> };
|
|
|
|
export type ChatMessagesQueryQueryVariables = Exact<{ [key: string]: never; }>;
|
|
|
|
|
|
export type ChatMessagesQueryQuery = { __typename?: 'Query', chatMessages: Array<{ __typename?: 'PilotMessage', id: string, role: string, text: string, messageKind?: string | null, requestId?: string | null, eventType?: string | null, phase?: string | null, transient?: boolean | null, thinking: Array<string>, tools: Array<string>, changeSetId?: string | null, changeStatus?: string | null, changeSummary?: string | null, createdAt: string, toolRuns: Array<{ __typename?: 'PilotToolRun', name: string, status: string, input: string, output: string, at: string }>, changeItems: Array<{ __typename?: 'PilotChangeItem', id: string, entity: string, entityId?: string | null, action: string, title: string, before: string, after: string, rolledBack: boolean }> }> };
|
|
|
|
export type CommunicationsQueryQueryVariables = Exact<{ [key: string]: never; }>;
|
|
|
|
|
|
export type CommunicationsQueryQuery = { __typename?: 'Query', communications: Array<{ __typename?: 'CommItem', id: string, at: string, contactId: string, contact: string, contactInboxId: string, sourceExternalId: string, sourceTitle: string, channel: string, kind: string, direction: string, text: string, audioUrl: string, duration: string, waveform: Array<number>, transcript: Array<string>, deliveryStatus?: string | null }> };
|
|
|
|
export type ConfirmLatestChangeSetMutationMutationVariables = Exact<{ [key: string]: never; }>;
|
|
|
|
|
|
export type ConfirmLatestChangeSetMutationMutation = { __typename?: 'Mutation', confirmLatestChangeSet: { __typename?: 'MutationResult', ok: boolean } };
|
|
|
|
export type ContactInboxesQueryQueryVariables = Exact<{ [key: string]: never; }>;
|
|
|
|
|
|
export type ContactInboxesQueryQuery = { __typename?: 'Query', contactInboxes: Array<{ __typename?: 'ContactInbox', id: string, contactId: string, contactName: string, channel: string, sourceExternalId: string, title: string, isHidden: boolean, lastMessageAt: string, updatedAt: string }> };
|
|
|
|
export type ContactsQueryQueryVariables = Exact<{ [key: string]: never; }>;
|
|
|
|
|
|
export type ContactsQueryQuery = { __typename?: 'Query', contacts: Array<{ __typename?: 'Contact', id: string, name: string, avatar: string, channels: Array<string>, lastContactAt: string, lastMessageText: string, lastMessageChannel: string, hasUnread: boolean, description: string }> };
|
|
|
|
export type CreateCalendarEventMutationMutationVariables = Exact<{
|
|
input: CreateCalendarEventInput;
|
|
}>;
|
|
|
|
|
|
export type CreateCalendarEventMutationMutation = { __typename?: 'Mutation', createCalendarEvent: { __typename?: 'CalendarEvent', id: string, title: string, start: string, end: string, contact: string, note: string, isArchived: boolean, createdAt: string, archiveNote: string, archivedAt: string } };
|
|
|
|
export type CreateChatConversationMutationMutationVariables = Exact<{
|
|
title?: InputMaybe<Scalars['String']['input']>;
|
|
}>;
|
|
|
|
|
|
export type CreateChatConversationMutationMutation = { __typename?: 'Mutation', createChatConversation: { __typename?: 'Conversation', id: string, title: string, createdAt: string, updatedAt: string, lastMessageAt?: string | null, lastMessageText?: string | null } };
|
|
|
|
export type CreateCommunicationMutationMutationVariables = Exact<{
|
|
input: CreateCommunicationInput;
|
|
}>;
|
|
|
|
|
|
export type CreateCommunicationMutationMutation = { __typename?: 'Mutation', createCommunication: { __typename?: 'MutationWithIdResult', ok: boolean, id: string } };
|
|
|
|
export type CreateDealMutationMutationVariables = Exact<{
|
|
input: CreateDealInput;
|
|
}>;
|
|
|
|
|
|
export type CreateDealMutationMutation = { __typename?: 'Mutation', createDeal: { __typename?: 'Deal', id: string, contact: string, title: string, stage: string, amount: string, paidAmount: string, nextStep: string, summary: string, currentStepId: string, steps: Array<{ __typename?: 'DealStep', id: string, title: string, description: string, status: string, dueAt: string, order: number, completedAt: string }> } };
|
|
|
|
export type CreateWorkspaceDocumentMutationVariables = Exact<{
|
|
input: CreateWorkspaceDocumentInput;
|
|
}>;
|
|
|
|
|
|
export type CreateWorkspaceDocumentMutation = { __typename?: 'Mutation', createWorkspaceDocument: { __typename?: 'WorkspaceDocument', id: string, title: string, type: string, owner: string, scope: string, updatedAt: string, summary: string, body: string } };
|
|
|
|
export type DealsQueryQueryVariables = Exact<{ [key: string]: never; }>;
|
|
|
|
|
|
export type DealsQueryQuery = { __typename?: 'Query', deals: Array<{ __typename?: 'Deal', id: string, contact: string, title: string, stage: string, amount: string, paidAmount: string, nextStep: string, summary: string, currentStepId: string, steps: Array<{ __typename?: 'DealStep', id: string, title: string, description: string, status: string, dueAt: string, order: number, completedAt: string }> }> };
|
|
|
|
export type DeleteWorkspaceDocumentMutationVariables = Exact<{
|
|
id: Scalars['ID']['input'];
|
|
}>;
|
|
|
|
|
|
export type DeleteWorkspaceDocumentMutation = { __typename?: 'Mutation', deleteWorkspaceDocument: { __typename?: 'MutationWithIdResult', ok: boolean, id: string } };
|
|
|
|
export type DocumentsQueryQueryVariables = Exact<{ [key: string]: never; }>;
|
|
|
|
|
|
export type DocumentsQueryQuery = { __typename?: 'Query', documents: Array<{ __typename?: 'WorkspaceDocument', id: string, title: string, type: string, owner: string, scope: string, updatedAt: string, summary: string, body: string }> };
|
|
|
|
export type FeedQueryQueryVariables = Exact<{ [key: string]: never; }>;
|
|
|
|
|
|
export type FeedQueryQuery = { __typename?: 'Query', feed: Array<{ __typename?: 'FeedCard', id: string, at: string, contact: string, text: string, decision: string, decisionNote: string, proposal: { __typename?: 'FeedProposal', title: string, details: Array<string>, key: string } }> };
|
|
|
|
export type GetClientTimelineQueryQueryVariables = Exact<{
|
|
contactId: Scalars['ID']['input'];
|
|
limit?: InputMaybe<Scalars['Int']['input']>;
|
|
}>;
|
|
|
|
|
|
export type GetClientTimelineQueryQuery = { __typename?: 'Query', getClientTimeline: Array<{ __typename?: 'ClientTimelineItem', id: string, contactId: string, contentType: string, contentId: string, datetime: string, message?: { __typename?: 'CommItem', id: string, at: string, contactId: string, contact: string, contactInboxId: string, sourceExternalId: string, sourceTitle: string, channel: string, kind: string, direction: string, text: string, audioUrl: string, duration: string, waveform: Array<number>, transcript: Array<string>, deliveryStatus?: string | null } | null, calendarEvent?: { __typename?: 'CalendarEvent', id: string, title: string, start: string, end: string, contact: string, note: string, isArchived: boolean, createdAt: string, archiveNote: string, archivedAt: string } | null, recommendation?: { __typename?: 'FeedCard', id: string, at: string, contact: string, text: string, decision: string, decisionNote: string, proposal: { __typename?: 'FeedProposal', title: string, details: Array<string>, key: string } } | null, document?: { __typename?: 'WorkspaceDocument', id: string, title: string, type: string, owner: string, scope: string, updatedAt: string, summary: string, body: string } | null }> };
|
|
|
|
export type LogPilotNoteMutationMutationVariables = Exact<{
|
|
text: Scalars['String']['input'];
|
|
}>;
|
|
|
|
|
|
export type LogPilotNoteMutationMutation = { __typename?: 'Mutation', logPilotNote: { __typename?: 'MutationResult', ok: boolean } };
|
|
|
|
export type LoginMutationMutationVariables = Exact<{
|
|
phone: Scalars['String']['input'];
|
|
password: Scalars['String']['input'];
|
|
}>;
|
|
|
|
|
|
export type LoginMutationMutation = { __typename?: 'Mutation', login: { __typename?: 'MutationResult', ok: boolean } };
|
|
|
|
export type LogoutMutationMutationVariables = Exact<{ [key: string]: never; }>;
|
|
|
|
|
|
export type LogoutMutationMutation = { __typename?: 'Mutation', logout: { __typename?: 'MutationResult', ok: boolean } };
|
|
|
|
export type MarkThreadReadMutationVariables = Exact<{
|
|
contactId: Scalars['ID']['input'];
|
|
}>;
|
|
|
|
|
|
export type MarkThreadReadMutation = { __typename?: 'Mutation', markThreadRead: { __typename?: 'MutationResult', ok: boolean } };
|
|
|
|
export type MeQueryQueryVariables = Exact<{ [key: string]: never; }>;
|
|
|
|
|
|
export type MeQueryQuery = { __typename?: 'Query', me: { __typename?: 'MePayload', user: { __typename?: 'MeUser', id: string, phone: string, name: string }, team: { __typename?: 'MeTeam', id: string, name: string }, conversation: { __typename?: 'Conversation', id: string, title: string } } };
|
|
|
|
export type PinsQueryQueryVariables = Exact<{ [key: string]: never; }>;
|
|
|
|
|
|
export type PinsQueryQuery = { __typename?: 'Query', pins: Array<{ __typename?: 'CommPin', id: string, contact: string, text: string }> };
|
|
|
|
export type RollbackChangeSetItemsMutationMutationVariables = Exact<{
|
|
changeSetId: Scalars['ID']['input'];
|
|
itemIds: Array<Scalars['ID']['input']> | Scalars['ID']['input'];
|
|
}>;
|
|
|
|
|
|
export type RollbackChangeSetItemsMutationMutation = { __typename?: 'Mutation', rollbackChangeSetItems: { __typename?: 'MutationResult', ok: boolean } };
|
|
|
|
export type RollbackLatestChangeSetMutationMutationVariables = Exact<{ [key: string]: never; }>;
|
|
|
|
|
|
export type RollbackLatestChangeSetMutationMutation = { __typename?: 'Mutation', rollbackLatestChangeSet: { __typename?: 'MutationResult', ok: boolean } };
|
|
|
|
export type SelectChatConversationMutationMutationVariables = Exact<{
|
|
id: Scalars['ID']['input'];
|
|
}>;
|
|
|
|
|
|
export type SelectChatConversationMutationMutation = { __typename?: 'Mutation', selectChatConversation: { __typename?: 'MutationResult', ok: boolean } };
|
|
|
|
export type SendPilotMessageMutationMutationVariables = Exact<{
|
|
text: Scalars['String']['input'];
|
|
}>;
|
|
|
|
|
|
export type SendPilotMessageMutationMutation = { __typename?: 'Mutation', sendPilotMessage: { __typename?: 'MutationResult', ok: boolean } };
|
|
|
|
export type SetContactInboxHiddenMutationVariables = Exact<{
|
|
inboxId: Scalars['ID']['input'];
|
|
hidden: Scalars['Boolean']['input'];
|
|
}>;
|
|
|
|
|
|
export type SetContactInboxHiddenMutation = { __typename?: 'Mutation', setContactInboxHidden: { __typename?: 'MutationResult', ok: boolean } };
|
|
|
|
export type ToggleContactPinMutationMutationVariables = Exact<{
|
|
contact: Scalars['String']['input'];
|
|
text: Scalars['String']['input'];
|
|
}>;
|
|
|
|
|
|
export type ToggleContactPinMutationMutation = { __typename?: 'Mutation', toggleContactPin: { __typename?: 'PinToggleResult', ok: boolean, pinned: boolean } };
|
|
|
|
export type UpdateCommunicationTranscriptMutationMutationVariables = Exact<{
|
|
id: Scalars['ID']['input'];
|
|
transcript: Array<Scalars['String']['input']> | Scalars['String']['input'];
|
|
}>;
|
|
|
|
|
|
export type UpdateCommunicationTranscriptMutationMutation = { __typename?: 'Mutation', updateCommunicationTranscript: { __typename?: 'MutationWithIdResult', ok: boolean, id: string } };
|
|
|
|
export type UpdateDealMutationMutationVariables = Exact<{
|
|
input: UpdateDealInput;
|
|
}>;
|
|
|
|
|
|
export type UpdateDealMutationMutation = { __typename?: 'Mutation', updateDeal: { __typename?: 'Deal', id: string, contact: string, title: string, stage: string, amount: string, paidAmount: string, nextStep: string, summary: string, currentStepId: string, steps: Array<{ __typename?: 'DealStep', id: string, title: string, description: string, status: string, dueAt: string, order: number, completedAt: string }> } };
|
|
|
|
export type UpdateFeedDecisionMutationMutationVariables = Exact<{
|
|
id: Scalars['ID']['input'];
|
|
decision: Scalars['String']['input'];
|
|
decisionNote?: InputMaybe<Scalars['String']['input']>;
|
|
}>;
|
|
|
|
|
|
export type UpdateFeedDecisionMutationMutation = { __typename?: 'Mutation', updateFeedDecision: { __typename?: 'MutationWithIdResult', ok: boolean, id: string } };
|
|
|
|
|
|
export const ArchiveCalendarEventMutationDocument = gql`
|
|
mutation ArchiveCalendarEventMutation($input: ArchiveCalendarEventInput!) {
|
|
archiveCalendarEvent(input: $input) {
|
|
id
|
|
title
|
|
start
|
|
end
|
|
contact
|
|
note
|
|
isArchived
|
|
createdAt
|
|
archiveNote
|
|
archivedAt
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __useArchiveCalendarEventMutationMutation__
|
|
*
|
|
* To run a mutation, you first call `useArchiveCalendarEventMutationMutation` within a Vue component and pass it any options that fit your needs.
|
|
* When your component renders, `useArchiveCalendarEventMutationMutation` returns an object that includes:
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
* - Several other properties: https://v4.apollo.vuejs.org/api/use-mutation.html#return
|
|
*
|
|
* @param options that will be passed into the mutation, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/mutation.html#options;
|
|
*
|
|
* @example
|
|
* const { mutate, loading, error, onDone } = useArchiveCalendarEventMutationMutation({
|
|
* variables: {
|
|
* input: // value for 'input'
|
|
* },
|
|
* });
|
|
*/
|
|
export function useArchiveCalendarEventMutationMutation(options: VueApolloComposable.UseMutationOptions<ArchiveCalendarEventMutationMutation, ArchiveCalendarEventMutationMutationVariables> | ReactiveFunction<VueApolloComposable.UseMutationOptions<ArchiveCalendarEventMutationMutation, ArchiveCalendarEventMutationMutationVariables>> = {}) {
|
|
return VueApolloComposable.useMutation<ArchiveCalendarEventMutationMutation, ArchiveCalendarEventMutationMutationVariables>(ArchiveCalendarEventMutationDocument, options);
|
|
}
|
|
export type ArchiveCalendarEventMutationMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<ArchiveCalendarEventMutationMutation, ArchiveCalendarEventMutationMutationVariables>;
|
|
export const ArchiveChatConversationMutationDocument = gql`
|
|
mutation ArchiveChatConversationMutation($id: ID!) {
|
|
archiveChatConversation(id: $id) {
|
|
ok
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __useArchiveChatConversationMutationMutation__
|
|
*
|
|
* To run a mutation, you first call `useArchiveChatConversationMutationMutation` within a Vue component and pass it any options that fit your needs.
|
|
* When your component renders, `useArchiveChatConversationMutationMutation` returns an object that includes:
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
* - Several other properties: https://v4.apollo.vuejs.org/api/use-mutation.html#return
|
|
*
|
|
* @param options that will be passed into the mutation, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/mutation.html#options;
|
|
*
|
|
* @example
|
|
* const { mutate, loading, error, onDone } = useArchiveChatConversationMutationMutation({
|
|
* variables: {
|
|
* id: // value for 'id'
|
|
* },
|
|
* });
|
|
*/
|
|
export function useArchiveChatConversationMutationMutation(options: VueApolloComposable.UseMutationOptions<ArchiveChatConversationMutationMutation, ArchiveChatConversationMutationMutationVariables> | ReactiveFunction<VueApolloComposable.UseMutationOptions<ArchiveChatConversationMutationMutation, ArchiveChatConversationMutationMutationVariables>> = {}) {
|
|
return VueApolloComposable.useMutation<ArchiveChatConversationMutationMutation, ArchiveChatConversationMutationMutationVariables>(ArchiveChatConversationMutationDocument, options);
|
|
}
|
|
export type ArchiveChatConversationMutationMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<ArchiveChatConversationMutationMutation, ArchiveChatConversationMutationMutationVariables>;
|
|
export const CalendarQueryDocument = gql`
|
|
query CalendarQuery($from: String, $to: String) {
|
|
calendar(dateRange: {from: $from, to: $to}) {
|
|
id
|
|
title
|
|
start
|
|
end
|
|
contact
|
|
note
|
|
isArchived
|
|
createdAt
|
|
archiveNote
|
|
archivedAt
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __useCalendarQueryQuery__
|
|
*
|
|
* To run a query within a Vue component, call `useCalendarQueryQuery` and pass it any options that fit your needs.
|
|
* When your component renders, `useCalendarQueryQuery` returns an object from Apollo Client that contains result, loading and error properties
|
|
* you can use to render your UI.
|
|
*
|
|
* @param variables that will be passed into the query
|
|
* @param options that will be passed into the query, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/query.html#options;
|
|
*
|
|
* @example
|
|
* const { result, loading, error } = useCalendarQueryQuery({
|
|
* from: // value for 'from'
|
|
* to: // value for 'to'
|
|
* });
|
|
*/
|
|
export function useCalendarQueryQuery(variables: CalendarQueryQueryVariables | VueCompositionApi.Ref<CalendarQueryQueryVariables> | ReactiveFunction<CalendarQueryQueryVariables> = {}, options: VueApolloComposable.UseQueryOptions<CalendarQueryQuery, CalendarQueryQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<CalendarQueryQuery, CalendarQueryQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<CalendarQueryQuery, CalendarQueryQueryVariables>> = {}) {
|
|
return VueApolloComposable.useQuery<CalendarQueryQuery, CalendarQueryQueryVariables>(CalendarQueryDocument, variables, options);
|
|
}
|
|
export function useCalendarQueryLazyQuery(variables: CalendarQueryQueryVariables | VueCompositionApi.Ref<CalendarQueryQueryVariables> | ReactiveFunction<CalendarQueryQueryVariables> = {}, options: VueApolloComposable.UseQueryOptions<CalendarQueryQuery, CalendarQueryQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<CalendarQueryQuery, CalendarQueryQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<CalendarQueryQuery, CalendarQueryQueryVariables>> = {}) {
|
|
return VueApolloComposable.useLazyQuery<CalendarQueryQuery, CalendarQueryQueryVariables>(CalendarQueryDocument, variables, options);
|
|
}
|
|
export type CalendarQueryQueryCompositionFunctionResult = VueApolloComposable.UseQueryReturn<CalendarQueryQuery, CalendarQueryQueryVariables>;
|
|
export const ChatConversationsQueryDocument = gql`
|
|
query ChatConversationsQuery {
|
|
chatConversations {
|
|
id
|
|
title
|
|
createdAt
|
|
updatedAt
|
|
lastMessageAt
|
|
lastMessageText
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __useChatConversationsQueryQuery__
|
|
*
|
|
* To run a query within a Vue component, call `useChatConversationsQueryQuery` and pass it any options that fit your needs.
|
|
* When your component renders, `useChatConversationsQueryQuery` returns an object from Apollo Client that contains result, loading and error properties
|
|
* you can use to render your UI.
|
|
*
|
|
* @param options that will be passed into the query, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/query.html#options;
|
|
*
|
|
* @example
|
|
* const { result, loading, error } = useChatConversationsQueryQuery();
|
|
*/
|
|
export function useChatConversationsQueryQuery(options: VueApolloComposable.UseQueryOptions<ChatConversationsQueryQuery, ChatConversationsQueryQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<ChatConversationsQueryQuery, ChatConversationsQueryQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<ChatConversationsQueryQuery, ChatConversationsQueryQueryVariables>> = {}) {
|
|
return VueApolloComposable.useQuery<ChatConversationsQueryQuery, ChatConversationsQueryQueryVariables>(ChatConversationsQueryDocument, {}, options);
|
|
}
|
|
export function useChatConversationsQueryLazyQuery(options: VueApolloComposable.UseQueryOptions<ChatConversationsQueryQuery, ChatConversationsQueryQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<ChatConversationsQueryQuery, ChatConversationsQueryQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<ChatConversationsQueryQuery, ChatConversationsQueryQueryVariables>> = {}) {
|
|
return VueApolloComposable.useLazyQuery<ChatConversationsQueryQuery, ChatConversationsQueryQueryVariables>(ChatConversationsQueryDocument, {}, options);
|
|
}
|
|
export type ChatConversationsQueryQueryCompositionFunctionResult = VueApolloComposable.UseQueryReturn<ChatConversationsQueryQuery, ChatConversationsQueryQueryVariables>;
|
|
export const ChatMessagesQueryDocument = gql`
|
|
query ChatMessagesQuery {
|
|
chatMessages {
|
|
id
|
|
role
|
|
text
|
|
messageKind
|
|
requestId
|
|
eventType
|
|
phase
|
|
transient
|
|
thinking
|
|
tools
|
|
toolRuns {
|
|
name
|
|
status
|
|
input
|
|
output
|
|
at
|
|
}
|
|
changeSetId
|
|
changeStatus
|
|
changeSummary
|
|
changeItems {
|
|
id
|
|
entity
|
|
entityId
|
|
action
|
|
title
|
|
before
|
|
after
|
|
rolledBack
|
|
}
|
|
createdAt
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __useChatMessagesQueryQuery__
|
|
*
|
|
* To run a query within a Vue component, call `useChatMessagesQueryQuery` and pass it any options that fit your needs.
|
|
* When your component renders, `useChatMessagesQueryQuery` returns an object from Apollo Client that contains result, loading and error properties
|
|
* you can use to render your UI.
|
|
*
|
|
* @param options that will be passed into the query, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/query.html#options;
|
|
*
|
|
* @example
|
|
* const { result, loading, error } = useChatMessagesQueryQuery();
|
|
*/
|
|
export function useChatMessagesQueryQuery(options: VueApolloComposable.UseQueryOptions<ChatMessagesQueryQuery, ChatMessagesQueryQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<ChatMessagesQueryQuery, ChatMessagesQueryQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<ChatMessagesQueryQuery, ChatMessagesQueryQueryVariables>> = {}) {
|
|
return VueApolloComposable.useQuery<ChatMessagesQueryQuery, ChatMessagesQueryQueryVariables>(ChatMessagesQueryDocument, {}, options);
|
|
}
|
|
export function useChatMessagesQueryLazyQuery(options: VueApolloComposable.UseQueryOptions<ChatMessagesQueryQuery, ChatMessagesQueryQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<ChatMessagesQueryQuery, ChatMessagesQueryQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<ChatMessagesQueryQuery, ChatMessagesQueryQueryVariables>> = {}) {
|
|
return VueApolloComposable.useLazyQuery<ChatMessagesQueryQuery, ChatMessagesQueryQueryVariables>(ChatMessagesQueryDocument, {}, options);
|
|
}
|
|
export type ChatMessagesQueryQueryCompositionFunctionResult = VueApolloComposable.UseQueryReturn<ChatMessagesQueryQuery, ChatMessagesQueryQueryVariables>;
|
|
export const CommunicationsQueryDocument = gql`
|
|
query CommunicationsQuery {
|
|
communications {
|
|
id
|
|
at
|
|
contactId
|
|
contact
|
|
contactInboxId
|
|
sourceExternalId
|
|
sourceTitle
|
|
channel
|
|
kind
|
|
direction
|
|
text
|
|
audioUrl
|
|
duration
|
|
waveform
|
|
transcript
|
|
deliveryStatus
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __useCommunicationsQueryQuery__
|
|
*
|
|
* To run a query within a Vue component, call `useCommunicationsQueryQuery` and pass it any options that fit your needs.
|
|
* When your component renders, `useCommunicationsQueryQuery` returns an object from Apollo Client that contains result, loading and error properties
|
|
* you can use to render your UI.
|
|
*
|
|
* @param options that will be passed into the query, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/query.html#options;
|
|
*
|
|
* @example
|
|
* const { result, loading, error } = useCommunicationsQueryQuery();
|
|
*/
|
|
export function useCommunicationsQueryQuery(options: VueApolloComposable.UseQueryOptions<CommunicationsQueryQuery, CommunicationsQueryQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<CommunicationsQueryQuery, CommunicationsQueryQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<CommunicationsQueryQuery, CommunicationsQueryQueryVariables>> = {}) {
|
|
return VueApolloComposable.useQuery<CommunicationsQueryQuery, CommunicationsQueryQueryVariables>(CommunicationsQueryDocument, {}, options);
|
|
}
|
|
export function useCommunicationsQueryLazyQuery(options: VueApolloComposable.UseQueryOptions<CommunicationsQueryQuery, CommunicationsQueryQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<CommunicationsQueryQuery, CommunicationsQueryQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<CommunicationsQueryQuery, CommunicationsQueryQueryVariables>> = {}) {
|
|
return VueApolloComposable.useLazyQuery<CommunicationsQueryQuery, CommunicationsQueryQueryVariables>(CommunicationsQueryDocument, {}, options);
|
|
}
|
|
export type CommunicationsQueryQueryCompositionFunctionResult = VueApolloComposable.UseQueryReturn<CommunicationsQueryQuery, CommunicationsQueryQueryVariables>;
|
|
export const ConfirmLatestChangeSetMutationDocument = gql`
|
|
mutation ConfirmLatestChangeSetMutation {
|
|
confirmLatestChangeSet {
|
|
ok
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __useConfirmLatestChangeSetMutationMutation__
|
|
*
|
|
* To run a mutation, you first call `useConfirmLatestChangeSetMutationMutation` within a Vue component and pass it any options that fit your needs.
|
|
* When your component renders, `useConfirmLatestChangeSetMutationMutation` returns an object that includes:
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
* - Several other properties: https://v4.apollo.vuejs.org/api/use-mutation.html#return
|
|
*
|
|
* @param options that will be passed into the mutation, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/mutation.html#options;
|
|
*
|
|
* @example
|
|
* const { mutate, loading, error, onDone } = useConfirmLatestChangeSetMutationMutation();
|
|
*/
|
|
export function useConfirmLatestChangeSetMutationMutation(options: VueApolloComposable.UseMutationOptions<ConfirmLatestChangeSetMutationMutation, ConfirmLatestChangeSetMutationMutationVariables> | ReactiveFunction<VueApolloComposable.UseMutationOptions<ConfirmLatestChangeSetMutationMutation, ConfirmLatestChangeSetMutationMutationVariables>> = {}) {
|
|
return VueApolloComposable.useMutation<ConfirmLatestChangeSetMutationMutation, ConfirmLatestChangeSetMutationMutationVariables>(ConfirmLatestChangeSetMutationDocument, options);
|
|
}
|
|
export type ConfirmLatestChangeSetMutationMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<ConfirmLatestChangeSetMutationMutation, ConfirmLatestChangeSetMutationMutationVariables>;
|
|
export const ContactInboxesQueryDocument = gql`
|
|
query ContactInboxesQuery {
|
|
contactInboxes {
|
|
id
|
|
contactId
|
|
contactName
|
|
channel
|
|
sourceExternalId
|
|
title
|
|
isHidden
|
|
lastMessageAt
|
|
updatedAt
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __useContactInboxesQueryQuery__
|
|
*
|
|
* To run a query within a Vue component, call `useContactInboxesQueryQuery` and pass it any options that fit your needs.
|
|
* When your component renders, `useContactInboxesQueryQuery` returns an object from Apollo Client that contains result, loading and error properties
|
|
* you can use to render your UI.
|
|
*
|
|
* @param options that will be passed into the query, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/query.html#options;
|
|
*
|
|
* @example
|
|
* const { result, loading, error } = useContactInboxesQueryQuery();
|
|
*/
|
|
export function useContactInboxesQueryQuery(options: VueApolloComposable.UseQueryOptions<ContactInboxesQueryQuery, ContactInboxesQueryQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<ContactInboxesQueryQuery, ContactInboxesQueryQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<ContactInboxesQueryQuery, ContactInboxesQueryQueryVariables>> = {}) {
|
|
return VueApolloComposable.useQuery<ContactInboxesQueryQuery, ContactInboxesQueryQueryVariables>(ContactInboxesQueryDocument, {}, options);
|
|
}
|
|
export function useContactInboxesQueryLazyQuery(options: VueApolloComposable.UseQueryOptions<ContactInboxesQueryQuery, ContactInboxesQueryQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<ContactInboxesQueryQuery, ContactInboxesQueryQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<ContactInboxesQueryQuery, ContactInboxesQueryQueryVariables>> = {}) {
|
|
return VueApolloComposable.useLazyQuery<ContactInboxesQueryQuery, ContactInboxesQueryQueryVariables>(ContactInboxesQueryDocument, {}, options);
|
|
}
|
|
export type ContactInboxesQueryQueryCompositionFunctionResult = VueApolloComposable.UseQueryReturn<ContactInboxesQueryQuery, ContactInboxesQueryQueryVariables>;
|
|
export const ContactsQueryDocument = gql`
|
|
query ContactsQuery {
|
|
contacts {
|
|
id
|
|
name
|
|
avatar
|
|
channels
|
|
lastContactAt
|
|
lastMessageText
|
|
lastMessageChannel
|
|
hasUnread
|
|
description
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __useContactsQueryQuery__
|
|
*
|
|
* To run a query within a Vue component, call `useContactsQueryQuery` and pass it any options that fit your needs.
|
|
* When your component renders, `useContactsQueryQuery` returns an object from Apollo Client that contains result, loading and error properties
|
|
* you can use to render your UI.
|
|
*
|
|
* @param options that will be passed into the query, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/query.html#options;
|
|
*
|
|
* @example
|
|
* const { result, loading, error } = useContactsQueryQuery();
|
|
*/
|
|
export function useContactsQueryQuery(options: VueApolloComposable.UseQueryOptions<ContactsQueryQuery, ContactsQueryQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<ContactsQueryQuery, ContactsQueryQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<ContactsQueryQuery, ContactsQueryQueryVariables>> = {}) {
|
|
return VueApolloComposable.useQuery<ContactsQueryQuery, ContactsQueryQueryVariables>(ContactsQueryDocument, {}, options);
|
|
}
|
|
export function useContactsQueryLazyQuery(options: VueApolloComposable.UseQueryOptions<ContactsQueryQuery, ContactsQueryQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<ContactsQueryQuery, ContactsQueryQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<ContactsQueryQuery, ContactsQueryQueryVariables>> = {}) {
|
|
return VueApolloComposable.useLazyQuery<ContactsQueryQuery, ContactsQueryQueryVariables>(ContactsQueryDocument, {}, options);
|
|
}
|
|
export type ContactsQueryQueryCompositionFunctionResult = VueApolloComposable.UseQueryReturn<ContactsQueryQuery, ContactsQueryQueryVariables>;
|
|
export const CreateCalendarEventMutationDocument = gql`
|
|
mutation CreateCalendarEventMutation($input: CreateCalendarEventInput!) {
|
|
createCalendarEvent(input: $input) {
|
|
id
|
|
title
|
|
start
|
|
end
|
|
contact
|
|
note
|
|
isArchived
|
|
createdAt
|
|
archiveNote
|
|
archivedAt
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __useCreateCalendarEventMutationMutation__
|
|
*
|
|
* To run a mutation, you first call `useCreateCalendarEventMutationMutation` within a Vue component and pass it any options that fit your needs.
|
|
* When your component renders, `useCreateCalendarEventMutationMutation` returns an object that includes:
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
* - Several other properties: https://v4.apollo.vuejs.org/api/use-mutation.html#return
|
|
*
|
|
* @param options that will be passed into the mutation, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/mutation.html#options;
|
|
*
|
|
* @example
|
|
* const { mutate, loading, error, onDone } = useCreateCalendarEventMutationMutation({
|
|
* variables: {
|
|
* input: // value for 'input'
|
|
* },
|
|
* });
|
|
*/
|
|
export function useCreateCalendarEventMutationMutation(options: VueApolloComposable.UseMutationOptions<CreateCalendarEventMutationMutation, CreateCalendarEventMutationMutationVariables> | ReactiveFunction<VueApolloComposable.UseMutationOptions<CreateCalendarEventMutationMutation, CreateCalendarEventMutationMutationVariables>> = {}) {
|
|
return VueApolloComposable.useMutation<CreateCalendarEventMutationMutation, CreateCalendarEventMutationMutationVariables>(CreateCalendarEventMutationDocument, options);
|
|
}
|
|
export type CreateCalendarEventMutationMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<CreateCalendarEventMutationMutation, CreateCalendarEventMutationMutationVariables>;
|
|
export const CreateChatConversationMutationDocument = gql`
|
|
mutation CreateChatConversationMutation($title: String) {
|
|
createChatConversation(title: $title) {
|
|
id
|
|
title
|
|
createdAt
|
|
updatedAt
|
|
lastMessageAt
|
|
lastMessageText
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __useCreateChatConversationMutationMutation__
|
|
*
|
|
* To run a mutation, you first call `useCreateChatConversationMutationMutation` within a Vue component and pass it any options that fit your needs.
|
|
* When your component renders, `useCreateChatConversationMutationMutation` returns an object that includes:
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
* - Several other properties: https://v4.apollo.vuejs.org/api/use-mutation.html#return
|
|
*
|
|
* @param options that will be passed into the mutation, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/mutation.html#options;
|
|
*
|
|
* @example
|
|
* const { mutate, loading, error, onDone } = useCreateChatConversationMutationMutation({
|
|
* variables: {
|
|
* title: // value for 'title'
|
|
* },
|
|
* });
|
|
*/
|
|
export function useCreateChatConversationMutationMutation(options: VueApolloComposable.UseMutationOptions<CreateChatConversationMutationMutation, CreateChatConversationMutationMutationVariables> | ReactiveFunction<VueApolloComposable.UseMutationOptions<CreateChatConversationMutationMutation, CreateChatConversationMutationMutationVariables>> = {}) {
|
|
return VueApolloComposable.useMutation<CreateChatConversationMutationMutation, CreateChatConversationMutationMutationVariables>(CreateChatConversationMutationDocument, options);
|
|
}
|
|
export type CreateChatConversationMutationMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<CreateChatConversationMutationMutation, CreateChatConversationMutationMutationVariables>;
|
|
export const CreateCommunicationMutationDocument = gql`
|
|
mutation CreateCommunicationMutation($input: CreateCommunicationInput!) {
|
|
createCommunication(input: $input) {
|
|
ok
|
|
id
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __useCreateCommunicationMutationMutation__
|
|
*
|
|
* To run a mutation, you first call `useCreateCommunicationMutationMutation` within a Vue component and pass it any options that fit your needs.
|
|
* When your component renders, `useCreateCommunicationMutationMutation` returns an object that includes:
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
* - Several other properties: https://v4.apollo.vuejs.org/api/use-mutation.html#return
|
|
*
|
|
* @param options that will be passed into the mutation, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/mutation.html#options;
|
|
*
|
|
* @example
|
|
* const { mutate, loading, error, onDone } = useCreateCommunicationMutationMutation({
|
|
* variables: {
|
|
* input: // value for 'input'
|
|
* },
|
|
* });
|
|
*/
|
|
export function useCreateCommunicationMutationMutation(options: VueApolloComposable.UseMutationOptions<CreateCommunicationMutationMutation, CreateCommunicationMutationMutationVariables> | ReactiveFunction<VueApolloComposable.UseMutationOptions<CreateCommunicationMutationMutation, CreateCommunicationMutationMutationVariables>> = {}) {
|
|
return VueApolloComposable.useMutation<CreateCommunicationMutationMutation, CreateCommunicationMutationMutationVariables>(CreateCommunicationMutationDocument, options);
|
|
}
|
|
export type CreateCommunicationMutationMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<CreateCommunicationMutationMutation, CreateCommunicationMutationMutationVariables>;
|
|
export const CreateDealMutationDocument = gql`
|
|
mutation CreateDealMutation($input: CreateDealInput!) {
|
|
createDeal(input: $input) {
|
|
id
|
|
contact
|
|
title
|
|
stage
|
|
amount
|
|
paidAmount
|
|
nextStep
|
|
summary
|
|
currentStepId
|
|
steps {
|
|
id
|
|
title
|
|
description
|
|
status
|
|
dueAt
|
|
order
|
|
completedAt
|
|
}
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __useCreateDealMutationMutation__
|
|
*
|
|
* To run a mutation, you first call `useCreateDealMutationMutation` within a Vue component and pass it any options that fit your needs.
|
|
* When your component renders, `useCreateDealMutationMutation` returns an object that includes:
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
* - Several other properties: https://v4.apollo.vuejs.org/api/use-mutation.html#return
|
|
*
|
|
* @param options that will be passed into the mutation, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/mutation.html#options;
|
|
*
|
|
* @example
|
|
* const { mutate, loading, error, onDone } = useCreateDealMutationMutation({
|
|
* variables: {
|
|
* input: // value for 'input'
|
|
* },
|
|
* });
|
|
*/
|
|
export function useCreateDealMutationMutation(options: VueApolloComposable.UseMutationOptions<CreateDealMutationMutation, CreateDealMutationMutationVariables> | ReactiveFunction<VueApolloComposable.UseMutationOptions<CreateDealMutationMutation, CreateDealMutationMutationVariables>> = {}) {
|
|
return VueApolloComposable.useMutation<CreateDealMutationMutation, CreateDealMutationMutationVariables>(CreateDealMutationDocument, options);
|
|
}
|
|
export type CreateDealMutationMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<CreateDealMutationMutation, CreateDealMutationMutationVariables>;
|
|
export const CreateWorkspaceDocumentDocument = gql`
|
|
mutation CreateWorkspaceDocument($input: CreateWorkspaceDocumentInput!) {
|
|
createWorkspaceDocument(input: $input) {
|
|
id
|
|
title
|
|
type
|
|
owner
|
|
scope
|
|
updatedAt
|
|
summary
|
|
body
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __useCreateWorkspaceDocumentMutation__
|
|
*
|
|
* To run a mutation, you first call `useCreateWorkspaceDocumentMutation` within a Vue component and pass it any options that fit your needs.
|
|
* When your component renders, `useCreateWorkspaceDocumentMutation` returns an object that includes:
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
* - Several other properties: https://v4.apollo.vuejs.org/api/use-mutation.html#return
|
|
*
|
|
* @param options that will be passed into the mutation, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/mutation.html#options;
|
|
*
|
|
* @example
|
|
* const { mutate, loading, error, onDone } = useCreateWorkspaceDocumentMutation({
|
|
* variables: {
|
|
* input: // value for 'input'
|
|
* },
|
|
* });
|
|
*/
|
|
export function useCreateWorkspaceDocumentMutation(options: VueApolloComposable.UseMutationOptions<CreateWorkspaceDocumentMutation, CreateWorkspaceDocumentMutationVariables> | ReactiveFunction<VueApolloComposable.UseMutationOptions<CreateWorkspaceDocumentMutation, CreateWorkspaceDocumentMutationVariables>> = {}) {
|
|
return VueApolloComposable.useMutation<CreateWorkspaceDocumentMutation, CreateWorkspaceDocumentMutationVariables>(CreateWorkspaceDocumentDocument, options);
|
|
}
|
|
export type CreateWorkspaceDocumentMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<CreateWorkspaceDocumentMutation, CreateWorkspaceDocumentMutationVariables>;
|
|
export const DealsQueryDocument = gql`
|
|
query DealsQuery {
|
|
deals {
|
|
id
|
|
contact
|
|
title
|
|
stage
|
|
amount
|
|
paidAmount
|
|
nextStep
|
|
summary
|
|
currentStepId
|
|
steps {
|
|
id
|
|
title
|
|
description
|
|
status
|
|
dueAt
|
|
order
|
|
completedAt
|
|
}
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __useDealsQueryQuery__
|
|
*
|
|
* To run a query within a Vue component, call `useDealsQueryQuery` and pass it any options that fit your needs.
|
|
* When your component renders, `useDealsQueryQuery` returns an object from Apollo Client that contains result, loading and error properties
|
|
* you can use to render your UI.
|
|
*
|
|
* @param options that will be passed into the query, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/query.html#options;
|
|
*
|
|
* @example
|
|
* const { result, loading, error } = useDealsQueryQuery();
|
|
*/
|
|
export function useDealsQueryQuery(options: VueApolloComposable.UseQueryOptions<DealsQueryQuery, DealsQueryQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<DealsQueryQuery, DealsQueryQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<DealsQueryQuery, DealsQueryQueryVariables>> = {}) {
|
|
return VueApolloComposable.useQuery<DealsQueryQuery, DealsQueryQueryVariables>(DealsQueryDocument, {}, options);
|
|
}
|
|
export function useDealsQueryLazyQuery(options: VueApolloComposable.UseQueryOptions<DealsQueryQuery, DealsQueryQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<DealsQueryQuery, DealsQueryQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<DealsQueryQuery, DealsQueryQueryVariables>> = {}) {
|
|
return VueApolloComposable.useLazyQuery<DealsQueryQuery, DealsQueryQueryVariables>(DealsQueryDocument, {}, options);
|
|
}
|
|
export type DealsQueryQueryCompositionFunctionResult = VueApolloComposable.UseQueryReturn<DealsQueryQuery, DealsQueryQueryVariables>;
|
|
export const DeleteWorkspaceDocumentDocument = gql`
|
|
mutation DeleteWorkspaceDocument($id: ID!) {
|
|
deleteWorkspaceDocument(id: $id) {
|
|
ok
|
|
id
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __useDeleteWorkspaceDocumentMutation__
|
|
*
|
|
* To run a mutation, you first call `useDeleteWorkspaceDocumentMutation` within a Vue component and pass it any options that fit your needs.
|
|
* When your component renders, `useDeleteWorkspaceDocumentMutation` returns an object that includes:
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
* - Several other properties: https://v4.apollo.vuejs.org/api/use-mutation.html#return
|
|
*
|
|
* @param options that will be passed into the mutation, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/mutation.html#options;
|
|
*
|
|
* @example
|
|
* const { mutate, loading, error, onDone } = useDeleteWorkspaceDocumentMutation({
|
|
* variables: {
|
|
* id: // value for 'id'
|
|
* },
|
|
* });
|
|
*/
|
|
export function useDeleteWorkspaceDocumentMutation(options: VueApolloComposable.UseMutationOptions<DeleteWorkspaceDocumentMutation, DeleteWorkspaceDocumentMutationVariables> | ReactiveFunction<VueApolloComposable.UseMutationOptions<DeleteWorkspaceDocumentMutation, DeleteWorkspaceDocumentMutationVariables>> = {}) {
|
|
return VueApolloComposable.useMutation<DeleteWorkspaceDocumentMutation, DeleteWorkspaceDocumentMutationVariables>(DeleteWorkspaceDocumentDocument, options);
|
|
}
|
|
export type DeleteWorkspaceDocumentMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<DeleteWorkspaceDocumentMutation, DeleteWorkspaceDocumentMutationVariables>;
|
|
export const DocumentsQueryDocument = gql`
|
|
query DocumentsQuery {
|
|
documents {
|
|
id
|
|
title
|
|
type
|
|
owner
|
|
scope
|
|
updatedAt
|
|
summary
|
|
body
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __useDocumentsQueryQuery__
|
|
*
|
|
* To run a query within a Vue component, call `useDocumentsQueryQuery` and pass it any options that fit your needs.
|
|
* When your component renders, `useDocumentsQueryQuery` returns an object from Apollo Client that contains result, loading and error properties
|
|
* you can use to render your UI.
|
|
*
|
|
* @param options that will be passed into the query, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/query.html#options;
|
|
*
|
|
* @example
|
|
* const { result, loading, error } = useDocumentsQueryQuery();
|
|
*/
|
|
export function useDocumentsQueryQuery(options: VueApolloComposable.UseQueryOptions<DocumentsQueryQuery, DocumentsQueryQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<DocumentsQueryQuery, DocumentsQueryQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<DocumentsQueryQuery, DocumentsQueryQueryVariables>> = {}) {
|
|
return VueApolloComposable.useQuery<DocumentsQueryQuery, DocumentsQueryQueryVariables>(DocumentsQueryDocument, {}, options);
|
|
}
|
|
export function useDocumentsQueryLazyQuery(options: VueApolloComposable.UseQueryOptions<DocumentsQueryQuery, DocumentsQueryQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<DocumentsQueryQuery, DocumentsQueryQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<DocumentsQueryQuery, DocumentsQueryQueryVariables>> = {}) {
|
|
return VueApolloComposable.useLazyQuery<DocumentsQueryQuery, DocumentsQueryQueryVariables>(DocumentsQueryDocument, {}, options);
|
|
}
|
|
export type DocumentsQueryQueryCompositionFunctionResult = VueApolloComposable.UseQueryReturn<DocumentsQueryQuery, DocumentsQueryQueryVariables>;
|
|
export const FeedQueryDocument = gql`
|
|
query FeedQuery {
|
|
feed {
|
|
id
|
|
at
|
|
contact
|
|
text
|
|
proposal {
|
|
title
|
|
details
|
|
key
|
|
}
|
|
decision
|
|
decisionNote
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __useFeedQueryQuery__
|
|
*
|
|
* To run a query within a Vue component, call `useFeedQueryQuery` and pass it any options that fit your needs.
|
|
* When your component renders, `useFeedQueryQuery` returns an object from Apollo Client that contains result, loading and error properties
|
|
* you can use to render your UI.
|
|
*
|
|
* @param options that will be passed into the query, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/query.html#options;
|
|
*
|
|
* @example
|
|
* const { result, loading, error } = useFeedQueryQuery();
|
|
*/
|
|
export function useFeedQueryQuery(options: VueApolloComposable.UseQueryOptions<FeedQueryQuery, FeedQueryQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<FeedQueryQuery, FeedQueryQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<FeedQueryQuery, FeedQueryQueryVariables>> = {}) {
|
|
return VueApolloComposable.useQuery<FeedQueryQuery, FeedQueryQueryVariables>(FeedQueryDocument, {}, options);
|
|
}
|
|
export function useFeedQueryLazyQuery(options: VueApolloComposable.UseQueryOptions<FeedQueryQuery, FeedQueryQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<FeedQueryQuery, FeedQueryQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<FeedQueryQuery, FeedQueryQueryVariables>> = {}) {
|
|
return VueApolloComposable.useLazyQuery<FeedQueryQuery, FeedQueryQueryVariables>(FeedQueryDocument, {}, options);
|
|
}
|
|
export type FeedQueryQueryCompositionFunctionResult = VueApolloComposable.UseQueryReturn<FeedQueryQuery, FeedQueryQueryVariables>;
|
|
export const GetClientTimelineQueryDocument = gql`
|
|
query GetClientTimelineQuery($contactId: ID!, $limit: Int) {
|
|
getClientTimeline(contactId: $contactId, limit: $limit) {
|
|
id
|
|
contactId
|
|
contentType
|
|
contentId
|
|
datetime
|
|
message {
|
|
id
|
|
at
|
|
contactId
|
|
contact
|
|
contactInboxId
|
|
sourceExternalId
|
|
sourceTitle
|
|
channel
|
|
kind
|
|
direction
|
|
text
|
|
audioUrl
|
|
duration
|
|
waveform
|
|
transcript
|
|
deliveryStatus
|
|
}
|
|
calendarEvent {
|
|
id
|
|
title
|
|
start
|
|
end
|
|
contact
|
|
note
|
|
isArchived
|
|
createdAt
|
|
archiveNote
|
|
archivedAt
|
|
}
|
|
recommendation {
|
|
id
|
|
at
|
|
contact
|
|
text
|
|
proposal {
|
|
title
|
|
details
|
|
key
|
|
}
|
|
decision
|
|
decisionNote
|
|
}
|
|
document {
|
|
id
|
|
title
|
|
type
|
|
owner
|
|
scope
|
|
updatedAt
|
|
summary
|
|
body
|
|
}
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __useGetClientTimelineQueryQuery__
|
|
*
|
|
* To run a query within a Vue component, call `useGetClientTimelineQueryQuery` and pass it any options that fit your needs.
|
|
* When your component renders, `useGetClientTimelineQueryQuery` returns an object from Apollo Client that contains result, loading and error properties
|
|
* you can use to render your UI.
|
|
*
|
|
* @param variables that will be passed into the query
|
|
* @param options that will be passed into the query, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/query.html#options;
|
|
*
|
|
* @example
|
|
* const { result, loading, error } = useGetClientTimelineQueryQuery({
|
|
* contactId: // value for 'contactId'
|
|
* limit: // value for 'limit'
|
|
* });
|
|
*/
|
|
export function useGetClientTimelineQueryQuery(variables: GetClientTimelineQueryQueryVariables | VueCompositionApi.Ref<GetClientTimelineQueryQueryVariables> | ReactiveFunction<GetClientTimelineQueryQueryVariables>, options: VueApolloComposable.UseQueryOptions<GetClientTimelineQueryQuery, GetClientTimelineQueryQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<GetClientTimelineQueryQuery, GetClientTimelineQueryQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<GetClientTimelineQueryQuery, GetClientTimelineQueryQueryVariables>> = {}) {
|
|
return VueApolloComposable.useQuery<GetClientTimelineQueryQuery, GetClientTimelineQueryQueryVariables>(GetClientTimelineQueryDocument, variables, options);
|
|
}
|
|
export function useGetClientTimelineQueryLazyQuery(variables?: GetClientTimelineQueryQueryVariables | VueCompositionApi.Ref<GetClientTimelineQueryQueryVariables> | ReactiveFunction<GetClientTimelineQueryQueryVariables>, options: VueApolloComposable.UseQueryOptions<GetClientTimelineQueryQuery, GetClientTimelineQueryQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<GetClientTimelineQueryQuery, GetClientTimelineQueryQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<GetClientTimelineQueryQuery, GetClientTimelineQueryQueryVariables>> = {}) {
|
|
return VueApolloComposable.useLazyQuery<GetClientTimelineQueryQuery, GetClientTimelineQueryQueryVariables>(GetClientTimelineQueryDocument, variables, options);
|
|
}
|
|
export type GetClientTimelineQueryQueryCompositionFunctionResult = VueApolloComposable.UseQueryReturn<GetClientTimelineQueryQuery, GetClientTimelineQueryQueryVariables>;
|
|
export const LogPilotNoteMutationDocument = gql`
|
|
mutation LogPilotNoteMutation($text: String!) {
|
|
logPilotNote(text: $text) {
|
|
ok
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __useLogPilotNoteMutationMutation__
|
|
*
|
|
* To run a mutation, you first call `useLogPilotNoteMutationMutation` within a Vue component and pass it any options that fit your needs.
|
|
* When your component renders, `useLogPilotNoteMutationMutation` returns an object that includes:
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
* - Several other properties: https://v4.apollo.vuejs.org/api/use-mutation.html#return
|
|
*
|
|
* @param options that will be passed into the mutation, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/mutation.html#options;
|
|
*
|
|
* @example
|
|
* const { mutate, loading, error, onDone } = useLogPilotNoteMutationMutation({
|
|
* variables: {
|
|
* text: // value for 'text'
|
|
* },
|
|
* });
|
|
*/
|
|
export function useLogPilotNoteMutationMutation(options: VueApolloComposable.UseMutationOptions<LogPilotNoteMutationMutation, LogPilotNoteMutationMutationVariables> | ReactiveFunction<VueApolloComposable.UseMutationOptions<LogPilotNoteMutationMutation, LogPilotNoteMutationMutationVariables>> = {}) {
|
|
return VueApolloComposable.useMutation<LogPilotNoteMutationMutation, LogPilotNoteMutationMutationVariables>(LogPilotNoteMutationDocument, options);
|
|
}
|
|
export type LogPilotNoteMutationMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<LogPilotNoteMutationMutation, LogPilotNoteMutationMutationVariables>;
|
|
export const LoginMutationDocument = gql`
|
|
mutation LoginMutation($phone: String!, $password: String!) {
|
|
login(phone: $phone, password: $password) {
|
|
ok
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __useLoginMutationMutation__
|
|
*
|
|
* To run a mutation, you first call `useLoginMutationMutation` within a Vue component and pass it any options that fit your needs.
|
|
* When your component renders, `useLoginMutationMutation` returns an object that includes:
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
* - Several other properties: https://v4.apollo.vuejs.org/api/use-mutation.html#return
|
|
*
|
|
* @param options that will be passed into the mutation, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/mutation.html#options;
|
|
*
|
|
* @example
|
|
* const { mutate, loading, error, onDone } = useLoginMutationMutation({
|
|
* variables: {
|
|
* phone: // value for 'phone'
|
|
* password: // value for 'password'
|
|
* },
|
|
* });
|
|
*/
|
|
export function useLoginMutationMutation(options: VueApolloComposable.UseMutationOptions<LoginMutationMutation, LoginMutationMutationVariables> | ReactiveFunction<VueApolloComposable.UseMutationOptions<LoginMutationMutation, LoginMutationMutationVariables>> = {}) {
|
|
return VueApolloComposable.useMutation<LoginMutationMutation, LoginMutationMutationVariables>(LoginMutationDocument, options);
|
|
}
|
|
export type LoginMutationMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<LoginMutationMutation, LoginMutationMutationVariables>;
|
|
export const LogoutMutationDocument = gql`
|
|
mutation LogoutMutation {
|
|
logout {
|
|
ok
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __useLogoutMutationMutation__
|
|
*
|
|
* To run a mutation, you first call `useLogoutMutationMutation` within a Vue component and pass it any options that fit your needs.
|
|
* When your component renders, `useLogoutMutationMutation` returns an object that includes:
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
* - Several other properties: https://v4.apollo.vuejs.org/api/use-mutation.html#return
|
|
*
|
|
* @param options that will be passed into the mutation, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/mutation.html#options;
|
|
*
|
|
* @example
|
|
* const { mutate, loading, error, onDone } = useLogoutMutationMutation();
|
|
*/
|
|
export function useLogoutMutationMutation(options: VueApolloComposable.UseMutationOptions<LogoutMutationMutation, LogoutMutationMutationVariables> | ReactiveFunction<VueApolloComposable.UseMutationOptions<LogoutMutationMutation, LogoutMutationMutationVariables>> = {}) {
|
|
return VueApolloComposable.useMutation<LogoutMutationMutation, LogoutMutationMutationVariables>(LogoutMutationDocument, options);
|
|
}
|
|
export type LogoutMutationMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<LogoutMutationMutation, LogoutMutationMutationVariables>;
|
|
export const MarkThreadReadDocument = gql`
|
|
mutation MarkThreadRead($contactId: ID!) {
|
|
markThreadRead(contactId: $contactId) {
|
|
ok
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __useMarkThreadReadMutation__
|
|
*
|
|
* To run a mutation, you first call `useMarkThreadReadMutation` within a Vue component and pass it any options that fit your needs.
|
|
* When your component renders, `useMarkThreadReadMutation` returns an object that includes:
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
* - Several other properties: https://v4.apollo.vuejs.org/api/use-mutation.html#return
|
|
*
|
|
* @param options that will be passed into the mutation, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/mutation.html#options;
|
|
*
|
|
* @example
|
|
* const { mutate, loading, error, onDone } = useMarkThreadReadMutation({
|
|
* variables: {
|
|
* contactId: // value for 'contactId'
|
|
* },
|
|
* });
|
|
*/
|
|
export function useMarkThreadReadMutation(options: VueApolloComposable.UseMutationOptions<MarkThreadReadMutation, MarkThreadReadMutationVariables> | ReactiveFunction<VueApolloComposable.UseMutationOptions<MarkThreadReadMutation, MarkThreadReadMutationVariables>> = {}) {
|
|
return VueApolloComposable.useMutation<MarkThreadReadMutation, MarkThreadReadMutationVariables>(MarkThreadReadDocument, options);
|
|
}
|
|
export type MarkThreadReadMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<MarkThreadReadMutation, MarkThreadReadMutationVariables>;
|
|
export const MeQueryDocument = gql`
|
|
query MeQuery {
|
|
me {
|
|
user {
|
|
id
|
|
phone
|
|
name
|
|
}
|
|
team {
|
|
id
|
|
name
|
|
}
|
|
conversation {
|
|
id
|
|
title
|
|
}
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __useMeQueryQuery__
|
|
*
|
|
* To run a query within a Vue component, call `useMeQueryQuery` and pass it any options that fit your needs.
|
|
* When your component renders, `useMeQueryQuery` returns an object from Apollo Client that contains result, loading and error properties
|
|
* you can use to render your UI.
|
|
*
|
|
* @param options that will be passed into the query, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/query.html#options;
|
|
*
|
|
* @example
|
|
* const { result, loading, error } = useMeQueryQuery();
|
|
*/
|
|
export function useMeQueryQuery(options: VueApolloComposable.UseQueryOptions<MeQueryQuery, MeQueryQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<MeQueryQuery, MeQueryQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<MeQueryQuery, MeQueryQueryVariables>> = {}) {
|
|
return VueApolloComposable.useQuery<MeQueryQuery, MeQueryQueryVariables>(MeQueryDocument, {}, options);
|
|
}
|
|
export function useMeQueryLazyQuery(options: VueApolloComposable.UseQueryOptions<MeQueryQuery, MeQueryQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<MeQueryQuery, MeQueryQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<MeQueryQuery, MeQueryQueryVariables>> = {}) {
|
|
return VueApolloComposable.useLazyQuery<MeQueryQuery, MeQueryQueryVariables>(MeQueryDocument, {}, options);
|
|
}
|
|
export type MeQueryQueryCompositionFunctionResult = VueApolloComposable.UseQueryReturn<MeQueryQuery, MeQueryQueryVariables>;
|
|
export const PinsQueryDocument = gql`
|
|
query PinsQuery {
|
|
pins {
|
|
id
|
|
contact
|
|
text
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __usePinsQueryQuery__
|
|
*
|
|
* To run a query within a Vue component, call `usePinsQueryQuery` and pass it any options that fit your needs.
|
|
* When your component renders, `usePinsQueryQuery` returns an object from Apollo Client that contains result, loading and error properties
|
|
* you can use to render your UI.
|
|
*
|
|
* @param options that will be passed into the query, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/query.html#options;
|
|
*
|
|
* @example
|
|
* const { result, loading, error } = usePinsQueryQuery();
|
|
*/
|
|
export function usePinsQueryQuery(options: VueApolloComposable.UseQueryOptions<PinsQueryQuery, PinsQueryQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<PinsQueryQuery, PinsQueryQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<PinsQueryQuery, PinsQueryQueryVariables>> = {}) {
|
|
return VueApolloComposable.useQuery<PinsQueryQuery, PinsQueryQueryVariables>(PinsQueryDocument, {}, options);
|
|
}
|
|
export function usePinsQueryLazyQuery(options: VueApolloComposable.UseQueryOptions<PinsQueryQuery, PinsQueryQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<PinsQueryQuery, PinsQueryQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<PinsQueryQuery, PinsQueryQueryVariables>> = {}) {
|
|
return VueApolloComposable.useLazyQuery<PinsQueryQuery, PinsQueryQueryVariables>(PinsQueryDocument, {}, options);
|
|
}
|
|
export type PinsQueryQueryCompositionFunctionResult = VueApolloComposable.UseQueryReturn<PinsQueryQuery, PinsQueryQueryVariables>;
|
|
export const RollbackChangeSetItemsMutationDocument = gql`
|
|
mutation RollbackChangeSetItemsMutation($changeSetId: ID!, $itemIds: [ID!]!) {
|
|
rollbackChangeSetItems(changeSetId: $changeSetId, itemIds: $itemIds) {
|
|
ok
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __useRollbackChangeSetItemsMutationMutation__
|
|
*
|
|
* To run a mutation, you first call `useRollbackChangeSetItemsMutationMutation` within a Vue component and pass it any options that fit your needs.
|
|
* When your component renders, `useRollbackChangeSetItemsMutationMutation` returns an object that includes:
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
* - Several other properties: https://v4.apollo.vuejs.org/api/use-mutation.html#return
|
|
*
|
|
* @param options that will be passed into the mutation, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/mutation.html#options;
|
|
*
|
|
* @example
|
|
* const { mutate, loading, error, onDone } = useRollbackChangeSetItemsMutationMutation({
|
|
* variables: {
|
|
* changeSetId: // value for 'changeSetId'
|
|
* itemIds: // value for 'itemIds'
|
|
* },
|
|
* });
|
|
*/
|
|
export function useRollbackChangeSetItemsMutationMutation(options: VueApolloComposable.UseMutationOptions<RollbackChangeSetItemsMutationMutation, RollbackChangeSetItemsMutationMutationVariables> | ReactiveFunction<VueApolloComposable.UseMutationOptions<RollbackChangeSetItemsMutationMutation, RollbackChangeSetItemsMutationMutationVariables>> = {}) {
|
|
return VueApolloComposable.useMutation<RollbackChangeSetItemsMutationMutation, RollbackChangeSetItemsMutationMutationVariables>(RollbackChangeSetItemsMutationDocument, options);
|
|
}
|
|
export type RollbackChangeSetItemsMutationMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<RollbackChangeSetItemsMutationMutation, RollbackChangeSetItemsMutationMutationVariables>;
|
|
export const RollbackLatestChangeSetMutationDocument = gql`
|
|
mutation RollbackLatestChangeSetMutation {
|
|
rollbackLatestChangeSet {
|
|
ok
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __useRollbackLatestChangeSetMutationMutation__
|
|
*
|
|
* To run a mutation, you first call `useRollbackLatestChangeSetMutationMutation` within a Vue component and pass it any options that fit your needs.
|
|
* When your component renders, `useRollbackLatestChangeSetMutationMutation` returns an object that includes:
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
* - Several other properties: https://v4.apollo.vuejs.org/api/use-mutation.html#return
|
|
*
|
|
* @param options that will be passed into the mutation, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/mutation.html#options;
|
|
*
|
|
* @example
|
|
* const { mutate, loading, error, onDone } = useRollbackLatestChangeSetMutationMutation();
|
|
*/
|
|
export function useRollbackLatestChangeSetMutationMutation(options: VueApolloComposable.UseMutationOptions<RollbackLatestChangeSetMutationMutation, RollbackLatestChangeSetMutationMutationVariables> | ReactiveFunction<VueApolloComposable.UseMutationOptions<RollbackLatestChangeSetMutationMutation, RollbackLatestChangeSetMutationMutationVariables>> = {}) {
|
|
return VueApolloComposable.useMutation<RollbackLatestChangeSetMutationMutation, RollbackLatestChangeSetMutationMutationVariables>(RollbackLatestChangeSetMutationDocument, options);
|
|
}
|
|
export type RollbackLatestChangeSetMutationMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<RollbackLatestChangeSetMutationMutation, RollbackLatestChangeSetMutationMutationVariables>;
|
|
export const SelectChatConversationMutationDocument = gql`
|
|
mutation SelectChatConversationMutation($id: ID!) {
|
|
selectChatConversation(id: $id) {
|
|
ok
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __useSelectChatConversationMutationMutation__
|
|
*
|
|
* To run a mutation, you first call `useSelectChatConversationMutationMutation` within a Vue component and pass it any options that fit your needs.
|
|
* When your component renders, `useSelectChatConversationMutationMutation` returns an object that includes:
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
* - Several other properties: https://v4.apollo.vuejs.org/api/use-mutation.html#return
|
|
*
|
|
* @param options that will be passed into the mutation, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/mutation.html#options;
|
|
*
|
|
* @example
|
|
* const { mutate, loading, error, onDone } = useSelectChatConversationMutationMutation({
|
|
* variables: {
|
|
* id: // value for 'id'
|
|
* },
|
|
* });
|
|
*/
|
|
export function useSelectChatConversationMutationMutation(options: VueApolloComposable.UseMutationOptions<SelectChatConversationMutationMutation, SelectChatConversationMutationMutationVariables> | ReactiveFunction<VueApolloComposable.UseMutationOptions<SelectChatConversationMutationMutation, SelectChatConversationMutationMutationVariables>> = {}) {
|
|
return VueApolloComposable.useMutation<SelectChatConversationMutationMutation, SelectChatConversationMutationMutationVariables>(SelectChatConversationMutationDocument, options);
|
|
}
|
|
export type SelectChatConversationMutationMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<SelectChatConversationMutationMutation, SelectChatConversationMutationMutationVariables>;
|
|
export const SendPilotMessageMutationDocument = gql`
|
|
mutation SendPilotMessageMutation($text: String!) {
|
|
sendPilotMessage(text: $text) {
|
|
ok
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __useSendPilotMessageMutationMutation__
|
|
*
|
|
* To run a mutation, you first call `useSendPilotMessageMutationMutation` within a Vue component and pass it any options that fit your needs.
|
|
* When your component renders, `useSendPilotMessageMutationMutation` returns an object that includes:
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
* - Several other properties: https://v4.apollo.vuejs.org/api/use-mutation.html#return
|
|
*
|
|
* @param options that will be passed into the mutation, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/mutation.html#options;
|
|
*
|
|
* @example
|
|
* const { mutate, loading, error, onDone } = useSendPilotMessageMutationMutation({
|
|
* variables: {
|
|
* text: // value for 'text'
|
|
* },
|
|
* });
|
|
*/
|
|
export function useSendPilotMessageMutationMutation(options: VueApolloComposable.UseMutationOptions<SendPilotMessageMutationMutation, SendPilotMessageMutationMutationVariables> | ReactiveFunction<VueApolloComposable.UseMutationOptions<SendPilotMessageMutationMutation, SendPilotMessageMutationMutationVariables>> = {}) {
|
|
return VueApolloComposable.useMutation<SendPilotMessageMutationMutation, SendPilotMessageMutationMutationVariables>(SendPilotMessageMutationDocument, options);
|
|
}
|
|
export type SendPilotMessageMutationMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<SendPilotMessageMutationMutation, SendPilotMessageMutationMutationVariables>;
|
|
export const SetContactInboxHiddenDocument = gql`
|
|
mutation SetContactInboxHidden($inboxId: ID!, $hidden: Boolean!) {
|
|
setContactInboxHidden(inboxId: $inboxId, hidden: $hidden) {
|
|
ok
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __useSetContactInboxHiddenMutation__
|
|
*
|
|
* To run a mutation, you first call `useSetContactInboxHiddenMutation` within a Vue component and pass it any options that fit your needs.
|
|
* When your component renders, `useSetContactInboxHiddenMutation` returns an object that includes:
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
* - Several other properties: https://v4.apollo.vuejs.org/api/use-mutation.html#return
|
|
*
|
|
* @param options that will be passed into the mutation, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/mutation.html#options;
|
|
*
|
|
* @example
|
|
* const { mutate, loading, error, onDone } = useSetContactInboxHiddenMutation({
|
|
* variables: {
|
|
* inboxId: // value for 'inboxId'
|
|
* hidden: // value for 'hidden'
|
|
* },
|
|
* });
|
|
*/
|
|
export function useSetContactInboxHiddenMutation(options: VueApolloComposable.UseMutationOptions<SetContactInboxHiddenMutation, SetContactInboxHiddenMutationVariables> | ReactiveFunction<VueApolloComposable.UseMutationOptions<SetContactInboxHiddenMutation, SetContactInboxHiddenMutationVariables>> = {}) {
|
|
return VueApolloComposable.useMutation<SetContactInboxHiddenMutation, SetContactInboxHiddenMutationVariables>(SetContactInboxHiddenDocument, options);
|
|
}
|
|
export type SetContactInboxHiddenMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<SetContactInboxHiddenMutation, SetContactInboxHiddenMutationVariables>;
|
|
export const ToggleContactPinMutationDocument = gql`
|
|
mutation ToggleContactPinMutation($contact: String!, $text: String!) {
|
|
toggleContactPin(contact: $contact, text: $text) {
|
|
ok
|
|
pinned
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __useToggleContactPinMutationMutation__
|
|
*
|
|
* To run a mutation, you first call `useToggleContactPinMutationMutation` within a Vue component and pass it any options that fit your needs.
|
|
* When your component renders, `useToggleContactPinMutationMutation` returns an object that includes:
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
* - Several other properties: https://v4.apollo.vuejs.org/api/use-mutation.html#return
|
|
*
|
|
* @param options that will be passed into the mutation, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/mutation.html#options;
|
|
*
|
|
* @example
|
|
* const { mutate, loading, error, onDone } = useToggleContactPinMutationMutation({
|
|
* variables: {
|
|
* contact: // value for 'contact'
|
|
* text: // value for 'text'
|
|
* },
|
|
* });
|
|
*/
|
|
export function useToggleContactPinMutationMutation(options: VueApolloComposable.UseMutationOptions<ToggleContactPinMutationMutation, ToggleContactPinMutationMutationVariables> | ReactiveFunction<VueApolloComposable.UseMutationOptions<ToggleContactPinMutationMutation, ToggleContactPinMutationMutationVariables>> = {}) {
|
|
return VueApolloComposable.useMutation<ToggleContactPinMutationMutation, ToggleContactPinMutationMutationVariables>(ToggleContactPinMutationDocument, options);
|
|
}
|
|
export type ToggleContactPinMutationMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<ToggleContactPinMutationMutation, ToggleContactPinMutationMutationVariables>;
|
|
export const UpdateCommunicationTranscriptMutationDocument = gql`
|
|
mutation UpdateCommunicationTranscriptMutation($id: ID!, $transcript: [String!]!) {
|
|
updateCommunicationTranscript(id: $id, transcript: $transcript) {
|
|
ok
|
|
id
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __useUpdateCommunicationTranscriptMutationMutation__
|
|
*
|
|
* To run a mutation, you first call `useUpdateCommunicationTranscriptMutationMutation` within a Vue component and pass it any options that fit your needs.
|
|
* When your component renders, `useUpdateCommunicationTranscriptMutationMutation` returns an object that includes:
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
* - Several other properties: https://v4.apollo.vuejs.org/api/use-mutation.html#return
|
|
*
|
|
* @param options that will be passed into the mutation, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/mutation.html#options;
|
|
*
|
|
* @example
|
|
* const { mutate, loading, error, onDone } = useUpdateCommunicationTranscriptMutationMutation({
|
|
* variables: {
|
|
* id: // value for 'id'
|
|
* transcript: // value for 'transcript'
|
|
* },
|
|
* });
|
|
*/
|
|
export function useUpdateCommunicationTranscriptMutationMutation(options: VueApolloComposable.UseMutationOptions<UpdateCommunicationTranscriptMutationMutation, UpdateCommunicationTranscriptMutationMutationVariables> | ReactiveFunction<VueApolloComposable.UseMutationOptions<UpdateCommunicationTranscriptMutationMutation, UpdateCommunicationTranscriptMutationMutationVariables>> = {}) {
|
|
return VueApolloComposable.useMutation<UpdateCommunicationTranscriptMutationMutation, UpdateCommunicationTranscriptMutationMutationVariables>(UpdateCommunicationTranscriptMutationDocument, options);
|
|
}
|
|
export type UpdateCommunicationTranscriptMutationMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<UpdateCommunicationTranscriptMutationMutation, UpdateCommunicationTranscriptMutationMutationVariables>;
|
|
export const UpdateDealMutationDocument = gql`
|
|
mutation UpdateDealMutation($input: UpdateDealInput!) {
|
|
updateDeal(input: $input) {
|
|
id
|
|
contact
|
|
title
|
|
stage
|
|
amount
|
|
paidAmount
|
|
nextStep
|
|
summary
|
|
currentStepId
|
|
steps {
|
|
id
|
|
title
|
|
description
|
|
status
|
|
dueAt
|
|
order
|
|
completedAt
|
|
}
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __useUpdateDealMutationMutation__
|
|
*
|
|
* To run a mutation, you first call `useUpdateDealMutationMutation` within a Vue component and pass it any options that fit your needs.
|
|
* When your component renders, `useUpdateDealMutationMutation` returns an object that includes:
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
* - Several other properties: https://v4.apollo.vuejs.org/api/use-mutation.html#return
|
|
*
|
|
* @param options that will be passed into the mutation, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/mutation.html#options;
|
|
*
|
|
* @example
|
|
* const { mutate, loading, error, onDone } = useUpdateDealMutationMutation({
|
|
* variables: {
|
|
* input: // value for 'input'
|
|
* },
|
|
* });
|
|
*/
|
|
export function useUpdateDealMutationMutation(options: VueApolloComposable.UseMutationOptions<UpdateDealMutationMutation, UpdateDealMutationMutationVariables> | ReactiveFunction<VueApolloComposable.UseMutationOptions<UpdateDealMutationMutation, UpdateDealMutationMutationVariables>> = {}) {
|
|
return VueApolloComposable.useMutation<UpdateDealMutationMutation, UpdateDealMutationMutationVariables>(UpdateDealMutationDocument, options);
|
|
}
|
|
export type UpdateDealMutationMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<UpdateDealMutationMutation, UpdateDealMutationMutationVariables>;
|
|
export const UpdateFeedDecisionMutationDocument = gql`
|
|
mutation UpdateFeedDecisionMutation($id: ID!, $decision: String!, $decisionNote: String) {
|
|
updateFeedDecision(id: $id, decision: $decision, decisionNote: $decisionNote) {
|
|
ok
|
|
id
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __useUpdateFeedDecisionMutationMutation__
|
|
*
|
|
* To run a mutation, you first call `useUpdateFeedDecisionMutationMutation` within a Vue component and pass it any options that fit your needs.
|
|
* When your component renders, `useUpdateFeedDecisionMutationMutation` returns an object that includes:
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
* - Several other properties: https://v4.apollo.vuejs.org/api/use-mutation.html#return
|
|
*
|
|
* @param options that will be passed into the mutation, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/mutation.html#options;
|
|
*
|
|
* @example
|
|
* const { mutate, loading, error, onDone } = useUpdateFeedDecisionMutationMutation({
|
|
* variables: {
|
|
* id: // value for 'id'
|
|
* decision: // value for 'decision'
|
|
* decisionNote: // value for 'decisionNote'
|
|
* },
|
|
* });
|
|
*/
|
|
export function useUpdateFeedDecisionMutationMutation(options: VueApolloComposable.UseMutationOptions<UpdateFeedDecisionMutationMutation, UpdateFeedDecisionMutationMutationVariables> | ReactiveFunction<VueApolloComposable.UseMutationOptions<UpdateFeedDecisionMutationMutation, UpdateFeedDecisionMutationMutationVariables>> = {}) {
|
|
return VueApolloComposable.useMutation<UpdateFeedDecisionMutationMutation, UpdateFeedDecisionMutationMutationVariables>(UpdateFeedDecisionMutationDocument, options);
|
|
}
|
|
export type UpdateFeedDecisionMutationMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<UpdateFeedDecisionMutationMutation, UpdateFeedDecisionMutationMutationVariables>; |