Billing Queries

These queries allow you to interact with billing data.

accountCreditHistory

Arguments

Argument	Type	Description
`clientId`required	ID!	ID of the client (pet owner)
`limit`	Int	Maximum number of results to return
`offset`	Int	Number of results to skip for pagination
`orderBy`	[AccountCreditHistoryOrderBy]	Order by

Example Query

query(
  $clientId: ID!,
  $limit: Int,
  $offset: Int,
  $orderBy: [AccountCreditHistoryOrderBy]
) {
  accountCreditHistory(
    clientId: $clientId,
    limit: $limit,
    offset: $offset,
    orderBy: $orderBy
  ) {
    id
    # Add other fields you need
  }
}

Variables

{
  "clientId": "1",
  "limit": 1,
  "offset": 1,
  "orderBy": {}
}

accountsReceivableBalance

Returns: AccountsReceivableBalance

Returns a client's accounts receivable balance.

Arguments

Argument	Type	Description
`clientId`	ID	ID of the client (pet owner)

Example Query

query($clientId: ID) {
  accountsReceivableBalance(clientId: $clientId) {
    id
    # Add other fields you need
  }
}

Variables

{
  "clientId": "1"
}

bills

Returns: [Bill]

Arguments

Argument	Type	Description
`clientId`required	ID!	ID of the client (pet owner)

Example Query

query($clientId: ID!) {
  bills(clientId: $clientId) {
    id
    # Add other fields you need
  }
}

Variables

{
  "clientId": "1"
}

ccTerminals

Returns: [String]

Arguments

Argument	Type	Description
`locationId`required	ID!	ID of the location

Example Query

query($locationId: ID!) {
  ccTerminals(locationId: $locationId) {
    id
    # Add other fields you need
  }
}

Variables

{
  "locationId": "1"
}

creditMemos

Returns: [CreditMemo]

Arguments

Argument	Type	Description
`alertIds`	[ID]	List of alert IDs
`clientTagIds`	[ID]	List of client tag IDs to filter by
`end`required	DateTime!	Ending point for the range
`limit`	Int	Maximum number of results to return
`locationIds`	[ID]	List of location IDs
`offset`	Int	Number of results to skip for pagination
`patientTagIds`	[ID]	List of patienttag IDs
`start`required	DateTime!	Starting point for the range
`updatedAtEnd`	NaiveDateTime	Updated at end
`updatedAtStart`	NaiveDateTime	Updated at start

Example Query

query(
  $alertIds: [ID],
  $clientTagIds: [ID],
  $end: DateTime!,
  $limit: Int,
  $locationIds: [ID],
  $offset: Int,
  $patientTagIds: [ID],
  $start: DateTime!,
  $updatedAtEnd: NaiveDateTime,
  $updatedAtStart: NaiveDateTime
) {
  creditMemos(
    alertIds: $alertIds,
    clientTagIds: $clientTagIds,
    end: $end,
    limit: $limit,
    locationIds: $locationIds,
    offset: $offset,
    patientTagIds: $patientTagIds,
    start: $start,
    updatedAtEnd: $updatedAtEnd,
    updatedAtStart: $updatedAtStart
  ) {
    id
    # Add other fields you need
  }
}

Variables

{
  "alertIds": "1",
  "clientTagIds": "1",
  "end": {},
  "limit": 1,
  "locationIds": "1",
  "offset": 1,
  "patientTagIds": "1",
  "start": {},
  "updatedAtEnd": {},
  "updatedAtStart": {}
}

creditMemosTotals

Returns: CreditMemoTotals

Arguments

Argument	Type	Description
`alertIds`	[ID]	List of alert IDs
`clientTagIds`	[ID]	List of client tag IDs to filter by
`end`	DateTime	Ending point for the range
`locationIds`	[ID]	List of location IDs
`patientTagIds`	[ID]	List of patienttag IDs
`start`	DateTime	Starting point for the range

Example Query

query(
  $alertIds: [ID],
  $clientTagIds: [ID],
  $end: DateTime,
  $locationIds: [ID],
  $patientTagIds: [ID],
  $start: DateTime
) {
  creditMemosTotals(
    alertIds: $alertIds,
    clientTagIds: $clientTagIds,
    end: $end,
    locationIds: $locationIds,
    patientTagIds: $patientTagIds,
    start: $start
  ) {
    id
    # Add other fields you need
  }
}

Variables

{
  "alertIds": "1",
  "clientTagIds": "1",
  "end": {},
  "locationIds": "1",
  "patientTagIds": "1",
  "start": {}
}

discountReasons

Returns: [DiscountReason]

Example Query

query {
  discountReasons {
    id
    # Add other fields you need
  }
}

estimatePdf

Returns: String

Arguments

Argument	Type	Description
`id`required	ID!	Unique identifier

Example Query

query($id: ID!) {
  estimatePdf(id: $id) {
    id
    # Add other fields you need
  }
}

Variables

{
  "id": "1"
}

estimates

Returns: [Estimate]

Arguments

Argument	Type	Description
`alertIds`	[ID]	List of alert IDs
`clientId`	ID	ID of the client (pet owner)
`clientTagIds`	[ID]	List of client tag IDs to filter by
`closed`	Boolean	Filter by closed status
`end`	DateTime	Ending point for the range
`invoiced`	Boolean	Invoiced
`limit`	Int	Maximum number of results to return
`locationId`	ID	ID of the location
`locationIds`	[ID]	List of location IDs
`offset`	Int	Number of results to skip for pagination
`patientTagIds`	[ID]	List of patienttag IDs
`providerId`	ID	ID of the provider
`start`	DateTime	Starting point for the range
`updatedAtEnd`	NaiveDateTime	Updated at end
`updatedAtStart`	NaiveDateTime	Updated at start

Example Query

query(
  $alertIds: [ID],
  $clientId: ID,
  $clientTagIds: [ID],
  $closed: Boolean,
  $end: DateTime,
  $invoiced: Boolean,
  $limit: Int,
  $locationId: ID,
  $locationIds: [ID],
  $offset: Int,
  $patientTagIds: [ID],
  $providerId: ID,
  $start: DateTime,
  $updatedAtEnd: NaiveDateTime,
  $updatedAtStart: NaiveDateTime
) {
  estimates(
    alertIds: $alertIds,
    clientId: $clientId,
    clientTagIds: $clientTagIds,
    closed: $closed,
    end: $end,
    invoiced: $invoiced,
    limit: $limit,
    locationId: $locationId,
    locationIds: $locationIds,
    offset: $offset,
    patientTagIds: $patientTagIds,
    providerId: $providerId,
    start: $start,
    updatedAtEnd: $updatedAtEnd,
    updatedAtStart: $updatedAtStart
  ) {
    id
    # Add other fields you need
  }
}

Variables

{
  "alertIds": "1",
  "clientId": "1",
  "clientTagIds": "1",
  "closed": true,
  "end": {},
  "invoiced": true,
  "limit": 1,
  "locationId": "1",
  "locationIds": "1",
  "offset": 1,
  "patientTagIds": "1",
  "providerId": "1",
  "start": {},
  "updatedAtEnd": {},
  "updatedAtStart": {}
}

estimatesTotals

Returns: EstimatesTotals

Arguments

Argument	Type	Description
`alertIds`	[ID]	List of alert IDs
`clientId`	ID	ID of the client (pet owner)
`clientTagIds`	[ID]	List of client tag IDs to filter by
`closed`	Boolean	Filter by closed status
`end`	DateTime	Ending point for the range
`invoiced`	Boolean	Invoiced
`limit`	Int	Maximum number of results to return
`locationIds`	[ID]	List of location IDs
`offset`	Int	Number of results to skip for pagination
`patientTagIds`	[ID]	List of patienttag IDs
`providerId`	ID	ID of the provider
`start`	DateTime	Starting point for the range

Example Query

query(
  $alertIds: [ID],
  $clientId: ID,
  $clientTagIds: [ID],
  $closed: Boolean,
  $end: DateTime,
  $invoiced: Boolean,
  $limit: Int,
  $locationIds: [ID],
  $offset: Int,
  $patientTagIds: [ID],
  $providerId: ID,
  $start: DateTime
) {
  estimatesTotals(
    alertIds: $alertIds,
    clientId: $clientId,
    clientTagIds: $clientTagIds,
    closed: $closed,
    end: $end,
    invoiced: $invoiced,
    limit: $limit,
    locationIds: $locationIds,
    offset: $offset,
    patientTagIds: $patientTagIds,
    providerId: $providerId,
    start: $start
  ) {
    id
    # Add other fields you need
  }
}

Variables

{
  "alertIds": "1",
  "clientId": "1",
  "clientTagIds": "1",
  "closed": true,
  "end": {},
  "invoiced": true,
  "limit": 1,
  "locationIds": "1",
  "offset": 1,
  "patientTagIds": "1",
  "providerId": "1",
  "start": {}
}

getCardconnectBaseUrlBySlug

Returns: String!

Arguments

Argument	Type	Description
`slug`required	String!	Slug

Example Query

query($slug: String!) {
  getCardconnectBaseUrlBySlug(slug: $slug) {
    id
    # Add other fields you need
  }
}

Variables

{
  "slug": "example"
}

getCardconnectCardInfo

Returns: CardconnectCardInfo!

Arguments

Argument	Type	Description
`clientId`required	ID!	ID of the client (pet owner)
`locationId`required	ID!	ID of the location

Example Query

query(
  $clientId: ID!,
  $locationId: ID!
) {
  getCardconnectCardInfo(
    clientId: $clientId,
    locationId: $locationId
  ) {
    id
    # Add other fields you need
  }
}

Variables

{
  "clientId": "1",
  "locationId": "1"
}

hasBalanceDue

Returns: Boolean

if the client has an open, due balance

Arguments

Argument	Type	Description
`clientId`required	ID!	ID of the client (pet owner)

Example Query

query($clientId: ID!) {
  hasBalanceDue(clientId: $clientId) {
    id
    # Add other fields you need
  }
}

Variables

{
  "clientId": "1"
}

inCollections

Returns: Boolean

Arguments

Argument	Type	Description
`clientId`required	ID!	ID of the client (pet owner)

Example Query

query($clientId: ID!) {
  inCollections(clientId: $clientId) {
    id
    # Add other fields you need
  }
}

Variables

{
  "clientId": "1"
}

invoicePdf

Returns: String

Arguments

Argument	Type	Description
`coownerClientId`	ID	ID of the co-owner client
`id`required	ID!	Unique identifier

Example Query

query(
  $coownerClientId: ID,
  $id: ID!
) {
  invoicePdf(
    coownerClientId: $coownerClientId,
    id: $id
  ) {
    id
    # Add other fields you need
  }
}

Variables

{
  "coownerClientId": "1",
  "id": "1"
}

masterProducts

Returns: [MasterProduct]

Example Query

query {
  masterProducts {
    id
    # Add other fields you need
  }
}

order

Returns: Order

Gets an order by id

Arguments

Argument	Type	Description
`id`required	ID!	Unique identifier

Example Query

query($id: ID!) {
  order(id: $id) {
    id
    # Add other fields you need
  }
}

Variables

{
  "id": "1"
}

orderItems

Returns: [OrderItem]

Arguments

Argument	Type	Description
`alertIds`	[ID]	List of alert IDs
`byInvoiceDate`	Boolean	Group or filter by invoice date
`categoryIds`	[ID]	List of category IDs to filter by
`clientTagIds`	[ID]	List of client tag IDs to filter by
`endDate`	Date	End of date range
`excludeHistorical`	Boolean	Exclude historical
`ids`	[ID]	List of IDs
`includeDeclined`	Boolean	Include declined
`isReturned`	Boolean	Is returned
`limit`	Int	Maximum number of results to return
`locationIds`	[ID]	List of location IDs
`names`	[String]	Names
`notRendered`	Boolean	Not rendered
`offset`	Int	Number of results to skip for pagination
`onlyControlledDrugs`	Boolean	Only controlled drugs
`onlyInventory`	Boolean	Only inventory
`onlyInvoiced`	Boolean	Only invoiced
`onlyPosted`	Boolean	Only posted
`orderFlagIds`	[ID]	List of orderflag IDs
`packageIds`	[ID]	List of package IDs
`patientIds`	[ID]	List of patient IDs
`patientTagIds`	[ID]	List of patienttag IDs
`productIds`	[ID]	List of product IDs
`providerId`	ID	ID of the provider
`providerIds`	[ID]	List of provider IDs
`scheduledDrugTypes`	[ScheduledDrugType]	Scheduled drug types
`startDate`	Date	Start of date range
`typeIds`	[ID]	List of type IDs
`updatedAtEnd`	NaiveDateTime	Updated at end
`updatedAtStart`	NaiveDateTime	Updated at start

Example Query

query(
  $alertIds: [ID],
  $byInvoiceDate: Boolean,
  $categoryIds: [ID],
  $clientTagIds: [ID],
  $endDate: Date,
  $excludeHistorical: Boolean,
  $ids: [ID],
  $includeDeclined: Boolean,
  $isReturned: Boolean,
  $limit: Int,
  $locationIds: [ID],
  $names: [String],
  $notRendered: Boolean,
  $offset: Int,
  $onlyControlledDrugs: Boolean,
  $onlyInventory: Boolean,
  $onlyInvoiced: Boolean,
  $onlyPosted: Boolean,
  $orderFlagIds: [ID],
  $packageIds: [ID],
  $patientIds: [ID],
  $patientTagIds: [ID],
  $productIds: [ID],
  $providerId: ID,
  $providerIds: [ID],
  $scheduledDrugTypes: [ScheduledDrugType],
  $startDate: Date,
  $typeIds: [ID],
  $updatedAtEnd: NaiveDateTime,
  $updatedAtStart: NaiveDateTime
) {
  orderItems(
    alertIds: $alertIds,
    byInvoiceDate: $byInvoiceDate,
    categoryIds: $categoryIds,
    clientTagIds: $clientTagIds,
    endDate: $endDate,
    excludeHistorical: $excludeHistorical,
    ids: $ids,
    includeDeclined: $includeDeclined,
    isReturned: $isReturned,
    limit: $limit,
    locationIds: $locationIds,
    names: $names,
    notRendered: $notRendered,
    offset: $offset,
    onlyControlledDrugs: $onlyControlledDrugs,
    onlyInventory: $onlyInventory,
    onlyInvoiced: $onlyInvoiced,
    onlyPosted: $onlyPosted,
    orderFlagIds: $orderFlagIds,
    packageIds: $packageIds,
    patientIds: $patientIds,
    patientTagIds: $patientTagIds,
    productIds: $productIds,
    providerId: $providerId,
    providerIds: $providerIds,
    scheduledDrugTypes: $scheduledDrugTypes,
    startDate: $startDate,
    typeIds: $typeIds,
    updatedAtEnd: $updatedAtEnd,
    updatedAtStart: $updatedAtStart
  ) {
    id
    # Add other fields you need
  }
}

Variables

{
  "alertIds": "1",
  "byInvoiceDate": true,
  "categoryIds": "1",
  "clientTagIds": "1",
  "endDate": {},
  "excludeHistorical": true,
  "ids": "1",
  "includeDeclined": true,
  "isReturned": true,
  "limit": 1,
  "locationIds": "1",
  "names": "example",
  "notRendered": true,
  "offset": 1,
  "onlyControlledDrugs": true,
  "onlyInventory": true,
  "onlyInvoiced": true,
  "onlyPosted": true,
  "orderFlagIds": "1",
  "packageIds": "1",
  "patientIds": "1",
  "patientTagIds": "1",
  "productIds": "1",
  "providerId": "1",
  "providerIds": "1",
  "scheduledDrugTypes": {},
  "startDate": {},
  "typeIds": "1",
  "updatedAtEnd": {},
  "updatedAtStart": {}
}

orderItemsTotals

Returns: OrderItemsTotals

Arguments

Argument	Type	Description
`alertIds`	[ID]	List of alert IDs
`byInvoiceDate`	Boolean	Group or filter by invoice date
`clientTagIds`	[ID]	List of client tag IDs to filter by
`end`	Date	Ending point for the range
`isReturned`	Boolean	Is returned
`locationIds`	[ID]	List of location IDs
`onlyControlledDrugs`	Boolean	Only controlled drugs
`onlyInvoiced`	Boolean	Only invoiced
`patientTagIds`	[ID]	List of patienttag IDs
`providerId`	ID	ID of the provider
`providerIds`	[ID]	List of provider IDs
`scheduledDrugTypes`	[ScheduledDrugType]	Scheduled drug types
`start`	Date	Starting point for the range

Example Query

query(
  $alertIds: [ID],
  $byInvoiceDate: Boolean,
  $clientTagIds: [ID],
  $end: Date,
  $isReturned: Boolean,
  $locationIds: [ID],
  $onlyControlledDrugs: Boolean,
  $onlyInvoiced: Boolean,
  $patientTagIds: [ID],
  $providerId: ID,
  $providerIds: [ID],
  $scheduledDrugTypes: [ScheduledDrugType],
  $start: Date
) {
  orderItemsTotals(
    alertIds: $alertIds,
    byInvoiceDate: $byInvoiceDate,
    clientTagIds: $clientTagIds,
    end: $end,
    isReturned: $isReturned,
    locationIds: $locationIds,
    onlyControlledDrugs: $onlyControlledDrugs,
    onlyInvoiced: $onlyInvoiced,
    patientTagIds: $patientTagIds,
    providerId: $providerId,
    providerIds: $providerIds,
    scheduledDrugTypes: $scheduledDrugTypes,
    start: $start
  ) {
    id
    # Add other fields you need
  }
}

Variables

{
  "alertIds": "1",
  "byInvoiceDate": true,
  "clientTagIds": "1",
  "end": {},
  "isReturned": true,
  "locationIds": "1",
  "onlyControlledDrugs": true,
  "onlyInvoiced": true,
  "patientTagIds": "1",
  "providerId": "1",
  "providerIds": "1",
  "scheduledDrugTypes": {},
  "start": {}
}

orderLineItems

Returns: OrderItemConnection

Arguments

Argument	Type	Description
`after`	String	Cursor for forward pagination
`before`	String	Cursor for backward pagination
`filters`	OrderLineItemsFilters	Filters
`first`	Int	First
`last`	Int	Last
`orderBy`	[OrderLineItemsOrderBy]	Order by

Example Query

query(
  $filters: OrderLineItemsFilters,
  $first: Int,
  $orderBy: [OrderLineItemsOrderBy]
) {
  orderLineItems(
    filters: $filters,
    first: $first,
    orderBy: $orderBy
  ) {
    edges {
      node {
        id
        # Add other fields you need
      }
    }
    pageInfo {
      hasNextPage
      endCursor
    }
  }
}

Variables

{
  "filters": {},
  "first": 1,
  "orderBy": {}
}

orders

Returns: [Order]

Lists all orders based on the query

Arguments

Argument	Type	Description
`alertIds`	[ID]	List of alert IDs
`clientId`	ID	ID of the client (pet owner)
`clientTagIds`	[ID]	List of client tag IDs to filter by
`end`	DateTime	Ending point for the range
`excludeHistorical`	Boolean	Exclude historical
`hideSubscriptions`	Boolean	Hide subscriptions
`ids`	[ID]	List of IDs
`includeAccountCredits`	Boolean	Include Account Credits on File as of this Instance
`includeNegatives`	Boolean	Include credit memos and not rendered line items as separate virtual negative invoices (typically, you do not ever want to set this to true)
`invoiced`	Boolean	Invoiced
`invoicedBy`	DateTime	Invoiced by
`limit`	Int	Maximum number of results to return
`localTimezone`	String	Local timezone
`locationId`	ID	ID of the location
`locationIds`	[ID]	List of location IDs
`mismatched`	Boolean	Mismatched
`notUncollectible`	Boolean	Not uncollectible
`offset`	Int	Number of results to skip for pagination
`onlyDiscounted`	Boolean	Only discounted
`onlySubscriptions`	Boolean	Only subscriptions
`orderBy`	InvoiceSortFieldEnum	Order by
`orderFlagIds`	[ID]	List of orderflag IDs
`patientTagIds`	[ID]	List of patienttag IDs
`posted`	Boolean	Posted
`providerId`	ID	ID of the provider
`start`	DateTime	Starting point for the range
`updatedAtEnd`	NaiveDateTime	Updated at end
`updatedAtStart`	NaiveDateTime	Updated at start

Example Query

query(
  $alertIds: [ID],
  $clientId: ID,
  $clientTagIds: [ID],
  $end: DateTime,
  $excludeHistorical: Boolean,
  $hideSubscriptions: Boolean,
  $ids: [ID],
  $includeAccountCredits: Boolean,
  $includeNegatives: Boolean,
  $invoiced: Boolean,
  $invoicedBy: DateTime,
  $limit: Int,
  $localTimezone: String,
  $locationId: ID,
  $locationIds: [ID],
  $mismatched: Boolean,
  $notUncollectible: Boolean,
  $offset: Int,
  $onlyDiscounted: Boolean,
  $onlySubscriptions: Boolean,
  $orderBy: InvoiceSortFieldEnum,
  $orderFlagIds: [ID],
  $patientTagIds: [ID],
  $posted: Boolean,
  $providerId: ID,
  $start: DateTime,
  $updatedAtEnd: NaiveDateTime,
  $updatedAtStart: NaiveDateTime
) {
  orders(
    alertIds: $alertIds,
    clientId: $clientId,
    clientTagIds: $clientTagIds,
    end: $end,
    excludeHistorical: $excludeHistorical,
    hideSubscriptions: $hideSubscriptions,
    ids: $ids,
    includeAccountCredits: $includeAccountCredits,
    includeNegatives: $includeNegatives,
    invoiced: $invoiced,
    invoicedBy: $invoicedBy,
    limit: $limit,
    localTimezone: $localTimezone,
    locationId: $locationId,
    locationIds: $locationIds,
    mismatched: $mismatched,
    notUncollectible: $notUncollectible,
    offset: $offset,
    onlyDiscounted: $onlyDiscounted,
    onlySubscriptions: $onlySubscriptions,
    orderBy: $orderBy,
    orderFlagIds: $orderFlagIds,
    patientTagIds: $patientTagIds,
    posted: $posted,
    providerId: $providerId,
    start: $start,
    updatedAtEnd: $updatedAtEnd,
    updatedAtStart: $updatedAtStart
  ) {
    id
    # Add other fields you need
  }
}

Variables

{
  "alertIds": "1",
  "clientId": "1",
  "clientTagIds": "1",
  "end": {},
  "excludeHistorical": true,
  "hideSubscriptions": true,
  "ids": "1",
  "includeAccountCredits": true,
  "includeNegatives": true,
  "invoiced": true,
  "invoicedBy": {},
  "limit": 1,
  "localTimezone": "example",
  "locationId": "1",
  "locationIds": "1",
  "mismatched": true,
  "notUncollectible": true,
  "offset": 1,
  "onlyDiscounted": true,
  "onlySubscriptions": true,
  "orderBy": {},
  "orderFlagIds": "1",
  "patientTagIds": "1",
  "posted": true,
  "providerId": "1",
  "start": {},
  "updatedAtEnd": {},
  "updatedAtStart": {}
}

ordersTotals

Returns: OrdersTotals

Returns a count of all orders based on a query, excludes datasync imported orders.

Arguments

Argument	Type	Description
`agingBuckets`	Boolean	Time periods for aging analysis
`alertIds`	[ID]	List of alert IDs
`clientId`	ID	ID of the client (pet owner)
`clientTagIds`	[ID]	List of client tag IDs to filter by
`end`	DateTime	Ending point for the range
`excludeHistorical`	Boolean	Exclude historical
`excludeHistoricalTotals`	Boolean	Exclude historical totals
`hideSubscriptions`	Boolean	Hide subscriptions
`includeAccountCredits`	Boolean	Include account credits
`includeNegatives`	Boolean	Include negatives
`invoiced`	Boolean	Invoiced
`localTimezone`	String	Local timezone
`locationIds`	[ID]	List of location IDs
`mismatched`	Boolean	Mismatched
`notUncollectible`	Boolean	Not uncollectible
`onlySubscriptions`	Boolean	Only subscriptions
`orderFlagIds`	[ID]	List of orderflag IDs
`patientTagIds`	[ID]	List of patienttag IDs
`posted`	Boolean	Posted
`providerId`	ID	ID of the provider
`start`	DateTime	Starting point for the range

Example Query

query(
  $agingBuckets: Boolean,
  $alertIds: [ID],
  $clientId: ID,
  $clientTagIds: [ID],
  $end: DateTime,
  $excludeHistorical: Boolean,
  $excludeHistoricalTotals: Boolean,
  $hideSubscriptions: Boolean,
  $includeAccountCredits: Boolean,
  $includeNegatives: Boolean,
  $invoiced: Boolean,
  $localTimezone: String,
  $locationIds: [ID],
  $mismatched: Boolean,
  $notUncollectible: Boolean,
  $onlySubscriptions: Boolean,
  $orderFlagIds: [ID],
  $patientTagIds: [ID],
  $posted: Boolean,
  $providerId: ID,
  $start: DateTime
) {
  ordersTotals(
    agingBuckets: $agingBuckets,
    alertIds: $alertIds,
    clientId: $clientId,
    clientTagIds: $clientTagIds,
    end: $end,
    excludeHistorical: $excludeHistorical,
    excludeHistoricalTotals: $excludeHistoricalTotals,
    hideSubscriptions: $hideSubscriptions,
    includeAccountCredits: $includeAccountCredits,
    includeNegatives: $includeNegatives,
    invoiced: $invoiced,
    localTimezone: $localTimezone,
    locationIds: $locationIds,
    mismatched: $mismatched,
    notUncollectible: $notUncollectible,
    onlySubscriptions: $onlySubscriptions,
    orderFlagIds: $orderFlagIds,
    patientTagIds: $patientTagIds,
    posted: $posted,
    providerId: $providerId,
    start: $start
  ) {
    id
    # Add other fields you need
  }
}

Variables

{
  "agingBuckets": true,
  "alertIds": "1",
  "clientId": "1",
  "clientTagIds": "1",
  "end": {},
  "excludeHistorical": true,
  "excludeHistoricalTotals": true,
  "hideSubscriptions": true,
  "includeAccountCredits": true,
  "includeNegatives": true,
  "invoiced": true,
  "localTimezone": "example",
  "locationIds": "1",
  "mismatched": true,
  "notUncollectible": true,
  "onlySubscriptions": true,
  "orderFlagIds": "1",
  "patientTagIds": "1",
  "posted": true,
  "providerId": "1",
  "start": {}
}

packs

Returns: [Pack]

Arguments

Argument	Type	Description
`alertIds`	[ID]	List of alert IDs
`clientId`	ID	ID of the client (pet owner)
`clientTagIds`	[ID]	List of client tag IDs to filter by
`locationIds`	[ID]	List of location IDs

Example Query

query(
  $alertIds: [ID],
  $clientId: ID,
  $clientTagIds: [ID],
  $locationIds: [ID]
) {
  packs(
    alertIds: $alertIds,
    clientId: $clientId,
    clientTagIds: $clientTagIds,
    locationIds: $locationIds
  ) {
    id
    # Add other fields you need
  }
}

Variables

{
  "alertIds": "1",
  "clientId": "1",
  "clientTagIds": "1",
  "locationIds": "1"
}

paymentProviders

Returns: [Provider]

Arguments

Argument	Type	Description
`alertIds`	[ID]	List of alert IDs
`end`	DateTime	Ending point for the range
`excludeHistorical`	Boolean	Exclude historical
`hideAccountCredit`	Boolean	Hide account credit
`locationIds`	[ID]	List of location IDs
`methods`	[PaymentMethod]	Methods
`start`	DateTime	Starting point for the range

Example Query

query(
  $alertIds: [ID],
  $end: DateTime,
  $excludeHistorical: Boolean,
  $hideAccountCredit: Boolean,
  $locationIds: [ID],
  $methods: [PaymentMethod],
  $start: DateTime
) {
  paymentProviders(
    alertIds: $alertIds,
    end: $end,
    excludeHistorical: $excludeHistorical,
    hideAccountCredit: $hideAccountCredit,
    locationIds: $locationIds,
    methods: $methods,
    start: $start
  ) {
    id
    # Add other fields you need
  }
}

Variables

{
  "alertIds": "1",
  "end": {},
  "excludeHistorical": true,
  "hideAccountCredit": true,
  "locationIds": "1",
  "methods": {},
  "start": {}
}

payments

Returns: [Payment]

Arguments

Argument	Type	Description
`alertIds`	[ID]	List of alert IDs
`clientId`	ID	ID of the client (pet owner)
`clientTagIds`	[ID]	List of client tag IDs to filter by
`end`	DateTime	Ending point for the range
`excludeHistorical`	Boolean	Exclude historical
`hideAccountCredit`	Boolean	Hide account credit
`hideNegativeAccountCredits`	Boolean	Hide negative account credits
`hideVoided`	Boolean	Hide voided
`ids`	[ID]	List of IDs
`limit`	Int	Maximum number of results to return
`locationId`	ID	ID of the location
`locationIds`	[ID]	List of location IDs
`method`	PaymentMethod	Method
`methods`	[PaymentMethod]	Methods
`methodsToExclude`	[PaymentMethod]	Methods to exclude
`offset`	Int	Number of results to skip for pagination
`onlyPositive`	Boolean	Only positive
`patientTagIds`	[ID]	List of patienttag IDs
`providerIds`	[ID]	List of provider IDs
`sort`	PaymentSort	Sort
`start`	DateTime	Starting point for the range
`updatedAtEnd`	NaiveDateTime	Updated at end
`updatedAtStart`	NaiveDateTime	Updated at start

Example Query

query(
  $alertIds: [ID],
  $clientId: ID,
  $clientTagIds: [ID],
  $end: DateTime,
  $excludeHistorical: Boolean,
  $hideAccountCredit: Boolean,
  $hideNegativeAccountCredits: Boolean,
  $hideVoided: Boolean,
  $ids: [ID],
  $limit: Int,
  $locationId: ID,
  $locationIds: [ID],
  $method: PaymentMethod,
  $methods: [PaymentMethod],
  $methodsToExclude: [PaymentMethod],
  $offset: Int,
  $onlyPositive: Boolean,
  $patientTagIds: [ID],
  $providerIds: [ID],
  $sort: PaymentSort,
  $start: DateTime,
  $updatedAtEnd: NaiveDateTime,
  $updatedAtStart: NaiveDateTime
) {
  payments(
    alertIds: $alertIds,
    clientId: $clientId,
    clientTagIds: $clientTagIds,
    end: $end,
    excludeHistorical: $excludeHistorical,
    hideAccountCredit: $hideAccountCredit,
    hideNegativeAccountCredits: $hideNegativeAccountCredits,
    hideVoided: $hideVoided,
    ids: $ids,
    limit: $limit,
    locationId: $locationId,
    locationIds: $locationIds,
    method: $method,
    methods: $methods,
    methodsToExclude: $methodsToExclude,
    offset: $offset,
    onlyPositive: $onlyPositive,
    patientTagIds: $patientTagIds,
    providerIds: $providerIds,
    sort: $sort,
    start: $start,
    updatedAtEnd: $updatedAtEnd,
    updatedAtStart: $updatedAtStart
  ) {
    id
    # Add other fields you need
  }
}

Variables

{
  "alertIds": "1",
  "clientId": "1",
  "clientTagIds": "1",
  "end": {},
  "excludeHistorical": true,
  "hideAccountCredit": true,
  "hideNegativeAccountCredits": true,
  "hideVoided": true,
  "ids": "1",
  "limit": 1,
  "locationId": "1",
  "locationIds": "1",
  "method": {},
  "methods": {},
  "methodsToExclude": {},
  "offset": 1,
  "onlyPositive": true,
  "patientTagIds": "1",
  "providerIds": "1",
  "sort": {},
  "start": {},
  "updatedAtEnd": {},
  "updatedAtStart": {}
}

paymentsTotals

Returns: PaymentsTotals

Arguments

Argument	Type	Description
`alertIds`	[ID]	List of alert IDs
`clientTagIds`	[ID]	List of client tag IDs to filter by
`end`	DateTime	Ending point for the range
`excludeHistorical`	Boolean	Exclude historical
`hideAccountCredit`	Boolean	Hide account credit
`locationIds`	[ID]	List of location IDs
`method`	PaymentMethod	Method
`patientTagIds`	[ID]	List of patienttag IDs
`start`	DateTime	Starting point for the range

Example Query

query(
  $alertIds: [ID],
  $clientTagIds: [ID],
  $end: DateTime,
  $excludeHistorical: Boolean,
  $hideAccountCredit: Boolean,
  $locationIds: [ID],
  $method: PaymentMethod,
  $patientTagIds: [ID],
  $start: DateTime
) {
  paymentsTotals(
    alertIds: $alertIds,
    clientTagIds: $clientTagIds,
    end: $end,
    excludeHistorical: $excludeHistorical,
    hideAccountCredit: $hideAccountCredit,
    locationIds: $locationIds,
    method: $method,
    patientTagIds: $patientTagIds,
    start: $start
  ) {
    id
    # Add other fields you need
  }
}

Variables

{
  "alertIds": "1",
  "clientTagIds": "1",
  "end": {},
  "excludeHistorical": true,
  "hideAccountCredit": true,
  "locationIds": "1",
  "method": {},
  "patientTagIds": "1",
  "start": {}
}

processorPayments

Returns: [ProcessorPayment]

Arguments

Argument	Type	Description
`end`required	DateTime!	Ending point for the range
`locationId`required	ID!	ID of the location
`start`required	DateTime!	Starting point for the range

Example Query

query(
  $end: DateTime!,
  $locationId: ID!,
  $start: DateTime!
) {
  processorPayments(
    end: $end,
    locationId: $locationId,
    start: $start
  ) {
    id
    # Add other fields you need
  }
}

Variables

{
  "end": {},
  "locationId": "1",
  "start": {}
}

product

Returns: Product

Arguments

Argument	Type	Description
`id`required	ID!	Unique identifier

Example Query

query($id: ID!) {
  product(id: $id) {
    id
    # Add other fields you need
  }
}

Variables

{
  "id": "1"
}

productManufacturer

Returns: ProductManufacturer

Arguments

Argument	Type	Description
`id`required	ID!	Unique identifier

Example Query

query($id: ID!) {
  productManufacturer(id: $id) {
    id
    # Add other fields you need
  }
}

Variables

{
  "id": "1"
}

productManufacturers

Returns: [ProductManufacturer]!

Arguments

Argument	Type	Description
`name`	String	Name of the resource

Example Query

query($name: String) {
  productManufacturers(name: $name) {
    id
    # Add other fields you need
  }
}

Variables

{
  "name": "example"
}

productManufacturersPaginated

Returns: ProductManufacturerPage!

Arguments

Argument	Type	Description
`after`	String	Cursor for forward pagination
`before`	String	Cursor for backward pagination
`name`	String	Name of the resource

Example Query

query($name: String) {
  productManufacturersPaginated(name: $name) {
    id
    # Add other fields you need
  }
}

Variables

{
  "name": "example"
}

products

Returns: [Product]

Arguments

Argument	Type	Description
`categoryIds`	[ID]	List of category IDs to filter by
`code`	String	Unique code identifier
`diagnosticCode`	String	Diagnostic or ICD code
`diagnosticCodeOrgLabType`	OrgLabType	Organization lab type for diagnostic code
`excludeChildren`	Boolean	Exclude child records from results
`hasDiagnosticCode`	Boolean	Has diagnostic code
`ids`	[ID]	List of IDs
`isControlledDrug`	Boolean	Is controlled drug
`isNonCompensated`	Boolean	Is non compensated
`limit`	Int	Maximum number of results to return
`name`	String	Name of the resource
`offset`	Int	Number of results to skip for pagination
`onlyBelowThreshold`	ID	Only below threshold
`onlyEnabledAt`	ID	Only enabled at
`onlyTrackInventory`	Boolean	Only track inventory
`partialProductId`	String	ID of the partialproduct
`sku`	String	Sku
`sortBy`	SortProductOptions	Sort by
`typeIds`	[ID]	List of type IDs
`updatedAtEnd`	NaiveDateTime	Updated at end
`updatedAtStart`	NaiveDateTime	Updated at start

Example Query

query(
  $categoryIds: [ID],
  $code: String,
  $diagnosticCode: String,
  $diagnosticCodeOrgLabType: OrgLabType,
  $excludeChildren: Boolean,
  $hasDiagnosticCode: Boolean,
  $ids: [ID],
  $isControlledDrug: Boolean,
  $isNonCompensated: Boolean,
  $limit: Int,
  $name: String,
  $offset: Int,
  $onlyBelowThreshold: ID,
  $onlyEnabledAt: ID,
  $onlyTrackInventory: Boolean,
  $partialProductId: String,
  $sku: String,
  $sortBy: SortProductOptions,
  $typeIds: [ID],
  $updatedAtEnd: NaiveDateTime,
  $updatedAtStart: NaiveDateTime
) {
  products(
    categoryIds: $categoryIds,
    code: $code,
    diagnosticCode: $diagnosticCode,
    diagnosticCodeOrgLabType: $diagnosticCodeOrgLabType,
    excludeChildren: $excludeChildren,
    hasDiagnosticCode: $hasDiagnosticCode,
    ids: $ids,
    isControlledDrug: $isControlledDrug,
    isNonCompensated: $isNonCompensated,
    limit: $limit,
    name: $name,
    offset: $offset,
    onlyBelowThreshold: $onlyBelowThreshold,
    onlyEnabledAt: $onlyEnabledAt,
    onlyTrackInventory: $onlyTrackInventory,
    partialProductId: $partialProductId,
    sku: $sku,
    sortBy: $sortBy,
    typeIds: $typeIds,
    updatedAtEnd: $updatedAtEnd,
    updatedAtStart: $updatedAtStart
  ) {
    id
    # Add other fields you need
  }
}

Variables

{
  "categoryIds": "1",
  "code": "example",
  "diagnosticCode": "example",
  "diagnosticCodeOrgLabType": {},
  "excludeChildren": true,
  "hasDiagnosticCode": true,
  "ids": "1",
  "isControlledDrug": true,
  "isNonCompensated": true,
  "limit": 1,
  "name": "example",
  "offset": 1,
  "onlyBelowThreshold": "1",
  "onlyEnabledAt": "1",
  "onlyTrackInventory": true,
  "partialProductId": "example",
  "sku": "example",
  "sortBy": {},
  "typeIds": "1",
  "updatedAtEnd": {},
  "updatedAtStart": {}
}

productsCount

Returns: Int

Arguments

Argument	Type	Description
`categoryIds`	[ID]	List of category IDs to filter by
`code`	String	Unique code identifier
`diagnosticCode`	String	Diagnostic or ICD code
`excludeChildren`	Boolean	Exclude child records from results
`name`	String	Name of the resource
`onlyBelowThreshold`	ID	Only below threshold
`onlyEnabledAt`	ID	Only enabled at
`onlyTrackInventory`	Boolean	Only track inventory
`partialProductId`	String	ID of the partialproduct
`sku`	String	Sku
`typeIds`	[ID]	List of type IDs

Example Query

query(
  $categoryIds: [ID],
  $code: String,
  $diagnosticCode: String,
  $excludeChildren: Boolean,
  $name: String,
  $onlyBelowThreshold: ID,
  $onlyEnabledAt: ID,
  $onlyTrackInventory: Boolean,
  $partialProductId: String,
  $sku: String,
  $typeIds: [ID]
) {
  productsCount(
    categoryIds: $categoryIds,
    code: $code,
    diagnosticCode: $diagnosticCode,
    excludeChildren: $excludeChildren,
    name: $name,
    onlyBelowThreshold: $onlyBelowThreshold,
    onlyEnabledAt: $onlyEnabledAt,
    onlyTrackInventory: $onlyTrackInventory,
    partialProductId: $partialProductId,
    sku: $sku,
    typeIds: $typeIds
  ) {
    id
    # Add other fields you need
  }
}

Variables

{
  "categoryIds": "1",
  "code": "example",
  "diagnosticCode": "example",
  "excludeChildren": true,
  "name": "example",
  "onlyBelowThreshold": "1",
  "onlyEnabledAt": "1",
  "onlyTrackInventory": true,
  "partialProductId": "example",
  "sku": "example",
  "typeIds": "1"
}

productsInStockCount

Returns: Decimal

Arguments

Argument	Type	Description
`insertedAt`	NaiveDateTime	Inserted at
`locationId`required	ID!	ID of the location

Example Query

query(
  $insertedAt: NaiveDateTime,
  $locationId: ID!
) {
  productsInStockCount(
    insertedAt: $insertedAt,
    locationId: $locationId
  ) {
    id
    # Add other fields you need
  }
}

Variables

{
  "insertedAt": {},
  "locationId": "1"
}

purchaseOrder

Returns: PurchaseOrder

Arguments

Argument	Type	Description
`id`required	ID!	Unique identifier

Example Query

query($id: ID!) {
  purchaseOrder(id: $id) {
    id
    # Add other fields you need
  }
}

Variables

{
  "id": "1"
}

purchaseOrders

Returns: [PurchaseOrder]

Arguments

Argument	Type	Description
`locationIds`	[ID]	List of location IDs
`orderedSince`	Date	Ordered since

Example Query

query(
  $locationIds: [ID],
  $orderedSince: Date
) {
  purchaseOrders(
    locationIds: $locationIds,
    orderedSince: $orderedSince
  ) {
    id
    # Add other fields you need
  }
}

Variables

{
  "locationIds": "1",
  "orderedSince": {}
}

refundedOrderItems

Returns: [OrderItem]

Arguments

Argument	Type	Description
`end`	DateTime	Ending point for the range
`locationIds`	[ID]	List of location IDs
`providerId`	ID	ID of the provider
`providerIds`	[ID]	List of provider IDs
`start`	DateTime	Starting point for the range

Example Query

query(
  $end: DateTime,
  $locationIds: [ID],
  $providerId: ID,
  $providerIds: [ID],
  $start: DateTime
) {
  refundedOrderItems(
    end: $end,
    locationIds: $locationIds,
    providerId: $providerId,
    providerIds: $providerIds,
    start: $start
  ) {
    id
    # Add other fields you need
  }
}

Variables

{
  "end": {},
  "locationIds": "1",
  "providerId": "1",
  "providerIds": "1",
  "start": {}
}

returnedOrderItems

Returns: [ReturnedOrderItem]

Arguments

Argument	Type	Description
`alertIds`	[ID]	List of alert IDs
`end`	DateTime	Ending point for the range
`locationIds`	[ID]	List of location IDs
`orderFlagIds`	[ID]	List of orderflag IDs
`providerId`	ID	ID of the provider
`providerIds`	[ID]	List of provider IDs
`start`	DateTime	Starting point for the range

Example Query

query(
  $alertIds: [ID],
  $end: DateTime,
  $locationIds: [ID],
  $orderFlagIds: [ID],
  $providerId: ID,
  $providerIds: [ID],
  $start: DateTime
) {
  returnedOrderItems(
    alertIds: $alertIds,
    end: $end,
    locationIds: $locationIds,
    orderFlagIds: $orderFlagIds,
    providerId: $providerId,
    providerIds: $providerIds,
    start: $start
  ) {
    id
    # Add other fields you need
  }
}

Variables

{
  "alertIds": "1",
  "end": {},
  "locationIds": "1",
  "orderFlagIds": "1",
  "providerId": "1",
  "providerIds": "1",
  "start": {}
}

searchCoupons

Returns: [Coupon]

Arguments

Argument	Type	Description
`limit`	Int	Maximum number of results to return
`term`	String	Term

Example Query

query(
  $limit: Int,
  $term: String
) {
  searchCoupons(
    limit: $limit,
    term: $term
  ) {
    id
    # Add other fields you need
  }
}

Variables

{
  "limit": 1,
  "term": "example"
}

searchInventoryBuckets

Returns: [InventoryBucket]

Arguments

Argument	Type	Description
`name`required	String!	Name of the resource

Example Query

query($name: String!) {
  searchInventoryBuckets(name: $name) {
    id
    # Add other fields you need
  }
}

Variables

{
  "name": "example"
}

searchPackages

Returns: [ProductPackage]

Arguments

Argument	Type	Description
`query`required	String!	Search query text

Example Query

query($query: String!) {
  searchPackages(query: $query) {
    id
    # Add other fields you need
  }
}

Variables

{
  "query": "example"
}

searchProductCategories

Returns: [ProductCategory]

Arguments

Argument	Type	Description
`name`required	String!	Name of the resource

Example Query

query($name: String!) {
  searchProductCategories(name: $name) {
    id
    # Add other fields you need
  }
}

Variables

{
  "name": "example"
}

searchProductTypes

Returns: [ProductType]

Arguments

Argument	Type	Description
`name`required	String!	Name of the resource

Example Query

query($name: String!) {
  searchProductTypes(name: $name) {
    id
    # Add other fields you need
  }
}

Variables

{
  "name": "example"
}

searchProductables

Returns: [Orderable]

Arguments

Argument	Type	Description
`limit`	Int	Maximum number of results to return
`locationId`	ID	ID of the location
`patientId`	ID	ID of the patient
`searchPackages`	Boolean	Search packages
`term`required	String!	Search products by name using this search term
`typeFlags`	ProductTypeFlags	Type flags

Example Query

query(
  $limit: Int,
  $locationId: ID,
  $patientId: ID,
  $searchPackages: Boolean,
  $term: String!,
  $typeFlags: ProductTypeFlags
) {
  searchProductables(
    limit: $limit,
    locationId: $locationId,
    patientId: $patientId,
    searchPackages: $searchPackages,
    term: $term,
    typeFlags: $typeFlags
  ) {
    id
    # Add other fields you need
  }
}

Variables

{
  "limit": 1,
  "locationId": "1",
  "patientId": "1",
  "searchPackages": true,
  "term": "example",
  "typeFlags": {}
}

searchProducts

Returns: [Product]

Arguments

Argument	Type	Description
`limit`	Int	Limit the number of results returned to the top LIMIT matches (defaults to 10)
`locationId`	ID	ID of the location
`term`required	String!	Search for products by name by specifying the search term
`typeFlags`	ProductTypeFlags	Type flags

Example Query

query(
  $limit: Int,
  $locationId: ID,
  $term: String!,
  $typeFlags: ProductTypeFlags
) {
  searchProducts(
    limit: $limit,
    locationId: $locationId,
    term: $term,
    typeFlags: $typeFlags
  ) {
    id
    # Add other fields you need
  }
}

Variables

{
  "limit": 1,
  "locationId": "1",
  "term": "example",
  "typeFlags": {}
}

searchVendors

Returns: [Vendor]

Arguments

Argument	Type	Description
`term`required	String!	Term

Example Query

query($term: String!) {
  searchVendors(term: $term) {
    id
    # Add other fields you need
  }
}

Variables

{
  "term": "example"
}

stripeConnectionToken

Returns: String

Arguments

Argument	Type	Description
`locationId`required	ID!	ID of the location

Example Query

query($locationId: ID!) {
  stripeConnectionToken(locationId: $locationId) {
    id
    # Add other fields you need
  }
}

Variables

{
  "locationId": "1"
}

stripePublishableKey

Returns: String

Arguments

Argument	Type	Description
`locationId`	ID	ID of the location

Example Query

query($locationId: ID) {
  stripePublishableKey(locationId: $locationId) {
    id
    # Add other fields you need
  }
}

Variables

{
  "locationId": "1"
}

vendor

Returns: Vendor

Arguments

Argument	Type	Description
`id`required	ID!	Unique identifier

Example Query

query($id: ID!) {
  vendor(id: $id) {
    id
    # Add other fields you need
  }
}

Variables

{
  "id": "1"
}

vendors

Returns: [Vendor]

Example Query

query {
  vendors {
    id
    # Add other fields you need
  }
}