import { r as registerInstance, B as Build, h } from './index-33e43734.js';
import { K as FireEnjin } from './index-32dcea94.js';
import { g as gql } from './index-abe36624.js';
import './index-ad375e48.js';
import './process-es6-cc264d03.js';
import './index.esm2017-6b1b7209.js';
import './tslib.es6-1584b5be.js';
import './localforage-9daa31d6.js';
import './_commonjsHelpers-4ed75ef8.js';

const AddAlertDocument = gql `
    mutation addAlert($data: AlertInput!) {
  addAlert(data: $data) {
    id
  }
}
    `;
const EditAlertDocument = gql `
    mutation editAlert($id: String!, $data: AlertInput!) {
  editAlert(id: $id, data: $data) {
    id
  }
}
    `;
const FindAlertDocument = gql `
    query findAlert($id: String!) {
  alert(id: $id) {
    id
    types
    tags
    emails
    userIds
    payload
    template {
      id
      html
      text
      amp
      sampleData
      type
      subject
      description
    }
    createdAt
    updatedAt
  }
}
    `;
const ListAlertsDocument = gql `
    query listAlerts($data: ListQueryInput!) {
  alerts(data: $data) {
    id
    types
    tags
    emails
    userIds
    template {
      id
      subject
      description
    }
    createdAt
    updatedAt
  }
}
    `;
const AddAtmosphericDocument = gql `
    mutation addAtmospheric($data: AtmosphericInput!) {
  addAtmospheric(data: $data) {
    id
  }
}
    `;
const DeleteAtmosphericDocument = gql `
    mutation deleteAtmospheric($id: String!) {
  deleteAtmospheric(id: $id) {
    id
  }
}
    `;
const EditAtmosphericDocument = gql `
    mutation editAtmospheric($id: String!, $data: AtmosphericInput!) {
  editAtmospheric(id: $id, data: $data) {
    id
  }
}
    `;
const FindAtmosphericDocument = gql `
    query findAtmospheric($id: String!) {
  atmospheric(id: $id) {
    id
    job {
      id
    }
    site {
      id
    }
    chamber
    temperature
    humidity
    grainsPerPound
    gramPerGram
    dewPoint
    vaporPressure
    kPa
    createdAt
    updatedAt
  }
}
    `;
const ListAtmosphericsDocument = gql `
    query listAtmospherics($data: ListQueryInput!) {
  atmospherics(data: $data) {
    id
    job {
      id
    }
    site {
      id
    }
    chamber
    temperature
    humidity
    grainsPerPound
    gramPerGram
    dewPoint
    vaporPressure
    kPa
    createdAt
    updatedAt
  }
}
    `;
const AddCompanyDocument = gql `
    mutation addCompany($data: CompanyInput!) {
  addCompany(data: $data) {
    id
  }
}
    `;
const DeleteCompanyDocument = gql `
    mutation deleteCompany($id: String!) {
  deleteCompany(id: $id) {
    id
  }
}
    `;
const EditCompanyDocument = gql `
    mutation editCompany($id: String!, $data: CompanyInput!) {
  editCompany(id: $id, data: $data) {
    id
  }
}
    `;
const FindCompanyDocument = gql `
    query findCompany($id: String!, $withUsers: Boolean!) {
  company(id: $id) {
    id
    name
    phone
    email
    website
    address {
      placeId
      lat
      lng
      full
      street
      unit
      city
      state
      zip
      country
    }
    users @include(if: $withUsers) {
      id
      firstName
      lastName
      email
      photo
    }
  }
}
    `;
const ListCompaniesDocument = gql `
    query listCompanies($data: ListQueryInput!) {
  companies(data: $data) {
    id
    name
    phone
    email
    website
    address {
      placeId
      lat
      lng
      full
      street
      unit
      city
      state
      zip
      country
    }
  }
}
    `;
const AddDotDocument = gql `
    mutation addDot($data: DotInput!) {
  addDot(data: $data) {
    id
  }
}
    `;
const DeleteDotDocument = gql `
    mutation deleteDot($id: String!) {
  deleteDot(id: $id) {
    id
  }
}
    `;
const EditDotDocument = gql `
    mutation editDot($id: String!, $data: DotInput!) {
  editDot(id: $id, data: $data) {
    id
  }
}
    `;
const FindDotDocument = gql `
    query findDot($id: String!) {
  dot(id: $id) {
    id
    placement
    job {
      id
    }
    site {
      id
    }
    material
    meter
    dryStandard
    evaporationPotentialGoal
    createdAt
    updatedAt
  }
}
    `;
const ListDotsDocument = gql `
    query listDots($data: ListQueryInput!) {
  dots(data: $data) {
    id
    placement
    job {
      id
    }
    site {
      id
    }
    material
    meter
    dryStandard
    evaporationPotentialGoal
    createdAt
    updatedAt
  }
}
    `;
const AddEfileDocument = gql `
    mutation addEfile($data: EfileInput!) {
  addEfile(data: $data) {
    id
  }
}
    `;
const DeleteEfileDocument = gql `
    mutation deleteEfile($id: String!) {
  deleteEfile(id: $id) {
    id
  }
}
    `;
const EditEfileDocument = gql `
    mutation editEfile($id: String!, $data: EfileInput!) {
  editEfile(id: $id, data: $data) {
    id
  }
}
    `;
const FindEfileDocument = gql `
    query findEfile($id: String!) {
  efile(id: $id) {
    id
    name
    url
    type
    tags
  }
}
    `;
const ListEfilesDocument = gql `
    query listEfiles($data: EfileListQueryInput!) {
  efiles(data: $data) {
    id
    name
    url
    type
    tags
  }
}
    `;
const AddExhaustDocument = gql `
    mutation addExhaust($data: ExhaustInput!) {
  addExhaust(data: $data) {
    id
  }
}
    `;
const DeleteExhaustDocument = gql `
    mutation deleteExhaust($id: String!) {
  deleteExhaust(id: $id) {
    id
  }
}
    `;
const EditExhaustDocument = gql `
    mutation editExhaust($id: String!, $data: ExhaustInput!) {
  editExhaust(id: $id, data: $data) {
    id
  }
}
    `;
const FindExhaustDocument = gql `
    query findExhaust($id: String!) {
  exhaust(id: $id) {
    id
    service {
      id
    }
    job {
      id
    }
    site {
      id
    }
    inventory {
      id
    }
    inletTemperature
    inletHumidity
    inletGrainsPerPound
    outletTemperature
    outletHumidity
    outletGrainsPerPound
    createdAt
    updatedAt
  }
}
    `;
const ListExhaustsDocument = gql `
    query listExhausts($data: ListQueryInput!) {
  exhausts(data: $data) {
    id
    service {
      id
    }
    job {
      id
    }
    site {
      id
    }
    inventory {
      id
    }
    inletTemperature
    inletHumidity
    inletGrainsPerPound
    outletTemperature
    outletHumidity
    outletGrainsPerPound
    createdAt
    updatedAt
  }
}
    `;
const ListFeedDocument = gql `
    query listFeed($data: FeedListQueryInput!) {
  feeds(data: $data) {
    id
    type
    backgroundImage
    href
    image
    readIds
    subject
    html
    createdAt
  }
}
    `;
const AddInventoryDocument = gql `
    mutation addInventory($data: InventoryInput!) {
  addInventory(data: $data) {
    id
  }
}
    `;
const DeleteInventoryDocument = gql `
    mutation deleteInventory($id: String!) {
  deleteInventory(id: $id) {
    id
  }
}
    `;
const EditInventoryDocument = gql `
    mutation editInventory($id: String!, $data: InventoryInput!) {
  editInventory(id: $id, data: $data) {
    id
  }
}
    `;
const FindInventoryDocument = gql `
    query findInventory($id: String!) {
  inventory(id: $id) {
    id
    name
    type
    group
    tags
    location {
      id
      name
      type
    }
    createdAt
    updatedAt
  }
}
    `;
const ListInventoriesDocument = gql `
    query listInventories($data: ListQueryInput!) {
  inventories(data: $data) {
    id
    name
    type
    group
    tags
    location {
      id
      name
      type
    }
    createdAt
  }
}
    `;
const AddInvoiceDocument = gql `
    mutation addInvoice($data: InvoiceInput!) {
  addInvoice(data: $data) {
    id
  }
}
    `;
const DeleteInvoiceDocument = gql `
    mutation deleteInvoice($id: String!) {
  deleteInvoice(id: $id) {
    id
  }
}
    `;
const EditInvoiceDocument = gql `
    mutation editInvoice($id: String!, $data: InvoiceInput!) {
  editInvoice(id: $id, data: $data) {
    id
  }
}
    `;
const FindInvoiceDocument = gql `
    query findInvoice($id: String!) {
  invoice(id: $id) {
    id
  }
}
    `;
const ListInvoicesDocument = gql `
    query listInvoices($data: ListQueryInput!) {
  invoices(data: $data) {
    id
  }
}
    `;
const AddJobDocument = gql `
    mutation addJob($data: JobInput!) {
  addJob(data: $data) {
    id
  }
}
    `;
const AddUserToJobDocument = gql `
    mutation addUserToJob($data: AddUserToJobInput!) {
  addUserToJob(data: $data) {
    id
  }
}
    `;
const DeleteJobDocument = gql `
    mutation deleteJob($id: String!) {
  deleteJob(id: $id) {
    id
  }
}
    `;
const EditJobDocument = gql `
    mutation editJob($id: String!, $data: JobInput!) {
  editJob(id: $id, data: $data) {
    id
  }
}
    `;
const FindJobDocument = gql `
    query findJob($id: String!, $withPayments: Boolean!, $withUsers: Boolean!, $withSites: Boolean!, $withPayModel: Boolean!, $withPhotos: Boolean!, $withEfiles: Boolean!, $withPayables: Boolean!, $withReadings: Boolean!) {
  job(id: $id) {
    id
    status
    type
    title
    picture
    phone
    amountBilled
    amountOwed
    amountDeducted
    dateOfLoss
    cause
    category
    claimNumber
    efileCount
    isFranchise
    matterportModelId
    tags
    afterhours
    appointment {
      id
      name
      scheduledOn
    }
    address {
      placeId
      lat
      lng
      full
      street
      unit
      city
      state
      zip
      country
    }
    customer {
      id
      firstName
      lastName
      email
      phone
    }
    manager {
      id
      firstName
      lastName
      email
      phone
    }
    referral {
      id
      firstName
      lastName
      email
    }
    location {
      id
      name
      email
      photo
      phone
      taxId
      address {
        placeId
        lat
        lng
        full
        street
        unit
        city
        state
        zip
        country
      }
    }
    services {
      id
      price
      amount
      quantity
      total
      createdAt
      updatedAt
      service {
        id
        name
      }
    }
    payModel @include(if: $withPayModel) {
      id
      name
    }
    users @include(if: $withUsers) {
      id
      firstName
      lastName
      email
      photo
    }
    payments @include(if: $withPayments) {
      id
      netTotal
      amount
      fee
      type
      method
      createdAt
      updatedAt
      user {
        id
        firstName
        lastName
        email
        photo
      }
    }
    payables @include(if: $withPayables) {
      id
      user {
        id
        firstName
        lastName
        email
        photo
      }
      percent
      amount
      approved
      createdAt
    }
    sites @include(if: $withSites) {
      id
      name
      affectedAreaTotalCuft
      affectedAreaTotalSqft
      areaTotalCuft
      areaTotalSqft
      class
      chamber
      floorType
      wallType
      ceilingType
      level
      offsets
      job {
        id
        title
      }
      areas {
        length
        width
        height
        sqft
        cuft
        lnft
      }
      dots {
        id
        placement
        material
        meter
        dryStandard
        evaporationPotentialGoal
        createdAt
        updatedAt
      }
      affectedAreas {
        length
        width
        height
        sqft
        cuft
        lnft
      }
      inventories {
        id
        name
      }
      services {
        id
        price
        amount
        quantity
        total
        createdAt
        updatedAt
        service {
          id
          name
        }
      }
      photos @include(if: $withPhotos) {
        id
        default
        url
      }
      createdAt
      updatedAt
    }
    efiles @include(if: $withEfiles) {
      id
      name
      url
      type
      tags
      template {
        id
        subject
        description
      }
    }
    readings @include(if: $withReadings) {
      name
      weather {
        id
        name
        temperature
        temperatureMin
        temperatureMax
        pressure
        humidity
        conditions {
          id
          main
          description
          icon
        }
      }
      chambers {
        name
        atmospheric {
          id
          temperature
          humidity
          grainsPerPound
          gramPerGram
          dewPoint
          vaporPressure
          kPa
          createdAt
        }
      }
      sites {
        id
        dots {
          id
          name
          moistureContent {
            id
            readings
            temperature
            grainsPerPound
            gramPerGram
            dewPoint
            vaporPressure
            kPa
          }
        }
        equipment {
          id
          inventory {
            id
            name
          }
          exhaust {
            id
            inletTemperature
            inletHumidity
            inletGrainsPerPound
            outletTemperature
            outletHumidity
            outletGrainsPerPound
            createdAt
          }
        }
      }
    }
  }
}
    `;
const ListJobsDocument = gql `
    query listJobs($data: JobListQueryInput!, $withPayables: Boolean!) {
  jobs(data: $data) {
    id
    title
    status
    picture
    type
    amountBilled
    amountOwed
    cause
    category
    tags
    location {
      id
    }
    address {
      placeId
      lat
      lng
      full
      street
      unit
      city
      state
      zip
      country
    }
    appointment {
      id
      name
      scheduledOn
    }
    referral {
      id
      firstName
      lastName
      email
      phone
    }
    manager {
      id
      firstName
      lastName
      email
      phone
    }
    payables @include(if: $withPayables) {
      id
      user {
        id
        firstName
        lastName
        email
        photo
      }
      percent
      amount
      approved
      createdAt
    }
    createdAt
  }
}
    `;
const RemoveUserFromJobDocument = gql `
    mutation removeUserFromJob($data: RemoveUserFromJobInput!) {
  removeUserFromJob(data: $data) {
    id
  }
}
    `;
const AddLocationDocument = gql `
    mutation addLocation($data: LocationInput!) {
  addLocation(data: $data) {
    id
  }
}
    `;
const AddUserToLocationDocument = gql `
    mutation addUserToLocation($data: AddUserToLocationInput!) {
  addUserToLocation(data: $data) {
    userId
  }
}
    `;
const DeleteLocationDocument = gql `
    mutation deleteLocation($id: String!) {
  deleteLocation(id: $id) {
    id
  }
}
    `;
const EditLocationDocument = gql `
    mutation editLocation($id: String!, $data: LocationInput!) {
  editLocation(id: $id, data: $data) {
    id
  }
}
    `;
const FindLocationDocument = gql `
    query findLocation($id: String!) {
  location(id: $id) {
    id
    type
    name
    email
    photo
    phone
    website
    isSearchable
    dba
    taxId
    googleTagManagerId
    googleTagManagerCampaignId
    googleTagManagerPhoneId
    bannerPhoto
    teamPhoto
    address {
      placeId
      lat
      lng
      full
      street
      unit
      city
      state
      zip
      country
    }
    owner {
      id
      firstName
      lastName
      email
    }
    defaultPayModel {
      id
      name
    }
    tags
  }
}
    `;
const ListLocationsDocument = gql `
    query listLocations($data: ListQueryInput!) {
  locations(data: $data) {
    id
    type
    name
    website
    email
    photo
    phone
    address {
      placeId
      lat
      lng
      full
      street
      unit
      city
      state
      zip
      country
    }
    tags
  }
}
    `;
const RemoveUserFromLocationDocument = gql `
    mutation removeUserFromLocation($data: RemoveUserFromLocationInput!) {
  removeUserFromLocation(data: $data) {
    id
  }
}
    `;
const SearchLocationsDocument = gql `
    query searchLocations($data: SearchLocationsInput!) {
  searchLocations(data: $data) {
    page
    limit
    pageCount
    resultCount
    results {
      id
      type
      name
      photo
      phone
      address {
        placeId
        lat
        lng
        full
        street
        unit
        city
        state
        zip
        country
      }
      tags
    }
  }
}
    `;
const ListLogsDocument = gql `
    query listLogs($data: LogListQueryInput!) {
  logs(data: $data) {
    id
    type
    name
    input
    output
    referrer
    resolveTime
    createdAt
  }
}
    `;
const AddMoistureContentDocument = gql `
    mutation addMoistureContent($data: MoistureContentInput!) {
  addMoistureContent(data: $data) {
    id
  }
}
    `;
const DeleteMoistureContentDocument = gql `
    mutation deleteMoistureContent($id: String!) {
  deleteMoistureContent(id: $id) {
    id
  }
}
    `;
const EditMoistureContentDocument = gql `
    mutation editMoistureContent($id: String!, $data: MoistureContentInput!) {
  editMoistureContent(id: $id, data: $data) {
    id
  }
}
    `;
const FindMoistureContentDocument = gql `
    query findMoistureContent($id: String!) {
  moistureContent(id: $id) {
    id
    dot {
      id
    }
    job {
      id
    }
    site {
      id
    }
    readings
    temperature
    grainsPerPound
    gramPerGram
    dewPoint
    vaporPressure
    kPa
    createdAt
    updatedAt
  }
}
    `;
const ListMoistureContentsDocument = gql `
    query listMoistureContents($data: ListQueryInput!) {
  moistureContents(data: $data) {
    id
    dot {
      id
    }
    job {
      id
    }
    site {
      id
    }
    readings
    temperature
    grainsPerPound
    gramPerGram
    dewPoint
    vaporPressure
    kPa
    createdAt
    updatedAt
  }
}
    `;
const AddNoteDocument = gql `
    mutation addNote($data: NoteInput!) {
  addNote(data: $data) {
    id
  }
}
    `;
const DeleteNoteDocument = gql `
    mutation deleteNote($id: String!) {
  deleteNote(id: $id) {
    id
  }
}
    `;
const EditNoteDocument = gql `
    mutation editNote($id: String!, $data: NoteInput!) {
  editNote(id: $id, data: $data) {
    id
  }
}
    `;
const FindNoteDocument = gql `
    query findNote($id: String!) {
  note(id: $id) {
    id
    html
    alert {
      id
      template {
        id
        subject
      }
    }
    user {
      id
      firstName
      lastName
      email
      photo
    }
    job {
      id
      title
    }
    company {
      id
      name
    }
    createdAt
    updatedAt
    createdBy {
      id
      firstName
      lastName
      email
      photo
    }
  }
}
    `;
const ListNotesDocument = gql `
    query listNotes($data: ListQueryInput!) {
  notes(data: $data) {
    id
    html
    alert {
      id
    }
    createdAt
    updatedAt
    createdBy {
      id
      firstName
      lastName
      email
      photo
    }
  }
}
    `;
const AddPayModelDocument = gql `
    mutation addPayModel($data: PayModelInput!) {
  addPayModel(data: $data) {
    id
  }
}
    `;
const EditPayModelDocument = gql `
    mutation editPayModel($id: String!, $data: PayModelInput!) {
  editPayModel(id: $id, data: $data) {
    id
  }
}
    `;
const FindPayModelDocument = gql `
    query findPayModel($id: String!) {
  payModel(id: $id) {
    id
    name
    payouts {
      role {
        id
        name
        type
        description
        permissions
      }
      transfer
      percentages {
        default
        hasReferral
      }
    }
    createdAt
    updatedAt
  }
}
    `;
const ListPayModelsDocument = gql `
    query listPayModels($data: ListQueryInput!) {
  payModels(data: $data) {
    id
    name
    payouts {
      role {
        id
        name
        type
        description
        permissions
      }
      transfer
      percentages {
        default
        hasReferral
      }
    }
    createdAt
    updatedAt
  }
}
    `;
const AddPaymentDocument = gql `
    mutation addPayment($data: PaymentInput!) {
  addPayment(data: $data) {
    id
  }
}
    `;
const ListPaymentsDocument = gql `
    query listPayments($data: PaymentListQueryInput!) {
  payments(data: $data) {
    id
    netTotal
    amount
    fee
    chargeId
    type
    method
    user {
      id
      firstName
      lastName
      email
    }
    job {
      id
      title
    }
    frequency
    checkNumber
    verifiedAt
    createdAt
    updatedAt
  }
}
    `;
const AddPhoneNumberDocument = gql `
    mutation addPhoneNumber($data: PhoneNumberInput!) {
  addPhoneNumber(data: $data) {
    id
  }
}
    `;
const DeletePhoneNumberDocument = gql `
    mutation deletePhoneNumber($id: String!) {
  deletePhoneNumber(id: $id) {
    id
  }
}
    `;
const EditPhoneNumberDocument = gql `
    mutation editPhoneNumber($id: String!, $data: PhoneNumberInput!) {
  editPhoneNumber(id: $id, data: $data) {
    id
  }
}
    `;
const FindPhoneNumberDocument = gql `
    query findPhoneNumber($id: String!) {
  phoneNumber(id: $id) {
    id
    name
    location {
      id
      name
    }
    phoneNumber
    tags
    createdAt
    updatedAt
  }
}
    `;
const ListPhoneNumbersDocument = gql `
    query listPhoneNumbers($data: ListQueryInput!) {
  phoneNumbers(data: $data) {
    id
    name
    location {
      id
      name
    }
    phoneNumber
    tags
    createdAt
    updatedAt
  }
}
    `;
const AddPhotoDocument = gql `
    mutation addPhoto($data: PhotoInput!) {
  addPhoto(data: $data) {
    id
  }
}
    `;
const DeletePhotoDocument = gql `
    mutation deletePhoto($id: String!) {
  deletePhoto(id: $id) {
    id
  }
}
    `;
const EditPhotoDocument = gql `
    mutation editPhoto($id: String!, $data: PhotoInput!) {
  editPhoto(id: $id, data: $data) {
    id
  }
}
    `;
const FindPhotoDocument = gql `
    query findPhoto($id: String!) {
  photo(id: $id) {
    id
    default
    url
    site {
      id
      name
    }
    job {
      id
      title
      picture
    }
  }
}
    `;
const AddPinDocument = gql `
    mutation addPin($data: PinInput!) {
  addPin(data: $data) {
    id
  }
}
    `;
const DeletePinDocument = gql `
    mutation deletePin($id: String!) {
  deletePin(id: $id) {
    id
  }
}
    `;
const FindPinDocument = gql `
    query findPin($id: String!) {
  pin(id: $id) {
    id
    icon
    order
    href
    name
    trigger
    payload
  }
}
    `;
const ListPinsDocument = gql `
    query listPins($data: PinListQueryInput!) {
  pins(data: $data) {
    id
    order
    icon
    href
    name
    trigger
    payload
  }
}
    `;
const ReorderPinsDocument = gql `
    mutation reorderPins($data: ReorderPinsInput!) {
  reorderPins(data: $data) {
    userId
    pins
  }
}
    `;
const AddServiceDocument = gql `
    mutation addService($data: ServiceInput!) {
  addService(data: $data) {
    id
  }
}
    `;
const DeleteServiceDocument = gql `
    mutation deleteService($id: String!) {
  deleteService(id: $id) {
    id
  }
}
    `;
const EditServiceDocument = gql `
    mutation editService($id: String!, $data: ServiceInput!) {
  editService(id: $id, data: $data) {
    id
  }
}
    `;
const FindServiceDocument = gql `
    query findService($id: String!) {
  service(id: $id) {
    id
    types
    name
    smartScoping
    autofill
    code
    description
    group
    prices
    tab
    unit
    createdAt
    updatedAt
  }
}
    `;
const ListServicesDocument = gql `
    query listServices($data: ListQueryInput!) {
  services(data: $data) {
    id
    name
    autofill
    smartScoping
    code
    description
    group
    prices
    types
    tab
    unit
  }
}
    `;
const AddSiteDocument = gql `
    mutation addSite($data: SiteInput!) {
  addSite(data: $data) {
    id
  }
}
    `;
const DeleteSiteDocument = gql `
    mutation deleteSite($id: String!) {
  deleteSite(id: $id) {
    id
  }
}
    `;
const EditSiteDocument = gql `
    mutation editSite($id: String!, $data: SiteInput!) {
  editSite(id: $id, data: $data) {
    id
  }
}
    `;
const FindSiteDocument = gql `
    query findSite($id: String!) {
  site(id: $id) {
    id
    name
    affectedAreaTotalCuft
    affectedAreaTotalSqft
    areaTotalCuft
    areaTotalSqft
    class
    chamber
    floorType
    wallType
    ceilingType
    level
    offsets
    job {
      id
      title
    }
    areas {
      length
      width
      height
      sqft
      cuft
      lnft
    }
    affectedAreas {
      length
      width
      height
      sqft
      cuft
      lnft
    }
    photos {
      id
      url
      tags
    }
    inventories {
      id
      name
    }
    services {
      id
      price
      amount
      quantity
      total
      createdAt
      updatedAt
      service {
        id
        name
      }
    }
    createdAt
    updatedAt
  }
}
    `;
const AddSupportDocument = gql `
    mutation addSupport($data: SupportInput!) {
  addSupport(data: $data) {
    id
  }
}
    `;
const DeleteSupportDocument = gql `
    mutation deleteSupport($id: String!) {
  deleteSupport(id: $id) {
    id
  }
}
    `;
const EditSupportDocument = gql `
    mutation editSupport($id: String!, $data: SupportInput!) {
  editSupport(id: $id, data: $data) {
    id
  }
}
    `;
const FindSupportDocument = gql `
    query findSupport($id: String!) {
  support(id: $id) {
    id
    name
    type
    html
    editor {
      time
      version
      blocks {
        data
        type
      }
    }
    tags
  }
}
    `;
const ListSupportsDocument = gql `
    query listSupports($data: ListQueryInput!) {
  supports(data: $data) {
    id
    name
    type
    tags
  }
}
    `;
const AddTemplateDocument = gql `
    mutation addTemplate($data: TemplateInput!) {
  addTemplate(data: $data) {
    id
  }
}
    `;
const DeleteTemplateDocument = gql `
    mutation deleteTemplate($id: String!) {
  deleteTemplate(id: $id) {
    id
  }
}
    `;
const EditTemplateDocument = gql `
    mutation editTemplate($id: String!, $data: TemplateInput!) {
  editTemplate(id: $id, data: $data) {
    id
  }
}
    `;
const FindTemplateDocument = gql `
    query findTemplate($id: String!) {
  template(id: $id) {
    id
    editor {
      time
      version
      blocks {
        data
        type
      }
    }
    tags
    description
    routes
    name
    subject
    type
    html
    head
    text
    amp
    header {
      id
      subject
      description
      html
    }
    footer {
      id
      subject
      description
      html
    }
    frame {
      id
      subject
      description
      html
      head
      header {
        id
        subject
        description
        html
      }
      footer {
        id
        subject
        description
        html
      }
    }
    attachments {
      cid
      filename
      content
      path
      encoding
      raw
      href
      httpHeaders
      contentDisposition
      contentType
      headers
    }
    partial
    sampleData
    createdAt
  }
}
    `;
const ListTemplatesDocument = gql `
    query listTemplates($data: ListQueryInput!, $withHtml: Boolean!) {
  templates(data: $data) {
    id
    name
    routes
    description
    subject
    type
    text
    html @include(if: $withHtml)
    head @include(if: $withHtml)
    header @include(if: $withHtml) {
      id
      subject
      description
      html
    }
    footer @include(if: $withHtml) {
      id
      subject
      description
      html
    }
    frame @include(if: $withHtml) {
      id
      subject
      description
      html
    }
    tags
    partial
    createdAt
  }
}
    `;
const AddTotallerDocument = gql `
    mutation addTotaller($data: TotallerInput!) {
  addTotaller(data: $data) {
    id
  }
}
    `;
const CalculateTotallerDocument = gql `
    mutation calculateTotaller($data: CalculateTotallerInput!) {
  calculateTotaller(data: $data) {
    id
    results
  }
}
    `;
const DeleteTotallerDocument = gql `
    mutation deleteTotaller($id: String!) {
  deleteTotaller(id: $id) {
    id
  }
}
    `;
const EditTotallerDocument = gql `
    mutation editTotaller($id: String!, $data: TotallerInput!) {
  editTotaller(id: $id, data: $data) {
    id
  }
}
    `;
const FindTotallerDocument = gql `
    query findTotaller($id: String!) {
  totaller(id: $id) {
    id
    name
    collection
    sums
    paths
    sampleData
    lastRunAt
    createdAt
    updatedAt
  }
}
    `;
const ListTotallersDocument = gql `
    query listTotallers($data: ListQueryInput!) {
  totallers(data: $data) {
    id
    name
    collection
    sums
    paths
    sampleData
    lastRunAt
    createdAt
    updatedAt
  }
}
    `;
const AddTriggerDocument = gql `
    mutation addTrigger($data: TriggerInput!) {
  addTrigger(data: $data) {
    id
  }
}
    `;
const DeleteTriggerDocument = gql `
    mutation deleteTrigger($id: String!) {
  deleteTrigger(id: $id) {
    id
  }
}
    `;
const EditTriggerDocument = gql `
    mutation editTrigger($id: String!, $data: TriggerInput!) {
  editTrigger(id: $id, data: $data) {
    id
  }
}
    `;
const FindTriggerDocument = gql `
    query findTrigger($id: String!) {
  trigger(id: $id) {
    id
    active
    name
    type
    when
    action
    payload
    sampleData
    lastFiredAt
  }
}
    `;
const ListTriggersDocument = gql `
    query listTriggers($data: ListQueryInput!) {
  triggers(data: $data) {
    id
    active
    name
    type
    when
    action
    payload
    lastFiredAt
  }
}
    `;
const AddUserDocument = gql `
    mutation addUser($data: UserInput!) {
  addUser(data: $data) {
    id
  }
}
    `;
const BulkUpdateUsersDocument = gql `
    mutation bulkUpdateUsers($data: BulkUpdateUsersInput!) {
  bulkUpdateUsers(data: $data) {
    users {
      id
    }
  }
}
    `;
const EditUserDocument = gql `
    mutation editUser($id: String!, $data: UserInput!) {
  editUser(id: $id, data: $data) {
    id
  }
}
    `;
const FindUserDocument = gql `
    query findUser($id: String!, $withFriends: Boolean!) {
  user(id: $id) {
    id
    online
    firstName
    lastName
    isSetup
    email
    phone
    active
    photo
    tags
    trade
    role
    isOnboarded
    isFranchise
    isFranchiseOwner
    birthday
    slackHandle
    role
    rating
    location {
      id
      name
      type
      defaultPayModel {
        id
        name
      }
    }
    company {
      id
      name
    }
    referredBy @include(if: $withFriends) {
      id
      firstName
      lastName
      email
      photo
    }
    friends @include(if: $withFriends) {
      id
      firstName
      lastName
      email
      photo
    }
    address {
      placeId
      lat
      lng
      full
      street
      unit
      city
      state
      zip
      country
    }
    billingAddress {
      placeId
      lat
      lng
      full
      street
      unit
      city
      state
      zip
      country
    }
  }
}
    `;
const ListUsersDocument = gql `
    query listUsers($data: UserListQueryInput!) {
  users(data: $data) {
    id
    firstName
    lastName
    email
    photo
    tags
    trade
    role
    lastOnline
    online
    address {
      placeId
      lat
      lng
      full
      street
      unit
      city
      state
      zip
      country
    }
  }
}
    `;
const AddWeatherDocument = gql `
    mutation addWeather($data: WeatherInput!) {
  addWeather(data: $data) {
    id
  }
}
    `;
const DeleteWeatherDocument = gql `
    mutation deleteWeather($id: String!) {
  deleteWeather(id: $id) {
    id
  }
}
    `;
const EditWeatherDocument = gql `
    mutation editWeather($id: String!, $data: WeatherInput!) {
  editWeather(id: $id, data: $data) {
    id
  }
}
    `;
const FindWeatherDocument = gql `
    query findWeather($id: String!) {
  weather(id: $id) {
    id
    name
    clouds
    wind {
      speed
      deg
      gust
    }
    conditions {
      id
      main
      description
      icon
    }
    temperature
    temperatureFeelsLike
    temperatureMin
    temperatureMax
    pressure
    humidity
    visibility
    createdAt
    updatedAt
  }
}
    `;
const ListWeatherDocument = gql `
    query listWeather($data: ListQueryInput!) {
  weathers(data: $data) {
    id
    name
    temperature
    temperatureFeelsLike
    temperatureMin
    temperatureMax
    pressure
    humidity
    createdAt
    updatedAt
  }
}
    `;
const AddPaymentMethodDocument = gql `
    mutation addPaymentMethod($data: AddPaymentMethodInput!) {
  addPaymentMethod(data: $data) {
    id
  }
}
    `;
const AddScopeServiceDocument = gql `
    mutation addScopeService($data: AddScopeServiceInput!) {
  addScopeService(data: $data) {
    id
  }
}
    `;
const BookJobDocument = gql `
    mutation bookJob($data: BookJobInput!) {
  bookJob(data: $data) {
    id
  }
}
    `;
const CreatePlaidTokenDocument = gql `
    mutation createPlaidToken($data: CreatePlaidTokenInput!) {
  createPlaidToken(data: $data) {
    token
    expiration
  }
}
    `;
const CreateQuickbooksAuthUrlDocument = gql `
    mutation createQuickbooksAuthUrl($data: CreateQuickbooksAuthUrlInput!) {
  createQuickbooksAuthUrl(data: $data) {
    authUrl
  }
}
    `;
const CreateQuickbooksTokenDocument = gql `
    mutation createQuickbooksToken($data: CreateQuickbooksTokenInput!) {
  createQuickbooksToken(data: $data) {
    refresh_token
    x_refresh_token_expires_in
    access_token
    token_type
    expires_in
    id_token
  }
}
    `;
const CreateStripeAccountLinkDocument = gql `
    mutation createStripeAccountLink($data: CreateStripeAccountLinkInput!) {
  createStripeAccountLink(data: $data) {
    url
  }
}
    `;
const CreateStripeOAuthTokenDocument = gql `
    mutation createStripeOAuthToken($data: CreateStripeOAuthTokenInput!) {
  createStripeOAuthToken(data: $data) {
    accountId
  }
}
    `;
const DeleteScopeServiceDocument = gql `
    mutation deleteScopeService($data: DeleteScopeServiceInput!) {
  deleteScopeService(data: $data) {
    id
  }
}
    `;
const EditScopeServiceDocument = gql `
    mutation editScopeService($data: EditScopeServiceInput!) {
  editScopeService(data: $data) {
    id
  }
}
    `;
const GenerateGoogleAuthUrlDocument = gql `
    mutation generateGoogleAuthUrl($data: GenerateGoogleAuthUrlInput!) {
  generateGoogleAuthUrl(data: $data) {
    authUrl
  }
}
    `;
const GeneratePayablesDocument = gql `
    mutation generatePayables($data: GeneratePayablesInput!) {
  generatePayables(data: $data) {
    payables {
      id
    }
  }
}
    `;
const GeneratePdfDocument = gql `
    mutation generatePdf($data: GeneratePdfInput!) {
  generatePdf(data: $data) {
    id
    url
  }
}
    `;
const GetGoogleAccessTokenDocument = gql `
    mutation getGoogleAccessToken($data: GetGoogleAccessTokenInput!) {
  getGoogleAccessToken(data: $data) {
    success
    error
  }
}
    `;
const ImporterDocument = gql `
    mutation importer($data: ImporterInput!) {
  importer(data: $data) {
    results
  }
}
    `;
const SendTemplateEmailDocument = gql `
    mutation sendTemplateEmail($data: SendTemplateEmailInput!) {
  sendTemplateEmail(data: $data) {
    id
  }
}
    `;
const SetPlaidAccessTokenDocument = gql `
    mutation setPlaidAccessToken($data: SetPlaidAccessTokenInput!) {
  setPlaidAccessToken(data: $data) {
    id
    token
  }
}
    `;
const SignContractDocument = gql `
    mutation signContract($data: SignContractInput!) {
  signContract(data: $data) {
    id
    url
  }
}
    `;
const UploadDocument = gql `
    mutation upload($data: UploadInput!) {
  upload(data: $data) {
    filename
    url
  }
}
    `;
const defaultWrapper = (action, _operationName, _operationType) => action();
function getSdk(client, withWrapper = defaultWrapper) {
  return {
    addAlert(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(AddAlertDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'addAlert', 'mutation');
    },
    editAlert(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(EditAlertDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'editAlert', 'mutation');
    },
    findAlert(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(FindAlertDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'findAlert', 'query');
    },
    listAlerts(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(ListAlertsDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'listAlerts', 'query');
    },
    addAtmospheric(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(AddAtmosphericDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'addAtmospheric', 'mutation');
    },
    deleteAtmospheric(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(DeleteAtmosphericDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'deleteAtmospheric', 'mutation');
    },
    editAtmospheric(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(EditAtmosphericDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'editAtmospheric', 'mutation');
    },
    findAtmospheric(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(FindAtmosphericDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'findAtmospheric', 'query');
    },
    listAtmospherics(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(ListAtmosphericsDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'listAtmospherics', 'query');
    },
    addCompany(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(AddCompanyDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'addCompany', 'mutation');
    },
    deleteCompany(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(DeleteCompanyDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'deleteCompany', 'mutation');
    },
    editCompany(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(EditCompanyDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'editCompany', 'mutation');
    },
    findCompany(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(FindCompanyDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'findCompany', 'query');
    },
    listCompanies(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(ListCompaniesDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'listCompanies', 'query');
    },
    addDot(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(AddDotDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'addDot', 'mutation');
    },
    deleteDot(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(DeleteDotDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'deleteDot', 'mutation');
    },
    editDot(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(EditDotDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'editDot', 'mutation');
    },
    findDot(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(FindDotDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'findDot', 'query');
    },
    listDots(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(ListDotsDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'listDots', 'query');
    },
    addEfile(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(AddEfileDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'addEfile', 'mutation');
    },
    deleteEfile(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(DeleteEfileDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'deleteEfile', 'mutation');
    },
    editEfile(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(EditEfileDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'editEfile', 'mutation');
    },
    findEfile(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(FindEfileDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'findEfile', 'query');
    },
    listEfiles(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(ListEfilesDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'listEfiles', 'query');
    },
    addExhaust(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(AddExhaustDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'addExhaust', 'mutation');
    },
    deleteExhaust(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(DeleteExhaustDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'deleteExhaust', 'mutation');
    },
    editExhaust(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(EditExhaustDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'editExhaust', 'mutation');
    },
    findExhaust(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(FindExhaustDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'findExhaust', 'query');
    },
    listExhausts(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(ListExhaustsDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'listExhausts', 'query');
    },
    listFeed(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(ListFeedDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'listFeed', 'query');
    },
    addInventory(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(AddInventoryDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'addInventory', 'mutation');
    },
    deleteInventory(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(DeleteInventoryDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'deleteInventory', 'mutation');
    },
    editInventory(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(EditInventoryDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'editInventory', 'mutation');
    },
    findInventory(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(FindInventoryDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'findInventory', 'query');
    },
    listInventories(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(ListInventoriesDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'listInventories', 'query');
    },
    addInvoice(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(AddInvoiceDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'addInvoice', 'mutation');
    },
    deleteInvoice(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(DeleteInvoiceDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'deleteInvoice', 'mutation');
    },
    editInvoice(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(EditInvoiceDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'editInvoice', 'mutation');
    },
    findInvoice(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(FindInvoiceDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'findInvoice', 'query');
    },
    listInvoices(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(ListInvoicesDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'listInvoices', 'query');
    },
    addJob(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(AddJobDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'addJob', 'mutation');
    },
    addUserToJob(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(AddUserToJobDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'addUserToJob', 'mutation');
    },
    deleteJob(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(DeleteJobDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'deleteJob', 'mutation');
    },
    editJob(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(EditJobDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'editJob', 'mutation');
    },
    findJob(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(FindJobDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'findJob', 'query');
    },
    listJobs(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(ListJobsDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'listJobs', 'query');
    },
    removeUserFromJob(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(RemoveUserFromJobDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'removeUserFromJob', 'mutation');
    },
    addLocation(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(AddLocationDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'addLocation', 'mutation');
    },
    addUserToLocation(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(AddUserToLocationDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'addUserToLocation', 'mutation');
    },
    deleteLocation(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(DeleteLocationDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'deleteLocation', 'mutation');
    },
    editLocation(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(EditLocationDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'editLocation', 'mutation');
    },
    findLocation(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(FindLocationDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'findLocation', 'query');
    },
    listLocations(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(ListLocationsDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'listLocations', 'query');
    },
    removeUserFromLocation(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(RemoveUserFromLocationDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'removeUserFromLocation', 'mutation');
    },
    searchLocations(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(SearchLocationsDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'searchLocations', 'query');
    },
    listLogs(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(ListLogsDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'listLogs', 'query');
    },
    addMoistureContent(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(AddMoistureContentDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'addMoistureContent', 'mutation');
    },
    deleteMoistureContent(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(DeleteMoistureContentDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'deleteMoistureContent', 'mutation');
    },
    editMoistureContent(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(EditMoistureContentDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'editMoistureContent', 'mutation');
    },
    findMoistureContent(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(FindMoistureContentDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'findMoistureContent', 'query');
    },
    listMoistureContents(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(ListMoistureContentsDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'listMoistureContents', 'query');
    },
    addNote(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(AddNoteDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'addNote', 'mutation');
    },
    deleteNote(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(DeleteNoteDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'deleteNote', 'mutation');
    },
    editNote(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(EditNoteDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'editNote', 'mutation');
    },
    findNote(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(FindNoteDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'findNote', 'query');
    },
    listNotes(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(ListNotesDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'listNotes', 'query');
    },
    addPayModel(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(AddPayModelDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'addPayModel', 'mutation');
    },
    editPayModel(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(EditPayModelDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'editPayModel', 'mutation');
    },
    findPayModel(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(FindPayModelDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'findPayModel', 'query');
    },
    listPayModels(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(ListPayModelsDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'listPayModels', 'query');
    },
    addPayment(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(AddPaymentDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'addPayment', 'mutation');
    },
    listPayments(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(ListPaymentsDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'listPayments', 'query');
    },
    addPhoneNumber(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(AddPhoneNumberDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'addPhoneNumber', 'mutation');
    },
    deletePhoneNumber(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(DeletePhoneNumberDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'deletePhoneNumber', 'mutation');
    },
    editPhoneNumber(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(EditPhoneNumberDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'editPhoneNumber', 'mutation');
    },
    findPhoneNumber(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(FindPhoneNumberDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'findPhoneNumber', 'query');
    },
    listPhoneNumbers(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(ListPhoneNumbersDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'listPhoneNumbers', 'query');
    },
    addPhoto(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(AddPhotoDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'addPhoto', 'mutation');
    },
    deletePhoto(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(DeletePhotoDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'deletePhoto', 'mutation');
    },
    editPhoto(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(EditPhotoDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'editPhoto', 'mutation');
    },
    findPhoto(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(FindPhotoDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'findPhoto', 'query');
    },
    addPin(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(AddPinDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'addPin', 'mutation');
    },
    deletePin(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(DeletePinDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'deletePin', 'mutation');
    },
    findPin(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(FindPinDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'findPin', 'query');
    },
    listPins(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(ListPinsDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'listPins', 'query');
    },
    reorderPins(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(ReorderPinsDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'reorderPins', 'mutation');
    },
    addService(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(AddServiceDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'addService', 'mutation');
    },
    deleteService(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(DeleteServiceDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'deleteService', 'mutation');
    },
    editService(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(EditServiceDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'editService', 'mutation');
    },
    findService(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(FindServiceDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'findService', 'query');
    },
    listServices(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(ListServicesDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'listServices', 'query');
    },
    addSite(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(AddSiteDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'addSite', 'mutation');
    },
    deleteSite(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(DeleteSiteDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'deleteSite', 'mutation');
    },
    editSite(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(EditSiteDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'editSite', 'mutation');
    },
    findSite(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(FindSiteDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'findSite', 'query');
    },
    addSupport(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(AddSupportDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'addSupport', 'mutation');
    },
    deleteSupport(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(DeleteSupportDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'deleteSupport', 'mutation');
    },
    editSupport(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(EditSupportDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'editSupport', 'mutation');
    },
    findSupport(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(FindSupportDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'findSupport', 'query');
    },
    listSupports(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(ListSupportsDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'listSupports', 'query');
    },
    addTemplate(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(AddTemplateDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'addTemplate', 'mutation');
    },
    deleteTemplate(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(DeleteTemplateDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'deleteTemplate', 'mutation');
    },
    editTemplate(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(EditTemplateDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'editTemplate', 'mutation');
    },
    findTemplate(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(FindTemplateDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'findTemplate', 'query');
    },
    listTemplates(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(ListTemplatesDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'listTemplates', 'query');
    },
    addTotaller(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(AddTotallerDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'addTotaller', 'mutation');
    },
    calculateTotaller(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(CalculateTotallerDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'calculateTotaller', 'mutation');
    },
    deleteTotaller(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(DeleteTotallerDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'deleteTotaller', 'mutation');
    },
    editTotaller(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(EditTotallerDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'editTotaller', 'mutation');
    },
    findTotaller(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(FindTotallerDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'findTotaller', 'query');
    },
    listTotallers(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(ListTotallersDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'listTotallers', 'query');
    },
    addTrigger(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(AddTriggerDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'addTrigger', 'mutation');
    },
    deleteTrigger(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(DeleteTriggerDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'deleteTrigger', 'mutation');
    },
    editTrigger(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(EditTriggerDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'editTrigger', 'mutation');
    },
    findTrigger(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(FindTriggerDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'findTrigger', 'query');
    },
    listTriggers(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(ListTriggersDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'listTriggers', 'query');
    },
    addUser(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(AddUserDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'addUser', 'mutation');
    },
    bulkUpdateUsers(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(BulkUpdateUsersDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'bulkUpdateUsers', 'mutation');
    },
    editUser(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(EditUserDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'editUser', 'mutation');
    },
    findUser(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(FindUserDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'findUser', 'query');
    },
    listUsers(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(ListUsersDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'listUsers', 'query');
    },
    addWeather(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(AddWeatherDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'addWeather', 'mutation');
    },
    deleteWeather(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(DeleteWeatherDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'deleteWeather', 'mutation');
    },
    editWeather(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(EditWeatherDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'editWeather', 'mutation');
    },
    findWeather(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(FindWeatherDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'findWeather', 'query');
    },
    listWeather(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(ListWeatherDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'listWeather', 'query');
    },
    addPaymentMethod(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(AddPaymentMethodDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'addPaymentMethod', 'mutation');
    },
    addScopeService(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(AddScopeServiceDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'addScopeService', 'mutation');
    },
    bookJob(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(BookJobDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'bookJob', 'mutation');
    },
    createPlaidToken(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(CreatePlaidTokenDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'createPlaidToken', 'mutation');
    },
    createQuickbooksAuthUrl(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(CreateQuickbooksAuthUrlDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'createQuickbooksAuthUrl', 'mutation');
    },
    createQuickbooksToken(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(CreateQuickbooksTokenDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'createQuickbooksToken', 'mutation');
    },
    createStripeAccountLink(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(CreateStripeAccountLinkDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'createStripeAccountLink', 'mutation');
    },
    createStripeOAuthToken(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(CreateStripeOAuthTokenDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'createStripeOAuthToken', 'mutation');
    },
    deleteScopeService(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(DeleteScopeServiceDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'deleteScopeService', 'mutation');
    },
    editScopeService(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(EditScopeServiceDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'editScopeService', 'mutation');
    },
    generateGoogleAuthUrl(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(GenerateGoogleAuthUrlDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'generateGoogleAuthUrl', 'mutation');
    },
    generatePayables(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(GeneratePayablesDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'generatePayables', 'mutation');
    },
    generatePdf(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(GeneratePdfDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'generatePdf', 'mutation');
    },
    getGoogleAccessToken(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(GetGoogleAccessTokenDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'getGoogleAccessToken', 'mutation');
    },
    importer(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(ImporterDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'importer', 'mutation');
    },
    sendTemplateEmail(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(SendTemplateEmailDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'sendTemplateEmail', 'mutation');
    },
    setPlaidAccessToken(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(SetPlaidAccessTokenDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'setPlaidAccessToken', 'mutation');
    },
    signContract(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(SignContractDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'signContract', 'mutation');
    },
    upload(variables, requestHeaders) {
      return withWrapper((wrappedRequestHeaders) => client.request(UploadDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), 'upload', 'mutation');
    }
  };
}

let Init = class {
  constructor(hostRef) {
    registerInstance(this, hostRef);
  }
  /**
   * Get the SDK
   * @returns The instance of Flood Team SDK
   */
  async getSdk() {
    return this.sdk;
  }
  /**
   * Get the GraphQL Client
   * @returns The instance of GraphQL SDK
   */
  async getClient() {
    return this.client;
  }
  componentDidLoad() {
    const { sdk, client } = new FireEnjin({
      getSdk,
      debug: Build === null || Build === void 0 ? void 0 : Build.isDev,
      token: this.token,
      connections: [
        {
          name: "default",
          type: "graphql",
          url: this.host || "https://theflood.team/graphql",
        },
      ],
    });
    this.sdk = sdk;
    this.client = client;
    console.log(this.sdk, this.client);
  }
  render() {
    return h("slot", null);
  }
};

export { Init as floodteam_init };

//# sourceMappingURL=floodteam-init.entry.js.map