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>;