import gql from 'graphql-tag'
import * as ApolloReactCommon from '@apollo/react-common'
import * as ApolloReactHooks from '@apollo/react-hooks'
export type Maybe<T> = T | null
/** All built-in and custom scalars, mapped to their actual values */
export type Scalars = {
  ID: string
  String: string
  Boolean: boolean
  Int: number
  Float: number
  DateTime: any
  JSON: any
  JSONObject: any
}

export type AcceptTermAndConditionInput = {
  termAndConditionId: Scalars['Int']
}

export type Address = Node & {
  __typename?: 'Address'
  addressLineFour?: Maybe<Scalars['String']>
  addressLineOne?: Maybe<Scalars['String']>
  addressLineThree?: Maybe<Scalars['String']>
  addressLineTwo?: Maybe<Scalars['String']>
  city?: Maybe<Scalars['String']>
  country?: Maybe<Scalars['String']>
  id: Scalars['Int']
  location?: Maybe<Location>
  postCode?: Maybe<Scalars['String']>
  postCodePartOne?: Maybe<Scalars['String']>
  postCodePartTwo?: Maybe<Scalars['String']>
  region?: Maybe<Scalars['String']>
}

export type Agent = Node & {
  __typename?: 'Agent'
  blankPinUrl?: Maybe<Scalars['String']>
  contacts?: Maybe<Array<Contact>>
  id: Scalars['Int']
  logo?: Maybe<Scalars['String']>
  mapPin?: Maybe<Scalars['String']>
  name: Scalars['String']
  offices?: Maybe<Array<Office>>
  officesAgg?: Maybe<OfficesAgg>
  primaryColor?: Maybe<Scalars['String']>
  shortName?: Maybe<Scalars['String']>
  website?: Maybe<Scalars['String']>
}

export type AgentWhereInput = {
  id?: Maybe<Scalars['Int']>
  id_not?: Maybe<Scalars['Int']>
  id_in?: Maybe<Array<Scalars['Int']>>
  id_not_in?: Maybe<Array<Scalars['Int']>>
  id_lt?: Maybe<Scalars['Int']>
  id_lte?: Maybe<Scalars['Int']>
  id_gt?: Maybe<Scalars['Int']>
  id_gte?: Maybe<Scalars['Int']>
  createdAt?: Maybe<Scalars['DateTime']>
  createdAt_not?: Maybe<Scalars['DateTime']>
  createdAt_in?: Maybe<Array<Scalars['DateTime']>>
  createdAt_not_in?: Maybe<Array<Scalars['DateTime']>>
  createdAt_lt?: Maybe<Scalars['DateTime']>
  createdAt_lte?: Maybe<Scalars['DateTime']>
  createdAt_gt?: Maybe<Scalars['DateTime']>
  createdAt_gte?: Maybe<Scalars['DateTime']>
  updatedAt?: Maybe<Scalars['DateTime']>
  updatedAt_not?: Maybe<Scalars['DateTime']>
  updatedAt_in?: Maybe<Array<Scalars['DateTime']>>
  updatedAt_not_in?: Maybe<Array<Scalars['DateTime']>>
  updatedAt_lt?: Maybe<Scalars['DateTime']>
  updatedAt_lte?: Maybe<Scalars['DateTime']>
  updatedAt_gt?: Maybe<Scalars['DateTime']>
  updatedAt_gte?: Maybe<Scalars['DateTime']>
  name?: Maybe<Scalars['String']>
  name_not?: Maybe<Scalars['String']>
  name_in?: Maybe<Array<Scalars['String']>>
  name_not_in?: Maybe<Array<Scalars['String']>>
  name_lt?: Maybe<Scalars['String']>
  name_lte?: Maybe<Scalars['String']>
  name_gt?: Maybe<Scalars['String']>
  name_gte?: Maybe<Scalars['String']>
  name_contains?: Maybe<Scalars['String']>
  name_not_contains?: Maybe<Scalars['String']>
  name_starts_with?: Maybe<Scalars['String']>
  name_not_starts_with?: Maybe<Scalars['String']>
  name_ends_with?: Maybe<Scalars['String']>
  name_not_ends_with?: Maybe<Scalars['String']>
  shortName?: Maybe<Scalars['String']>
  shortName_not?: Maybe<Scalars['String']>
  shortName_in?: Maybe<Array<Scalars['String']>>
  shortName_not_in?: Maybe<Array<Scalars['String']>>
  shortName_lt?: Maybe<Scalars['String']>
  shortName_lte?: Maybe<Scalars['String']>
  shortName_gt?: Maybe<Scalars['String']>
  shortName_gte?: Maybe<Scalars['String']>
  shortName_contains?: Maybe<Scalars['String']>
  shortName_not_contains?: Maybe<Scalars['String']>
  shortName_starts_with?: Maybe<Scalars['String']>
  shortName_not_starts_with?: Maybe<Scalars['String']>
  shortName_ends_with?: Maybe<Scalars['String']>
  shortName_not_ends_with?: Maybe<Scalars['String']>
  website?: Maybe<Scalars['String']>
  website_not?: Maybe<Scalars['String']>
  website_in?: Maybe<Array<Scalars['String']>>
  website_not_in?: Maybe<Array<Scalars['String']>>
  website_lt?: Maybe<Scalars['String']>
  website_lte?: Maybe<Scalars['String']>
  website_gt?: Maybe<Scalars['String']>
  website_gte?: Maybe<Scalars['String']>
  website_contains?: Maybe<Scalars['String']>
  website_not_contains?: Maybe<Scalars['String']>
  website_starts_with?: Maybe<Scalars['String']>
  website_not_starts_with?: Maybe<Scalars['String']>
  website_ends_with?: Maybe<Scalars['String']>
  website_not_ends_with?: Maybe<Scalars['String']>
  mapPin?: Maybe<Scalars['String']>
  mapPin_not?: Maybe<Scalars['String']>
  mapPin_in?: Maybe<Array<Scalars['String']>>
  mapPin_not_in?: Maybe<Array<Scalars['String']>>
  mapPin_lt?: Maybe<Scalars['String']>
  mapPin_lte?: Maybe<Scalars['String']>
  mapPin_gt?: Maybe<Scalars['String']>
  mapPin_gte?: Maybe<Scalars['String']>
  mapPin_contains?: Maybe<Scalars['String']>
  mapPin_not_contains?: Maybe<Scalars['String']>
  mapPin_starts_with?: Maybe<Scalars['String']>
  mapPin_not_starts_with?: Maybe<Scalars['String']>
  mapPin_ends_with?: Maybe<Scalars['String']>
  mapPin_not_ends_with?: Maybe<Scalars['String']>
  logo?: Maybe<Scalars['String']>
  logo_not?: Maybe<Scalars['String']>
  logo_in?: Maybe<Array<Scalars['String']>>
  logo_not_in?: Maybe<Array<Scalars['String']>>
  logo_lt?: Maybe<Scalars['String']>
  logo_lte?: Maybe<Scalars['String']>
  logo_gt?: Maybe<Scalars['String']>
  logo_gte?: Maybe<Scalars['String']>
  logo_contains?: Maybe<Scalars['String']>
  logo_not_contains?: Maybe<Scalars['String']>
  logo_starts_with?: Maybe<Scalars['String']>
  logo_not_starts_with?: Maybe<Scalars['String']>
  logo_ends_with?: Maybe<Scalars['String']>
  logo_not_ends_with?: Maybe<Scalars['String']>
  offices_every?: Maybe<OfficeWhereInput>
  offices_some?: Maybe<OfficeWhereInput>
  offices_none?: Maybe<OfficeWhereInput>
  AND?: Maybe<Array<AgentWhereInput>>
  OR?: Maybe<Array<AgentWhereInput>>
  NOT?: Maybe<Array<AgentWhereInput>>
}

export type AvailabilityCondition = {
  __typename?: 'AvailabilityCondition'
  from?: Maybe<Scalars['DateTime']>
  id: Scalars['Int']
  isRange: Scalars['Boolean']
  to?: Maybe<Scalars['DateTime']>
}

export type AvailabilityConditionCreateInput = {
  from?: Maybe<Scalars['DateTime']>
  to?: Maybe<Scalars['DateTime']>
  isRange: Scalars['Boolean']
}

export type AvailabilityConditionCreateOneInput = {
  create?: Maybe<AvailabilityConditionCreateInput>
}

export type AvailabilityConditionUpdateDataInput = {
  from?: Maybe<Scalars['DateTime']>
  to?: Maybe<Scalars['DateTime']>
  isRange?: Maybe<Scalars['Boolean']>
}

export type AvailabilityConditionUpdateOneInput = {
  upsert?: Maybe<AvailabilityConditionUpsertNestedInput>
  delete?: Maybe<Scalars['Boolean']>
}

export type AvailabilityConditionUpsertNestedInput = {
  update: AvailabilityConditionUpdateDataInput
  create: AvailabilityConditionCreateInput
}

export type AvailabilityConditionWhereInput = {
  from?: Maybe<Scalars['DateTime']>
  from_not?: Maybe<Scalars['DateTime']>
  from_in?: Maybe<Array<Scalars['DateTime']>>
  from_not_in?: Maybe<Array<Scalars['DateTime']>>
  from_lt?: Maybe<Scalars['DateTime']>
  from_lte?: Maybe<Scalars['DateTime']>
  from_gt?: Maybe<Scalars['DateTime']>
  from_gte?: Maybe<Scalars['DateTime']>
  to?: Maybe<Scalars['DateTime']>
  to_not?: Maybe<Scalars['DateTime']>
  to_in?: Maybe<Array<Scalars['DateTime']>>
  to_not_in?: Maybe<Array<Scalars['DateTime']>>
  to_lt?: Maybe<Scalars['DateTime']>
  to_lte?: Maybe<Scalars['DateTime']>
  to_gt?: Maybe<Scalars['DateTime']>
  to_gte?: Maybe<Scalars['DateTime']>
  isRange?: Maybe<Scalars['Boolean']>
  isRange_not?: Maybe<Scalars['Boolean']>
  AND?: Maybe<Array<AvailabilityConditionWhereInput>>
  OR?: Maybe<Array<AvailabilityConditionWhereInput>>
  NOT?: Maybe<Array<AvailabilityConditionWhereInput>>
}

export enum BuildingGroup {
  Presale = 'PRESALE',
  Private = 'PRIVATE',
  Standard = 'STANDARD',
}

export type Contact = {
  __typename?: 'Contact'
  avatarUrl?: Maybe<Scalars['String']>
  createdAt: Scalars['DateTime']
  emails?: Maybe<Array<Email>>
  firstName?: Maybe<Scalars['String']>
  id: Scalars['Int']
  jobTitle?: Maybe<Scalars['String']>
  lastName?: Maybe<Scalars['String']>
  name: Scalars['String']
  phones?: Maybe<Array<Phone>>
  updatedAt: Scalars['DateTime']
}

export enum ContactType {
  Landline = 'LANDLINE',
  Organization = 'ORGANIZATION',
  Personal = 'PERSONAL',
  Primary = 'PRIMARY',
  Work = 'WORK',
}

export type ContactUpdateDataInput = {
  name?: Maybe<Scalars['String']>
  avatarUrl?: Maybe<Scalars['String']>
  jobTitle?: Maybe<Scalars['String']>
  phones?: Maybe<PhoneUpdateManyInput>
  emails?: Maybe<EmailUpdateManyInput>
}

export type ContactUpdateManyInput = {
  set?: Maybe<Array<ContactWhereUniqueInput>>
}

export type ContactUpdateOneRequiredInput = {
  update?: Maybe<ContactUpdateDataInput>
}

export type ContactWhereUniqueInput = {
  id?: Maybe<Scalars['Int']>
}

export enum Currency {
  Eur = 'EUR',
  Gbp = 'GBP',
  Usd = 'USD',
}

export type Distance = {
  __typename?: 'Distance'
  id: Scalars['Int']
  text?: Maybe<Scalars['String']>
  value?: Maybe<Scalars['Int']>
}

export type Duration = {
  __typename?: 'Duration'
  id: Scalars['Int']
  text?: Maybe<Scalars['String']>
  value?: Maybe<Scalars['Int']>
}

export type Email = {
  __typename?: 'Email'
  id: Scalars['Int']
  type?: Maybe<ContactType>
  value?: Maybe<Scalars['String']>
}

export type EmailCreateInput = {
  value?: Maybe<Scalars['String']>
  type?: Maybe<ContactType>
}

export type EmailMessage = {
  __typename?: 'EmailMessage'
  createdAt: Scalars['DateTime']
  emailBodyKey?: Maybe<Scalars['String']>
  emailCustomMessage?: Maybe<Scalars['String']>
  emailHeading?: Maybe<Scalars['String']>
  emailSubject: Scalars['String']
  emailTo: Scalars['String']
  id: Scalars['Int']
  sentAt?: Maybe<Scalars['DateTime']>
  state: EmailMessageState
  updatedAt: Scalars['DateTime']
}

export enum EmailMessageState {
  Pending = 'PENDING',
  Processing = 'PROCESSING',
  Sent = 'SENT',
}

export type EmailUpdateDataInput = {
  value?: Maybe<Scalars['String']>
  type?: Maybe<ContactType>
}

export type EmailUpdateManyInput = {
  create?: Maybe<Array<EmailCreateInput>>
  update?: Maybe<Array<EmailUpdateWithWhereUniqueNestedInput>>
  delete?: Maybe<Array<EmailWhereUniqueInput>>
}

export type EmailUpdateWithWhereUniqueNestedInput = {
  where: EmailWhereUniqueInput
  data: EmailUpdateDataInput
}

export type EmailWhereUniqueInput = {
  id?: Maybe<Scalars['Int']>
}

export type EmptyInput = {
  empty?: Maybe<Scalars['String']>
}

export type Floorplan = {
  __typename?: 'Floorplan'
  floor?: Maybe<Scalars['String']>
  id: Scalars['Int']
  name?: Maybe<Scalars['String']>
  url: Scalars['String']
}

export type Lead = {
  __typename?: 'Lead'
  createdAt: Scalars['DateTime']
  emailMessages?: Maybe<Array<EmailMessage>>
  id: Scalars['Int']
  isDeleted?: Maybe<Scalars['Boolean']>
  offers?: Maybe<Array<Offer>>
  office?: Maybe<Office>
  opportunity: Opportunity
  status: LeadStatusType
}

export type LeadCreateInput = {
  office: OfficeCreateOneInput
  status?: Maybe<LeadStatusType>
  offers?: Maybe<OfferCreateManyWithoutLeadInput>
}

export type LeadCreateManyInput = {
  create?: Maybe<Array<LeadCreateInput>>
}

export type LeadCreateOneWithoutOffersInput = {
  connect?: Maybe<LeadWhereUniqueInput>
}

export enum LeadStatusType {
  Accepted = 'ACCEPTED',
  NotSubmitted = 'NOT_SUBMITTED',
  Overturn = 'OVERTURN',
  Pending = 'PENDING',
  Rejected = 'REJECTED',
}

export type LeadUpdateInput = {
  status?: Maybe<LeadStatusType>
  offers?: Maybe<OfferUpdateManyWithoutLeadInput>
  isDeleted?: Maybe<Scalars['Boolean']>
}

export type LeadWhereInput = {
  id?: Maybe<Scalars['Int']>
  id_not?: Maybe<Scalars['Int']>
  id_in?: Maybe<Array<Scalars['Int']>>
  id_not_in?: Maybe<Array<Scalars['Int']>>
  id_lt?: Maybe<Scalars['Int']>
  id_lte?: Maybe<Scalars['Int']>
  id_gt?: Maybe<Scalars['Int']>
  id_gte?: Maybe<Scalars['Int']>
  createdAt?: Maybe<Scalars['DateTime']>
  createdAt_not?: Maybe<Scalars['DateTime']>
  createdAt_in?: Maybe<Array<Scalars['DateTime']>>
  createdAt_not_in?: Maybe<Array<Scalars['DateTime']>>
  createdAt_lt?: Maybe<Scalars['DateTime']>
  createdAt_lte?: Maybe<Scalars['DateTime']>
  createdAt_gt?: Maybe<Scalars['DateTime']>
  createdAt_gte?: Maybe<Scalars['DateTime']>
  office?: Maybe<OfficeWhereInput>
  status?: Maybe<LeadStatusType>
  status_not?: Maybe<LeadStatusType>
  status_in?: Maybe<Array<LeadStatusType>>
  status_not_in?: Maybe<Array<LeadStatusType>>
  isDeleted?: Maybe<Scalars['Boolean']>
  isDeleted_not?: Maybe<Scalars['Boolean']>
  opportunity?: Maybe<OpportunityWhereInput>
  AND?: Maybe<Array<LeadWhereInput>>
  OR?: Maybe<Array<LeadWhereInput>>
  NOT?: Maybe<Array<LeadWhereInput>>
}

export type LeadWhereUniqueInput = {
  id?: Maybe<Scalars['Int']>
}

export type Location = Node & {
  __typename?: 'Location'
  id: Scalars['Int']
  latitude: Scalars['Float']
  longitude: Scalars['Float']
  transport?: Maybe<Array<Maybe<Transport>>>
}

export type MonthlyQuotingRateCondition = {
  __typename?: 'MonthlyQuotingRateCondition'
  currency: Currency
  from?: Maybe<Scalars['Float']>
  id: Scalars['Int']
  isRange: Scalars['Boolean']
  to?: Maybe<Scalars['Float']>
  unit: MonthlyQuotingRateUnit
}

export type MonthlyQuotingRateConditionCreateInput = {
  from?: Maybe<Scalars['Float']>
  to?: Maybe<Scalars['Float']>
  currency?: Maybe<Currency>
  unit: MonthlyQuotingRateUnit
  isRange: Scalars['Boolean']
}

export type MonthlyQuotingRateConditionCreateOneInput = {
  create?: Maybe<MonthlyQuotingRateConditionCreateInput>
}

export type MonthlyQuotingRateConditionUpdateDataInput = {
  from?: Maybe<Scalars['Float']>
  to?: Maybe<Scalars['Float']>
  currency?: Maybe<Currency>
  unit?: Maybe<MonthlyQuotingRateUnit>
  isRange?: Maybe<Scalars['Boolean']>
}

export type MonthlyQuotingRateConditionUpdateOneInput = {
  upsert?: Maybe<MonthlyQuotingRateConditionUpsertNestedInput>
  delete?: Maybe<Scalars['Boolean']>
}

export type MonthlyQuotingRateConditionUpsertNestedInput = {
  update: MonthlyQuotingRateConditionUpdateDataInput
  create: MonthlyQuotingRateConditionCreateInput
}

export type MonthlyQuotingRateConditionWhereInput = {
  from?: Maybe<Scalars['Float']>
  from_not?: Maybe<Scalars['Float']>
  from_in?: Maybe<Array<Scalars['Float']>>
  from_not_in?: Maybe<Array<Scalars['Float']>>
  from_lt?: Maybe<Scalars['Float']>
  from_lte?: Maybe<Scalars['Float']>
  from_gt?: Maybe<Scalars['Float']>
  from_gte?: Maybe<Scalars['Float']>
  to?: Maybe<Scalars['Float']>
  to_not?: Maybe<Scalars['Float']>
  to_in?: Maybe<Array<Scalars['Float']>>
  to_not_in?: Maybe<Array<Scalars['Float']>>
  to_lt?: Maybe<Scalars['Float']>
  to_lte?: Maybe<Scalars['Float']>
  to_gt?: Maybe<Scalars['Float']>
  to_gte?: Maybe<Scalars['Float']>
  currency?: Maybe<Currency>
  currency_not?: Maybe<Currency>
  currency_in?: Maybe<Array<Currency>>
  currency_not_in?: Maybe<Array<Currency>>
  unit?: Maybe<MonthlyQuotingRateUnit>
  unit_not?: Maybe<MonthlyQuotingRateUnit>
  unit_in?: Maybe<Array<MonthlyQuotingRateUnit>>
  unit_not_in?: Maybe<Array<MonthlyQuotingRateUnit>>
  isRange?: Maybe<Scalars['Boolean']>
  isRange_not?: Maybe<Scalars['Boolean']>
  AND?: Maybe<Array<MonthlyQuotingRateConditionWhereInput>>
  OR?: Maybe<Array<MonthlyQuotingRateConditionWhereInput>>
  NOT?: Maybe<Array<MonthlyQuotingRateConditionWhereInput>>
}

export enum MonthlyQuotingRateUnit {
  PerDesk = 'PER_DESK',
  PerSquareFoot = 'PER_SQUARE_FOOT',
  PerSquareMeter = 'PER_SQUARE_METER',
}

export type Mutation = {
  __typename?: 'Mutation'
  acceptTermAndCondition?: Maybe<User>
  createOffer: Offer
  createOpportunity: Opportunity
  delayTermAndCondition?: Maybe<User>
  deleteOffer?: Maybe<Offer>
  sendOperatorLeads?: Maybe<SendOperatorLeadsOutput>
  updateLead?: Maybe<Lead>
  updateOffer?: Maybe<Offer>
  updateOpportunity?: Maybe<Opportunity>
  updateUser?: Maybe<User>
}

export type MutationAcceptTermAndConditionArgs = {
  data: AcceptTermAndConditionInput
}

export type MutationCreateOfferArgs = {
  data: OfferCreateInput
}

export type MutationCreateOpportunityArgs = {
  data: OpportunityCreateInput
}

export type MutationDelayTermAndConditionArgs = {
  data?: Maybe<EmptyInput>
}

export type MutationDeleteOfferArgs = {
  where: OfferWhereUniqueInput
}

export type MutationSendOperatorLeadsArgs = {
  data: SendOperatorLeadsInput
}

export type MutationUpdateLeadArgs = {
  data: LeadUpdateInput
  where: LeadWhereUniqueInput
}

export type MutationUpdateOfferArgs = {
  data: OfferUpdateInput
  where: OfferWhereUniqueInput
}

export type MutationUpdateOpportunityArgs = {
  data: OpportunityUpdateInput
  where: OpportunityWhereUniqueInput
}

export type MutationUpdateUserArgs = {
  data: UserUpdateInput
  where: UserWhereUniqueInput
}

export type Node = {
  id: Scalars['Int']
}

export type Offer = {
  __typename?: 'Offer'
  availableFromCondition?: Maybe<AvailabilityCondition>
  costCondition?: Maybe<OfficeCostCondition>
  createdAt: Scalars['DateTime']
  description?: Maybe<Scalars['String']>
  id: Scalars['Int']
  lead: Lead
  monthlyQuotingRateCondition?: Maybe<MonthlyQuotingRateCondition>
  officeSizeCondition?: Maybe<OfficeSizeCondition>
  termLengthCondition?: Maybe<TermLengthCondition>
  user?: Maybe<User>
}

export type OfferCreateInput = {
  termLengthCondition?: Maybe<TermLengthConditionCreateOneInput>
  availableFromCondition?: Maybe<AvailabilityConditionCreateOneInput>
  officeSizeCondition?: Maybe<OfficeSizeConditionCreateOneInput>
  monthlyQuotingRateCondition?: Maybe<MonthlyQuotingRateConditionCreateOneInput>
  costCondition?: Maybe<OfficeCostConditionCreateOneInput>
  description?: Maybe<Scalars['String']>
  lead: LeadCreateOneWithoutOffersInput
}

export type OfferCreateManyWithoutLeadInput = {
  create?: Maybe<Array<OfferCreateWithoutLeadInput>>
  connect?: Maybe<Array<OfferWhereUniqueInput>>
}

export type OfferCreateWithoutLeadInput = {
  termLengthCondition?: Maybe<TermLengthConditionCreateOneInput>
  availableFromCondition?: Maybe<AvailabilityConditionCreateOneInput>
  officeSizeCondition?: Maybe<OfficeSizeConditionCreateOneInput>
  monthlyQuotingRateCondition?: Maybe<MonthlyQuotingRateConditionCreateOneInput>
  costCondition?: Maybe<OfficeCostConditionCreateOneInput>
  description?: Maybe<Scalars['String']>
}

export type OfferUpdateInput = {
  termLengthCondition?: Maybe<TermLengthConditionUpdateOneInput>
  availableFromCondition?: Maybe<AvailabilityConditionUpdateOneInput>
  officeSizeCondition?: Maybe<OfficeSizeConditionUpdateOneInput>
  monthlyQuotingRateCondition?: Maybe<MonthlyQuotingRateConditionUpdateOneInput>
  costCondition?: Maybe<OfficeCostConditionUpdateOneInput>
  description?: Maybe<Scalars['String']>
}

export type OfferUpdateManyWithoutLeadInput = {
  create?: Maybe<Array<OfferCreateWithoutLeadInput>>
  update?: Maybe<Array<OfferUpdateWithWhereUniqueWithoutLeadInput>>
  delete?: Maybe<Array<OfferWhereUniqueInput>>
}

export type OfferUpdateWithWhereUniqueWithoutLeadInput = {
  where: OfferWhereUniqueInput
  data: OfferUpdateInput
}

export type OfferWhereUniqueInput = {
  id?: Maybe<Scalars['Int']>
}

export type Office = Node & {
  __typename?: 'Office'
  address?: Maybe<Address>
  amenities?: Maybe<Array<OfficeAmenity>>
  attributes?: Maybe<Array<OfficeAttribute>>
  availability?: Maybe<OfficeAvailability>
  buildingGroup: BuildingGroup
  contacts?: Maybe<Array<Contact>>
  description?: Maybe<Scalars['String']>
  deskPerMonthCost?: Maybe<Scalars['Float']>
  floorplans?: Maybe<Array<Floorplan>>
  id: Scalars['Int']
  isActive?: Maybe<Scalars['Boolean']>
  isDeleted?: Maybe<Scalars['Boolean']>
  monthlyQuotingRate?: Maybe<MonthlyQuotingRateCondition>
  name: Scalars['String']
  officeSuites?: Maybe<Array<OfficeSuite>>
  operator: Operator
  photos?: Maybe<Array<Photo>>
  statuses?: Maybe<Array<OfficeStatusItem>>
  websiteURL?: Maybe<Scalars['String']>
}

export type OfficeAvailabilityArgs = {
  where?: Maybe<OfficeSuiteWhereInput>
}

export type OfficeOfficeSuitesArgs = {
  where?: Maybe<OfficeSuiteWhereInput>
}

export type OfficePhotosArgs = {
  first?: Maybe<Scalars['Int']>
}

export type OfficeAmenity = Node & {
  __typename?: 'OfficeAmenity'
  description?: Maybe<Scalars['String']>
  icon?: Maybe<Scalars['String']>
  id: Scalars['Int']
  isEnabled: Scalars['Boolean']
  key: Scalars['String']
}

export type OfficeAttribute = Node & {
  __typename?: 'OfficeAttribute'
  attributeDescription?: Maybe<Scalars['String']>
  attributeName: Scalars['String']
  attributeValue?: Maybe<Scalars['String']>
  capacity?: Maybe<Scalars['Float']>
  comissionRate?: Maybe<Scalars['Float']>
  costPerDesk?: Maybe<Scalars['Float']>
  free?: Maybe<Scalars['Boolean']>
  id: Scalars['Int']
}

export type OfficeAvailability = {
  __typename?: 'OfficeAvailability'
  availableFrom?: Maybe<Scalars['DateTime']>
  availableOfficeSuitesCount: Scalars['Int']
  totalOfficeSuitesCount: Scalars['Int']
  unavailableOfficeSuitesCount: Scalars['Int']
  uncertainOfficeSuitesCount: Scalars['Int']
}

export type OfficeCostCondition = {
  __typename?: 'OfficeCostCondition'
  currency: Currency
  from?: Maybe<Scalars['Float']>
  id: Scalars['Int']
  isRange: Scalars['Boolean']
  to?: Maybe<Scalars['Float']>
  unit: OfficeCostUnit
}

export type OfficeCostConditionCreateInput = {
  from?: Maybe<Scalars['Float']>
  to?: Maybe<Scalars['Float']>
  currency?: Maybe<Currency>
  unit: OfficeCostUnit
  isRange: Scalars['Boolean']
}

export type OfficeCostConditionCreateOneInput = {
  create?: Maybe<OfficeCostConditionCreateInput>
}

export type OfficeCostConditionUpdateDataInput = {
  from?: Maybe<Scalars['Float']>
  to?: Maybe<Scalars['Float']>
  currency?: Maybe<Currency>
  unit?: Maybe<OfficeCostUnit>
  isRange?: Maybe<Scalars['Boolean']>
}

export type OfficeCostConditionUpdateOneInput = {
  upsert?: Maybe<OfficeCostConditionUpsertNestedInput>
  delete?: Maybe<Scalars['Boolean']>
}

export type OfficeCostConditionUpsertNestedInput = {
  update: OfficeCostConditionUpdateDataInput
  create: OfficeCostConditionCreateInput
}

export type OfficeCostConditionWhereInput = {
  from?: Maybe<Scalars['Float']>
  from_not?: Maybe<Scalars['Float']>
  from_in?: Maybe<Array<Scalars['Float']>>
  from_not_in?: Maybe<Array<Scalars['Float']>>
  from_lt?: Maybe<Scalars['Float']>
  from_lte?: Maybe<Scalars['Float']>
  from_gt?: Maybe<Scalars['Float']>
  from_gte?: Maybe<Scalars['Float']>
  to?: Maybe<Scalars['Float']>
  to_not?: Maybe<Scalars['Float']>
  to_in?: Maybe<Array<Scalars['Float']>>
  to_not_in?: Maybe<Array<Scalars['Float']>>
  to_lt?: Maybe<Scalars['Float']>
  to_lte?: Maybe<Scalars['Float']>
  to_gt?: Maybe<Scalars['Float']>
  to_gte?: Maybe<Scalars['Float']>
  currency?: Maybe<Currency>
  currency_not?: Maybe<Currency>
  currency_in?: Maybe<Array<Currency>>
  currency_not_in?: Maybe<Array<Currency>>
  unit?: Maybe<OfficeCostUnit>
  unit_not?: Maybe<OfficeCostUnit>
  unit_in?: Maybe<Array<OfficeCostUnit>>
  unit_not_in?: Maybe<Array<OfficeCostUnit>>
  isRange?: Maybe<Scalars['Boolean']>
  isRange_not?: Maybe<Scalars['Boolean']>
  AND?: Maybe<Array<OfficeCostConditionWhereInput>>
  OR?: Maybe<Array<OfficeCostConditionWhereInput>>
  NOT?: Maybe<Array<OfficeCostConditionWhereInput>>
}

export enum OfficeCostUnit {
  PerMonth = 'PER_MONTH',
  PerYear = 'PER_YEAR',
  Total = 'TOTAL',
}

export type OfficeCreateOneInput = {
  connect?: Maybe<OfficeWhereUniqueInput>
}

export type OfficesAgg = {
  __typename?: 'OfficesAgg'
  size?: Maybe<Scalars['Int']>
}

export type OfficeSizeCondition = {
  __typename?: 'OfficeSizeCondition'
  from?: Maybe<Scalars['Int']>
  id: Scalars['Int']
  isRange: Scalars['Boolean']
  to?: Maybe<Scalars['Int']>
  unit: OfficeSizeUnit
}

export type OfficeSizeConditionCreateInput = {
  from?: Maybe<Scalars['Int']>
  to?: Maybe<Scalars['Int']>
  unit: OfficeSizeUnit
  isRange: Scalars['Boolean']
}

export type OfficeSizeConditionCreateOneInput = {
  create?: Maybe<OfficeSizeConditionCreateInput>
}

export type OfficeSizeConditionUpdateDataInput = {
  from?: Maybe<Scalars['Int']>
  to?: Maybe<Scalars['Int']>
  unit?: Maybe<OfficeSizeUnit>
  isRange?: Maybe<Scalars['Boolean']>
}

export type OfficeSizeConditionUpdateOneInput = {
  upsert?: Maybe<OfficeSizeConditionUpsertNestedInput>
  delete?: Maybe<Scalars['Boolean']>
}

export type OfficeSizeConditionUpsertNestedInput = {
  update: OfficeSizeConditionUpdateDataInput
  create: OfficeSizeConditionCreateInput
}

export type OfficeSizeConditionWhereInput = {
  from?: Maybe<Scalars['Int']>
  from_not?: Maybe<Scalars['Int']>
  from_in?: Maybe<Array<Scalars['Int']>>
  from_not_in?: Maybe<Array<Scalars['Int']>>
  from_lt?: Maybe<Scalars['Int']>
  from_lte?: Maybe<Scalars['Int']>
  from_gt?: Maybe<Scalars['Int']>
  from_gte?: Maybe<Scalars['Int']>
  to?: Maybe<Scalars['Int']>
  to_not?: Maybe<Scalars['Int']>
  to_in?: Maybe<Array<Scalars['Int']>>
  to_not_in?: Maybe<Array<Scalars['Int']>>
  to_lt?: Maybe<Scalars['Int']>
  to_lte?: Maybe<Scalars['Int']>
  to_gt?: Maybe<Scalars['Int']>
  to_gte?: Maybe<Scalars['Int']>
  unit?: Maybe<OfficeSizeUnit>
  unit_not?: Maybe<OfficeSizeUnit>
  unit_in?: Maybe<Array<OfficeSizeUnit>>
  unit_not_in?: Maybe<Array<OfficeSizeUnit>>
  isRange?: Maybe<Scalars['Boolean']>
  isRange_not?: Maybe<Scalars['Boolean']>
  AND?: Maybe<Array<OfficeSizeConditionWhereInput>>
  OR?: Maybe<Array<OfficeSizeConditionWhereInput>>
  NOT?: Maybe<Array<OfficeSizeConditionWhereInput>>
}

export enum OfficeSizeUnit {
  Desk = 'DESK',
  SquareFoot = 'SQUARE_FOOT',
  SquareMeter = 'SQUARE_METER',
}

export type OfficeStatusItem = Node & {
  __typename?: 'OfficeStatusItem'
  id: Scalars['Int']
  status: OfficeStatusType
  timestamp: Scalars['DateTime']
  user: User
}

export enum OfficeStatusType {
  Active = 'ACTIVE',
  Disabled = 'DISABLED',
  Pending = 'PENDING',
}

export type OfficeSuite = {
  __typename?: 'OfficeSuite'
  availableFrom?: Maybe<AvailabilityCondition>
  canBePartitioned?: Maybe<Scalars['Boolean']>
  createdAt: Scalars['DateTime']
  description?: Maybe<Scalars['String']>
  externalId?: Maybe<Scalars['String']>
  floor?: Maybe<Scalars['String']>
  floorplans?: Maybe<Array<Floorplan>>
  id: Scalars['Int']
  isActive: Scalars['Boolean']
  isExterior?: Maybe<Scalars['Boolean']>
  monthlyQuotingRateCurrency: Currency
  monthlyQuotingRateDesk?: Maybe<OfficeSuiteCostCondition>
  monthlyQuotingRateSpace?: Maybe<OfficeSuiteCostCondition>
  monthlyQuotingRateTotal?: Maybe<OfficeSuiteCostCondition>
  name?: Maybe<Scalars['String']>
  office: Office
  photos?: Maybe<Array<Photo>>
  sizeDesks?: Maybe<OfficeSuiteSizeDesksCondition>
  sizeSpace?: Maybe<OfficeSuiteSizeSpaceCondition>
  spaceLocation: OfficeSuiteSpaceLocation
  status: OfficeSuiteStatus
  type?: Maybe<SpaceType>
  updatedAt: Scalars['DateTime']
}

export type OfficeSuiteCostCondition = {
  __typename?: 'OfficeSuiteCostCondition'
  from?: Maybe<Scalars['Float']>
  id: Scalars['Int']
  isRange: Scalars['Boolean']
  to?: Maybe<Scalars['Float']>
}

export type OfficeSuiteCostConditionWhereInput = {
  AND?: Maybe<Array<OfficeSuiteCostConditionWhereInput>>
  from?: Maybe<Scalars['Float']>
  from_gt?: Maybe<Scalars['Float']>
  from_gte?: Maybe<Scalars['Float']>
  from_in?: Maybe<Array<Scalars['Float']>>
  from_lt?: Maybe<Scalars['Float']>
  from_lte?: Maybe<Scalars['Float']>
  from_not?: Maybe<Scalars['Float']>
  from_not_in?: Maybe<Array<Scalars['Float']>>
  id?: Maybe<Scalars['Int']>
  id_gt?: Maybe<Scalars['Int']>
  id_gte?: Maybe<Scalars['Int']>
  id_in?: Maybe<Array<Scalars['Int']>>
  id_lt?: Maybe<Scalars['Int']>
  id_lte?: Maybe<Scalars['Int']>
  id_not?: Maybe<Scalars['Int']>
  id_not_in?: Maybe<Array<Scalars['Int']>>
  isRange?: Maybe<Scalars['Boolean']>
  isRange_not?: Maybe<Scalars['Boolean']>
  NOT?: Maybe<Array<OfficeSuiteCostConditionWhereInput>>
  OR?: Maybe<Array<OfficeSuiteCostConditionWhereInput>>
  to?: Maybe<Scalars['Float']>
  to_gt?: Maybe<Scalars['Float']>
  to_gte?: Maybe<Scalars['Float']>
  to_in?: Maybe<Array<Scalars['Float']>>
  to_lt?: Maybe<Scalars['Float']>
  to_lte?: Maybe<Scalars['Float']>
  to_not?: Maybe<Scalars['Float']>
  to_not_in?: Maybe<Array<Scalars['Float']>>
}

export type OfficeSuiteSizeDesksCondition = {
  __typename?: 'OfficeSuiteSizeDesksCondition'
  from?: Maybe<Scalars['Int']>
  id: Scalars['Int']
  isRange: Scalars['Boolean']
  to?: Maybe<Scalars['Int']>
}

export type OfficeSuiteSizeDesksConditionWhereInput = {
  AND?: Maybe<Array<OfficeSuiteSizeDesksConditionWhereInput>>
  from?: Maybe<Scalars['Int']>
  from_gt?: Maybe<Scalars['Int']>
  from_gte?: Maybe<Scalars['Int']>
  from_in?: Maybe<Array<Scalars['Int']>>
  from_lt?: Maybe<Scalars['Int']>
  from_lte?: Maybe<Scalars['Int']>
  from_not?: Maybe<Scalars['Int']>
  from_not_in?: Maybe<Array<Scalars['Int']>>
  id?: Maybe<Scalars['Int']>
  id_gt?: Maybe<Scalars['Int']>
  id_gte?: Maybe<Scalars['Int']>
  id_in?: Maybe<Array<Scalars['Int']>>
  id_lt?: Maybe<Scalars['Int']>
  id_lte?: Maybe<Scalars['Int']>
  id_not?: Maybe<Scalars['Int']>
  id_not_in?: Maybe<Array<Scalars['Int']>>
  isRange?: Maybe<Scalars['Boolean']>
  isRange_not?: Maybe<Scalars['Boolean']>
  NOT?: Maybe<Array<OfficeSuiteSizeDesksConditionWhereInput>>
  OR?: Maybe<Array<OfficeSuiteSizeDesksConditionWhereInput>>
  to?: Maybe<Scalars['Int']>
  to_gt?: Maybe<Scalars['Int']>
  to_gte?: Maybe<Scalars['Int']>
  to_in?: Maybe<Array<Scalars['Int']>>
  to_lt?: Maybe<Scalars['Int']>
  to_lte?: Maybe<Scalars['Int']>
  to_not?: Maybe<Scalars['Int']>
  to_not_in?: Maybe<Array<Scalars['Int']>>
}

export type OfficeSuiteSizeSpaceCondition = {
  __typename?: 'OfficeSuiteSizeSpaceCondition'
  from?: Maybe<Scalars['Float']>
  id: Scalars['Int']
  isRange: Scalars['Boolean']
  to?: Maybe<Scalars['Float']>
  unit: OfficeSuiteSpaceUnit
}

export type OfficeSuiteSizeSpaceConditionWhereInput = {
  AND?: Maybe<Array<OfficeSuiteSizeSpaceConditionWhereInput>>
  from?: Maybe<Scalars['Float']>
  from_gt?: Maybe<Scalars['Float']>
  from_gte?: Maybe<Scalars['Float']>
  from_in?: Maybe<Array<Scalars['Float']>>
  from_lt?: Maybe<Scalars['Float']>
  from_lte?: Maybe<Scalars['Float']>
  from_not?: Maybe<Scalars['Float']>
  from_not_in?: Maybe<Array<Scalars['Float']>>
  id?: Maybe<Scalars['Int']>
  id_gt?: Maybe<Scalars['Int']>
  id_gte?: Maybe<Scalars['Int']>
  id_in?: Maybe<Array<Scalars['Int']>>
  id_lt?: Maybe<Scalars['Int']>
  id_lte?: Maybe<Scalars['Int']>
  id_not?: Maybe<Scalars['Int']>
  id_not_in?: Maybe<Array<Scalars['Int']>>
  isRange?: Maybe<Scalars['Boolean']>
  isRange_not?: Maybe<Scalars['Boolean']>
  NOT?: Maybe<Array<OfficeSuiteSizeSpaceConditionWhereInput>>
  OR?: Maybe<Array<OfficeSuiteSizeSpaceConditionWhereInput>>
  to?: Maybe<Scalars['Float']>
  to_gt?: Maybe<Scalars['Float']>
  to_gte?: Maybe<Scalars['Float']>
  to_in?: Maybe<Array<Scalars['Float']>>
  to_lt?: Maybe<Scalars['Float']>
  to_lte?: Maybe<Scalars['Float']>
  to_not?: Maybe<Scalars['Float']>
  to_not_in?: Maybe<Array<Scalars['Float']>>
  unit?: Maybe<OfficeSuiteSpaceUnit>
  unit_in?: Maybe<Array<OfficeSuiteSpaceUnit>>
  unit_not?: Maybe<OfficeSuiteSpaceUnit>
  unit_not_in?: Maybe<Array<OfficeSuiteSpaceUnit>>
}

export enum OfficeSuiteSpaceLocation {
  EntireFloor = 'ENTIRE_FLOOR',
  Exterior = 'EXTERIOR',
  Interior = 'INTERIOR',
}

export enum OfficeSuiteSpaceUnit {
  SquareFoot = 'SQUARE_FOOT',
  SquareMeter = 'SQUARE_METER',
}

export enum OfficeSuiteStatus {
  Available = 'AVAILABLE',
  Occupied = 'OCCUPIED',
  UnderOffer = 'UNDER_OFFER',
}

export type OfficeSuiteWhereInput = {
  AND?: Maybe<Array<OfficeSuiteWhereInput>>
  availableFrom?: Maybe<AvailabilityConditionWhereInput>
  canBePartitioned?: Maybe<Scalars['Boolean']>
  canBePartitioned_not?: Maybe<Scalars['Boolean']>
  floor?: Maybe<Scalars['String']>
  floor_contains?: Maybe<Scalars['String']>
  floor_ends_with?: Maybe<Scalars['String']>
  floor_gt?: Maybe<Scalars['String']>
  floor_gte?: Maybe<Scalars['String']>
  floor_in?: Maybe<Array<Scalars['String']>>
  floor_lt?: Maybe<Scalars['String']>
  floor_lte?: Maybe<Scalars['String']>
  floor_not?: Maybe<Scalars['String']>
  floor_not_contains?: Maybe<Scalars['String']>
  floor_not_ends_with?: Maybe<Scalars['String']>
  floor_not_in?: Maybe<Array<Scalars['String']>>
  floor_not_starts_with?: Maybe<Scalars['String']>
  floor_starts_with?: Maybe<Scalars['String']>
  id?: Maybe<Scalars['Int']>
  id_gt?: Maybe<Scalars['Int']>
  id_gte?: Maybe<Scalars['Int']>
  id_in?: Maybe<Array<Scalars['Int']>>
  id_lt?: Maybe<Scalars['Int']>
  id_lte?: Maybe<Scalars['Int']>
  id_not?: Maybe<Scalars['Int']>
  id_not_in?: Maybe<Array<Scalars['Int']>>
  monthlyQuotingRateCurrency?: Maybe<Currency>
  monthlyQuotingRateCurrency_in?: Maybe<Array<Currency>>
  monthlyQuotingRateCurrency_not?: Maybe<Currency>
  monthlyQuotingRateCurrency_not_in?: Maybe<Array<Currency>>
  monthlyQuotingRateDesk?: Maybe<OfficeSuiteCostConditionWhereInput>
  monthlyQuotingRateSpace?: Maybe<OfficeSuiteCostConditionWhereInput>
  monthlyQuotingRateTotal?: Maybe<OfficeSuiteCostConditionWhereInput>
  NOT?: Maybe<Array<OfficeSuiteWhereInput>>
  OR?: Maybe<Array<OfficeSuiteWhereInput>>
  photos_every?: Maybe<PhotoWhereInput>
  photos_none?: Maybe<PhotoWhereInput>
  photos_some?: Maybe<PhotoWhereInput>
  sizeDesks?: Maybe<OfficeSuiteSizeDesksConditionWhereInput>
  sizeSpace?: Maybe<OfficeSuiteSizeSpaceConditionWhereInput>
  spaceLocation?: Maybe<OfficeSuiteSpaceLocation>
  spaceLocation_in?: Maybe<Array<OfficeSuiteSpaceLocation>>
  spaceLocation_not?: Maybe<OfficeSuiteSpaceLocation>
  spaceLocation_not_in?: Maybe<Array<OfficeSuiteSpaceLocation>>
  status?: Maybe<OfficeSuiteStatus>
  status_in?: Maybe<Array<OfficeSuiteStatus>>
  status_not?: Maybe<OfficeSuiteStatus>
  status_not_in?: Maybe<Array<OfficeSuiteStatus>>
  type?: Maybe<SpaceType>
  type_in?: Maybe<Array<SpaceType>>
  type_not?: Maybe<SpaceType>
  type_not_in?: Maybe<Array<SpaceType>>
}

export type OfficeWhereInput = {
  id?: Maybe<Scalars['Int']>
  id_in?: Maybe<Array<Scalars['Int']>>
  operator?: Maybe<OperatorWhereInput>
  officeSuites_some?: Maybe<OfficeSuiteWhereInput>
}

export type OfficeWhereUniqueInput = {
  id?: Maybe<Scalars['Int']>
}

export type Operator = Node & {
  __typename?: 'Operator'
  contacts?: Maybe<Array<Contact>>
  externalId?: Maybe<Scalars['String']>
  id: Scalars['Int']
  isPayingCustomer?: Maybe<Scalars['Boolean']>
  logo?: Maybe<Scalars['String']>
  mapPin?: Maybe<Scalars['String']>
  name: Scalars['String']
  offices?: Maybe<Array<Office>>
  officesAgg?: Maybe<OfficesAgg>
  primaryColor?: Maybe<Scalars['String']>
  shortName?: Maybe<Scalars['String']>
  website?: Maybe<Scalars['String']>
}

export type OperatorWhereInput = {
  id_in?: Maybe<Array<Scalars['Int']>>
}

export type OpportunitiesAgg = {
  __typename?: 'OpportunitiesAgg'
  size: Scalars['Int']
}

export type Opportunity = Node & {
  __typename?: 'Opportunity'
  availableFromCondition?: Maybe<AvailabilityCondition>
  budgetCondition?: Maybe<OfficeCostCondition>
  companyName?: Maybe<Scalars['String']>
  companyWebsite?: Maybe<Scalars['String']>
  contactEmail?: Maybe<Scalars['String']>
  contactFullName?: Maybe<Scalars['String']>
  createdAt: Scalars['DateTime']
  detailsUpdatedAt?: Maybe<Scalars['DateTime']>
  id: Scalars['Int']
  isDeleted?: Maybe<Scalars['Boolean']>
  leads?: Maybe<Array<Lead>>
  meta?: Maybe<Scalars['JSON']>
  notes?: Maybe<Scalars['String']>
  officeSizeCondition?: Maybe<OfficeSizeCondition>
  status: OpportunityStatusType
  termLengthCondition?: Maybe<TermLengthCondition>
  user: User
}

export type OpportunityLeadsArgs = {
  first?: Maybe<Scalars['Int']>
  orderBy?: Maybe<OpportunityLeadOrderByInput>
  search?: Maybe<Scalars['String']>
  skip?: Maybe<Scalars['Int']>
  where?: Maybe<LeadWhereInput>
}

export type OpportunityCreateInput = {
  status?: Maybe<OpportunityStatusType>
  companyName?: Maybe<Scalars['String']>
  companyWebsite?: Maybe<Scalars['String']>
  contactFullName?: Maybe<Scalars['String']>
  contactEmail?: Maybe<Scalars['String']>
  termLengthCondition?: Maybe<TermLengthConditionCreateOneInput>
  availableFromCondition?: Maybe<AvailabilityConditionCreateOneInput>
  officeSizeCondition?: Maybe<OfficeSizeConditionCreateOneInput>
  budgetCondition?: Maybe<OfficeCostConditionCreateOneInput>
  notes?: Maybe<Scalars['String']>
  leads?: Maybe<LeadCreateManyInput>
  isDeleted?: Maybe<Scalars['Boolean']>
}

export enum OpportunityLeadOrderByInput {
  OfficeNameAsc = 'officeName_ASC',
  OfficeNameDesc = 'officeName_DESC',
  OperatorNameAsc = 'operatorName_ASC',
  OperatorNameDesc = 'operatorName_DESC',
}

export enum OpportunityOrderByInput {
  CompanyNameAsc = 'companyName_ASC',
  CompanyNameDesc = 'companyName_DESC',
  ContactEmailAsc = 'contactEmail_ASC',
  ContactEmailDesc = 'contactEmail_DESC',
  CreatedAtAsc = 'createdAt_ASC',
  CreatedAtDesc = 'createdAt_DESC',
  IdAsc = 'id_ASC',
  IdDesc = 'id_DESC',
  IsDeletedAsc = 'isDeleted_ASC',
  IsDeletedDesc = 'isDeleted_DESC',
  NotesAsc = 'notes_ASC',
  NotesDesc = 'notes_DESC',
  StatusAsc = 'status_ASC',
  StatusDesc = 'status_DESC',
  UpdatedAtAsc = 'updatedAt_ASC',
  UpdatedAtDesc = 'updatedAt_DESC',
}

export enum OpportunityStatusType {
  Active = 'ACTIVE',
  Lost = 'LOST',
  Onhold = 'ONHOLD',
  Won = 'WON',
}

export type OpportunityUpdateInput = {
  status?: Maybe<OpportunityStatusType>
  leads?: Maybe<LeadCreateManyInput>
  companyName?: Maybe<Scalars['String']>
  companyWebsite?: Maybe<Scalars['String']>
  contactFullName?: Maybe<Scalars['String']>
  contactEmail?: Maybe<Scalars['String']>
  notes?: Maybe<Scalars['String']>
  meta?: Maybe<Scalars['JSON']>
  termLengthCondition?: Maybe<TermLengthConditionUpdateOneInput>
  availableFromCondition?: Maybe<AvailabilityConditionUpdateOneInput>
  officeSizeCondition?: Maybe<OfficeSizeConditionUpdateOneInput>
  budgetCondition?: Maybe<OfficeCostConditionUpdateOneInput>
  isDeleted?: Maybe<Scalars['Boolean']>
}

export type OpportunityWhereInput = {
  AND?: Maybe<Array<OpportunityWhereInput>>
  OR?: Maybe<Array<OpportunityWhereInput>>
  NOT?: Maybe<Array<OpportunityWhereInput>>
  id?: Maybe<Scalars['Int']>
  id_not?: Maybe<Scalars['Int']>
  id_in?: Maybe<Array<Scalars['Int']>>
  id_not_in?: Maybe<Array<Scalars['Int']>>
  id_lt?: Maybe<Scalars['Int']>
  id_lte?: Maybe<Scalars['Int']>
  id_gt?: Maybe<Scalars['Int']>
  id_gte?: Maybe<Scalars['Int']>
  status?: Maybe<OpportunityStatusType>
  status_not?: Maybe<OpportunityStatusType>
  status_in?: Maybe<Array<OpportunityStatusType>>
  status_not_in?: Maybe<Array<OpportunityStatusType>>
  companyName?: Maybe<Scalars['String']>
  companyName_not?: Maybe<Scalars['String']>
  companyName_in?: Maybe<Array<Scalars['String']>>
  companyName_not_in?: Maybe<Array<Scalars['String']>>
  companyName_lt?: Maybe<Scalars['String']>
  companyName_lte?: Maybe<Scalars['String']>
  companyName_gt?: Maybe<Scalars['String']>
  companyName_gte?: Maybe<Scalars['String']>
  companyName_contains?: Maybe<Scalars['String']>
  companyName_not_contains?: Maybe<Scalars['String']>
  companyName_starts_with?: Maybe<Scalars['String']>
  companyName_not_starts_with?: Maybe<Scalars['String']>
  companyName_ends_with?: Maybe<Scalars['String']>
  companyName_not_ends_with?: Maybe<Scalars['String']>
  contactEmail?: Maybe<Scalars['String']>
  contactEmail_not?: Maybe<Scalars['String']>
  contactEmail_in?: Maybe<Array<Scalars['String']>>
  contactEmail_not_in?: Maybe<Array<Scalars['String']>>
  contactEmail_lt?: Maybe<Scalars['String']>
  contactEmail_lte?: Maybe<Scalars['String']>
  contactEmail_gt?: Maybe<Scalars['String']>
  contactEmail_gte?: Maybe<Scalars['String']>
  contactEmail_contains?: Maybe<Scalars['String']>
  contactEmail_not_contains?: Maybe<Scalars['String']>
  contactEmail_starts_with?: Maybe<Scalars['String']>
  contactEmail_not_starts_with?: Maybe<Scalars['String']>
  contactEmail_ends_with?: Maybe<Scalars['String']>
  contactEmail_not_ends_with?: Maybe<Scalars['String']>
  termLengthCondition?: Maybe<TermLengthConditionWhereInput>
  availableFromCondition?: Maybe<AvailabilityConditionWhereInput>
  officeSizeCondition?: Maybe<OfficeSizeConditionWhereInput>
  budgetCondition?: Maybe<OfficeCostConditionWhereInput>
  notes?: Maybe<Scalars['String']>
  notes_not?: Maybe<Scalars['String']>
  notes_in?: Maybe<Array<Scalars['String']>>
  notes_not_in?: Maybe<Array<Scalars['String']>>
  notes_lt?: Maybe<Scalars['String']>
  notes_lte?: Maybe<Scalars['String']>
  notes_gt?: Maybe<Scalars['String']>
  notes_gte?: Maybe<Scalars['String']>
  notes_contains?: Maybe<Scalars['String']>
  notes_not_contains?: Maybe<Scalars['String']>
  notes_starts_with?: Maybe<Scalars['String']>
  notes_not_starts_with?: Maybe<Scalars['String']>
  notes_ends_with?: Maybe<Scalars['String']>
  notes_not_ends_with?: Maybe<Scalars['String']>
  isDeleted?: Maybe<Scalars['Boolean']>
  isDeleted_not?: Maybe<Scalars['Boolean']>
}

export type OpportunityWhereUniqueInput = {
  id?: Maybe<Scalars['Int']>
}

export type Phone = {
  __typename?: 'Phone'
  id: Scalars['Int']
  type?: Maybe<ContactType>
  value?: Maybe<Scalars['String']>
}

export type PhoneCreateInput = {
  value?: Maybe<Scalars['String']>
  type?: Maybe<ContactType>
}

export type PhoneUpdateDataInput = {
  value?: Maybe<Scalars['String']>
  type?: Maybe<ContactType>
}

export type PhoneUpdateManyInput = {
  create?: Maybe<Array<PhoneCreateInput>>
  update?: Maybe<Array<PhoneUpdateWithWhereUniqueNestedInput>>
  delete?: Maybe<Array<PhoneWhereUniqueInput>>
}

export type PhoneUpdateWithWhereUniqueNestedInput = {
  where: PhoneWhereUniqueInput
  data: PhoneUpdateDataInput
}

export type PhoneWhereUniqueInput = {
  id?: Maybe<Scalars['Int']>
}

export type Photo = Node & {
  __typename?: 'Photo'
  height?: Maybe<Scalars['String']>
  id: Scalars['Int']
  type?: Maybe<PhotoType>
  url: Scalars['String']
  width?: Maybe<Scalars['String']>
}

export enum PhotoType {
  Common = 'COMMON',
  Cover = 'COVER',
  FeaturedOne = 'FEATURED_ONE',
  FeaturedTwo = 'FEATURED_TWO',
}

export type PhotoUpdateOneInput = {
  disconnect?: Maybe<Scalars['Boolean']>
  connect?: Maybe<PhotoWhereUniqueInput>
}

export type PhotoWhereInput = {
  AND?: Maybe<Array<PhotoWhereInput>>
  id?: Maybe<Scalars['Int']>
  id_gt?: Maybe<Scalars['Int']>
  id_gte?: Maybe<Scalars['Int']>
  id_in?: Maybe<Array<Scalars['Int']>>
  id_lt?: Maybe<Scalars['Int']>
  id_lte?: Maybe<Scalars['Int']>
  id_not?: Maybe<Scalars['Int']>
  id_not_in?: Maybe<Array<Scalars['Int']>>
}

export type PhotoWhereUniqueInput = {
  id?: Maybe<Scalars['Int']>
}

export type Query = {
  __typename?: 'Query'
  agents: Array<Maybe<Agent>>
  me?: Maybe<User>
  office?: Maybe<Office>
  offices: Array<Maybe<Office>>
  operators?: Maybe<Array<Maybe<Operator>>>
  opportunities: Array<Maybe<Opportunity>>
  opportunitiesAgg: OpportunitiesAgg
  opportunity: Opportunity
}

export type QueryAgentsArgs = {
  where?: Maybe<AgentWhereInput>
}

export type QueryOfficeArgs = {
  where: OfficeWhereUniqueInput
}

export type QueryOfficesArgs = {
  after?: Maybe<Scalars['String']>
  before?: Maybe<Scalars['String']>
  first?: Maybe<Scalars['Int']>
  last?: Maybe<Scalars['Int']>
  skip?: Maybe<Scalars['Int']>
  where?: Maybe<OfficeWhereInput>
}

export type QueryOpportunitiesArgs = {
  after?: Maybe<Scalars['String']>
  before?: Maybe<Scalars['String']>
  first?: Maybe<Scalars['Int']>
  last?: Maybe<Scalars['Int']>
  orderBy?: Maybe<OpportunityOrderByInput>
  skip?: Maybe<Scalars['Int']>
  where?: Maybe<OpportunityWhereInput>
}

export type QueryOpportunityArgs = {
  id: Scalars['Int']
}

export type Region = {
  __typename?: 'Region'
  id: Scalars['Int']
  name: Scalars['String']
  polygon: Scalars['JSON']
}

export type SendOperatorLeadsInput = {
  leadIds: Array<Scalars['Int']>
  message?: Maybe<Scalars['String']>
  heading?: Maybe<Scalars['String']>
  sendCopyToMyself?: Maybe<Scalars['Boolean']>
}

export type SendOperatorLeadsOutput = {
  __typename?: 'SendOperatorLeadsOutput'
  isSucceeded?: Maybe<Scalars['Boolean']>
}

export enum SpaceType {
  CoworkingDesks = 'COWORKING_DESKS',
  Membership = 'MEMBERSHIP',
  PipelineManagedSpace = 'PIPELINE_MANAGED_SPACE',
  PrivateOffice = 'PRIVATE_OFFICE',
  SelfContainedManagedSpace = 'SELF_CONTAINED_MANAGED_SPACE',
}

export type TermAndCondition = {
  __typename?: 'TermAndCondition'
  canBeDelayed: Scalars['Boolean']
  documentHtmlUrl: Scalars['String']
  documentPdfUrl: Scalars['String']
  id: Scalars['Int']
  isAccepted: Scalars['Boolean']
  updatedAt: Scalars['DateTime']
}

export type TermLengthCondition = {
  __typename?: 'TermLengthCondition'
  from?: Maybe<Scalars['Int']>
  id: Scalars['Int']
  isRange: Scalars['Boolean']
  to?: Maybe<Scalars['Int']>
}

export type TermLengthConditionCreateInput = {
  from?: Maybe<Scalars['Int']>
  to?: Maybe<Scalars['Int']>
  isRange: Scalars['Boolean']
}

export type TermLengthConditionCreateOneInput = {
  create?: Maybe<TermLengthConditionCreateInput>
}

export type TermLengthConditionUpdateDataInput = {
  from?: Maybe<Scalars['Int']>
  to?: Maybe<Scalars['Int']>
  isRange?: Maybe<Scalars['Boolean']>
}

export type TermLengthConditionUpdateOneInput = {
  upsert?: Maybe<TermLengthConditionUpsertNestedInput>
  delete?: Maybe<Scalars['Boolean']>
}

export type TermLengthConditionUpsertNestedInput = {
  update: TermLengthConditionUpdateDataInput
  create: TermLengthConditionCreateInput
}

export type TermLengthConditionWhereInput = {
  from?: Maybe<Scalars['Int']>
  from_not?: Maybe<Scalars['Int']>
  from_in?: Maybe<Array<Scalars['Int']>>
  from_not_in?: Maybe<Array<Scalars['Int']>>
  from_lt?: Maybe<Scalars['Int']>
  from_lte?: Maybe<Scalars['Int']>
  from_gt?: Maybe<Scalars['Int']>
  from_gte?: Maybe<Scalars['Int']>
  to?: Maybe<Scalars['Int']>
  to_not?: Maybe<Scalars['Int']>
  to_in?: Maybe<Array<Scalars['Int']>>
  to_not_in?: Maybe<Array<Scalars['Int']>>
  to_lt?: Maybe<Scalars['Int']>
  to_lte?: Maybe<Scalars['Int']>
  to_gt?: Maybe<Scalars['Int']>
  to_gte?: Maybe<Scalars['Int']>
  isRange?: Maybe<Scalars['Boolean']>
  isRange_not?: Maybe<Scalars['Boolean']>
  AND?: Maybe<Array<TermLengthConditionWhereInput>>
  OR?: Maybe<Array<TermLengthConditionWhereInput>>
  NOT?: Maybe<Array<TermLengthConditionWhereInput>>
}

export type Transport = {
  __typename?: 'Transport'
  distance: Distance
  duration: Duration
  id: Scalars['Int']
  lines?: Maybe<Array<Maybe<Scalars['String']>>>
  name?: Maybe<Scalars['String']>
  type?: Maybe<TransportTypes>
}

export enum TransportTypes {
  SubwayStation = 'SUBWAY_STATION',
  TrainStation = 'TRAIN_STATION',
  TransitStation = 'TRANSIT_STATION',
}

export type User = {
  __typename?: 'User'
  agent?: Maybe<Agent>
  awsId?: Maybe<Scalars['String']>
  contact: Contact
  currency: Currency
  enabled: Scalars['Boolean']
  id: Scalars['Int']
  operator?: Maybe<Operator>
  permissions: Array<UserPermissionKey>
  regions?: Maybe<Array<Maybe<Region>>>
  termAndCondition?: Maybe<TermAndCondition>
  type: UserType
  userName: Scalars['String']
}

export enum UserPermissionKey {
  AccessToAllOpportunities = 'ACCESS_TO_ALL_OPPORTUNITIES',
  AgentsPermissions = 'AGENTS_PERMISSIONS',
  ContentManagement = 'CONTENT_MANAGEMENT',
  ReferralsAndReports = 'REFERRALS_AND_REPORTS',
  UserManagement = 'USER_MANAGEMENT',
  UserManagementSetRole = 'USER_MANAGEMENT_SET_ROLE',
  UserRoleManagement = 'USER_ROLE_MANAGEMENT',
  UserRoleManagementDelete = 'USER_ROLE_MANAGEMENT_DELETE',
  UserRoleSuperAdminManagement = 'USER_ROLE_SUPER_ADMIN_MANAGEMENT',
}

export enum UserType {
  Agent = 'AGENT',
  Operator = 'OPERATOR',
  Platform = 'PLATFORM',
}

export type UserUpdateInput = {
  currency?: Maybe<Currency>
  contact?: Maybe<ContactUpdateOneRequiredInput>
}

export type UserWhereUniqueInput = {
  id?: Maybe<Scalars['Int']>
  awsId?: Maybe<Scalars['String']>
}

export type OfficeModalAvailabilityFragment = {
  __typename?: 'OfficeAvailability'
} & Pick<OfficeAvailability, 'availableOfficeSuitesCount' | 'availableFrom'>

export type ContactViewFragment = { __typename?: 'Contact' } & Pick<
  Contact,
  'id' | 'name' | 'avatarUrl'
> & {
    emails: Maybe<Array<{ __typename?: 'Email' } & Pick<Email, 'id' | 'value'>>>
  }

export type OfficeTransportAndContactQueryVariables = {
  where: OfficeWhereUniqueInput
}

export type OfficeTransportAndContactQuery = { __typename?: 'Query' } & {
  office: Maybe<
    { __typename?: 'Office' } & Pick<Office, 'id'> & {
        availability: Maybe<
          {
            __typename?: 'OfficeAvailability'
          } & OfficeModalAvailabilityFragment
        >
        contacts: Maybe<Array<{ __typename?: 'Contact' } & ContactViewFragment>>
        operator: { __typename?: 'Operator' } & Pick<Operator, 'id'> & {
            contacts: Maybe<
              Array<{ __typename?: 'Contact' } & ContactViewFragment>
            >
          }
        address: Maybe<
          { __typename?: 'Address' } & Pick<Address, 'id'> & {
              location: Maybe<
                { __typename?: 'Location' } & Pick<Location, 'id'> & {
                    transport: Maybe<
                      Array<
                        Maybe<
                          { __typename?: 'Transport' } & TransportViewFragment
                        >
                      >
                    >
                  }
              >
            }
        >
      }
  >
}

export type OfficeGalleryFragment = { __typename?: 'Office' } & Pick<
  Office,
  'id' | 'name'
> & { photos: Maybe<Array<{ __typename?: 'Photo' } & Pick<Photo, 'id'>>> }

export type OfficeSuiteGalleryFragment = { __typename?: 'OfficeSuite' } & Pick<
  OfficeSuite,
  'id' | 'name'
> & { photos: Maybe<Array<{ __typename?: 'Photo' } & Pick<Photo, 'id'>>> }

export type OpportunityOfficesQueryVariables = {
  where?: Maybe<OfficeWhereInput>
}

export type OpportunityOfficesQuery = { __typename?: 'Query' } & {
  offices: Array<
    Maybe<
      { __typename?: 'Office' } & Pick<Office, 'id'> & {
          operator: { __typename?: 'Operator' } & Pick<
            Operator,
            'id' | 'name' | 'logo'
          >
          address: Maybe<
            { __typename?: 'Address' } & Pick<Address, 'id' | 'city'>
          >
        }
    >
  >
}

export type TransportViewFragment = { __typename?: 'Transport' } & Pick<
  Transport,
  'id' | 'name' | 'type' | 'lines'
> & {
    distance: { __typename?: 'Distance' } & Pick<
      Distance,
      'id' | 'text' | 'value'
    >
    duration: { __typename?: 'Duration' } & Pick<
      Duration,
      'id' | 'text' | 'value'
    >
  }

export type LeadFragmentFragment = { __typename?: 'Lead' } & Pick<
  Lead,
  'id' | 'createdAt' | 'status'
> & {
    office: Maybe<{ __typename?: 'Office' } & OfficeFragmentFragment>
    emailMessages: Maybe<
      Array<
        { __typename?: 'EmailMessage' } & Pick<
          EmailMessage,
          | 'id'
          | 'createdAt'
          | 'sentAt'
          | 'state'
          | 'emailBodyKey'
          | 'emailCustomMessage'
          | 'emailHeading'
        >
      >
    >
    offers: Maybe<
      Array<
        { __typename?: 'Offer' } & Pick<Offer, 'id' | 'description'> & {
            termLengthCondition: Maybe<
              { __typename?: 'TermLengthCondition' } & Pick<
                TermLengthCondition,
                'id' | 'from' | 'to' | 'isRange'
              >
            >
            availableFromCondition: Maybe<
              { __typename?: 'AvailabilityCondition' } & Pick<
                AvailabilityCondition,
                'id' | 'from' | 'to' | 'isRange'
              >
            >
            costCondition: Maybe<
              { __typename?: 'OfficeCostCondition' } & Pick<
                OfficeCostCondition,
                'id' | 'from' | 'to' | 'isRange' | 'unit' | 'currency'
              >
            >
            officeSizeCondition: Maybe<
              { __typename?: 'OfficeSizeCondition' } & Pick<
                OfficeSizeCondition,
                'id' | 'from' | 'to' | 'isRange' | 'unit'
              >
            >
            monthlyQuotingRateCondition: Maybe<
              { __typename?: 'MonthlyQuotingRateCondition' } & Pick<
                MonthlyQuotingRateCondition,
                'id' | 'from' | 'to' | 'isRange' | 'unit' | 'currency'
              >
            >
          }
      >
    >
  }

export type LeadReportFragment = { __typename?: 'Lead' } & {
  office: Maybe<{ __typename?: 'Office' } & OfficeReportFragment>
} & LeadFragmentFragment

export type UpdateLeadStatusMutationVariables = {
  status: LeadStatusType
  id: Scalars['Int']
}

export type UpdateLeadStatusMutation = { __typename?: 'Mutation' } & {
  updateLead: Maybe<{ __typename?: 'Lead' } & Pick<Lead, 'id' | 'status'>>
}

export type UpdateLeadMutationVariables = {
  data: LeadUpdateInput
  where: LeadWhereUniqueInput
}

export type UpdateLeadMutation = { __typename?: 'Mutation' } & {
  updateLead: Maybe<{ __typename?: 'Lead' } & Pick<Lead, 'id'>>
}

export type SendOperatorLeadsMutationVariables = {
  data: SendOperatorLeadsInput
}

export type SendOperatorLeadsMutation = { __typename?: 'Mutation' } & {
  sendOperatorLeads: Maybe<
    { __typename?: 'SendOperatorLeadsOutput' } & Pick<
      SendOperatorLeadsOutput,
      'isSucceeded'
    >
  >
}

export type ReferralsFragmentFragment = { __typename?: 'Lead' } & Pick<
  Lead,
  'id' | 'createdAt' | 'status'
> & {
    office: Maybe<{ __typename?: 'Office' } & OfficeLeadFragmentFragment>
    emailMessages: Maybe<
      Array<
        { __typename?: 'EmailMessage' } & Pick<
          EmailMessage,
          | 'id'
          | 'createdAt'
          | 'sentAt'
          | 'state'
          | 'emailBodyKey'
          | 'emailCustomMessage'
          | 'emailHeading'
        >
      >
    >
    offers: Maybe<
      Array<
        { __typename?: 'Offer' } & Pick<Offer, 'id' | 'description'> & {
            termLengthCondition: Maybe<
              { __typename?: 'TermLengthCondition' } & Pick<
                TermLengthCondition,
                'id' | 'from' | 'to' | 'isRange'
              >
            >
            availableFromCondition: Maybe<
              { __typename?: 'AvailabilityCondition' } & Pick<
                AvailabilityCondition,
                'id' | 'from' | 'to' | 'isRange'
              >
            >
            costCondition: Maybe<
              { __typename?: 'OfficeCostCondition' } & Pick<
                OfficeCostCondition,
                'id' | 'from' | 'to' | 'isRange' | 'unit' | 'currency'
              >
            >
            officeSizeCondition: Maybe<
              { __typename?: 'OfficeSizeCondition' } & Pick<
                OfficeSizeCondition,
                'id' | 'from' | 'to' | 'isRange' | 'unit'
              >
            >
            monthlyQuotingRateCondition: Maybe<
              { __typename?: 'MonthlyQuotingRateCondition' } & Pick<
                MonthlyQuotingRateCondition,
                'id' | 'from' | 'to' | 'isRange' | 'unit' | 'currency'
              >
            >
          }
      >
    >
  }

export type MonthlyQuotingRateFragmentFragment = {
  __typename?: 'MonthlyQuotingRateCondition'
} & Pick<
  MonthlyQuotingRateCondition,
  'id' | 'from' | 'to' | 'unit' | 'isRange' | 'currency'
>

export type OfficeFragmentFragment = { __typename?: 'Office' } & Pick<
  Office,
  'id' | 'name' | 'description' | 'websiteURL'
> & {
    monthlyQuotingRate: Maybe<
      {
        __typename?: 'MonthlyQuotingRateCondition'
      } & MonthlyQuotingRateFragmentFragment
    >
    photos: Maybe<Array<{ __typename?: 'Photo' } & Pick<Photo, 'id'>>>
    operator: { __typename?: 'Operator' } & Pick<
      Operator,
      'id' | 'name' | 'mapPin' | 'logo' | 'website' | 'isPayingCustomer'
    >
    address: Maybe<
      { __typename?: 'Address' } & Pick<
        Address,
        | 'id'
        | 'addressLineOne'
        | 'addressLineTwo'
        | 'addressLineThree'
        | 'addressLineFour'
        | 'city'
        | 'postCodePartOne'
      > & {
          location: Maybe<
            { __typename?: 'Location' } & Pick<
              Location,
              'id' | 'latitude' | 'longitude'
            >
          >
        }
    >
    amenities: Maybe<
      Array<
        { __typename?: 'OfficeAmenity' } & Pick<
          OfficeAmenity,
          'id' | 'key' | 'icon' | 'isEnabled'
        >
      >
    >
  }

export type OfficeReportFragment = { __typename?: 'Office' } & {
  address: Maybe<
    { __typename?: 'Address' } & {
      location: Maybe<
        { __typename?: 'Location' } & {
          transport: Maybe<
            Array<Maybe<{ __typename?: 'Transport' } & TransportViewFragment>>
          >
        }
      >
    }
  >
} & OfficeFragmentFragment

export type OfficeFloorplansFragmentFragment = { __typename?: 'Office' } & {
  floorplans: Maybe<
    Array<
      { __typename?: 'Floorplan' } & Pick<
        Floorplan,
        'id' | 'url' | 'name' | 'floor'
      >
    >
  >
}

export type OfficeMapFragmentFragment = { __typename?: 'Office' } & Pick<
  Office,
  'id' | 'name'
> & {
    monthlyQuotingRate: Maybe<
      {
        __typename?: 'MonthlyQuotingRateCondition'
      } & MonthlyQuotingRateFragmentFragment
    >
    photos: Maybe<Array<{ __typename?: 'Photo' } & Pick<Photo, 'id'>>>
    operator: { __typename?: 'Operator' } & Pick<
      Operator,
      'id' | 'name' | 'mapPin' | 'logo'
    >
    address: Maybe<
      { __typename?: 'Address' } & Pick<
        Address,
        'id' | 'addressLineOne' | 'postCodePartOne'
      > & {
          location: Maybe<
            { __typename?: 'Location' } & Pick<
              Location,
              'id' | 'latitude' | 'longitude'
            >
          >
        }
    >
    floorplans: Maybe<
      Array<{ __typename?: 'Floorplan' } & Pick<Floorplan, 'id'>>
    >
  }

export type OfficesFragmentFragment = { __typename?: 'Office' } & Pick<
  Office,
  'id' | 'name'
> & {
    monthlyQuotingRate: Maybe<
      {
        __typename?: 'MonthlyQuotingRateCondition'
      } & MonthlyQuotingRateFragmentFragment
    >
    photos: Maybe<Array<{ __typename?: 'Photo' } & Pick<Photo, 'id'>>>
    operator: { __typename?: 'Operator' } & Pick<
      Operator,
      'id' | 'name' | 'mapPin' | 'logo'
    >
    address: Maybe<
      { __typename?: 'Address' } & Pick<
        Address,
        'id' | 'addressLineOne' | 'city' | 'postCodePartOne'
      > & {
          location: Maybe<
            { __typename?: 'Location' } & Pick<
              Location,
              'id' | 'latitude' | 'longitude'
            >
          >
        }
    >
  }

export type OfficeAvailabilityFragment = {
  __typename?: 'OfficeAvailability'
} & Pick<
  OfficeAvailability,
  | 'totalOfficeSuitesCount'
  | 'availableOfficeSuitesCount'
  | 'uncertainOfficeSuitesCount'
  | 'availableFrom'
>

export type MapOfficesQueryVariables = {
  where?: Maybe<OfficeWhereInput>
}

export type MapOfficesQuery = { __typename?: 'Query' } & {
  offices: Array<Maybe<{ __typename?: 'Office' } & OfficeMapFragmentFragment>>
}

export type OfficeAdditionalInfoFragment = { __typename?: 'Office' } & Pick<
  Office,
  'id'
> & {
    photos: Maybe<Array<{ __typename?: 'Photo' } & Pick<Photo, 'id'>>>
    availability: Maybe<
      { __typename?: 'OfficeAvailability' } & OfficeAvailabilityFragment
    >
  }

export type OfficeAdditionalInfoQueryVariables = {
  where: OfficeWhereUniqueInput
}

export type OfficeAdditionalInfoQuery = { __typename?: 'Query' } & {
  office: Maybe<{ __typename?: 'Office' } & OfficeAdditionalInfoFragment>
}

export type OfficesAdditinalInfoQueryVariables = {
  where?: Maybe<OfficeWhereInput>
}

export type OfficesAdditinalInfoQuery = { __typename?: 'Query' } & {
  offices: Array<
    Maybe<{ __typename?: 'Office' } & OfficeAdditionalInfoFragment>
  >
}

export type OfficesQueryVariables = {
  where?: Maybe<OfficeWhereInput>
  first?: Maybe<Scalars['Int']>
  skip?: Maybe<Scalars['Int']>
}

export type OfficesQuery = { __typename?: 'Query' } & {
  offices: Array<Maybe<{ __typename?: 'Office' } & OfficesFragmentFragment>>
}

export type OperatorOfficesQueryVariables = {
  where?: Maybe<OfficeWhereInput>
}

export type OperatorOfficesQuery = { __typename?: 'Query' } & {
  offices: Array<
    Maybe<
      { __typename?: 'Office' } & {
        operator: { __typename?: 'Operator' } & Pick<
          Operator,
          'id' | 'name' | 'mapPin'
        >
      } & OfficeMapFragmentFragment
    >
  >
}

export type FullOfficeInfoFragment = { __typename?: 'Office' } & {
  officeSuites: Maybe<
    Array<{ __typename?: 'OfficeSuite' } & FullOfficeSuiteFragment>
  >
} & OfficeFragmentFragment &
  OfficeFloorplansFragmentFragment

export type OfficeQueryVariables = {
  where: OfficeWhereUniqueInput
}

export type OfficeQuery = { __typename?: 'Query' } & {
  office: Maybe<{ __typename?: 'Office' } & FullOfficeInfoFragment>
}

export type OfficeLeadFragmentFragment = { __typename?: 'Office' } & Pick<
  Office,
  'id' | 'name'
> & {
    photos: Maybe<Array<{ __typename?: 'Photo' } & Pick<Photo, 'id'>>>
    operator: { __typename?: 'Operator' } & Pick<
      Operator,
      'id' | 'name' | 'logo' | 'website'
    >
    address: Maybe<
      { __typename?: 'Address' } & Pick<
        Address,
        'id' | 'addressLineOne' | 'postCodePartOne'
      >
    >
  }

export type AvailableFromFragmentFragment = { __typename?: 'OfficeSuite' } & {
  availableFrom: Maybe<
    { __typename?: 'AvailabilityCondition' } & Pick<
      AvailabilityCondition,
      'id' | 'from' | 'to' | 'isRange'
    >
  >
}

export type SizeDesksFragmentFragment = { __typename?: 'OfficeSuite' } & {
  sizeDesks: Maybe<
    { __typename?: 'OfficeSuiteSizeDesksCondition' } & Pick<
      OfficeSuiteSizeDesksCondition,
      'id' | 'from' | 'to' | 'isRange'
    >
  >
}

export type SizeSpaceFragmentFragment = { __typename?: 'OfficeSuite' } & {
  sizeSpace: Maybe<
    { __typename?: 'OfficeSuiteSizeSpaceCondition' } & Pick<
      OfficeSuiteSizeSpaceCondition,
      'id' | 'from' | 'to' | 'unit' | 'isRange'
    >
  >
}

export type OfficeSuiteFragment = { __typename?: 'OfficeSuite' } & Pick<
  OfficeSuite,
  | 'id'
  | 'isActive'
  | 'externalId'
  | 'name'
  | 'description'
  | 'floor'
  | 'spaceLocation'
  | 'status'
  | 'canBePartitioned'
  | 'updatedAt'
  | 'createdAt'
  | 'monthlyQuotingRateCurrency'
> & {
    monthlyQuotingRateTotal: Maybe<
      { __typename?: 'OfficeSuiteCostCondition' } & Pick<
        OfficeSuiteCostCondition,
        'id' | 'from' | 'to' | 'isRange'
      >
    >
    monthlyQuotingRateDesk: Maybe<
      { __typename?: 'OfficeSuiteCostCondition' } & Pick<
        OfficeSuiteCostCondition,
        'id' | 'from' | 'to' | 'isRange'
      >
    >
    monthlyQuotingRateSpace: Maybe<
      { __typename?: 'OfficeSuiteCostCondition' } & Pick<
        OfficeSuiteCostCondition,
        'id' | 'from' | 'to' | 'isRange'
      >
    >
    sizeDesks: Maybe<
      { __typename?: 'OfficeSuiteSizeDesksCondition' } & Pick<
        OfficeSuiteSizeDesksCondition,
        'id' | 'from' | 'to' | 'isRange'
      >
    >
    sizeSpace: Maybe<
      { __typename?: 'OfficeSuiteSizeSpaceCondition' } & Pick<
        OfficeSuiteSizeSpaceCondition,
        'id' | 'from' | 'to' | 'isRange' | 'unit'
      >
    >
    photos: Maybe<
      Array<
        { __typename?: 'Photo' } & Pick<
          Photo,
          'id' | 'url' | 'type' | 'width' | 'height'
        >
      >
    >
  }

export type OfficeSuiteFloorplansFragment = { __typename?: 'OfficeSuite' } & {
  floorplans: Maybe<
    Array<
      { __typename?: 'Floorplan' } & Pick<
        Floorplan,
        'id' | 'url' | 'name' | 'floor'
      >
    >
  >
}

export type FullOfficeSuiteFragment = {
  __typename?: 'OfficeSuite'
} & OfficeSuiteFragment &
  SizeDesksFragmentFragment &
  SizeSpaceFragmentFragment &
  AvailableFromFragmentFragment &
  OfficeSuiteFloorplansFragment

export type OperatorBaseFieldsFragment = { __typename?: 'Operator' } & Pick<
  Operator,
  'id' | 'name' | 'logo'
>

export type OperatorOfficesAggQueryVariables = {}

export type OperatorOfficesAggQuery = { __typename?: 'Query' } & {
  operators: Maybe<
    Array<
      Maybe<
        { __typename?: 'Operator' } & {
          officesAgg: Maybe<
            { __typename?: 'OfficesAgg' } & Pick<OfficesAgg, 'size'>
          >
        } & OperatorBaseFieldsFragment
      >
    >
  >
}

export type OpportunityFragmentFragment = { __typename?: 'Opportunity' } & Pick<
  Opportunity,
  | 'id'
  | 'isDeleted'
  | 'companyName'
  | 'contactFullName'
  | 'contactEmail'
  | 'companyWebsite'
  | 'createdAt'
  | 'detailsUpdatedAt'
  | 'status'
  | 'notes'
  | 'meta'
> & {
    officeSizeCondition: Maybe<
      { __typename?: 'OfficeSizeCondition' } & Pick<
        OfficeSizeCondition,
        'id' | 'from' | 'to' | 'isRange' | 'unit'
      >
    >
    budgetCondition: Maybe<
      { __typename?: 'OfficeCostCondition' } & Pick<
        OfficeCostCondition,
        'id' | 'from' | 'to' | 'isRange' | 'unit' | 'currency'
      >
    >
    availableFromCondition: Maybe<
      { __typename?: 'AvailabilityCondition' } & Pick<
        AvailabilityCondition,
        'id' | 'from' | 'to' | 'isRange'
      >
    >
    termLengthCondition: Maybe<
      { __typename?: 'TermLengthCondition' } & Pick<
        TermLengthCondition,
        'id' | 'from' | 'to' | 'isRange'
      >
    >
  }

export type OpportunityReportFragmentFragment = {
  __typename?: 'Opportunity'
} & {
  leads: Maybe<Array<{ __typename?: 'Lead' } & LeadReportFragment>>
  user: { __typename?: 'User' } & Pick<User, 'id'> & {
      contact: { __typename?: 'Contact' } & Pick<
        Contact,
        'id' | 'name' | 'jobTitle' | 'avatarUrl'
      > & {
          emails: Maybe<Array<{ __typename?: 'Email' } & Pick<Email, 'value'>>>
          phones: Maybe<Array<{ __typename?: 'Phone' } & Pick<Phone, 'value'>>>
        }
      agent: Maybe<
        { __typename?: 'Agent' } & Pick<
          Agent,
          'id' | 'name' | 'logo' | 'mapPin' | 'blankPinUrl' | 'primaryColor'
        >
      >
    }
} & OpportunityFragmentFragment

export type OpportunitiesQueryVariables = {
  where?: Maybe<OpportunityWhereInput>
  orderBy?: Maybe<OpportunityOrderByInput>
  skip?: Maybe<Scalars['Int']>
  first?: Maybe<Scalars['Int']>
}

export type OpportunitiesQuery = { __typename?: 'Query' } & {
  opportunities: Array<
    Maybe<
      { __typename?: 'Opportunity' } & {
        leads: Maybe<Array<{ __typename?: 'Lead' } & Pick<Lead, 'id'>>>
      } & OpportunityFragmentFragment
    >
  >
}

export type OpportunityQueryVariables = {
  id: Scalars['Int']
  referralsSkip?: Maybe<Scalars['Int']>
  referralsFirst?: Maybe<Scalars['Int']>
  referralsOrderBy?: Maybe<OpportunityLeadOrderByInput>
  referralsSearchText?: Maybe<Scalars['String']>
}

export type OpportunityQuery = { __typename?: 'Query' } & {
  opportunity: { __typename?: 'Opportunity' } & {
    user: { __typename?: 'User' } & Pick<User, 'id'> & {
        contact: { __typename?: 'Contact' } & Pick<
          Contact,
          'id' | 'name' | 'jobTitle' | 'avatarUrl'
        > & {
            emails: Maybe<
              Array<{ __typename?: 'Email' } & Pick<Email, 'value'>>
            >
            phones: Maybe<
              Array<{ __typename?: 'Phone' } & Pick<Phone, 'value'>>
            >
          }
        agent: Maybe<
          { __typename?: 'Agent' } & Pick<
            Agent,
            'id' | 'name' | 'logo' | 'mapPin' | 'blankPinUrl' | 'primaryColor'
          >
        >
      }
    leads: Maybe<Array<{ __typename?: 'Lead' } & LeadFragmentFragment>>
  } & OpportunityFragmentFragment
}

export type ReportOpportunityQueryVariables = {
  id: Scalars['Int']
}

export type ReportOpportunityQuery = { __typename?: 'Query' } & {
  opportunity: { __typename?: 'Opportunity' } & {
    user: { __typename?: 'User' } & Pick<User, 'id'> & {
        contact: { __typename?: 'Contact' } & Pick<
          Contact,
          'id' | 'name' | 'jobTitle' | 'avatarUrl'
        > & {
            emails: Maybe<
              Array<{ __typename?: 'Email' } & Pick<Email, 'value'>>
            >
            phones: Maybe<
              Array<{ __typename?: 'Phone' } & Pick<Phone, 'value'>>
            >
          }
        agent: Maybe<
          { __typename?: 'Agent' } & Pick<
            Agent,
            'id' | 'name' | 'logo' | 'mapPin' | 'blankPinUrl' | 'primaryColor'
          >
        >
      }
  } & OpportunityReportFragmentFragment
}

export type OpportunitiesAggQueryVariables = {}

export type OpportunitiesAggQuery = { __typename?: 'Query' } & {
  opportunitiesAgg: { __typename?: 'OpportunitiesAgg' } & Pick<
    OpportunitiesAgg,
    'size'
  >
}

export type OpportunityReferralsQueryVariables = {
  opportunityId: Scalars['Int']
  referralsWhere?: Maybe<LeadWhereInput>
  referralsSkip?: Maybe<Scalars['Int']>
  referralsFirst?: Maybe<Scalars['Int']>
  referralsOrderBy?: Maybe<OpportunityLeadOrderByInput>
  referralsSearchText?: Maybe<Scalars['String']>
}

export type OpportunityReferralsQuery = { __typename?: 'Query' } & {
  opportunity: { __typename?: 'Opportunity' } & Pick<Opportunity, 'id'> & {
      leads: Maybe<Array<{ __typename?: 'Lead' } & ReferralsFragmentFragment>>
    }
}

export type AddLeadsMutationVariables = {
  id: Scalars['Int']
  leads?: Maybe<Array<LeadCreateInput>>
}

export type AddLeadsMutation = { __typename?: 'Mutation' } & {
  updateOpportunity: Maybe<
    { __typename?: 'Opportunity' } & Pick<Opportunity, 'id'>
  >
}

export type UpdateOpportunityStatusMutationVariables = {
  status: OpportunityStatusType
  id: Scalars['Int']
}

export type UpdateOpportunityStatusMutation = { __typename?: 'Mutation' } & {
  updateOpportunity: Maybe<
    { __typename?: 'Opportunity' } & Pick<Opportunity, 'id' | 'status'>
  >
}

export type CreateOpportunityMutationVariables = {
  data: OpportunityCreateInput
}

export type CreateOpportunityMutation = { __typename?: 'Mutation' } & {
  createOpportunity: { __typename?: 'Opportunity' } & Pick<Opportunity, 'id'>
}

export type UpdateOpportunityMutationVariables = {
  data: OpportunityUpdateInput
  where: OpportunityWhereUniqueInput
}

export type UpdateOpportunityMutation = { __typename?: 'Mutation' } & {
  updateOpportunity: Maybe<
    { __typename?: 'Opportunity' } & Pick<Opportunity, 'id'>
  >
}

export type UpdateOpportunityMetaMutationVariables = {
  data: OpportunityUpdateInput
  where: OpportunityWhereUniqueInput
}

export type UpdateOpportunityMetaMutation = { __typename?: 'Mutation' } & {
  updateOpportunity: Maybe<
    { __typename?: 'Opportunity' } & Pick<Opportunity, 'id' | 'meta'>
  >
}

export type DeleteOpportunityMutationVariables = {
  id: Scalars['Int']
  isDeleted: Scalars['Boolean']
}

export type DeleteOpportunityMutation = { __typename?: 'Mutation' } & {
  updateOpportunity: Maybe<
    { __typename?: 'Opportunity' } & Pick<Opportunity, 'id' | 'isDeleted'>
  >
}

export type MeQueryVariables = {}

export type MeQuery = { __typename?: 'Query' } & {
  me: Maybe<
    { __typename?: 'User' } & Pick<
      User,
      'id' | 'type' | 'permissions' | 'currency'
    > & {
        contact: { __typename?: 'Contact' } & Pick<
          Contact,
          'id' | 'name' | 'avatarUrl' | 'jobTitle'
        > & {
            emails: Maybe<
              Array<
                { __typename?: 'Email' } & Pick<Email, 'id' | 'value' | 'type'>
              >
            >
            phones: Maybe<
              Array<
                { __typename?: 'Phone' } & Pick<Phone, 'id' | 'value' | 'type'>
              >
            >
          }
        operator: Maybe<
          { __typename?: 'Operator' } & Pick<
            Operator,
            'id' | 'name' | 'logo' | 'website'
          >
        >
        agent: Maybe<
          { __typename?: 'Agent' } & Pick<
            Agent,
            'id' | 'name' | 'logo' | 'website'
          >
        >
        regions: Maybe<
          Array<
            Maybe<
              { __typename?: 'Region' } & Pick<
                Region,
                'id' | 'name' | 'polygon'
              >
            >
          >
        >
      }
  >
}

export type UpdateUserMutationVariables = {
  data: UserUpdateInput
  where: UserWhereUniqueInput
}

export type UpdateUserMutation = { __typename?: 'Mutation' } & {
  updateUser: Maybe<{ __typename?: 'User' } & Pick<User, 'id'>>
}

export type AcceptTermAndConditionMutationVariables = {
  data: AcceptTermAndConditionInput
}

export type AcceptTermAndConditionMutation = { __typename?: 'Mutation' } & {
  acceptTermAndCondition: Maybe<
    { __typename?: 'User' } & Pick<User, 'id'> & {
        termAndCondition: Maybe<
          { __typename?: 'TermAndCondition' } & Pick<
            TermAndCondition,
            'id' | 'isAccepted'
          >
        >
      }
  >
}

export type DelayTermAndConditionMutationVariables = {}

export type DelayTermAndConditionMutation = { __typename?: 'Mutation' } & {
  delayTermAndCondition: Maybe<
    { __typename?: 'User' } & Pick<User, 'id'> & {
        termAndCondition: Maybe<
          { __typename?: 'TermAndCondition' } & Pick<
            TermAndCondition,
            'id' | 'canBeDelayed'
          >
        >
      }
  >
}

export const OfficeModalAvailabilityFragmentDoc = gql`
  fragment OfficeModalAvailability on OfficeAvailability {
    availableOfficeSuitesCount
    availableFrom
  }
`
export const ContactViewFragmentDoc = gql`
  fragment ContactView on Contact {
    id
    name
    avatarUrl
    emails {
      id
      value
    }
  }
`
export const OfficeGalleryFragmentDoc = gql`
  fragment OfficeGallery on Office {
    id
    name
    photos {
      id
    }
  }
`
export const OfficeSuiteGalleryFragmentDoc = gql`
  fragment OfficeSuiteGallery on OfficeSuite {
    id
    name
    photos {
      id
    }
  }
`
export const OfficeLeadFragmentFragmentDoc = gql`
  fragment OfficeLeadFragment on Office {
    id
    name
    photos(first: 1) {
      id
    }
    operator {
      id
      name
      logo
      website
    }
    address {
      id
      addressLineOne
      postCodePartOne
    }
  }
`
export const ReferralsFragmentFragmentDoc = gql`
  fragment ReferralsFragment on Lead {
    id
    createdAt
    office {
      ...OfficeLeadFragment
    }
    status
    emailMessages {
      id
      createdAt
      sentAt
      state
      emailBodyKey
      emailCustomMessage
      emailHeading
    }
    offers {
      id
      description
      termLengthCondition {
        id
        from
        to
        isRange
      }
      availableFromCondition {
        id
        from
        to
        isRange
      }
      costCondition {
        id
        from
        to
        isRange
        unit
        currency
      }
      officeSizeCondition {
        id
        from
        to
        isRange
        unit
      }
      monthlyQuotingRateCondition {
        id
        from
        to
        isRange
        unit
        currency
      }
    }
  }
  ${OfficeLeadFragmentFragmentDoc}
`
export const MonthlyQuotingRateFragmentFragmentDoc = gql`
  fragment monthlyQuotingRateFragment on MonthlyQuotingRateCondition {
    id
    from
    to
    unit
    isRange
    currency
  }
`
export const OfficeMapFragmentFragmentDoc = gql`
  fragment OfficeMapFragment on Office {
    id
    name
    monthlyQuotingRate {
      ...monthlyQuotingRateFragment
    }
    photos(first: 1) {
      id
    }
    operator {
      id
      name
      mapPin
      logo
    }
    address {
      id
      addressLineOne
      postCodePartOne
      location {
        id
        latitude
        longitude
      }
    }
    floorplans {
      id
    }
  }
  ${MonthlyQuotingRateFragmentFragmentDoc}
`
export const OfficesFragmentFragmentDoc = gql`
  fragment officesFragment on Office {
    id
    name
    monthlyQuotingRate {
      ...monthlyQuotingRateFragment
    }
    photos(first: 1) {
      id
    }
    operator {
      id
      name
      mapPin
      logo
    }
    address {
      id
      addressLineOne
      city
      postCodePartOne
      location {
        id
        latitude
        longitude
      }
    }
  }
  ${MonthlyQuotingRateFragmentFragmentDoc}
`
export const OfficeAvailabilityFragmentDoc = gql`
  fragment OfficeAvailability on OfficeAvailability {
    totalOfficeSuitesCount
    availableOfficeSuitesCount
    uncertainOfficeSuitesCount
    availableFrom
  }
`
export const OfficeAdditionalInfoFragmentDoc = gql`
  fragment OfficeAdditionalInfo on Office {
    id
    photos {
      id
    }
    availability {
      ...OfficeAvailability
    }
  }
  ${OfficeAvailabilityFragmentDoc}
`
export const OfficeFragmentFragmentDoc = gql`
  fragment OfficeFragment on Office {
    id
    name
    description
    websiteURL
    monthlyQuotingRate {
      ...monthlyQuotingRateFragment
    }
    photos {
      id
    }
    operator {
      id
      name
      mapPin
      logo
      website
      isPayingCustomer
    }
    address {
      id
      addressLineOne
      addressLineTwo
      addressLineThree
      addressLineFour
      city
      postCodePartOne
      location {
        id
        latitude
        longitude
      }
    }
    amenities {
      id
      key
      icon
      isEnabled
    }
  }
  ${MonthlyQuotingRateFragmentFragmentDoc}
`
export const OfficeFloorplansFragmentFragmentDoc = gql`
  fragment OfficeFloorplansFragment on Office {
    floorplans {
      id
      url
      name
      floor
    }
  }
`
export const OfficeSuiteFragmentDoc = gql`
  fragment OfficeSuite on OfficeSuite {
    id
    isActive
    externalId
    name
    description
    floor
    spaceLocation
    status
    canBePartitioned
    updatedAt
    createdAt
    monthlyQuotingRateTotal {
      id
      from
      to
      isRange
    }
    monthlyQuotingRateDesk {
      id
      from
      to
      isRange
    }
    monthlyQuotingRateSpace {
      id
      from
      to
      isRange
    }
    monthlyQuotingRateCurrency
    sizeDesks {
      id
      from
      to
      isRange
    }
    sizeSpace {
      id
      from
      to
      isRange
      unit
    }
    photos {
      id
      url
      type
      width
      height
    }
    status
  }
`
export const SizeDesksFragmentFragmentDoc = gql`
  fragment SizeDesksFragment on OfficeSuite {
    sizeDesks {
      id
      from
      to
      isRange
    }
  }
`
export const SizeSpaceFragmentFragmentDoc = gql`
  fragment SizeSpaceFragment on OfficeSuite {
    sizeSpace {
      id
      from
      to
      unit
      isRange
    }
  }
`
export const AvailableFromFragmentFragmentDoc = gql`
  fragment AvailableFromFragment on OfficeSuite {
    availableFrom {
      id
      from
      to
      isRange
    }
  }
`
export const OfficeSuiteFloorplansFragmentDoc = gql`
  fragment OfficeSuiteFloorplans on OfficeSuite {
    floorplans {
      id
      url
      name
      floor
    }
  }
`
export const FullOfficeSuiteFragmentDoc = gql`
  fragment FullOfficeSuite on OfficeSuite {
    ...OfficeSuite
    ...SizeDesksFragment
    ...SizeSpaceFragment
    ...AvailableFromFragment
    ...OfficeSuiteFloorplans
  }
  ${OfficeSuiteFragmentDoc}
  ${SizeDesksFragmentFragmentDoc}
  ${SizeSpaceFragmentFragmentDoc}
  ${AvailableFromFragmentFragmentDoc}
  ${OfficeSuiteFloorplansFragmentDoc}
`
export const FullOfficeInfoFragmentDoc = gql`
  fragment FullOfficeInfo on Office {
    ...OfficeFragment
    ...OfficeFloorplansFragment
    officeSuites {
      ...FullOfficeSuite
    }
  }
  ${OfficeFragmentFragmentDoc}
  ${OfficeFloorplansFragmentFragmentDoc}
  ${FullOfficeSuiteFragmentDoc}
`
export const OperatorBaseFieldsFragmentDoc = gql`
  fragment OperatorBaseFields on Operator {
    id
    name
    logo
  }
`
export const OpportunityFragmentFragmentDoc = gql`
  fragment opportunityFragment on Opportunity {
    id
    isDeleted
    companyName
    contactFullName
    contactEmail
    companyWebsite
    createdAt
    detailsUpdatedAt
    officeSizeCondition {
      id
      from
      to
      isRange
      unit
    }
    budgetCondition {
      id
      from
      to
      isRange
      unit
      currency
    }
    status
    notes
    meta
    availableFromCondition {
      id
      from
      to
      isRange
    }
    termLengthCondition {
      id
      from
      to
      isRange
    }
  }
`
export const LeadFragmentFragmentDoc = gql`
  fragment leadFragment on Lead {
    id
    createdAt
    office {
      ...OfficeFragment
    }
    status
    emailMessages {
      id
      createdAt
      sentAt
      state
      emailBodyKey
      emailCustomMessage
      emailHeading
    }
    offers {
      id
      description
      termLengthCondition {
        id
        from
        to
        isRange
      }
      availableFromCondition {
        id
        from
        to
        isRange
      }
      costCondition {
        id
        from
        to
        isRange
        unit
        currency
      }
      officeSizeCondition {
        id
        from
        to
        isRange
        unit
      }
      monthlyQuotingRateCondition {
        id
        from
        to
        isRange
        unit
        currency
      }
    }
  }
  ${OfficeFragmentFragmentDoc}
`
export const TransportViewFragmentDoc = gql`
  fragment TransportView on Transport {
    id
    name
    type
    distance {
      id
      text
      value
    }
    duration {
      id
      text
      value
    }
    lines
  }
`
export const OfficeReportFragmentDoc = gql`
  fragment officeReport on Office {
    ...OfficeFragment
    address {
      location {
        transport {
          ...TransportView
        }
      }
    }
  }
  ${OfficeFragmentFragmentDoc}
  ${TransportViewFragmentDoc}
`
export const LeadReportFragmentDoc = gql`
  fragment leadReport on Lead {
    ...leadFragment
    office {
      ...officeReport
    }
  }
  ${LeadFragmentFragmentDoc}
  ${OfficeReportFragmentDoc}
`
export const OpportunityReportFragmentFragmentDoc = gql`
  fragment opportunityReportFragment on Opportunity {
    ...opportunityFragment
    leads {
      ...leadReport
    }
    user {
      id
      contact {
        id
        name
        jobTitle
        avatarUrl
        emails {
          value
        }
        phones {
          value
        }
      }
      agent {
        id
        name
        logo
        mapPin
        blankPinUrl
        primaryColor
      }
    }
  }
  ${OpportunityFragmentFragmentDoc}
  ${LeadReportFragmentDoc}
`
export const OfficeTransportAndContactDocument = gql`
  query OfficeTransportAndContact($where: OfficeWhereUniqueInput!) {
    office(where: $where) {
      id
      availability {
        ...OfficeModalAvailability
      }
      contacts {
        ...ContactView
      }
      operator {
        id
        contacts {
          ...ContactView
        }
      }
      address {
        id
        location {
          id
          transport {
            ...TransportView
          }
        }
      }
    }
  }
  ${OfficeModalAvailabilityFragmentDoc}
  ${ContactViewFragmentDoc}
  ${TransportViewFragmentDoc}
`

/**
 * __useOfficeTransportAndContactQuery__
 *
 * To run a query within a React component, call `useOfficeTransportAndContactQuery` and pass it any options that fit your needs.
 * When your component renders, `useOfficeTransportAndContactQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useOfficeTransportAndContactQuery({
 *   variables: {
 *      where: // value for 'where'
 *   },
 * });
 */
export function useOfficeTransportAndContactQuery(
  baseOptions?: ApolloReactHooks.QueryHookOptions<
    OfficeTransportAndContactQuery,
    OfficeTransportAndContactQueryVariables
  >,
) {
  return ApolloReactHooks.useQuery<
    OfficeTransportAndContactQuery,
    OfficeTransportAndContactQueryVariables
  >(OfficeTransportAndContactDocument, baseOptions)
}
export function useOfficeTransportAndContactLazyQuery(
  baseOptions?: ApolloReactHooks.LazyQueryHookOptions<
    OfficeTransportAndContactQuery,
    OfficeTransportAndContactQueryVariables
  >,
) {
  return ApolloReactHooks.useLazyQuery<
    OfficeTransportAndContactQuery,
    OfficeTransportAndContactQueryVariables
  >(OfficeTransportAndContactDocument, baseOptions)
}
export type OfficeTransportAndContactQueryHookResult = ReturnType<
  typeof useOfficeTransportAndContactQuery
>
export type OfficeTransportAndContactLazyQueryHookResult = ReturnType<
  typeof useOfficeTransportAndContactLazyQuery
>
export type OfficeTransportAndContactQueryResult = ApolloReactCommon.QueryResult<
  OfficeTransportAndContactQuery,
  OfficeTransportAndContactQueryVariables
>
export const OpportunityOfficesDocument = gql`
  query opportunityOffices($where: OfficeWhereInput) {
    offices(where: $where) {
      id
      operator {
        id
        name
        logo
      }
      address {
        id
        city
      }
    }
  }
`

/**
 * __useOpportunityOfficesQuery__
 *
 * To run a query within a React component, call `useOpportunityOfficesQuery` and pass it any options that fit your needs.
 * When your component renders, `useOpportunityOfficesQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useOpportunityOfficesQuery({
 *   variables: {
 *      where: // value for 'where'
 *   },
 * });
 */
export function useOpportunityOfficesQuery(
  baseOptions?: ApolloReactHooks.QueryHookOptions<
    OpportunityOfficesQuery,
    OpportunityOfficesQueryVariables
  >,
) {
  return ApolloReactHooks.useQuery<
    OpportunityOfficesQuery,
    OpportunityOfficesQueryVariables
  >(OpportunityOfficesDocument, baseOptions)
}
export function useOpportunityOfficesLazyQuery(
  baseOptions?: ApolloReactHooks.LazyQueryHookOptions<
    OpportunityOfficesQuery,
    OpportunityOfficesQueryVariables
  >,
) {
  return ApolloReactHooks.useLazyQuery<
    OpportunityOfficesQuery,
    OpportunityOfficesQueryVariables
  >(OpportunityOfficesDocument, baseOptions)
}
export type OpportunityOfficesQueryHookResult = ReturnType<
  typeof useOpportunityOfficesQuery
>
export type OpportunityOfficesLazyQueryHookResult = ReturnType<
  typeof useOpportunityOfficesLazyQuery
>
export type OpportunityOfficesQueryResult = ApolloReactCommon.QueryResult<
  OpportunityOfficesQuery,
  OpportunityOfficesQueryVariables
>
export const UpdateLeadStatusDocument = gql`
  mutation updateLeadStatus($status: LeadStatusType!, $id: Int!) {
    updateLead(data: { status: $status }, where: { id: $id }) {
      id
      status
    }
  }
`
export type UpdateLeadStatusMutationFn = ApolloReactCommon.MutationFunction<
  UpdateLeadStatusMutation,
  UpdateLeadStatusMutationVariables
>

/**
 * __useUpdateLeadStatusMutation__
 *
 * To run a mutation, you first call `useUpdateLeadStatusMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateLeadStatusMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [updateLeadStatusMutation, { data, loading, error }] = useUpdateLeadStatusMutation({
 *   variables: {
 *      status: // value for 'status'
 *      id: // value for 'id'
 *   },
 * });
 */
export function useUpdateLeadStatusMutation(
  baseOptions?: ApolloReactHooks.MutationHookOptions<
    UpdateLeadStatusMutation,
    UpdateLeadStatusMutationVariables
  >,
) {
  return ApolloReactHooks.useMutation<
    UpdateLeadStatusMutation,
    UpdateLeadStatusMutationVariables
  >(UpdateLeadStatusDocument, baseOptions)
}
export type UpdateLeadStatusMutationHookResult = ReturnType<
  typeof useUpdateLeadStatusMutation
>
export type UpdateLeadStatusMutationResult = ApolloReactCommon.MutationResult<
  UpdateLeadStatusMutation
>
export type UpdateLeadStatusMutationOptions = ApolloReactCommon.BaseMutationOptions<
  UpdateLeadStatusMutation,
  UpdateLeadStatusMutationVariables
>
export const UpdateLeadDocument = gql`
  mutation updateLead($data: LeadUpdateInput!, $where: LeadWhereUniqueInput!) {
    updateLead(data: $data, where: $where) {
      id
    }
  }
`
export type UpdateLeadMutationFn = ApolloReactCommon.MutationFunction<
  UpdateLeadMutation,
  UpdateLeadMutationVariables
>

/**
 * __useUpdateLeadMutation__
 *
 * To run a mutation, you first call `useUpdateLeadMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateLeadMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [updateLeadMutation, { data, loading, error }] = useUpdateLeadMutation({
 *   variables: {
 *      data: // value for 'data'
 *      where: // value for 'where'
 *   },
 * });
 */
export function useUpdateLeadMutation(
  baseOptions?: ApolloReactHooks.MutationHookOptions<
    UpdateLeadMutation,
    UpdateLeadMutationVariables
  >,
) {
  return ApolloReactHooks.useMutation<
    UpdateLeadMutation,
    UpdateLeadMutationVariables
  >(UpdateLeadDocument, baseOptions)
}
export type UpdateLeadMutationHookResult = ReturnType<
  typeof useUpdateLeadMutation
>
export type UpdateLeadMutationResult = ApolloReactCommon.MutationResult<
  UpdateLeadMutation
>
export type UpdateLeadMutationOptions = ApolloReactCommon.BaseMutationOptions<
  UpdateLeadMutation,
  UpdateLeadMutationVariables
>
export const SendOperatorLeadsDocument = gql`
  mutation sendOperatorLeads($data: SendOperatorLeadsInput!) {
    sendOperatorLeads(data: $data) {
      isSucceeded
    }
  }
`
export type SendOperatorLeadsMutationFn = ApolloReactCommon.MutationFunction<
  SendOperatorLeadsMutation,
  SendOperatorLeadsMutationVariables
>

/**
 * __useSendOperatorLeadsMutation__
 *
 * To run a mutation, you first call `useSendOperatorLeadsMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useSendOperatorLeadsMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [sendOperatorLeadsMutation, { data, loading, error }] = useSendOperatorLeadsMutation({
 *   variables: {
 *      data: // value for 'data'
 *   },
 * });
 */
export function useSendOperatorLeadsMutation(
  baseOptions?: ApolloReactHooks.MutationHookOptions<
    SendOperatorLeadsMutation,
    SendOperatorLeadsMutationVariables
  >,
) {
  return ApolloReactHooks.useMutation<
    SendOperatorLeadsMutation,
    SendOperatorLeadsMutationVariables
  >(SendOperatorLeadsDocument, baseOptions)
}
export type SendOperatorLeadsMutationHookResult = ReturnType<
  typeof useSendOperatorLeadsMutation
>
export type SendOperatorLeadsMutationResult = ApolloReactCommon.MutationResult<
  SendOperatorLeadsMutation
>
export type SendOperatorLeadsMutationOptions = ApolloReactCommon.BaseMutationOptions<
  SendOperatorLeadsMutation,
  SendOperatorLeadsMutationVariables
>
export const MapOfficesDocument = gql`
  query mapOffices($where: OfficeWhereInput) {
    offices(where: $where) {
      ...OfficeMapFragment
    }
  }
  ${OfficeMapFragmentFragmentDoc}
`

/**
 * __useMapOfficesQuery__
 *
 * To run a query within a React component, call `useMapOfficesQuery` and pass it any options that fit your needs.
 * When your component renders, `useMapOfficesQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useMapOfficesQuery({
 *   variables: {
 *      where: // value for 'where'
 *   },
 * });
 */
export function useMapOfficesQuery(
  baseOptions?: ApolloReactHooks.QueryHookOptions<
    MapOfficesQuery,
    MapOfficesQueryVariables
  >,
) {
  return ApolloReactHooks.useQuery<MapOfficesQuery, MapOfficesQueryVariables>(
    MapOfficesDocument,
    baseOptions,
  )
}
export function useMapOfficesLazyQuery(
  baseOptions?: ApolloReactHooks.LazyQueryHookOptions<
    MapOfficesQuery,
    MapOfficesQueryVariables
  >,
) {
  return ApolloReactHooks.useLazyQuery<
    MapOfficesQuery,
    MapOfficesQueryVariables
  >(MapOfficesDocument, baseOptions)
}
export type MapOfficesQueryHookResult = ReturnType<typeof useMapOfficesQuery>
export type MapOfficesLazyQueryHookResult = ReturnType<
  typeof useMapOfficesLazyQuery
>
export type MapOfficesQueryResult = ApolloReactCommon.QueryResult<
  MapOfficesQuery,
  MapOfficesQueryVariables
>
export const OfficeAdditionalInfoDocument = gql`
  query officeAdditionalInfo($where: OfficeWhereUniqueInput!) {
    office(where: $where) {
      ...OfficeAdditionalInfo
    }
  }
  ${OfficeAdditionalInfoFragmentDoc}
`

/**
 * __useOfficeAdditionalInfoQuery__
 *
 * To run a query within a React component, call `useOfficeAdditionalInfoQuery` and pass it any options that fit your needs.
 * When your component renders, `useOfficeAdditionalInfoQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useOfficeAdditionalInfoQuery({
 *   variables: {
 *      where: // value for 'where'
 *   },
 * });
 */
export function useOfficeAdditionalInfoQuery(
  baseOptions?: ApolloReactHooks.QueryHookOptions<
    OfficeAdditionalInfoQuery,
    OfficeAdditionalInfoQueryVariables
  >,
) {
  return ApolloReactHooks.useQuery<
    OfficeAdditionalInfoQuery,
    OfficeAdditionalInfoQueryVariables
  >(OfficeAdditionalInfoDocument, baseOptions)
}
export function useOfficeAdditionalInfoLazyQuery(
  baseOptions?: ApolloReactHooks.LazyQueryHookOptions<
    OfficeAdditionalInfoQuery,
    OfficeAdditionalInfoQueryVariables
  >,
) {
  return ApolloReactHooks.useLazyQuery<
    OfficeAdditionalInfoQuery,
    OfficeAdditionalInfoQueryVariables
  >(OfficeAdditionalInfoDocument, baseOptions)
}
export type OfficeAdditionalInfoQueryHookResult = ReturnType<
  typeof useOfficeAdditionalInfoQuery
>
export type OfficeAdditionalInfoLazyQueryHookResult = ReturnType<
  typeof useOfficeAdditionalInfoLazyQuery
>
export type OfficeAdditionalInfoQueryResult = ApolloReactCommon.QueryResult<
  OfficeAdditionalInfoQuery,
  OfficeAdditionalInfoQueryVariables
>
export const OfficesAdditinalInfoDocument = gql`
  query officesAdditinalInfo($where: OfficeWhereInput) {
    offices(where: $where) {
      ...OfficeAdditionalInfo
    }
  }
  ${OfficeAdditionalInfoFragmentDoc}
`

/**
 * __useOfficesAdditinalInfoQuery__
 *
 * To run a query within a React component, call `useOfficesAdditinalInfoQuery` and pass it any options that fit your needs.
 * When your component renders, `useOfficesAdditinalInfoQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useOfficesAdditinalInfoQuery({
 *   variables: {
 *      where: // value for 'where'
 *   },
 * });
 */
export function useOfficesAdditinalInfoQuery(
  baseOptions?: ApolloReactHooks.QueryHookOptions<
    OfficesAdditinalInfoQuery,
    OfficesAdditinalInfoQueryVariables
  >,
) {
  return ApolloReactHooks.useQuery<
    OfficesAdditinalInfoQuery,
    OfficesAdditinalInfoQueryVariables
  >(OfficesAdditinalInfoDocument, baseOptions)
}
export function useOfficesAdditinalInfoLazyQuery(
  baseOptions?: ApolloReactHooks.LazyQueryHookOptions<
    OfficesAdditinalInfoQuery,
    OfficesAdditinalInfoQueryVariables
  >,
) {
  return ApolloReactHooks.useLazyQuery<
    OfficesAdditinalInfoQuery,
    OfficesAdditinalInfoQueryVariables
  >(OfficesAdditinalInfoDocument, baseOptions)
}
export type OfficesAdditinalInfoQueryHookResult = ReturnType<
  typeof useOfficesAdditinalInfoQuery
>
export type OfficesAdditinalInfoLazyQueryHookResult = ReturnType<
  typeof useOfficesAdditinalInfoLazyQuery
>
export type OfficesAdditinalInfoQueryResult = ApolloReactCommon.QueryResult<
  OfficesAdditinalInfoQuery,
  OfficesAdditinalInfoQueryVariables
>
export const OfficesDocument = gql`
  query offices($where: OfficeWhereInput, $first: Int, $skip: Int) {
    offices(where: $where, first: $first, skip: $skip) {
      ...officesFragment
    }
  }
  ${OfficesFragmentFragmentDoc}
`

/**
 * __useOfficesQuery__
 *
 * To run a query within a React component, call `useOfficesQuery` and pass it any options that fit your needs.
 * When your component renders, `useOfficesQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useOfficesQuery({
 *   variables: {
 *      where: // value for 'where'
 *      first: // value for 'first'
 *      skip: // value for 'skip'
 *   },
 * });
 */
export function useOfficesQuery(
  baseOptions?: ApolloReactHooks.QueryHookOptions<
    OfficesQuery,
    OfficesQueryVariables
  >,
) {
  return ApolloReactHooks.useQuery<OfficesQuery, OfficesQueryVariables>(
    OfficesDocument,
    baseOptions,
  )
}
export function useOfficesLazyQuery(
  baseOptions?: ApolloReactHooks.LazyQueryHookOptions<
    OfficesQuery,
    OfficesQueryVariables
  >,
) {
  return ApolloReactHooks.useLazyQuery<OfficesQuery, OfficesQueryVariables>(
    OfficesDocument,
    baseOptions,
  )
}
export type OfficesQueryHookResult = ReturnType<typeof useOfficesQuery>
export type OfficesLazyQueryHookResult = ReturnType<typeof useOfficesLazyQuery>
export type OfficesQueryResult = ApolloReactCommon.QueryResult<
  OfficesQuery,
  OfficesQueryVariables
>
export const OperatorOfficesDocument = gql`
  query operatorOffices($where: OfficeWhereInput) {
    offices(where: $where) {
      ...OfficeMapFragment
      operator {
        id
        name
        mapPin
      }
    }
  }
  ${OfficeMapFragmentFragmentDoc}
`

/**
 * __useOperatorOfficesQuery__
 *
 * To run a query within a React component, call `useOperatorOfficesQuery` and pass it any options that fit your needs.
 * When your component renders, `useOperatorOfficesQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useOperatorOfficesQuery({
 *   variables: {
 *      where: // value for 'where'
 *   },
 * });
 */
export function useOperatorOfficesQuery(
  baseOptions?: ApolloReactHooks.QueryHookOptions<
    OperatorOfficesQuery,
    OperatorOfficesQueryVariables
  >,
) {
  return ApolloReactHooks.useQuery<
    OperatorOfficesQuery,
    OperatorOfficesQueryVariables
  >(OperatorOfficesDocument, baseOptions)
}
export function useOperatorOfficesLazyQuery(
  baseOptions?: ApolloReactHooks.LazyQueryHookOptions<
    OperatorOfficesQuery,
    OperatorOfficesQueryVariables
  >,
) {
  return ApolloReactHooks.useLazyQuery<
    OperatorOfficesQuery,
    OperatorOfficesQueryVariables
  >(OperatorOfficesDocument, baseOptions)
}
export type OperatorOfficesQueryHookResult = ReturnType<
  typeof useOperatorOfficesQuery
>
export type OperatorOfficesLazyQueryHookResult = ReturnType<
  typeof useOperatorOfficesLazyQuery
>
export type OperatorOfficesQueryResult = ApolloReactCommon.QueryResult<
  OperatorOfficesQuery,
  OperatorOfficesQueryVariables
>
export const OfficeDocument = gql`
  query office($where: OfficeWhereUniqueInput!) {
    office(where: $where) {
      ...FullOfficeInfo
    }
  }
  ${FullOfficeInfoFragmentDoc}
`

/**
 * __useOfficeQuery__
 *
 * To run a query within a React component, call `useOfficeQuery` and pass it any options that fit your needs.
 * When your component renders, `useOfficeQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useOfficeQuery({
 *   variables: {
 *      where: // value for 'where'
 *   },
 * });
 */
export function useOfficeQuery(
  baseOptions?: ApolloReactHooks.QueryHookOptions<
    OfficeQuery,
    OfficeQueryVariables
  >,
) {
  return ApolloReactHooks.useQuery<OfficeQuery, OfficeQueryVariables>(
    OfficeDocument,
    baseOptions,
  )
}
export function useOfficeLazyQuery(
  baseOptions?: ApolloReactHooks.LazyQueryHookOptions<
    OfficeQuery,
    OfficeQueryVariables
  >,
) {
  return ApolloReactHooks.useLazyQuery<OfficeQuery, OfficeQueryVariables>(
    OfficeDocument,
    baseOptions,
  )
}
export type OfficeQueryHookResult = ReturnType<typeof useOfficeQuery>
export type OfficeLazyQueryHookResult = ReturnType<typeof useOfficeLazyQuery>
export type OfficeQueryResult = ApolloReactCommon.QueryResult<
  OfficeQuery,
  OfficeQueryVariables
>
export const OperatorOfficesAggDocument = gql`
  query operatorOfficesAgg {
    operators {
      ...OperatorBaseFields
      officesAgg {
        size
      }
    }
  }
  ${OperatorBaseFieldsFragmentDoc}
`

/**
 * __useOperatorOfficesAggQuery__
 *
 * To run a query within a React component, call `useOperatorOfficesAggQuery` and pass it any options that fit your needs.
 * When your component renders, `useOperatorOfficesAggQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useOperatorOfficesAggQuery({
 *   variables: {
 *   },
 * });
 */
export function useOperatorOfficesAggQuery(
  baseOptions?: ApolloReactHooks.QueryHookOptions<
    OperatorOfficesAggQuery,
    OperatorOfficesAggQueryVariables
  >,
) {
  return ApolloReactHooks.useQuery<
    OperatorOfficesAggQuery,
    OperatorOfficesAggQueryVariables
  >(OperatorOfficesAggDocument, baseOptions)
}
export function useOperatorOfficesAggLazyQuery(
  baseOptions?: ApolloReactHooks.LazyQueryHookOptions<
    OperatorOfficesAggQuery,
    OperatorOfficesAggQueryVariables
  >,
) {
  return ApolloReactHooks.useLazyQuery<
    OperatorOfficesAggQuery,
    OperatorOfficesAggQueryVariables
  >(OperatorOfficesAggDocument, baseOptions)
}
export type OperatorOfficesAggQueryHookResult = ReturnType<
  typeof useOperatorOfficesAggQuery
>
export type OperatorOfficesAggLazyQueryHookResult = ReturnType<
  typeof useOperatorOfficesAggLazyQuery
>
export type OperatorOfficesAggQueryResult = ApolloReactCommon.QueryResult<
  OperatorOfficesAggQuery,
  OperatorOfficesAggQueryVariables
>
export const OpportunitiesDocument = gql`
  query opportunities(
    $where: OpportunityWhereInput
    $orderBy: OpportunityOrderByInput
    $skip: Int
    $first: Int
  ) {
    opportunities(
      where: $where
      orderBy: $orderBy
      skip: $skip
      first: $first
    ) {
      ...opportunityFragment
      leads {
        id
      }
    }
  }
  ${OpportunityFragmentFragmentDoc}
`

/**
 * __useOpportunitiesQuery__
 *
 * To run a query within a React component, call `useOpportunitiesQuery` and pass it any options that fit your needs.
 * When your component renders, `useOpportunitiesQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useOpportunitiesQuery({
 *   variables: {
 *      where: // value for 'where'
 *      orderBy: // value for 'orderBy'
 *      skip: // value for 'skip'
 *      first: // value for 'first'
 *   },
 * });
 */
export function useOpportunitiesQuery(
  baseOptions?: ApolloReactHooks.QueryHookOptions<
    OpportunitiesQuery,
    OpportunitiesQueryVariables
  >,
) {
  return ApolloReactHooks.useQuery<
    OpportunitiesQuery,
    OpportunitiesQueryVariables
  >(OpportunitiesDocument, baseOptions)
}
export function useOpportunitiesLazyQuery(
  baseOptions?: ApolloReactHooks.LazyQueryHookOptions<
    OpportunitiesQuery,
    OpportunitiesQueryVariables
  >,
) {
  return ApolloReactHooks.useLazyQuery<
    OpportunitiesQuery,
    OpportunitiesQueryVariables
  >(OpportunitiesDocument, baseOptions)
}
export type OpportunitiesQueryHookResult = ReturnType<
  typeof useOpportunitiesQuery
>
export type OpportunitiesLazyQueryHookResult = ReturnType<
  typeof useOpportunitiesLazyQuery
>
export type OpportunitiesQueryResult = ApolloReactCommon.QueryResult<
  OpportunitiesQuery,
  OpportunitiesQueryVariables
>
export const OpportunityDocument = gql`
  query opportunity(
    $id: Int!
    $referralsSkip: Int
    $referralsFirst: Int
    $referralsOrderBy: OpportunityLeadOrderByInput
    $referralsSearchText: String
  ) {
    opportunity(id: $id) {
      ...opportunityFragment
      user {
        id
        contact {
          id
          name
          jobTitle
          avatarUrl
          emails {
            value
          }
          phones {
            value
          }
        }
        agent {
          id
          name
          logo
          mapPin
          blankPinUrl
          primaryColor
        }
      }
      leads(
        skip: $referralsSkip
        first: $referralsFirst
        orderBy: $referralsOrderBy
        search: $referralsSearchText
      ) {
        ...leadFragment
      }
    }
  }
  ${OpportunityFragmentFragmentDoc}
  ${LeadFragmentFragmentDoc}
`

/**
 * __useOpportunityQuery__
 *
 * To run a query within a React component, call `useOpportunityQuery` and pass it any options that fit your needs.
 * When your component renders, `useOpportunityQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useOpportunityQuery({
 *   variables: {
 *      id: // value for 'id'
 *      referralsSkip: // value for 'referralsSkip'
 *      referralsFirst: // value for 'referralsFirst'
 *      referralsOrderBy: // value for 'referralsOrderBy'
 *      referralsSearchText: // value for 'referralsSearchText'
 *   },
 * });
 */
export function useOpportunityQuery(
  baseOptions?: ApolloReactHooks.QueryHookOptions<
    OpportunityQuery,
    OpportunityQueryVariables
  >,
) {
  return ApolloReactHooks.useQuery<OpportunityQuery, OpportunityQueryVariables>(
    OpportunityDocument,
    baseOptions,
  )
}
export function useOpportunityLazyQuery(
  baseOptions?: ApolloReactHooks.LazyQueryHookOptions<
    OpportunityQuery,
    OpportunityQueryVariables
  >,
) {
  return ApolloReactHooks.useLazyQuery<
    OpportunityQuery,
    OpportunityQueryVariables
  >(OpportunityDocument, baseOptions)
}
export type OpportunityQueryHookResult = ReturnType<typeof useOpportunityQuery>
export type OpportunityLazyQueryHookResult = ReturnType<
  typeof useOpportunityLazyQuery
>
export type OpportunityQueryResult = ApolloReactCommon.QueryResult<
  OpportunityQuery,
  OpportunityQueryVariables
>
export const ReportOpportunityDocument = gql`
  query reportOpportunity($id: Int!) {
    opportunity(id: $id) {
      ...opportunityReportFragment
      user {
        id
        contact {
          id
          name
          jobTitle
          avatarUrl
          emails {
            value
          }
          phones {
            value
          }
        }
        agent {
          id
          name
          logo
          mapPin
          blankPinUrl
          primaryColor
        }
      }
    }
  }
  ${OpportunityReportFragmentFragmentDoc}
`

/**
 * __useReportOpportunityQuery__
 *
 * To run a query within a React component, call `useReportOpportunityQuery` and pass it any options that fit your needs.
 * When your component renders, `useReportOpportunityQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useReportOpportunityQuery({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export function useReportOpportunityQuery(
  baseOptions?: ApolloReactHooks.QueryHookOptions<
    ReportOpportunityQuery,
    ReportOpportunityQueryVariables
  >,
) {
  return ApolloReactHooks.useQuery<
    ReportOpportunityQuery,
    ReportOpportunityQueryVariables
  >(ReportOpportunityDocument, baseOptions)
}
export function useReportOpportunityLazyQuery(
  baseOptions?: ApolloReactHooks.LazyQueryHookOptions<
    ReportOpportunityQuery,
    ReportOpportunityQueryVariables
  >,
) {
  return ApolloReactHooks.useLazyQuery<
    ReportOpportunityQuery,
    ReportOpportunityQueryVariables
  >(ReportOpportunityDocument, baseOptions)
}
export type ReportOpportunityQueryHookResult = ReturnType<
  typeof useReportOpportunityQuery
>
export type ReportOpportunityLazyQueryHookResult = ReturnType<
  typeof useReportOpportunityLazyQuery
>
export type ReportOpportunityQueryResult = ApolloReactCommon.QueryResult<
  ReportOpportunityQuery,
  ReportOpportunityQueryVariables
>
export const OpportunitiesAggDocument = gql`
  query opportunitiesAgg {
    opportunitiesAgg {
      size
    }
  }
`

/**
 * __useOpportunitiesAggQuery__
 *
 * To run a query within a React component, call `useOpportunitiesAggQuery` and pass it any options that fit your needs.
 * When your component renders, `useOpportunitiesAggQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useOpportunitiesAggQuery({
 *   variables: {
 *   },
 * });
 */
export function useOpportunitiesAggQuery(
  baseOptions?: ApolloReactHooks.QueryHookOptions<
    OpportunitiesAggQuery,
    OpportunitiesAggQueryVariables
  >,
) {
  return ApolloReactHooks.useQuery<
    OpportunitiesAggQuery,
    OpportunitiesAggQueryVariables
  >(OpportunitiesAggDocument, baseOptions)
}
export function useOpportunitiesAggLazyQuery(
  baseOptions?: ApolloReactHooks.LazyQueryHookOptions<
    OpportunitiesAggQuery,
    OpportunitiesAggQueryVariables
  >,
) {
  return ApolloReactHooks.useLazyQuery<
    OpportunitiesAggQuery,
    OpportunitiesAggQueryVariables
  >(OpportunitiesAggDocument, baseOptions)
}
export type OpportunitiesAggQueryHookResult = ReturnType<
  typeof useOpportunitiesAggQuery
>
export type OpportunitiesAggLazyQueryHookResult = ReturnType<
  typeof useOpportunitiesAggLazyQuery
>
export type OpportunitiesAggQueryResult = ApolloReactCommon.QueryResult<
  OpportunitiesAggQuery,
  OpportunitiesAggQueryVariables
>
export const OpportunityReferralsDocument = gql`
  query opportunityReferrals(
    $opportunityId: Int!
    $referralsWhere: LeadWhereInput
    $referralsSkip: Int
    $referralsFirst: Int
    $referralsOrderBy: OpportunityLeadOrderByInput
    $referralsSearchText: String
  ) {
    opportunity(id: $opportunityId) {
      id
      leads(
        where: $referralsWhere
        skip: $referralsSkip
        first: $referralsFirst
        orderBy: $referralsOrderBy
        search: $referralsSearchText
      ) {
        ...ReferralsFragment
      }
    }
  }
  ${ReferralsFragmentFragmentDoc}
`

/**
 * __useOpportunityReferralsQuery__
 *
 * To run a query within a React component, call `useOpportunityReferralsQuery` and pass it any options that fit your needs.
 * When your component renders, `useOpportunityReferralsQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useOpportunityReferralsQuery({
 *   variables: {
 *      opportunityId: // value for 'opportunityId'
 *      referralsWhere: // value for 'referralsWhere'
 *      referralsSkip: // value for 'referralsSkip'
 *      referralsFirst: // value for 'referralsFirst'
 *      referralsOrderBy: // value for 'referralsOrderBy'
 *      referralsSearchText: // value for 'referralsSearchText'
 *   },
 * });
 */
export function useOpportunityReferralsQuery(
  baseOptions?: ApolloReactHooks.QueryHookOptions<
    OpportunityReferralsQuery,
    OpportunityReferralsQueryVariables
  >,
) {
  return ApolloReactHooks.useQuery<
    OpportunityReferralsQuery,
    OpportunityReferralsQueryVariables
  >(OpportunityReferralsDocument, baseOptions)
}
export function useOpportunityReferralsLazyQuery(
  baseOptions?: ApolloReactHooks.LazyQueryHookOptions<
    OpportunityReferralsQuery,
    OpportunityReferralsQueryVariables
  >,
) {
  return ApolloReactHooks.useLazyQuery<
    OpportunityReferralsQuery,
    OpportunityReferralsQueryVariables
  >(OpportunityReferralsDocument, baseOptions)
}
export type OpportunityReferralsQueryHookResult = ReturnType<
  typeof useOpportunityReferralsQuery
>
export type OpportunityReferralsLazyQueryHookResult = ReturnType<
  typeof useOpportunityReferralsLazyQuery
>
export type OpportunityReferralsQueryResult = ApolloReactCommon.QueryResult<
  OpportunityReferralsQuery,
  OpportunityReferralsQueryVariables
>
export const AddLeadsDocument = gql`
  mutation addLeads($id: Int!, $leads: [LeadCreateInput!]) {
    updateOpportunity(data: { leads: { create: $leads } }, where: { id: $id }) {
      id
    }
  }
`
export type AddLeadsMutationFn = ApolloReactCommon.MutationFunction<
  AddLeadsMutation,
  AddLeadsMutationVariables
>

/**
 * __useAddLeadsMutation__
 *
 * To run a mutation, you first call `useAddLeadsMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useAddLeadsMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [addLeadsMutation, { data, loading, error }] = useAddLeadsMutation({
 *   variables: {
 *      id: // value for 'id'
 *      leads: // value for 'leads'
 *   },
 * });
 */
export function useAddLeadsMutation(
  baseOptions?: ApolloReactHooks.MutationHookOptions<
    AddLeadsMutation,
    AddLeadsMutationVariables
  >,
) {
  return ApolloReactHooks.useMutation<
    AddLeadsMutation,
    AddLeadsMutationVariables
  >(AddLeadsDocument, baseOptions)
}
export type AddLeadsMutationHookResult = ReturnType<typeof useAddLeadsMutation>
export type AddLeadsMutationResult = ApolloReactCommon.MutationResult<
  AddLeadsMutation
>
export type AddLeadsMutationOptions = ApolloReactCommon.BaseMutationOptions<
  AddLeadsMutation,
  AddLeadsMutationVariables
>
export const UpdateOpportunityStatusDocument = gql`
  mutation updateOpportunityStatus($status: OpportunityStatusType!, $id: Int!) {
    updateOpportunity(data: { status: $status }, where: { id: $id }) {
      id
      status
    }
  }
`
export type UpdateOpportunityStatusMutationFn = ApolloReactCommon.MutationFunction<
  UpdateOpportunityStatusMutation,
  UpdateOpportunityStatusMutationVariables
>

/**
 * __useUpdateOpportunityStatusMutation__
 *
 * To run a mutation, you first call `useUpdateOpportunityStatusMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateOpportunityStatusMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [updateOpportunityStatusMutation, { data, loading, error }] = useUpdateOpportunityStatusMutation({
 *   variables: {
 *      status: // value for 'status'
 *      id: // value for 'id'
 *   },
 * });
 */
export function useUpdateOpportunityStatusMutation(
  baseOptions?: ApolloReactHooks.MutationHookOptions<
    UpdateOpportunityStatusMutation,
    UpdateOpportunityStatusMutationVariables
  >,
) {
  return ApolloReactHooks.useMutation<
    UpdateOpportunityStatusMutation,
    UpdateOpportunityStatusMutationVariables
  >(UpdateOpportunityStatusDocument, baseOptions)
}
export type UpdateOpportunityStatusMutationHookResult = ReturnType<
  typeof useUpdateOpportunityStatusMutation
>
export type UpdateOpportunityStatusMutationResult = ApolloReactCommon.MutationResult<
  UpdateOpportunityStatusMutation
>
export type UpdateOpportunityStatusMutationOptions = ApolloReactCommon.BaseMutationOptions<
  UpdateOpportunityStatusMutation,
  UpdateOpportunityStatusMutationVariables
>
export const CreateOpportunityDocument = gql`
  mutation createOpportunity($data: OpportunityCreateInput!) {
    createOpportunity(data: $data) {
      id
    }
  }
`
export type CreateOpportunityMutationFn = ApolloReactCommon.MutationFunction<
  CreateOpportunityMutation,
  CreateOpportunityMutationVariables
>

/**
 * __useCreateOpportunityMutation__
 *
 * To run a mutation, you first call `useCreateOpportunityMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCreateOpportunityMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [createOpportunityMutation, { data, loading, error }] = useCreateOpportunityMutation({
 *   variables: {
 *      data: // value for 'data'
 *   },
 * });
 */
export function useCreateOpportunityMutation(
  baseOptions?: ApolloReactHooks.MutationHookOptions<
    CreateOpportunityMutation,
    CreateOpportunityMutationVariables
  >,
) {
  return ApolloReactHooks.useMutation<
    CreateOpportunityMutation,
    CreateOpportunityMutationVariables
  >(CreateOpportunityDocument, baseOptions)
}
export type CreateOpportunityMutationHookResult = ReturnType<
  typeof useCreateOpportunityMutation
>
export type CreateOpportunityMutationResult = ApolloReactCommon.MutationResult<
  CreateOpportunityMutation
>
export type CreateOpportunityMutationOptions = ApolloReactCommon.BaseMutationOptions<
  CreateOpportunityMutation,
  CreateOpportunityMutationVariables
>
export const UpdateOpportunityDocument = gql`
  mutation updateOpportunity(
    $data: OpportunityUpdateInput!
    $where: OpportunityWhereUniqueInput!
  ) {
    updateOpportunity(data: $data, where: $where) {
      id
    }
  }
`
export type UpdateOpportunityMutationFn = ApolloReactCommon.MutationFunction<
  UpdateOpportunityMutation,
  UpdateOpportunityMutationVariables
>

/**
 * __useUpdateOpportunityMutation__
 *
 * To run a mutation, you first call `useUpdateOpportunityMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateOpportunityMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [updateOpportunityMutation, { data, loading, error }] = useUpdateOpportunityMutation({
 *   variables: {
 *      data: // value for 'data'
 *      where: // value for 'where'
 *   },
 * });
 */
export function useUpdateOpportunityMutation(
  baseOptions?: ApolloReactHooks.MutationHookOptions<
    UpdateOpportunityMutation,
    UpdateOpportunityMutationVariables
  >,
) {
  return ApolloReactHooks.useMutation<
    UpdateOpportunityMutation,
    UpdateOpportunityMutationVariables
  >(UpdateOpportunityDocument, baseOptions)
}
export type UpdateOpportunityMutationHookResult = ReturnType<
  typeof useUpdateOpportunityMutation
>
export type UpdateOpportunityMutationResult = ApolloReactCommon.MutationResult<
  UpdateOpportunityMutation
>
export type UpdateOpportunityMutationOptions = ApolloReactCommon.BaseMutationOptions<
  UpdateOpportunityMutation,
  UpdateOpportunityMutationVariables
>
export const UpdateOpportunityMetaDocument = gql`
  mutation updateOpportunityMeta(
    $data: OpportunityUpdateInput!
    $where: OpportunityWhereUniqueInput!
  ) {
    updateOpportunity(data: $data, where: $where) {
      id
      meta
    }
  }
`
export type UpdateOpportunityMetaMutationFn = ApolloReactCommon.MutationFunction<
  UpdateOpportunityMetaMutation,
  UpdateOpportunityMetaMutationVariables
>

/**
 * __useUpdateOpportunityMetaMutation__
 *
 * To run a mutation, you first call `useUpdateOpportunityMetaMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateOpportunityMetaMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [updateOpportunityMetaMutation, { data, loading, error }] = useUpdateOpportunityMetaMutation({
 *   variables: {
 *      data: // value for 'data'
 *      where: // value for 'where'
 *   },
 * });
 */
export function useUpdateOpportunityMetaMutation(
  baseOptions?: ApolloReactHooks.MutationHookOptions<
    UpdateOpportunityMetaMutation,
    UpdateOpportunityMetaMutationVariables
  >,
) {
  return ApolloReactHooks.useMutation<
    UpdateOpportunityMetaMutation,
    UpdateOpportunityMetaMutationVariables
  >(UpdateOpportunityMetaDocument, baseOptions)
}
export type UpdateOpportunityMetaMutationHookResult = ReturnType<
  typeof useUpdateOpportunityMetaMutation
>
export type UpdateOpportunityMetaMutationResult = ApolloReactCommon.MutationResult<
  UpdateOpportunityMetaMutation
>
export type UpdateOpportunityMetaMutationOptions = ApolloReactCommon.BaseMutationOptions<
  UpdateOpportunityMetaMutation,
  UpdateOpportunityMetaMutationVariables
>
export const DeleteOpportunityDocument = gql`
  mutation deleteOpportunity($id: Int!, $isDeleted: Boolean!) {
    updateOpportunity(data: { isDeleted: $isDeleted }, where: { id: $id }) {
      id
      isDeleted
    }
  }
`
export type DeleteOpportunityMutationFn = ApolloReactCommon.MutationFunction<
  DeleteOpportunityMutation,
  DeleteOpportunityMutationVariables
>

/**
 * __useDeleteOpportunityMutation__
 *
 * To run a mutation, you first call `useDeleteOpportunityMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useDeleteOpportunityMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [deleteOpportunityMutation, { data, loading, error }] = useDeleteOpportunityMutation({
 *   variables: {
 *      id: // value for 'id'
 *      isDeleted: // value for 'isDeleted'
 *   },
 * });
 */
export function useDeleteOpportunityMutation(
  baseOptions?: ApolloReactHooks.MutationHookOptions<
    DeleteOpportunityMutation,
    DeleteOpportunityMutationVariables
  >,
) {
  return ApolloReactHooks.useMutation<
    DeleteOpportunityMutation,
    DeleteOpportunityMutationVariables
  >(DeleteOpportunityDocument, baseOptions)
}
export type DeleteOpportunityMutationHookResult = ReturnType<
  typeof useDeleteOpportunityMutation
>
export type DeleteOpportunityMutationResult = ApolloReactCommon.MutationResult<
  DeleteOpportunityMutation
>
export type DeleteOpportunityMutationOptions = ApolloReactCommon.BaseMutationOptions<
  DeleteOpportunityMutation,
  DeleteOpportunityMutationVariables
>
export const MeDocument = gql`
  query me {
    me {
      id
      type
      contact {
        id
        name
        avatarUrl
        jobTitle
        emails {
          id
          value
          type
        }
        phones {
          id
          value
          type
        }
      }
      operator {
        id
        name
        logo
        website
      }
      agent {
        id
        name
        logo
        website
      }
      permissions
      currency
      regions {
        id
        name
        polygon
      }
    }
  }
`

/**
 * __useMeQuery__
 *
 * To run a query within a React component, call `useMeQuery` and pass it any options that fit your needs.
 * When your component renders, `useMeQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useMeQuery({
 *   variables: {
 *   },
 * });
 */
export function useMeQuery(
  baseOptions?: ApolloReactHooks.QueryHookOptions<MeQuery, MeQueryVariables>,
) {
  return ApolloReactHooks.useQuery<MeQuery, MeQueryVariables>(
    MeDocument,
    baseOptions,
  )
}
export function useMeLazyQuery(
  baseOptions?: ApolloReactHooks.LazyQueryHookOptions<
    MeQuery,
    MeQueryVariables
  >,
) {
  return ApolloReactHooks.useLazyQuery<MeQuery, MeQueryVariables>(
    MeDocument,
    baseOptions,
  )
}
export type MeQueryHookResult = ReturnType<typeof useMeQuery>
export type MeLazyQueryHookResult = ReturnType<typeof useMeLazyQuery>
export type MeQueryResult = ApolloReactCommon.QueryResult<
  MeQuery,
  MeQueryVariables
>
export const UpdateUserDocument = gql`
  mutation updateUser($data: UserUpdateInput!, $where: UserWhereUniqueInput!) {
    updateUser(data: $data, where: $where) {
      id
    }
  }
`
export type UpdateUserMutationFn = ApolloReactCommon.MutationFunction<
  UpdateUserMutation,
  UpdateUserMutationVariables
>

/**
 * __useUpdateUserMutation__
 *
 * To run a mutation, you first call `useUpdateUserMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateUserMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [updateUserMutation, { data, loading, error }] = useUpdateUserMutation({
 *   variables: {
 *      data: // value for 'data'
 *      where: // value for 'where'
 *   },
 * });
 */
export function useUpdateUserMutation(
  baseOptions?: ApolloReactHooks.MutationHookOptions<
    UpdateUserMutation,
    UpdateUserMutationVariables
  >,
) {
  return ApolloReactHooks.useMutation<
    UpdateUserMutation,
    UpdateUserMutationVariables
  >(UpdateUserDocument, baseOptions)
}
export type UpdateUserMutationHookResult = ReturnType<
  typeof useUpdateUserMutation
>
export type UpdateUserMutationResult = ApolloReactCommon.MutationResult<
  UpdateUserMutation
>
export type UpdateUserMutationOptions = ApolloReactCommon.BaseMutationOptions<
  UpdateUserMutation,
  UpdateUserMutationVariables
>
export const AcceptTermAndConditionDocument = gql`
  mutation acceptTermAndCondition($data: AcceptTermAndConditionInput!) {
    acceptTermAndCondition(data: $data) {
      id
      termAndCondition {
        id
        isAccepted
      }
    }
  }
`
export type AcceptTermAndConditionMutationFn = ApolloReactCommon.MutationFunction<
  AcceptTermAndConditionMutation,
  AcceptTermAndConditionMutationVariables
>

/**
 * __useAcceptTermAndConditionMutation__
 *
 * To run a mutation, you first call `useAcceptTermAndConditionMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useAcceptTermAndConditionMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [acceptTermAndConditionMutation, { data, loading, error }] = useAcceptTermAndConditionMutation({
 *   variables: {
 *      data: // value for 'data'
 *   },
 * });
 */
export function useAcceptTermAndConditionMutation(
  baseOptions?: ApolloReactHooks.MutationHookOptions<
    AcceptTermAndConditionMutation,
    AcceptTermAndConditionMutationVariables
  >,
) {
  return ApolloReactHooks.useMutation<
    AcceptTermAndConditionMutation,
    AcceptTermAndConditionMutationVariables
  >(AcceptTermAndConditionDocument, baseOptions)
}
export type AcceptTermAndConditionMutationHookResult = ReturnType<
  typeof useAcceptTermAndConditionMutation
>
export type AcceptTermAndConditionMutationResult = ApolloReactCommon.MutationResult<
  AcceptTermAndConditionMutation
>
export type AcceptTermAndConditionMutationOptions = ApolloReactCommon.BaseMutationOptions<
  AcceptTermAndConditionMutation,
  AcceptTermAndConditionMutationVariables
>
export const DelayTermAndConditionDocument = gql`
  mutation delayTermAndCondition {
    delayTermAndCondition(data: {}) {
      id
      termAndCondition {
        id
        canBeDelayed
      }
    }
  }
`
export type DelayTermAndConditionMutationFn = ApolloReactCommon.MutationFunction<
  DelayTermAndConditionMutation,
  DelayTermAndConditionMutationVariables
>

/**
 * __useDelayTermAndConditionMutation__
 *
 * To run a mutation, you first call `useDelayTermAndConditionMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useDelayTermAndConditionMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [delayTermAndConditionMutation, { data, loading, error }] = useDelayTermAndConditionMutation({
 *   variables: {
 *   },
 * });
 */
export function useDelayTermAndConditionMutation(
  baseOptions?: ApolloReactHooks.MutationHookOptions<
    DelayTermAndConditionMutation,
    DelayTermAndConditionMutationVariables
  >,
) {
  return ApolloReactHooks.useMutation<
    DelayTermAndConditionMutation,
    DelayTermAndConditionMutationVariables
  >(DelayTermAndConditionDocument, baseOptions)
}
export type DelayTermAndConditionMutationHookResult = ReturnType<
  typeof useDelayTermAndConditionMutation
>
export type DelayTermAndConditionMutationResult = ApolloReactCommon.MutationResult<
  DelayTermAndConditionMutation
>
export type DelayTermAndConditionMutationOptions = ApolloReactCommon.BaseMutationOptions<
  DelayTermAndConditionMutation,
  DelayTermAndConditionMutationVariables
>