GraphQL Schema V2

Schema

schema {
  query: GQLQueries
  mutation: GQLMutations
}

Activity Log

type ActivityLogGQLType {
  displayText: String
  doneBy: ID
  id: String!
  timestamp: DateTime
}

Addon

type AddOnGQLType {
  accountingCode: String
  activeSubscribersCount: Int!
  billingCycle: BillingCycleInfoGQLType
  billingModel: BillingModelGQLType
  billingType: BillingTypeGQLType
  canBeDeleted: Boolean!
  code: String
  currency: CurrencyGQLType
  data: String
  description: String
  displaySettings: String
  fixedPricing: FixedPricingGQLType
  hasActiveSubscribers: Boolean!
  id: ID
  imageUrl: String
  invoiceName: String
  name: String!
  perUnitPricing: PerUnitPricingGQLType
  pricingModel: PricingModelGQLType
  siteId: String!
  status: ActiveStatusGQLType
  variablePricing: VariablePricingGQLType
}

input AddOnGQLInputType {
  accountingCode: String
  billingCycle: BillingCycleInfoGQLInputType
  billingModel: BillingModelGQLType
  billingType: BillingTypeGQLType
  code: String
  data: String
  description: String
  displaySettings: String
  fixedPricing: FixedPricingGQLInputType
  id: ID
  imageUrl: String
  invoiceName: String
  name: String!
  perUnitPricing: PerUnitPricingGQLInputType
  pricingModel: PricingModelGQLType
  status: ActiveStatusGQLType
  variablePricing: VariablePricingGQLInputType
}

Addon Subscription

type AddOnSubscriptionGQLType {
  addOn: AddOnGQLType
  endedOn: DateTime
  id: String!
  changedTo: String
  quantity: Long
  startedOn: DateTime
  status: SubscriptionStatusGQLType
}

input AddonSubscriptionGQLInputType {
  id: String
  originalAddOnId: ID
  planSubscriptionId: String!
  quantity: Long!
}

Address

type AddressGQLType {
  city: String
  countryCode: String
  line1: String
  line2: String
  postalCode: String
  province: String
}

input AddressGQLInputType {
  city: String
  countryCode: String
  line1: String
  line2: String
  postalCode: String
  province: String
}

Add Plan Result

type AddPlanResultGQLType {
  checkoutUrl: String
  needCustomization: Boolean
  needInfoFields: Boolean
  needPaymentMethod: Boolean
}

Attachment

type AttachmentGQLType {
    canBeDeleted: Boolean
    createdAtUtc: DateTime
    externalFileName: String!
    fileName: String!
    fileSizeKb: Decimal
}

Available Subscription Event

type AvailableSubscriptionEventGQLType {
  availablePlaceholders: [SubscriptionEventPlaceholderGQLType]
  defaultActions: [SubscriptionEventActionGQLType]
  id: String!
  name: String!
}

Billing Cycle Data

type BillingCycleDataGQLType {
  credit: Decimal
  pausingData: [PausingDataGQLType]
  termLimit: TermLimitGQLType
}

Billing Cycle

type BillingCycleGQLType {
  data: BillingCycleDataGQLType
  end: DateTime
  id: ID
  index: Int
  invoiceId: String
  nextBillingCycleId: ID
  planSubscription: SubscriptionGQLType
  planSubscriptionId: String
  siteId: String!
  start: DateTime
}

Billing Cycle Info

type BillingCycleInfoGQLType {
  dueInvoiceDueSettings: DueInvoiceDueSettingsGQLType
  duration: Int!
  earlyInvoiceCreationSettings: EarlyInvoiceCreationSettingsGQLType
  termLimit: TermLimitGQLType
  unit: IntervalUnitGQLType
  usageQuery: UsageQueryGQLType
}

input BillingCycleInfoGQLInputType {
  dueInvoiceDueSettings: DueInvoiceDueSettingsGQLInputType
  duration: Int!
  earlyInvoiceCreationSettings: EarlyInvoiceCreationSettingsGQLInputType
  termLimit: TermLimitGQLInputType
  unit: IntervalUnitGQLType
  usageQuery: UsageQueryGQLInputType
}

Billing Cycle Mutations

type BillingCycleMutations { 
    retryPostBilling: ResultGQLType_String 
    surchargeEntries: SurchargeEntriesMutations 
    surchargeEntry(surchargeEntryId: Guid!): SurchargeEntryMutations 
    usageEntries: UsageEntriesMutations 
    usageEntry(usageEntryId: Guid!): UsageEntryMutations 
}

Billing Info

type BillingInfoGQLType {
  additionalInfo: String
  address: AddressGQLType
  email: String
  firstName: String
  lastName: String
  name: String
  phoneNumber: String
}

input BillingInfoGQLInputType {
  additionalInfo: String
  address: AddressGQLInputType
  email: String
  firstName: String
  lastName: String
  phoneNumber: String
}

Change Log

type ChangeLogGQLType {
  by: ID
  description: String!
  id: String!
  timestamp: DateTime
}

Coupon

type CouponGQLType {
  couponCodes: [CouponCodeGQLType]
  id: ID
  name: String!
  quantity: Int
  siteId: String!
  status: ActiveStatusGQLType
  type: CouponTypeGQLType
  usageLimit: Int
  usageRule: RuleGQLType
  validityRule: RuleGQLType
  value: Decimal!
}

input CouponGQLInputType {
  id: ID
  name: String
  status: ActiveStatusGQLType
  type: CouponTypeGQLType
  usageRule: RuleGQLInput
  validityRule: RuleGQLInput
  value: Decimal
}

Coupon Code

type CouponCodeGQLType {
  code: String!
  coupon: CouponGQLType
  id: ID
  redemptionCount: Int!
  siteId: String!
}

Plan Subscription Coupon Code

type PlanSubscriptionCouponCodeGQLType {
  couponCode: CouponCodeGQLType
  data: CouponDataGQLType
  status: PlanSubscriptionCouponCodeStatusGQLType
}

Coupon Data

type CouponDataGQLType {
  billingCycleStartIndex: int
  usageCount: int
}

Currency

type CurrencyGQLType {
  code: String
  displayText: String
  symbol: String
}

Customer

type CustomerGQLType {
  activePlan: String
  activities: [ActivityLogGQLType]
  address: AddressGQLType
  balance: Decimal
  comment: String
  company: String
  customFields: [KeyValuePairGQLType]
  customerId: String
  documents: [StorageObjectGQLType]
  emailAddress: String
  emails: [EmailGQLType]
  firstJoined: DateTime
  firstName: String
  fullName: String
  id: ID
  infoFields(pinnedOnly: Boolean): [CustomerInfoFieldGQLType]
  invoices: [InvoiceInfoGQLType]
  lastName: String
  lastPaymentDate: DateTime
  lifeTimeRevenue: Decimal!
  lifeTimeRevenueCurrency: String!
  manualPayment: Boolean
  onePaymentsSummary(to: DateTime!): CustomerPaymentSummaryGQLType
  paymentMethods: [PaymentMethodGQLType]
  paymentSchedules: [PaymentScheduleGQLType]
  scheduledPaymentsSummary(from: DateTime!, to: DateTime!): CustomerPaymentSummaryGQLType
  shippingAddress: AddressGQLType
  siteId: String!
  status: SubscriptionStatusGQLType
  subscriptions: [SubscriptionGQLType]
  subscriptionsSummary(to: DateTime!): CustomerPaymentSummaryGQLType
  totalMrr: Decimal
  transactions: [TransactionInfoGQLType]
}

input CustomerGQLInputType {
  customFields: [KeyValuePairGQLInputType]
  customerId: String
  emailAddress: String!
  firstName: String!
  infoFields: [CustomerInfoFieldGQLInputType]
  lastName: String!
}

Customer Info Field

type CustomerInfoFieldGQLType {
  editable: Boolean
  label: String!
  name: String!
  pinned: Boolean
  required: Boolean
  type: String
  validation: String
  value: String!
}

input CustomerInfoFieldGQLInputType {
  editable: Boolean
  label: String!
  name: String!
  required: Boolean
  pinned: Boolean
  type: String
  validation: String
  value: String!
}

Customer Payment Summary

type CustomerPaymentSummaryGQLType 
{
    nextPaymentDate : DateTime
    totalDuePayments : Decimal
    totalOverDuePayments : Decimal
    currency : String
}

Delay

type DelayGQLType {
  delayType: DelayTypeGQLType
  interval: IntervalGQLType
  specificDate: Int
  specificDay: SpecificDayGQLType
}

input DelayInputGQLType {
  delayType: DelayTypeGQLType
  interval: IntervalGQLInputType
  specificDate: Int
  specificDay: SpecificDayGQLType
}

Draft Invoice

type DraftInvoiceGQLType {
  billedOn: DateTime
  createdOn: DateTime
  customer: CustomerGQLType
  data: String
  details: InvoiceDetailsGQLType
  dueOn: DateTime
  id: ID
  siteId: String!
  subTotal: Decimal
  total: Decimal
}

input DraftInvoiceGQLInputType {
  billedOn: DateTime
  customerId: String
  data: String
  details: InvoiceInfoGQLInputType
  dueOn: DateTime
}

input DraftFromInvoiceGQLInputType {
  billedOn: DateTime
  dueOn: DateTime
  invoiceId: String!
}

Due Invoice Due Settings

type DueInvoiceDueSettingsGQLType {
  action: ActionOnDueInvoiceDueGQLType
  duration: Int
  unit: IntervalUnitGQLType
}

input DueInvoiceDueSettingsGQLInputType {
  action: ActionOnDueInvoiceDueGQLType
  duration: Int
  unit: IntervalUnitGQLType
}

Dunning Profile

type DunningProfileGQLType {
  dunningFailAction: DunningFailActionGQLType
  id: ID
  name: String
  trials: [DunningTrialSettingsGQLType]
}

input DunningProfileGQLInputType {
  dunningFailAction: DunningFailActionGQLType
  id: ID
  name: String!
  trials: [DunningTrialSettingsGQLInputType]
}

Dunning Trial Settings

type DunningTrialSettingsGQLType {
  index: Int
  template: String
  trialDelayInDays: Decimal
  trialPercentage: Decimal
}

input DunningTrialSettingsGQLInputType {
  index: Int!
  template: String!
  trialDelayInDays: Decimal!
  trialPercentage: Decimal!
}

Early Invoice Creation Settings

type EarlyInvoiceCreationSettingsGQLType {
  duration: Int
  unit: IntervalUnitGQLType
}

input EarlyInvoiceCreationSettingsGQLInputType {
  duration: Int
  unit: IntervalUnitGQLType
}

Email

type EmailGQLType {
  address: String
  attachments: [StorageObjectGQLType]
  displayText: String
  id: String
  sentOn: DateTime
}

input EmailSettingsGQLInputType {
  settings: String!
  useApi: Boolean!
  useSmtp: Boolean!
}

Global Setting

type GlobalSettingGQLType {
  data: String!
  id: String!
}

Setting

type SettingGQLType {
  data: String!
  id: String!
  siteId: String!
}

input SettingGQLInputType {
  data: String!
  id: String!
}

Info Field

type InfoFieldGQLType {
  disabled: Boolean
  editable: Boolean
  label: String!
  name: String!
  required: Boolean!
  type: String
  validation: String
}

input InfoFieldGQLInputType {
  disabled: Boolean
  editable: Boolean
  label: String!
  name: String!
  required: Boolean!
  type: String
  validation: String
}

Interval

type IntervalGQLType {
  duration: Int!
  unit: IntervalUnitGQLType
}

input IntervalGQLInputType {
  duration: Int!
  unit: IntervalUnitGQLType
}

Invoice Details

type InvoiceDetailsGQLType {
  billingInfo: BillingInfoGQLType
  comments: String
  currency: String!
  discounts: [InvoiceSubtotalGQLType]
  extraFees: [InvoiceSubtotalGQLType]
  footer: String
  header: String
  lineItems: [InvoiceLineItemGQLType]
  paymentDetails: String
  taxes: [InvoiceSubtotalGQLType]
  terms: String
}

Invoice

type InvoiceGQLType {
  attachments: [AttachmentGQLType]
  billedOn: DateTime
  createdOn: DateTime
  customer: CustomerGQLType
  data: String
  details: InvoiceDetailsGQLType
  dueOn: DateTime
  hasPaymentAttempts: Boolean
  id: ID
  number: String
  paidOn: DateTime
  paymentAttemptsCount: Int
  paymentInfo: PaymentInfoGQLType
  relatedEntity: RelatedEntityGQLType
  relatedEntityId: String
  siteId: String!
  status: InvoiceStatusGQLType
  subTotal: Decimal
  total: Decimal
  transactions: [TransactionGQLType]
  url: String
}

Invoice Info

type InvoiceInfoGQLType {
  billedOn: DateTime
  createdOn: DateTime
  details: InvoiceDetailsGQLType
  dueOn: DateTime
  id: ID
  number: String
  siteId: String!
  status: InvoiceStatusGQLType
  subTotal: Decimal
  total: Decimal
  url: String
}

input InvoiceInfoGQLInputType {
  billingInfo: BillingInfoGQLInputType
  comments: String
  currency: String!
  discounts: [InvoiceSubtotalGQLInputType]
  extraFees: [InvoiceSubtotalGQLInputType]
  footer: String
  header: String
  lineItems: [InvoiceLineItemGQLInputType]
  paymentDetails: String
  taxes: [InvoiceSubtotalGQLInputType]
  terms: String
}

Invoice Line Item

type InvoiceLineItemGQLType {
  data: String
  end: DateTime
  item: String!
  order: Int!
  quantity: Decimal!
  start: DateTime!
  total: Decimal
  unitPrice: Decimal!
}

input InvoiceLineItemGQLInputType {
  data: String
  end: DateTime
  item: String
  order: Int
  quantity: Decimal
  start: DateTime
  total: Decimal
  unitPrice: Decimal
}

Invoice From Draft

input InvoiceFromDraftGQLInputType {
  billedOn: DateTime
  draftInvoiceId: String!
  dueOn: DateTime
}

Invoice Subtotal

type InvoiceSubtotalGQLType {
  amount: Decimal!
  definition: SummaryItemDefinitionGQLType
  description: String!
  order: Int!
}

input InvoiceSubtotalGQLInputType {
  amount: Decimal!
  definition: SummaryItemDefinitionGQLInputType
  description: String
  order: Int
}

Key Value Pair

type KeyValuePairGQLType {
  key: String!
  value: String!
}

input KeyValuePairGQLInputType {
  key: String!
  value: String!
}

Pausing Data

type PausingDataGQLType {
  pausingDuration: Seconds!
  remainingPeriodWhenPaused: Seconds!
  timestamp: DateTime!
}

Pausing Rule

type PausingRuleGQLType {
  operands: PausingRuleGQLType
  operation: RuleOperationGQLType
  value: String
}

input PausingRuleGQLInputType {
  operands: PausingRuleGQLInputType
  operation: String
  value: String
}

Payment Attempt

type PaymentAttemptGQLType {
  succeeded: Boolean
  transactionId: String
  utcTimestamp: DateTime
}

Payment Info

type PaymentInfoGQLType {
  paymentAttempts: [PaymentAttemptGQLType]
}

One-Time Payment

type OneTimePaymentGQLType {
  code: String
  currency: CurrencyGQLType
  data: String
  id: ID
  info: OneTimePaymentInfoGQLType
  name: String!
  siteId: String!
  status: ActiveStatusGQLType
  url: String
}

input OneTimePaymentGQLInputType {
  code: String!
  currencyCode: String!
  data: String
  info: OneTimePaymentInfoGQLInputType
  name: String!
  status: ActiveStatusGQLType
}

One-Time Payment Info

type OneTimePaymentInfoGQLType {
  comments: String
  discounts: [SummaryItemDefinitionGQLType]
  extraFees: [SummaryItemDefinitionGQLType]
  infoFields: [InfoFieldGQLType]
  lineItems: [OneTimePaymenLineItemGQLType]
  paymentDetails: String
  taxes: [SummaryItemDefinitionGQLType]
  terms: String
}

input OneTimePaymentInfoGQLInputType {
  comments: String
  discounts: [SummaryItemDefinitionGQLInputType]
  extraFees: [SummaryItemDefinitionGQLInputType]
  infoFields: [InfoFieldGQLInputType]
  lineItems: [OneTimePaymentLineItemGQLInputType]
  paymentDetails: String
  taxes: [SummaryItemDefinitionGQLInputType]
  terms: String
}

One-Time Payment Line Item

type OneTimePaymentLineItemGQLType {
  data: String
  description: String
  fixedPricing: FixedPricingGQLType
  item: String
  perUnitPricing: PerUnitPricingGQLType
  pricingModel: PricingModelGQLType
  variablePricing: VariablePricingGQLType
}

input OneTimePaymentLineItemGQLInputType {
  data: String
  description: String
  fixedPricing: FixedPricingGQLInputType
  item: String
  perUnitPricing: PerUnitPricingGQLInputType
  pricingModel: PricingModelGQLType
  variablePricing: VariablePricingGQLInputType
}

Payment Method

type PaymentMethodGQLType {
  billingInfo: BillingInfoGQLType
  displayText: String!
  id: String!
  identifier: String
  isDefault: Boolean!
  metaData: String
  providerReference: String
  sitePaymentMethodId: String!
  type: String!
}

input PaymentMethodGQLInputType {
  billingInfo: BillingInfoGQLInputType
  displayText: String!
  id: String
  identifier: String
  isDefault: Boolean!
  metaData: String
  providerReference: String
  sitePaymentMethodId: String!
  type: String!
}

Payment Method Properties

type PaymentMethodPropertiesGQLType {
  allowsAddPaymentMethod: Boolean
  allowsAddition: Boolean
  allowsMultiplePerCustomer: Boolean
  extraFee: Decimal
  type: PaymentMethodTypeGQLType
}

Payment Schedule

type PaymentScheduleGQLType {
  attachments: [AttachmentGQLType]
  createdOn: DateTime
  currency: CurrencyGQLType
  customer: CustomerGQLType
  data: PaymentScheduleDataGQLType
  dunningProfile: DunningProfileGQLType
  id: ID
  invoice: InvoiceGQLType
  invoiceId: String
  name: String!
  paymentMethod: PaymentMethodGQLType
  product: String!
  scheduledPayments: [ScheduledPaymentGQLType]
  siteId: String!
}

type PaymentScheduleDataGQLType {
  allowPaymentMethodChange: Boolean
  extraDetails: String
  invoicing: PaymentScheduleInvoicingGQLType
  status: PaymentScheduleStatusGQLType
}

input PaymentScheduleGQLInputType {
  currencyCode: String
  customerId: String
  data: PaymentScheduleDataGQLInputType
  dunningProfileId: ID
  id: String
  name: String!
  paymentMethod: PaymentMethodGQLInputType
  product: String!
  scheduledPayments: [ScheduledPaymentGQLInputType]
}

input PaymentScheduleDataGQLInputType {
  allowPaymentMethodChange: Boolean
  extraDetails: String
  invoicing: PaymentScheduleInvoicingGQLType
  status: PaymentScheduleStatusGQLType
}

Payment Schedule Template

type PaymentScheduleTemplateGQLType {
  data: String
  description: String!
  id: ID
  name: String!
  payments: [PaymentScheduleTemplateItemGQLType]
  siteId: String!
}

input PaymentScheduleTemplateGQLInputType {
  data: String
  description: String
  id: ID
  name: String!
  payments: [PaymentScheduleTemplateItemGQLInputType]
}

input PaymentScheduleFromTemplateGQLInputType {
  baseAmount: Decimal
  baseDate: DateTime
  currencyCode: String
  customerId: String
  paymentScheduleTemplateId: ID
  product: String
  selectedPaymentMethodId: String
}

Payment Schedule Template Item

type PaymentScheduleTemplateItemGQLType {
  intervalDuration: Int!
  intervalUnit: IntervalUnitGQLType
  name: String!
  order: Int!
  percentageAmount: Decimal!
}

input PaymentScheduleTemplateItemGQLInputType {
  intervalDuration: Int!
  intervalUnit: IntervalUnitGQLType
  name: String!
  order: Int!
  percentageAmount: Decimal!
}

Per Unit Pricing

type PerUnitPricingGQLType {
  displayCurrencyConversion: Decimal
  extraFees: [SummaryItemDefinitionGQLType]
  freeQuantity: Long!
  pricePerUnit: Decimal!
  rules: PricingRulesGQLType
  taxes: [SummaryItemDefinitionGQLType]
  unit: String!
}

input PerUnitPricingGQLInputType {
  displayCurrencyConversion: Decimal
  extraFees: [SummaryItemDefinitionGQLInputType]
  freeQuantity: Long!
  pricePerUnit: Decimal!
  rules: PricingRulesGQLInputType
  taxes: [SummaryItemDefinitionGQLInputType]
  unit: String!
}

Plan

type PlanGQLType {
    accountingCode: String
    activeSubscribersCount: Int
    addOns: [AddOnGQLType]
    billingCycle: BillingCycleInfoGQLType
    billingModel: BillingModelGQLType
    billingType: BillingTypeGQLType
    canBeDeleted: Boolean!
    changeLog: [ChangeLogGQLType]
    checkoutNotes: String
    data: String
    defaultCurrency: CurrencyGQLType
    description: String
    discountedFrom: Decimal
    displayCurrency: CurrencyGQLType
    displaySettings: String
    dunningProfile: DunningProfileGQLType
    effectiveEndDate: DateTime
    effectiveStartDate: DateTime
    fixedPricing: FixedPricingGQLType
    hasActiveSubscribers: Boolean
    hostedPageUrl: String
    id: ID
    imageUrl: String
    infoFields: [InfoFieldGQLType]
    invoiceName: String
    name: String!
    perUnitPricing: PerUnitPricingGQLType
    planCode: String!
    planFutureStarts: [PlanFutureStartGQLType]
    planPausingDurations: [PlanPausingDurationGQLType]
    planRules: PlanRulesGQLType
    pricingModel: PricingModelGQLType
    productName: String
    setupFee: Decimal
    siteId: String!
    status: ActiveStatusGQLType
    trialPeriod: TrialPeriodSettingsGQLType
    variablePricing: VariablePricingGQLType
}

input PlanGQLInputType {
  accountingCode: String
  addOns: [AddOnGQLInputType]
  billingCycle: BillingCycleInfoGQLInputType
  billingModel: BillingModelGQLType
  billingType: BillingTypeGQLType
  checkoutNotes: String
  data: String
  defaultCurrencyCode: String
  description: String
  discountedFrom: Decimal
  displayCurrencyCode: String
  displaySettings: String
  dunningProfileId: ID
  fixedPricing: FixedPricingGQLInputType
  id: ID
  imageUrl: String
  infoFields: [InfoFieldGQLInputType]
  invoiceName: String
  name: String!
  perUnitPricing: PerUnitPricingGQLInputType
  planCode: String!
  planFutureStarts: [PlanFutureStartGQLInputType]
  planPausingDurations: [PlanPausingDurationGQLInputType]
  planRules: PlanRulesGQLInputType
  pricingModel: PricingModelGQLType
  productName: String!
  setupFee: Decimal
  status: ActiveStatusGQLType
  trialPeriod: TrialPeriodSettingsGQLInputType
  variablePricing: VariablePricingGQLInputType
}

Plan Future Start

type PlanFutureStartGQLType {
  displayText: String!
  id: ID
  interval: IntervalGQLType
  planId: ID
  rule: RuleGQLType
  siteId: String!
}

input PlanFutureStartGQLInputType {
  displayText: String!
  interval: IntervalGQLInputType
  planId: ID
  rule: RuleGQLInput
}

Plan Pausing Duration

type PlanPausingDurationGQLType {
  displayText: String!
  id: ID
  pausingRule: PausingRuleGQLType
  pausingValue: IntervalGQLType
  planId: ID
  siteId: String!
}

input PlanPausingDurationGQLInputType {
  displayText: String!
  pausingRule: PausingRuleGQLInputType
  pausingValue: IntervalGQLInputType
  planId: ID
}

Plan Rules

type PlanRulesGQLType {
  exactTotalAddonsQuantity: Long
  maxTotalAddonsQuantity: Long
}

input PlanRulesGQLInputType {
  exactTotalAddonsQuantity: Long
  maxTotalAddonsQuantity: Long
}

Possible Value

type PossibleValueGQLType {
  label: String!
  value: Int!
}

input PossibleValueGQLInputType {
  label: String!
  value: Int!
}

Pricing Rules

type PricingRulesGQLType {
  max: Int
  min: Int
  step: Int
  values: [PossibleValueGQLType]
}

input PricingRulesGQLInputType {
  max: Int
  min: Int
  step: Int
  values: [PossibleValueGQLInputType]
}

Fixed Pricing

type FixedPricingGQLType {
  displayCurrencyConversion: Decimal
  extraFees: [SummaryItemDefinitionGQLType]
  price: Decimal!
  required: Boolean
  taxes: [SummaryItemDefinitionGQLType]
}

input FixedPricingGQLInputType {
  displayCurrencyConversion: Decimal
  extraFees: [SummaryItemDefinitionGQLInputType]
  price: Decimal!
  required: Boolean
  rules: PricingRulesGQLInputType
  taxes: [SummaryItemDefinitionGQLInputType]
}

Pricing Tier

type PricingTierGQLType {
  from: Long!
  price: Decimal!
  to: Long
}

input PricingTierGQLInputType {
  from: Long!
  price: Decimal!
  to: Long
}

Variable Pricing

type VariablePricingGQLType {
  displayCurrencyConversion: Decimal
  extraFees: [SummaryItemDefinitionGQLType]
  rules: PricingRulesGQLType
  taxes: [SummaryItemDefinitionGQLType]
  tiers: [PricingTierGQLType]
  type: VariablePricingTypeGQLType
  unit: String
}
input VariablePricingGQLInputType {
  displayCurrencyConversion: Decimal
  extraFees: [SummaryItemDefinitionGQLInputType]
  rules: PricingRulesGQLInputType
  taxes: [SummaryItemDefinitionGQLInputType]
  tiers: [PricingTierGQLInputType]
  type: VariablePricingTypeGQLType
  unit: String!
}

Change Plan Subscription Result

type ChangePlanSubscriptionResultGQLType {
  checkoutUrl: String
  isFailed: Boolean
  isSuccess: Boolean
  message: String
  needCustomization: Boolean
  needInfoFields: Boolean
  needPaymentMethod: Boolean
  planSubscriptionId: String
}

Organization

type OrganizationGQLType {
  id: String
  name: String
  users: [UserGQLType]
}

Result

type ResultGQLType_{requestedEntity} {
  isSuccess: Boolean!
  message: String
  value: {requestedEntityGQLType}
}

Result GraphQL Type

type ResultGQLType {
  isSuccess: Boolean!
  message: String
}

Pagination Result

type PaginationResultGQLType_{requestedEntity} {
  data: List[{requestedEntityGQLType}]
  isSuccess: Boolean!
  message: String
  pagination: PaginationGQLType
}

Rule

type RuleGQLType {
  name: String
  operands: [RuleGQLType]
  operation: RuleOperationGQLType
  value: String
  valueType: ValueTypeGQLType
}

input RuleGQLInput {
  name: String
  operands: [RuleGQLInput]
  operation: String
  value: String
  valueType: ValueTypeGQLType
}

Scheduled Payment Status

type ScheduledPaymentGQLType {
  amount: Decimal
  data: String
  date: DateTime
  id: ID
  invoice: InvoiceGQLType
  invoiceId: String
  name: String!
  reference: String
  siteId: String!
  status: SchedulePaymentStatusGQLType
}

Site Info

type SiteInfoGQLType {
  isDemo: Boolean!
  isTest: Boolean!
  name: String
  organization: OrganizationGQLType
  siteId: String!
  url: String
}

Site Integration

type SiteIntegrationGQLType {
  code: String!
  displaySettings: String!
  id: String!
  imageUrl: String!
  isEnabled: Boolean!
  settings: String!
  siteId: String!
  type: String!
}

input SiteIntegrationGQLInputType {
  isEnabled: Boolean
  settings: String
}

Site Payment Method

type SitePaymentMethodGQLType {
  displayImage: String
  displayText: String
  id: ID
  paymentProviderCode: String!
  properties: PaymentMethodPropertiesGQLType
  siteId: String!
}

Site Payment Provider

type SitePaymentProviderGQLType {
  imageUrl: String
  isEnabled: Boolean!
  paymentProviderCode: String!
  settings: String!
  siteId: String!
}

input SitePaymentProviderGQLInputType {
  imageUrl: String
  paymentProviderCode: String!
  settings: String!
}

Storage Object

type StorageObjectGQLType {
  displayText: String
  id: ID
  objectPath: String
}

type SubscribeCustomerOnPlanResultGQLType {
  checkoutUrl: String
  needCustomization: Boolean
  needPaymentMethod: Boolean
}

Subscription

type SubscriptionGQLType {
  activeCoupon: PlanSubscriptionCouponCodeGQLType
  addOns: [AddOnSubscriptionGQLType]
  currency: String!
  currentBillingCycleEnd: DateTime
  currentBillingCycleIndex: Int
  currentBillingCycleStart: DateTime
  endedOn: DateTime
  id: String!
  pausingInfo: PausingDataGQLType
  plan: PlanGQLType
  quantity: Long
  siteId: String!
  startedOn: DateTime
  status: SubscriptionStatusGQLType
}

Subscription Event

type SubscriptionEventGQLType {
  actions: [SubscriptionEventActionGQLType]
  conditions: RuleGQLType
  delay: DelayGQLType
  id: ID
  info: SubscriptionEventInfoGQLType
  name: String!
  siteId: String!
  subscriptionEventId: String!
}

input SubscriptionEventGQLInputType {
  actions: [SubscriptionEventActionGQLInputType]
  conditions: RuleGQLInput
  delay: DelayInputGQLType
  info: SubscriptionEventInfoInputGQLType
  name: String!
  subscriptionEventId: String!
}

Subscription Event Info

type SubscriptionEventInfoGQLType {
  index: Int
}

input SubscriptionEventInfoInputGQLType {
  index: Int
}

Subscription Event Placeholder

type SubscriptionEventPlaceholderGQLType {
  label: String
  name: String
  valueType: ValueTypeGQLType
}

Subscription Event Action

type SubscriptionEventActionGQLType {
  chatMessaging: SubscriptionEventActionChatMessagingGQLType
  email: SubscriptionEventActionEmailGQLType
  isEnabled: Boolean!
  name: String!
  sms: SubscriptionEventActionSmsGQLType
  webhook: SubscriptionEventActionWebhookGQLType
}

input SubscriptionEventActionGQLInputType {
  chatMessaging: SubscriptionEventActionChatMessagingGQLInputType
  email: SubscriptionEventActionEmailGQLInputType
  isEnabled: Boolean!
  name: String!
  sms: SubscriptionEventActionSmsGQLInputType
  webhook: SubscriptionEventActionWebhookGQLInputType
}

Subscription Event Action Email

type SubscriptionEventActionEmailGQLType {
  bCC: String
  body: String
  cC: String
  disableBodyTemplate: Boolean
  fromDisplayName: String
  subject: String
  to: String
}

input SubscriptionEventActionEmailGQLInputType {
  bCC: String
  body: String
  cC: String
  disableBodyTemplate: Boolean
  fromDisplayName: String
  isHtml: Boolean
  subject: String
  to: String
}

Subscription Event Action Chat Messaging

type SubscriptionEventActionChatMessagingGQLType {
  body: String
  languageCode: String
  messageType: MessageTypeGQLType
  to: String
}

input SubscriptionEventActionChatMessagingGQLInputType {
  body: String
  languageCode: String
  messageType: MessageTypeGQLType
  templateName: String
  to: String!
}

Subscription Event Action SMS

type SubscriptionEventActionSmsGQLType {
  body: String
  to: String
}

input SubscriptionEventActionSmsGQLInputType {
  body: String!
  to: String!
}

Subscription Event Action Webhook

type SubscriptionEventActionWebhookGQLType {
  customHeaders: [KeyValuePairGQLType!]
  endpoint: String
  method: String
  payload: String
}

input SubscriptionEventActionWebhookGQLInputType {
  customHeaders: [KeyValuePairGQLInputType]
  endpoint: String
  method: String
  payload: String
}

Summary Item Definition

type SummaryItemDefinitionGQLType {
  name: String
  rule: RuleGQLType
  type: DefinitionTypeGQLType
  value: Decimal
}

input SummaryItemDefinitionGQLInputType {
  name: String
  rule: RuleGQLInput
  type: DefinitionTypeGQLType
  value: Decimal!
}

Tax Invoice Data

type TaxInvoiceDataGQLType {
  base64: String
  isSuccess: Boolean
  message: String
  name: String
}

Term Limit

type TermLimitGQLType {
  actionOnEnd: ActionOnTermEndGQLType
  cycles: Int
}

input TermLimitGQLInputType {
  actionOnEnd: ActionOnTermEndGQLType
  cycles: Int
}

Transaction

type TransactionGQLType {
  amount: Decimal
  currency: String
  customer: CustomerGQLType
  gatewayResponse: String
  id: ID
  invoice: InvoiceGQLType
  paymentMethod: PaymentMethodGQLType
  sitePaymentMethod: SitePaymentMethodGQLType 
  referenceNumber: String
  siteId: String!
  status: TransactionStatusGQLType
  timestamp: DateTime
  type: String
  utcTimestamp: DateTime
}

Transaction Info

type TransactionInfoGQLType {
  amount: Decimal
  currency: String
  id: ID
  paymentMethod: PaymentMethodGQLType
  status: TransactionStatusGQLType
  timestamp: DateTime
  utcTimestamp: DateTime
}

Trial Period Settings

type TrialPeriodSettingsGQLType {
  duration: Int!
  requiresCreditCard: Boolean!
  unit: IntervalUnitGQLType
}

input TrialPeriodSettingsGQLInputType {
  duration: Int!
  requiresCreditCard: Boolean
  unit: IntervalUnitGQLType
}

Usage Entries Mutations

type UsageEntriesMutations { 
    add(usageEntry: UsageEntryGQLInputType!): ResultGQLType 
}

Usage Entry

type UsageEntryGQLType { 
    code: String 
    comment: String 
    id: ID 
    quantity: Decimal 
    requesterId: ID 
    utcTimestamp: DateTime 
}

Usage Entry Mutations

type UsageEntryMutations { 
    delete: ResultGQLType 
}

Usage Query

type UsageQueryGQLType {
  codes: [String]
  customHeaders: [KeyValuePairGQLType!]
  endpoint: String
  method: String
}

input UsageQueryGQLInputType {
  codes: [String]
  customHeaders: [KeyValuePairGQLInputType]
  endpoint: String
  method: String
}

Usage Query Response

type UsageQueryResponseGQLType { 
    message: String 
    status: String 
    statusCode: Int 
    timestamp: DateTime 
}

Usage Query Result

type UsageQueryResultGQLType { 
    end: DateTime 
    start: DateTime 
    usage: [KeyValuePairGQLType] 
}

Usage Query Result

type QueryUsageResultGQLType {
  content: String
  isFailed: Boolean
  isSuccess: Boolean
  message: String
  status: String
  statusCode: Int
}

User

type UserGQLType {
  email: String
  id: String
  name: String
  organizationId: String
}

GQL Queries

type GQLQueries {
  addons(filter: FilterGQLInputType, pagination: PaginationGQLInputType, siteId: String!, sorting: [SortingGQLInputType]): PaginationResultGQLType_AddOn
  availableActions(siteId: String!): [String]
  availableSubscriptionEvents(siteId: String!): [AvailableSubscriptionEventGQLType]
  billingCycles(filter: FilterGQLInputType, pagination: PaginationGQLInputType, siteId: String!, sorting: [SortingGQLInputType]): PaginationResultGQLType_BillingCycle
  coupon(couponId: String!, siteId: String!): CouponGQLType
  coupons(filter: FilterGQLInputType, pagination: PaginationGQLInputType, siteId: String!, sorting: [SortingGQLInputType]): PaginationResultGQLType_Coupon
  currencySettings(siteId: String!): SettingGQLType
  customer(customerId: String!, siteId: String!): CustomerGQLType
  customerByEmail(email: String!, siteId: String!): CustomerGQLType
  customerOperationJwt(customerId: String!, operation: String!, siteId: String!, subscriptionId: String): ResultGQLType_String
  customers(filter: FilterGQLInputType, pagination: PaginationGQLInputType, siteId: String!, sorting: [SortingGQLInputType]): PaginationResultGQLType_Customer
  downloadTaxInvoice(invoiceId: String!, siteId: String!): ResultGQLType_TaxInvoiceData
  draftInvoice(draftInvoiceId: String!, siteId: String!): DraftInvoiceGQLType
  draftInvoices(filter: FilterGQLInputType, pagination: PaginationGQLInputType, siteId: String!, sorting: [SortingGQLInputType]): PaginationResultGQLType_DraftInvoice
  dunningProfile(dunningProfileId: String!, siteId: String!): DunningProfileGQLType
  dunningProfiles(filter: FilterGQLInputType, pagination: PaginationGQLInputType, siteId: String!, sorting: [SortingGQLInputType]): PaginationResultGQLType_DunningProfile
  getApiSecret(siteId: String!): ResultGQLType_String
  getSiteManualPaymentMethods(siteId: String!): [SitePaymentMethodGQLType]
  getSitePaymentMethods(siteId: String!): [SitePaymentMethodGQLType]
  globalSettings(ids: [String]): [GlobalSettingGQLType]
  integrationAuthUrl(integrationId: String!, siteId: String!): ResultGQLType_String
  integrationStatus(integrationId: String!, siteId: String!): ResultGQLType_Boolean
  integrations(siteId: String!, type: String): [SiteIntegrationGQLType]
  invoice(invoiceId: String!, siteId: String!): InvoiceGQLType
  invoices(filter: FilterGQLInputType, pagination: PaginationGQLInputType, siteId: String!, sorting: [SortingGQLInputType]): PaginationResultGQLType_Invoice
  invoicesById(ids: [String]!, pagination: PaginationGQLInputType, siteId: String!, sorting: [SortingGQLInputType]): PaginationResultGQLType_Invoice
  oneTimePayment(oneTimePaymentId: String!, siteId: String!): OneTimePaymentGQLType
  oneTimePayments(filter: FilterGQLInputType, pagination: PaginationGQLInputType, siteId: String!, sorting: [SortingGQLInputType]): PaginationResultGQLType_OneTimePayment
  paymentSchedule(paymentScheduleId: String!, siteId: String!): PaymentScheduleGQLType
  paymentScheduleTemplate(paymentScheduleTemplateId: String!, siteId: String!): PaymentScheduleTemplateGQLType
  paymentScheduleTemplates(filter: FilterGQLInputType, pagination: PaginationGQLInputType, siteId: String!, sorting: [SortingGQLInputType]): PaginationResultGQLType_PaymentScheduleTemplate
  paymentSchedules(filter: FilterGQLInputType, pagination: PaginationGQLInputType, siteId: String!, sorting: [SortingGQLInputType]): PaginationResultGQLType_PaymentSchedule
  paymentSchedulesById(ids: [String]!, pagination: PaginationGQLInputType, siteId: String!, sorting: [SortingGQLInputType]): PaginationResultGQLType_PaymentSchedule
  plan(planCode: String!, siteId: String!): PlanGQLType
  plans(filter: FilterGQLInputType, pagination: PaginationGQLInputType, siteId: String!, sorting: [SortingGQLInputType]): PaginationResultGQLType_Plan
  portalSettings(url: String!): SettingGQLType
  queryUsage(siteId: String!, subscriptionId: String!, utcEndDate: DateTime!, utcStartDate: DateTime!): ResultGQLType_QueryUsageResult
  settings(settings: [String], siteId: String!): [SettingGQLType]
  siteInfo(siteId: String!): ResultGQLType_Site
  siteIntegration(integrationId: String!, siteId: String!): SiteIntegrationGQLType
  siteIntegrationAvailability(integrationCategory: String!, siteId: String!): ResultGQLType
  sitePaymentProviders(siteId: String!): [SitePaymentProviderGQLType]
  subscriptionEvents(filter: FilterGQLInputType, pagination: PaginationGQLInputType, siteId: String!, sorting: [SortingGQLInputType]): PaginationResultGQLType_SiteSubscriptionEvent
  transaction(siteId: String!, transactionId: String!): TransactionGQLType
  transactions(filter: FilterGQLInputType, pagination: PaginationGQLInputType, siteId: String!, sorting: [SortingGQLInputType]): PaginationResultGQLType_Transaction
 }

Pagination

type PaginationGQLType {
  page: Int
  perPage: Int
  totalRecords: Int
}

input PaginationGQLInputType {
  page: Int
  perPage: Int
}

Sorting

input SortingGQLInputType {
  direction: SortingDirectionGQLType
  field: String
}

Filter

input FilterGQLInputType {
  field: String
  operands: [FilterGQLInputType]
  operator: OperatorGQLType
  value: String
}

Admin Requirements

input AdminRequirementsGQLInputType {
addons: [String]
infoFields: [String]
needPlanQuantity: Boolean
}

GQL Mutations

type GQLMutations {
  apiSecret(siteId: String!): ApiSecretMutations
  coupon(couponId: String, siteId: String!): CouponMutations
  coupons(siteId: String!): CouponsMutations
  customer(customerId: String, siteId: String!): CustomerMutations
  customers(siteId: String!): CustomersMutations
  draftInvoice(draftInvoiceId: String!, siteId: String!): DraftInvoiceMutations
  draftInvoices(siteId: String!): DraftInvoicesMutations
  dunningProfile(dunningProfileId: String!, siteId: String!): DunningProfileMutations
  dunningProfiles(siteId: String!): DunningProfilesMutations
  integration(integrationId: String!, siteId: String!): IntegrationMutations
  invoice(invoiceId: String, siteId: String!): InvoiceMutations
  oneTimePayment(id: String!, siteId: String!): OneTimePaymentMutations
  oneTimePayments(siteId: String!): OneTimePaymentsMutations
  paymentSchedule(paymentScheduleId: String!, siteId: String!): PaymentScheduleMutations
  paymentScheduleTemplate(paymentScheduleTemplateId: String!, siteId: String!): PaymentScheduleTemplateMutations
  paymentScheduleTemplates(siteId: String!): PaymentScheduleTemplatesMutations
  plan(planId: String!, siteId: String!): PlanMutations
  plans(siteId: String!): PlansMutations
  setting(siteId: String!): SettingMutations
  sitePaymentProvider(paymentProviderCode: String!, siteId: String!): SitePaymentProviderMutations
  subscriptionEvent(siteId: String!, siteSubscriptionEventId: Guid!): SubscriptionEventMutations
  subscriptionEvents(siteId: String!): SubscriptionEventsMutations
  webhookSecret(siteId: String!): WebhookSecretMutations
}

API Secret Mutations

type ApiSecretMutations {
  regenerate: ResultGQLType_String
}

Coupon Codes Mutations

type CouponCodesMutations {
  delete: ResultGQLType
}

Coupon Mutations

type CouponMutations {
  codes(ids: [String]!): CouponCodesMutations
  delete: ResultGQLType
  update(coupon: CouponGQLInputType!): ResultGQLType
}

Coupon With Codes Mutations

type CouponWithCodesMutations {
  withCodes(code: String!, quantity: Int!): ResultGQLType_Coupon
}

Coupons Mutations

type CouponsMutations {
  create(coupon: CouponGQLInputType): CouponWithCodesMutations
}

Discounts Mutations

type DiscountsMutations {
  add(amount: Decimal!): ResultGQLType
  remove(amount: Decimal!): ResultGQLType
  update(amounts: [Decimal]!): ResultGQLType
}

Custom Field Mutations

type CustomFieldMutations {
  delete: ResultGQLType
  update(customField: KeyValuePairGQLInputType!): ResultGQLType
}

Custom Fields Mutations

type CustomFieldsMutations {
  add(customField: KeyValuePairGQLInputType!): ResultGQLType
  update(customFields: [KeyValuePairGQLInputType]): ResultGQLType
}

Customer Id Mutations

type CustomerIdMutations {
  update(newCustomerId: String!): ResultGQLType_String
}

Customer Mutations

type CustomerMutations {
  customField(name: String!): CustomFieldMutations
  customFields: CustomFieldsMutations
  customerId: CustomerIdMutations
  infoField(name: String!): InfoFieldMutations
  infoFields: InfoFieldsMutations
  paymentMethod(paymentMethodId: String!): PaymentMethodMutations
  paymentMethods: PaymentMethodsMutations
  paymentSchedules: PaymentSchedulesMutations
  subscription(planSubscriptionId: String!): CustomerSubscriptionMutations
  subscriptions: CustomerSubscriptionsMutations
  syncCustomerClaims(externalUserId: String!): Boolean
}

Customer Subscription Mutations

type CustomerSubscriptionMutations {
  addFreeAddon(addonId: ID!): ResultGQLType
  applyCoupon(couponCode: String!): ResultGQLType
  cancel(immediateCancellation: Boolean): ResultGQLType

  # 'Move' is equivalent to 'Change', and 'Moving' is equivalent to 'Changing'.

  change(
      addonsQuantity: [KeyValuePairGQLInputType]
      immediateMoving: Boolean!
      infoFields: [KeyValuePairGQLInputType]
      planCode: String!
      planQuantity: Long
      version: String
  ): ResultGQLType_ChangePlanSubscriptionResult
  
  customizeAddons(addonsQuantity: [KeyValuePairGQLInputType]): ResultGQLType_CustomizePlanSubscriptionAddonsResult  customizeAddons(addonsQuantity: [KeyValuePairGQLInputType]): ResultGQLType_CustomizePlanSubscriptionAddonsResult
  pause(pauseDurationId: String): ResultGQLType
  pauseWithInterval(pauseInterval: IntervalGQLInputType!): ResultGQLType
  reactivate: ResultGQLType
  removeFreeAddon(addonSubscriptionId: String!): ResultGQLType
  resume: ResultGQLType
  suspend: ResultGQLType
  updateFreeAddon(addonSubscriptions: [AddonSubscriptionGQLInputType]!): ResultGQLType
}

Customer Subscriptions Mutations

type CustomerSubscriptionsMutations {
  add(
      addonsQuantity: [KeyValuePairGQLInputType]
      futureStart: IntervalGQLInputType
      infoFields: [CustomerInfoFieldGQLInputType]
      invoiceId: String
      planCode: String!
      planQuantity: Long
      version: String
  ): ResultGQLType_AssignPlanResult}

Customers Mutations

type CustomersMutations {
  create(customer: CustomerGQLInputType!): ResultGQLType_Customer
}

Draft Invoice Mutations

type DraftInvoiceMutations {
  delete: ResultGQLType
  update(draftInvoice: DraftInvoiceGQLInputType!): ResultGQLType
}

Draft Invoices Mutations

type DraftInvoicesMutations {
  create(draftInvoice: DraftInvoiceGQLInputType!): ResultGQLType_String
  createFromInvoice(draftFromInvoice: DraftFromInvoiceGQLInputType!): ResultGQLType_DraftInvoice
}

Dunning Profile Mutations

type DunningProfileMutations {
  update(dunningProfile: DunningProfileGQLInputType!): ResultGQLType_DunningProfile
}

Dunning Profiles Mutations

type DunningProfilesMutations {
  create(dunningProfile: DunningProfileGQLInputType!): ResultGQLType_DunningProfile
}

Info Field Mutations

type InfoFieldMutations {
  delete: ResultGQLType
  pin: ResultGQLType
  unpin: ResultGQLType
  update(infoField: CustomerInfoFieldGQLInputType!): ResultGQLType
}

Info Fields Mutations

type InfoFieldsMutations {
  add(infoField: CustomerInfoFieldGQLInputType!): ResultGQLType
  update(infoFields: [CustomerInfoFieldGQLInputType]!): ResultGQLType
}

Integration Mutations

type IntegrationMutations {
  update(integration: SiteIntegrationGQLInputType!): ResultGQLType
}

Invoice Mutations

type InvoiceMutations {
  createFromDraft(invoiceFromDraft: InvoiceFromDraftGQLInputType!): ResultGQLType_String
  discounts: DiscountsMutations
  markAsPaid(sitePaymentMethodId: String!): ResultGQLType
  narrative: InvoiceNarrativeMutations
  pushTo(category: String): ResultGQLType
  requestPaymentUsing(paymentMethodId: String): ResultGQLType
  sendPaymentLink: ResultGQLType
  void: ResultGQLType
}

Invoices Mutations

type InvoicesMutations {
  create(invoice: InvoiceGQLInputType!): ResultGQLType
}

Invoice Narrative Mutations

type InvoiceNarrativeMutations {
  update(comments: String, footer: String, header: String): ResultGQLType
}

One-Time Payment Mutations

type OneTimePaymentMutations {
  update(oneTimePayment: OneTimePaymentGQLInputType!): ResultGQLType
}

One-Time Payments Mutations

type OneTimePaymentsMutations {
  create(oneTimePayment: OneTimePaymentGQLInputType!): ResultGQLType
}

Payment Method Mutations

type PaymentMethodMutations {
  makeDefault: ResultGQLType
  remove: ResultGQLType
}

Payment Methods Mutations

type PaymentMethodsMutations {
  add(paymentMethod: PaymentMethodGQLInputType!): ResultGQLType
}

Payment Schedule Mutations

type PaymentScheduleMutations {
  dunningProfile(dunningProfileId: String): PaymentScheduleDunningProfileMutations
  paymentMethod(paymentMethod: PaymentMethodGQLInputType): PaymentSchedulePaymentMethodMutations
  scheduledPayment(scheduledPaymentId: String!): ScheduledPaymentMutations
  scheduledPaymentList(ids: [String!]!): ScheduledPaymentListMutations
  scheduledPayments: ScheduledPaymentsMutations
  update(paymentSchedule: PaymentScheduleGQLInputType!): ResultGQLType_PaymentSchedule
}

Payment Schedules Mutations

type PaymentSchedulesMutations {
  create(paymentSchedule: PaymentScheduleGQLInputType!, requestNewPaymentMethod: Boolean): ResultGQLType_PaymentSchedule
  createFromTemplate(paymentScheduleFromTemplate: PaymentScheduleFromTemplateGQLInputType!): ResultGQLType_PaymentSchedule
}

Payment Schedule Payment Method Mutations

type PaymentSchedulePaymentMethodMutations {
  remove: ResultGQLType
  updateTo: ResultGQLType
}

Payment Schedule Template Mutations

type PaymentScheduleTemplateMutations {
  delete: ResultGQLType
  update(paymentScheduleTemplate: PaymentScheduleTemplateGQLInputType!): ResultGQLType
}

Payment Schedule Templates Mutations

type PaymentScheduleTemplatesMutations {
  create(paymentScheduleTemplate: PaymentScheduleTemplateGQLInputType!): ResultGQLType
}

Payment Schedule Dunning Profile Mutations

type PaymentScheduleDunningProfileMutations {
  remove: ResultGQLType
  updateTo: ResultGQLType
}

Plan Mutations

type PlanMutations {
  copy: ResultGQLType_Plan
  delete: ResultGQLType
  update(plan: PlanGQLInputType!): ResultGQLType
}

Plans Mutations

type PlansMutations {
  create(plan: PlanGQLInputType!): ResultGQLType
}

Scheduled Payment List Mutations

type ScheduledPaymentListMutations {
  delete: ResultGQLType
  markAsPaid: ResultGQLType
}

Scheduled Payment Mutations

type ScheduledPaymentMutations {
  delete: ResultGQLType
  markAsPaid: ResultGQLType
  update(scheduledPayment: ScheduledPaymentGQLInputType!): ResultGQLType
}

Scheduled Payments Mutations

type ScheduledPaymentsMutations {
  create(scheduledPayment: ScheduledPaymentGQLInputType!): ResultGQLType
}

Setting Mutations

type SettingMutations {
  update(setting: SettingGQLInputType!): ResultGQLType
}

Site Payment Provider Mutations

type SitePaymentProviderMutations {
  update(sitePaymentProvider: SitePaymentProviderGQLInputType!): ResultGQLType
}

Subscription Event Mutations

type SubscriptionEventMutations {
  update(event: SubscriptionEventGQLInputType!): ResultGQLType
}

Subscription Events Mutations

type SubscriptionEventsMutations {
  add(event: SubscriptionEventGQLInputType!): ResultGQLType
  delete(id: Guid!): ResultGQLType
}

Webhook Secret Mutations

type WebhookSecretMutations {
  regenerate: ResultGQLType_String
}

Querying Types

Action On Due Invoice Due

enum ActionOnDueInvoiceDueGQLType {
  Cancel
  DoNothing
  Suspend
}

Action On Term End

enum ActionOnTermEndGQLType {
  Ask
  Cancel
  Renew
}

Active Status

enum ActiveStatusGQLType {
  Active
  Inactive
}

Billing Cycle Model

enum BillingCycleModel
{
    StartImmediately
    FixedBillingCycleWithFutureStart
    FixedBillingCycleStartsImmediately
}

Billing Mode

enum BillingModelGQLType {
  PostPaid
  PrePaid
}

Billing Type

enum BillingTypeGQLType {
  OneTime
  Recurring
}

Change Mode

enum ChangeMode
{
    MaintainBillingCycle
    ShiftBillingCycle
}

Coupon Type

enum CouponTypeGQLType {
  FixedAmount
  Percentage
}

Definition Type

enum DefinitionTypeGQLType {
  FixedAmount
  Percentage
}

Delay Type

enum DelayTypeGQLType {
  After
  None
  SpecificDate
  SpecificDay
}

Dunning Fail Action

enum DunningFailActionGQLType {
  Cancel
  DoNothing
}

Interval Unit

enum IntervalUnitGQLType {
  Day
  Hour
  Minute
  Month
  Quarter
  Week
  Year
}

Invoice Status

enum InvoiceStatusGQLType {
  Open
  OverDue
  Paid
  PartiallyPaid
  PartiallyRefunded
  Processing
  Refunded
  Unknown
  Void
  Voiding
}

Message Type

enum MessageTypeGQLType {
  Template
  Text
}

Operator

enum OperatorGQLType {
  And
  Contains
  EndsWith
  Equal
  GreaterThan
  GreaterThanOrEqual
  In
  LessThan
  LessThanOrEqual
  NotNull
  Or
  StartsWith
}

Plan Subscription Coupon Code Status

enum PlanSubscriptionCouponCodeStatusGQLType {
  Active
  Expired
}

Transaction Status

enum TransactionStatusGQLType {
  Authorized
  Captured
  Failed
  Pending
  Refunded
}

Payment Schedule Invoicing Type

enum PaymentScheduleInvoicingGQLType {
  InvoicePerPayment
  NoInvoice
  SingleInvoice
}

Payment Schedule Status

enum PaymentScheduleStatusGQLType {
  Accepted
  NotAccepted
}

Payment Method Type

enum PaymentMethodTypeGQLType {
  Card
  Cash
  Cheque
  DirectDebit
  POS
  PayPal
  Sepa
  Souhoola
  Sympl
  Transfer
  Valu
  Wallet
}

Pricing Model

enum PricingModelGQLType {
  Fixed
  Free
  PerUnit
  Variable
}

enum RelatedEntityGQLType {
  AddonsSubscriptions
  BillingCycle
  CheckoutSession
  DraftInvoice
  Invoice
  OneTimePayment
  PaymentSchedule
  PlanSubscription
  ScheduledPayment
}

Rule Operation

enum RuleOperationGQLType {
  AlwaysFalse
  AlwaysTrue
  And
  ContainsAll
  ContainsAny
  DoesNotContainAll
  DoesNotContainAny
  Equal
  GreaterThan
  GreaterThanOrEqual
  In
  Key
  LessThan
  LessThanOrEqual
  NotEqual
  NotIn
  Or
  Value
}

Schedule Payment Status

enum SchedulePaymentStatusGQLType {
  Cancelled
  Failed
  NotPaid
  Overdue
  Paid
  PartiallyPaid
  Processing
  Rejected
}

input ScheduledPaymentGQLInputType {
  amount: Decimal
  data: String
  date: DateTime
  id: String
  name: String!
  paymentScheduleId: String
  reference: String
  status: SchedulePaymentStatusGQLType
}

Sorting Direction

enum SortingDirectionGQLType {
  Ascending
  Descending
}

Specific Day

enum SpecificDayGQLType {
  Friday
  Monday
  Saturday
  Sunday
  Tuesday
  Wednesday
}

Subscription Status

enum SubscriptionStatusGQLType {
  Activating
  Active
  Cancelled
  Cancelling
  FutureStartDate
  InTrial
  Changed
  Changing
  NoSubscription
  NonRenewing
  Paused
  Pausing
  Suspended
}

Value Type

enum ValueTypeGQLType {
  DateTime
  List
  None
  Number
  Object
  Text
}

Variable Pricing Type

enum VariablePricingTypeGQLType {
  StairStep
  Tiered
  Volume
}

Api And WebhooksGraphQL Schema V1 (Deprecated)

ReportsGetting Started