abowire/dist/gen/graphql.d.ts

This is the official **Abowire Javascript SDK**, which makes it easy to connect to the Abowire **GraphQL API** and includes all the required dependencies you need.

import { TypedDocumentNode as DocumentNode } from '@graphql-typed-document-node/core';
export type Maybe<T> = T | null;
export type InputMaybe<T> = Maybe<T>;
export type Exact<T extends {
    [key: string]: unknown;
}> = {
    [K in keyof T]: T[K];
};
export type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
    [SubKey in K]?: Maybe<T[SubKey]>;
};
export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
    [SubKey in K]: Maybe<T[SubKey]>;
};
export type Scalars = {
    ID: string;
    String: string;
    Boolean: boolean;
    Int: number;
    Float: number;
    Any: any;
    Currency: any;
    Date: any;
    JSON: any;
    Void: any;
};
export type AcceptMemberInviteInput = {
    accountId: Scalars['ID'];
    userId: Scalars['ID'];
};
export type Account = {
    __typename?: 'Account';
    billing?: Maybe<Billing>;
    capabilities: AccountCapabilities;
    createdAt?: Maybe<Scalars['Date']>;
    id: Scalars['ID'];
    isProduction?: Maybe<Scalars['Boolean']>;
    metadata?: Maybe<Scalars['JSON']>;
    name: Scalars['String'];
    settings: AccountSettings;
    updatedAt?: Maybe<Scalars['Date']>;
};
export type AccountAnalyticsSettings = {
    __typename?: 'AccountAnalyticsSettings';
    dashboardId?: Maybe<Scalars['String']>;
    isAvailableInGlobalDashboard?: Maybe<Scalars['Boolean']>;
};
export type AccountBillingSettings = {
    __typename?: 'AccountBillingSettings';
    customTaxRate?: Maybe<CustomTaxRate>;
    footerText?: Maybe<Scalars['String']>;
    invoiceFormat?: Maybe<AccountBillingSettingsInvoiceFormat>;
    logoUrl?: Maybe<Scalars['String']>;
    numberingFormat?: Maybe<AccountBillingSettingsNumberingFormat>;
    taxSchemes?: Maybe<Array<Scalars['String']>>;
};
export type AccountBillingSettingsInput = {
    customTaxRate?: InputMaybe<CustomTaxRateInput>;
    footerText?: InputMaybe<Scalars['String']>;
    invoiceFormat?: InputMaybe<AccountBillingSettingsInvoiceFormatInput>;
    logoUrl?: InputMaybe<Scalars['String']>;
    numberingFormat?: InputMaybe<AccountBillingSettingsNumberingFormatInput>;
    taxSchemes?: InputMaybe<Array<Scalars['String']>>;
};
export type AccountBillingSettingsInvoiceFormat = {
    __typename?: 'AccountBillingSettingsInvoiceFormat';
    default: InvoiceFormat;
    rules?: Maybe<Array<AccountBillingSettingsInvoiceFormatCountryRule>>;
};
export type AccountBillingSettingsInvoiceFormatCountryRule = {
    __typename?: 'AccountBillingSettingsInvoiceFormatCountryRule';
    countryCode: Scalars['String'];
    format: InvoiceFormat;
};
export type AccountBillingSettingsInvoiceFormatCountryRuleInput = {
    countryCode: Scalars['String'];
    format: InvoiceFormat;
};
export type AccountBillingSettingsInvoiceFormatInput = {
    default: InvoiceFormat;
    rules?: InputMaybe<Array<AccountBillingSettingsInvoiceFormatCountryRuleInput>>;
};
export type AccountBillingSettingsNumberingFormat = {
    __typename?: 'AccountBillingSettingsNumberingFormat';
    creditNote?: Maybe<Scalars['String']>;
    invoice?: Maybe<Scalars['String']>;
};
export type AccountBillingSettingsNumberingFormatInput = {
    creditNote?: InputMaybe<Scalars['String']>;
    invoice?: InputMaybe<Scalars['String']>;
};
export type AccountCapabilities = {
    __typename?: 'AccountCapabilities';
    canBill?: Maybe<Scalars['Boolean']>;
    canCreateApps?: Maybe<Scalars['Boolean']>;
    canCreateCustomDomains?: Maybe<Scalars['Boolean']>;
    canCustomizeFields?: Maybe<Scalars['Boolean']>;
    canInviteMembers?: Maybe<Scalars['Boolean']>;
    canManageLicenses?: Maybe<Scalars['Boolean']>;
    hasAnalytics?: Maybe<Scalars['Boolean']>;
    hasCancellationNotice?: Maybe<Scalars['Boolean']>;
    hasCheckout?: Maybe<Scalars['Boolean']>;
    hasCustomerPortal?: Maybe<Scalars['Boolean']>;
    hasIntegrations?: Maybe<Scalars['Boolean']>;
};
export type AccountDomainConfigSettings = {
    __typename?: 'AccountDomainConfigSettings';
    hostname: Scalars['String'];
    isVerified: Scalars['Boolean'];
    verificationRecord: AccountDomainConfigVerificationSettings;
};
export type AccountDomainConfigVerificationSettings = {
    __typename?: 'AccountDomainConfigVerificationSettings';
    name: Scalars['String'];
    type: Scalars['String'];
    value: Scalars['String'];
};
export type AccountDomainSettings = {
    __typename?: 'AccountDomainSettings';
    config?: Maybe<AccountDomainConfigSettings>;
    name: Scalars['String'];
};
export type AccountList = {
    __typename?: 'AccountList';
    count: Scalars['Int'];
    cursor?: Maybe<Scalars['String']>;
    items: Array<Maybe<Account>>;
    total: Scalars['Int'];
};
export type AccountMetadataField = {
    __typename?: 'AccountMetadataField';
    default?: Maybe<Scalars['String']>;
    description: Scalars['String'];
    displayInCheckoutStep?: Maybe<Scalars['String']>;
    displayInInvoices?: Maybe<Scalars['Boolean']>;
    format?: Maybe<Scalars['String']>;
    isPersonalInformation?: Maybe<Scalars['Boolean']>;
    label?: Maybe<Scalars['String']>;
    name: Scalars['String'];
    options?: Maybe<Array<AccountMetadataOptionField>>;
    required: Scalars['Boolean'];
    type: Scalars['String'];
};
export type AccountMetadataFieldInput = {
    default?: InputMaybe<Scalars['String']>;
    description: Scalars['String'];
    displayInCheckoutStep?: InputMaybe<Scalars['String']>;
    displayInInvoices?: InputMaybe<Scalars['Boolean']>;
    format?: InputMaybe<Scalars['String']>;
    isPersonalInformation?: InputMaybe<Scalars['Boolean']>;
    label?: InputMaybe<Scalars['String']>;
    name: Scalars['String'];
    options?: InputMaybe<Array<AccountMetadataOptionFieldInput>>;
    required: Scalars['Boolean'];
    type: Scalars['String'];
};
export type AccountMetadataOptionField = {
    __typename?: 'AccountMetadataOptionField';
    label: Scalars['String'];
    value: Scalars['String'];
};
export type AccountMetadataOptionFieldInput = {
    label: Scalars['String'];
    value: Scalars['String'];
};
export type AccountMetadataSettings = {
    __typename?: 'AccountMetadataSettings';
    billingProfile?: Maybe<Array<AccountMetadataField>>;
    creditNote?: Maybe<Array<AccountMetadataField>>;
    customer?: Maybe<Array<AccountMetadataField>>;
    invoice?: Maybe<Array<AccountMetadataField>>;
    license?: Maybe<Array<AccountMetadataField>>;
    licenseUser?: Maybe<Array<AccountMetadataField>>;
    person?: Maybe<Array<AccountMetadataField>>;
    product?: Maybe<Array<AccountMetadataField>>;
    subscription?: Maybe<Array<AccountMetadataField>>;
    transaction?: Maybe<Array<AccountMetadataField>>;
};
export type AccountMetadataSettingsInput = {
    billingProfile?: InputMaybe<Array<AccountMetadataFieldInput>>;
    creditNote?: InputMaybe<Array<AccountMetadataFieldInput>>;
    customer?: InputMaybe<Array<AccountMetadataFieldInput>>;
    invoice?: InputMaybe<Array<AccountMetadataFieldInput>>;
    license?: InputMaybe<Array<AccountMetadataFieldInput>>;
    licenseUser?: InputMaybe<Array<AccountMetadataFieldInput>>;
    person?: InputMaybe<Array<AccountMetadataFieldInput>>;
    product?: InputMaybe<Array<AccountMetadataFieldInput>>;
    subscription?: InputMaybe<Array<AccountMetadataFieldInput>>;
    transaction?: InputMaybe<Array<AccountMetadataFieldInput>>;
};
export type AccountPaymentMethodSettings = {
    __typename?: 'AccountPaymentMethodSettings';
    isActive: Scalars['Boolean'];
    providerName: PaymentProviderName;
    type: PaymentMethodType;
};
export type AccountPaymentMethodSettingsInput = {
    isActive?: InputMaybe<Scalars['Boolean']>;
    providerName: PaymentProviderName;
    type: PaymentMethodType;
};
export type AccountPaymentSettings = {
    __typename?: 'AccountPaymentSettings';
    paymentMethods?: Maybe<Array<AccountPaymentMethodSettings>>;
    providers?: Maybe<Array<PaymentProvider>>;
};
export type AccountPaymentSettingsInput = {
    paymentMethods?: InputMaybe<Array<AccountPaymentMethodSettingsInput>>;
};
export type AccountSettings = {
    __typename?: 'AccountSettings';
    analytics?: Maybe<AccountAnalyticsSettings>;
    billing: AccountBillingSettings;
    capabilities?: Maybe<Array<ProductCapabilitySettings>>;
    domain: AccountDomainSettings;
    metadata?: Maybe<AccountMetadataSettings>;
    payments?: Maybe<AccountPaymentSettings>;
    theme?: Maybe<AccountThemeSettings>;
};
export type AccountSettingsInput = {
    billing?: InputMaybe<AccountBillingSettingsInput>;
    capabilities?: InputMaybe<Array<ProductCapabilitySettingsInput>>;
    metadata?: InputMaybe<AccountMetadataSettingsInput>;
    payments?: InputMaybe<AccountPaymentSettingsInput>;
    theme?: InputMaybe<AccountThemeSettingsInput>;
};
export type AccountTheme = {
    __typename?: 'AccountTheme';
    logoUrl?: Maybe<Scalars['String']>;
};
export type AccountThemeSettings = {
    __typename?: 'AccountThemeSettings';
    dark?: Maybe<AccountTheme>;
    light?: Maybe<AccountTheme>;
};
export type AccountThemeSettingsInput = {
    dark?: InputMaybe<AccountThemesInput>;
    light?: InputMaybe<AccountThemesInput>;
};
export type AccountThemesInput = {
    logoUrl?: InputMaybe<Scalars['String']>;
};
export type ActivateLicenseInput = {
    code: Scalars['String'];
    metadata?: InputMaybe<Scalars['JSON']>;
    subscriptionId?: InputMaybe<Scalars['ID']>;
};
export type AddAccountDomainInput = {
    name: Scalars['String'];
};
export type AddDiscountCouponInput = {
    amount?: InputMaybe<Scalars['Int']>;
    codeLength?: InputMaybe<Scalars['Int']>;
    discountId: Scalars['ID'];
    prefix?: InputMaybe<Scalars['String']>;
};
export type AddPaymentMethodInput = {
    customerId: Scalars['ID'];
    externalId?: InputMaybe<Scalars['String']>;
    metadata?: InputMaybe<Scalars['JSON']>;
    providerName?: InputMaybe<PaymentProviderName>;
    type: PaymentMethodType;
};
export type AnalyticsSessionToken = {
    __typename?: 'AnalyticsSessionToken';
    dashboardId: Scalars['String'];
    token: Scalars['String'];
};
export type ApiClient = {
    __typename?: 'ApiClient';
    id: Scalars['ID'];
    redirectUrls?: Maybe<Array<Scalars['String']>>;
    scopes?: Maybe<Array<Scope>>;
    secret?: Maybe<Scalars['String']>;
    type: Scalars['String'];
};
export type App = {
    __typename?: 'App';
    accountIds?: Maybe<Array<Scalars['String']>>;
    apiClients: Array<ApiClient>;
    categories?: Maybe<Array<Scalars['String']>>;
    contactEmail?: Maybe<Scalars['String']>;
    createdAt?: Maybe<Scalars['Date']>;
    description?: Maybe<Scalars['String']>;
    id: Scalars['ID'];
    instances?: Maybe<AppInstanceList>;
    isInstalled: Scalars['Boolean'];
    isPublic: Scalars['Boolean'];
    logoUrl?: Maybe<Scalars['String']>;
    name: Scalars['String'];
    pageContent?: Maybe<Scalars['String']>;
    privacyUrl?: Maybe<Scalars['String']>;
    tosUrl?: Maybe<Scalars['String']>;
    updatedAt?: Maybe<Scalars['Date']>;
    webhooks: Webhook;
};
export type AppInstance = {
    __typename?: 'AppInstance';
    account: Account;
    app: PublicApp;
    createdAt: Scalars['Date'];
    id: Scalars['ID'];
};
export type AppInstanceList = {
    __typename?: 'AppInstanceList';
    count: Scalars['Int'];
    cursor?: Maybe<Scalars['String']>;
    items: Array<AppInstance>;
    total: Scalars['Int'];
};
export type AppList = {
    __typename?: 'AppList';
    count: Scalars['Int'];
    cursor?: Maybe<Scalars['String']>;
    items: Array<App>;
    total: Scalars['Int'];
};
export type Bank = {
    __typename?: 'Bank';
    id: Scalars['String'];
    logo: Scalars['String'];
    name: Scalars['String'];
};
export type BankAccount = {
    __typename?: 'BankAccount';
    currency: Scalars['String'];
    iban: Scalars['String'];
    name?: Maybe<Scalars['String']>;
    ownerName: Scalars['String'];
    transactions: Array<BankTransaction>;
};
export type BankAccountList = {
    __typename?: 'BankAccountList';
    count: Scalars['Int'];
    cursor?: Maybe<Scalars['String']>;
    items: Array<BankAccount>;
    total: Scalars['Int'];
};
export type BankList = {
    __typename?: 'BankList';
    count: Scalars['Int'];
    cursor?: Maybe<Scalars['String']>;
    items: Array<Bank>;
    total: Scalars['Int'];
};
export type BankTransaction = {
    __typename?: 'BankTransaction';
    account: BankAccount;
    amount: Scalars['String'];
    bookedAt: Scalars['String'];
    currency: Scalars['String'];
    debtor: Scalars['String'];
    description: Scalars['String'];
    iban?: Maybe<Scalars['String']>;
    id: Scalars['String'];
    ignoreDebtor?: Maybe<Scalars['Boolean']>;
    status: BankTransactionStatus;
    transaction?: Maybe<Transaction>;
};
export type BankTransactionList = {
    __typename?: 'BankTransactionList';
    count: Scalars['Int'];
    cursor?: Maybe<Scalars['String']>;
    items: Array<BankTransaction>;
    total: Scalars['Int'];
};
export declare enum BankTransactionStatus {
    Ignored = "IGNORED",
    Matched = "MATCHED",
    NotMatched = "NOT_MATCHED"
}
export type BankTransactionSync = {
    __typename?: 'BankTransactionSync';
    status: Scalars['String'];
};
export type Billing = {
    __typename?: 'Billing';
    address: Scalars['String'];
    address2?: Maybe<Scalars['String']>;
    city: Scalars['String'];
    companyName?: Maybe<Scalars['String']>;
    contactPerson?: Maybe<Person>;
    countryCode: Scalars['String'];
    invoiceFormat?: Maybe<InvoiceFormat>;
    metadata?: Maybe<Scalars['JSON']>;
    postalCode: Scalars['String'];
    street?: Maybe<Scalars['String']>;
    streetNumber?: Maybe<Scalars['String']>;
    taxIds?: Maybe<Array<TaxId>>;
};
export type BillingInput = {
    address?: InputMaybe<Scalars['String']>;
    address2?: InputMaybe<Scalars['String']>;
    city: Scalars['String'];
    companyName?: InputMaybe<Scalars['String']>;
    contactPerson?: InputMaybe<PersonInput>;
    countryCode: Scalars['String'];
    invoiceFormat?: InputMaybe<InvoiceFormat>;
    metadata?: InputMaybe<Scalars['JSON']>;
    postalCode: Scalars['String'];
    street?: InputMaybe<Scalars['String']>;
    streetNumber?: InputMaybe<Scalars['String']>;
    taxIds?: InputMaybe<Array<TaxIdInput>>;
};
export declare enum BillingTerms {
    EndOfPeriod = "END_OF_PERIOD",
    StartOfPeriod = "START_OF_PERIOD"
}
export type CancelSubscriptionInput = {
    applyCancellationNow?: InputMaybe<Scalars['Boolean']>;
};
export type CreateAccountInput = {
    billing?: InputMaybe<BillingInput>;
    isProduction?: InputMaybe<Scalars['Boolean']>;
    metadata?: InputMaybe<Scalars['JSON']>;
    name: Scalars['String'];
    settings?: InputMaybe<AccountSettingsInput>;
};
export type CreateApiClientInput = {
    redirectUrls?: InputMaybe<Array<Scalars['String']>>;
    scopes?: InputMaybe<Array<Scope>>;
    type: Scalars['String'];
};
export type CreateAppInput = {
    name: Scalars['String'];
};
export type CreateCreditNoteInput = {
    amount: Scalars['Float'];
    applyRefund?: InputMaybe<Scalars['Boolean']>;
    customerId: Scalars['ID'];
    description: Scalars['String'];
    invoiceId: Scalars['ID'];
    metadata?: InputMaybe<Scalars['JSON']>;
};
export type CreateCustomerInput = {
    billing?: InputMaybe<BillingInput>;
    currency?: InputMaybe<Scalars['Currency']>;
    locale?: InputMaybe<Scalars['String']>;
    metadata?: InputMaybe<Scalars['JSON']>;
    name: Scalars['String'];
    paymentMethod?: InputMaybe<UpdatePaymentMethodInput>;
    people?: InputMaybe<Array<PersonInput>>;
};
export type CreateCustomerSessionInput = {
    couponCode?: InputMaybe<Scalars['String']>;
    customer?: InputMaybe<CreateCustomerInput>;
    customerId?: InputMaybe<Scalars['ID']>;
    productId?: InputMaybe<Scalars['ID']>;
    subscriptionId?: InputMaybe<Scalars['ID']>;
    usage?: InputMaybe<Array<SubscriptionUsageInput>>;
};
export type CreateDiscountInput = {
    amount: Scalars['Float'];
    currency?: InputMaybe<Scalars['Currency']>;
    expirationDate?: InputMaybe<Scalars['Date']>;
    isActive?: InputMaybe<Scalars['Boolean']>;
    maxPeriods?: InputMaybe<Scalars['Int']>;
    metadata?: InputMaybe<Scalars['JSON']>;
    name: Scalars['String'];
    type: DiscountType;
};
export type CreateInvoiceInput = {
    autoCollectPayment?: InputMaybe<Scalars['Boolean']>;
    billingPeriodEnd: Scalars['Date'];
    billingPeriodStart: Scalars['Date'];
    currency?: InputMaybe<Scalars['Currency']>;
    customerId: Scalars['ID'];
    discountCode?: InputMaybe<Scalars['String']>;
    dueDate: Scalars['Date'];
    items: Array<InvoiceItemInput>;
    locale?: InputMaybe<Scalars['String']>;
    metadata?: InputMaybe<Scalars['JSON']>;
    paymentTermDays?: InputMaybe<Scalars['Int']>;
};
export type CreateLicenseInput = {
    licenseUserId?: InputMaybe<Scalars['ID']>;
    metadata?: InputMaybe<Scalars['JSON']>;
    status?: InputMaybe<LicenseStatusInput>;
    subscriptionId: Scalars['ID'];
    units?: InputMaybe<Array<Scalars['String']>>;
};
export type CreateLicenseUserInput = {
    customerId: Scalars['ID'];
    metadata?: InputMaybe<Scalars['JSON']>;
    name: Scalars['String'];
};
export type CreateProductInput = {
    addons?: InputMaybe<Array<Scalars['String']>>;
    canDowngradeTo?: InputMaybe<Array<Scalars['String']>>;
    canUpgradeTo?: InputMaybe<Array<Scalars['String']>>;
    capabilities?: InputMaybe<Array<ProductCapabilityInput>>;
    currency?: InputMaybe<Scalars['Currency']>;
    isActive?: InputMaybe<Scalars['Boolean']>;
    licensing?: InputMaybe<LicensingInput>;
    metadata?: InputMaybe<Scalars['JSON']>;
    name: Scalars['String'];
    nextProductId?: InputMaybe<Scalars['String']>;
    plan?: InputMaybe<PlanInput>;
    pricing?: InputMaybe<Array<PricingInput>>;
    sku: Scalars['String'];
    taxRateCode?: InputMaybe<TaxRateCode>;
};
export type CreateSubscriptionInput = {
    couponCode?: InputMaybe<Scalars['String']>;
    customerId: Scalars['ID'];
    endDate?: InputMaybe<Scalars['Date']>;
    freeTrialEndDate?: InputMaybe<Scalars['Date']>;
    freeTrialStartDate?: InputMaybe<Scalars['Date']>;
    isActive?: InputMaybe<Scalars['Boolean']>;
    metadata?: InputMaybe<Scalars['JSON']>;
    productId: Scalars['ID'];
    startDate?: InputMaybe<Scalars['Date']>;
    usage?: InputMaybe<Array<SubscriptionUsageInput>>;
};
export type CreateTransactionInput = {
    amount: Scalars['Float'];
    creditNoteId?: InputMaybe<Scalars['ID']>;
    currency: Scalars['Currency'];
    invoiceId?: InputMaybe<Scalars['ID']>;
    metadata?: InputMaybe<Scalars['JSON']>;
    paymentMethodType: PaymentMethodType;
    reference?: InputMaybe<Scalars['String']>;
    type: TransactionType;
};
export type CreateWebhookInput = {
    endpoint: Scalars['String'];
    events: Array<Scalars['String']>;
    headers?: InputMaybe<Scalars['JSON']>;
};
export type CreditNote = {
    __typename?: 'CreditNote';
    createdAt?: Maybe<Scalars['Date']>;
    customer: Customer;
    file: Scalars['String'];
    fileFormat: InvoiceFormat;
    id: Scalars['ID'];
    invoice: InvoiceListItem;
    items: Array<CreditNoteItem>;
    metadata?: Maybe<Scalars['JSON']>;
    number: Scalars['String'];
    pdfFile?: Maybe<Scalars['String']>;
    subtotal: Scalars['Float'];
    taxes?: Maybe<Array<CreditNoteTaxItem>>;
    total: Scalars['Float'];
    transactions: TransactionList;
    updatedAt?: Maybe<Scalars['Date']>;
};
export type CreditNoteDiscount = {
    __typename?: 'CreditNoteDiscount';
    amount: Scalars['Float'];
    description: Scalars['String'];
};
export type CreditNoteExport = {
    __typename?: 'CreditNoteExport';
    content: Scalars['String'];
};
export type CreditNoteExportInput = {
    ids: Array<Scalars['ID']>;
};
export type CreditNoteItem = {
    __typename?: 'CreditNoteItem';
    description: Scalars['String'];
    price: Scalars['Float'];
    quantity: Scalars['Float'];
    unitPrice: Scalars['Float'];
};
export type CreditNoteList = {
    __typename?: 'CreditNoteList';
    count: Scalars['Int'];
    cursor?: Maybe<Scalars['String']>;
    items: Array<CreditNoteListItem>;
    total: Scalars['Int'];
};
export type CreditNoteListItem = {
    __typename?: 'CreditNoteListItem';
    createdAt?: Maybe<Scalars['Date']>;
    customer: Customer;
    id: Scalars['ID'];
    invoice: InvoiceListItem;
    items: Array<CreditNoteItem>;
    metadata?: Maybe<Scalars['JSON']>;
    number: Scalars['String'];
    subtotal: Scalars['Float'];
    taxes?: Maybe<Array<CreditNoteTaxItem>>;
    total: Scalars['Float'];
    transactions: TransactionList;
    updatedAt?: Maybe<Scalars['Date']>;
};
export type CreditNotePreview = {
    __typename?: 'CreditNotePreview';
    content: Scalars['String'];
};
export type CreditNoteTaxItem = {
    __typename?: 'CreditNoteTaxItem';
    amount: Scalars['Float'];
    description: Scalars['String'];
    rate: Scalars['Float'];
};
export type CustomTaxRate = {
    __typename?: 'CustomTaxRate';
    code: Scalars['String'];
    description: Scalars['String'];
    rate: Scalars['Float'];
};
export type CustomTaxRateInput = {
    code: Scalars['String'];
    description: Scalars['String'];
    rate: Scalars['Float'];
};
export type Customer = {
    __typename?: 'Customer';
    billing?: Maybe<Billing>;
    capabilities?: Maybe<Array<ProductCapability>>;
    createdAt?: Maybe<Scalars['Date']>;
    creditNotes: CreditNoteList;
    currency?: Maybe<Scalars['Currency']>;
    discountCoupons: DiscountCouponList;
    id: Scalars['ID'];
    invoices: InvoiceList;
    licenseUsers: LicenseUserList;
    locale?: Maybe<Scalars['String']>;
    metadata?: Maybe<Scalars['JSON']>;
    name: Scalars['String'];
    paymentMethod?: Maybe<PaymentMethod>;
    people?: Maybe<Array<Person>>;
    subscriptions: SubscriptionList;
    transactions: TransactionList;
    updatedAt?: Maybe<Scalars['Date']>;
};
export type CustomerCreditNotesArgs = {
    filters?: InputMaybe<FilterInput>;
};
export type CustomerDiscountCouponsArgs = {
    filters?: InputMaybe<FilterInput>;
};
export type CustomerInvoicesArgs = {
    filters?: InputMaybe<FilterInput>;
};
export type CustomerLicenseUsersArgs = {
    filters?: InputMaybe<FilterInput>;
};
export type CustomerSubscriptionsArgs = {
    filters?: InputMaybe<FilterInput>;
};
export type CustomerTransactionsArgs = {
    filters?: InputMaybe<FilterInput>;
};
export type CustomerList = {
    __typename?: 'CustomerList';
    count: Scalars['Int'];
    cursor?: Maybe<Scalars['String']>;
    items: Array<Customer>;
    total: Scalars['Int'];
};
export type CustomerSession = {
    __typename?: 'CustomerSession';
    customer?: Maybe<Customer>;
    estimation?: Maybe<PriceEstimation>;
    fields?: Maybe<Array<AccountMetadataField>>;
    id: Scalars['ID'];
    payment?: Maybe<PaymentSession>;
    product?: Maybe<Product>;
    subscription?: Maybe<Subscription>;
};
export type CustomerSessionProduct = {
    __typename?: 'CustomerSessionProduct';
    canDowngradeTo: CustomerSessionProductList;
    canUpgradeTo: CustomerSessionProductList;
    currency: Scalars['Currency'];
    id: Scalars['ID'];
    name: Scalars['String'];
    nextProduct?: Maybe<CustomerSessionProduct>;
    plan: Plan;
    pricing: Array<Pricing>;
    sku: Scalars['String'];
};
export type CustomerSessionProductList = {
    __typename?: 'CustomerSessionProductList';
    count: Scalars['Int'];
    cursor?: Maybe<Scalars['String']>;
    items: Array<CustomerSessionProduct>;
    total: Scalars['Int'];
};
export type Discount = {
    __typename?: 'Discount';
    amount: Scalars['Float'];
    coupons: DiscountCouponList;
    createdAt?: Maybe<Scalars['Date']>;
    currency?: Maybe<Scalars['Currency']>;
    expirationDate?: Maybe<Scalars['Date']>;
    id: Scalars['ID'];
    isActive?: Maybe<Scalars['Boolean']>;
    maxPeriods?: Maybe<Scalars['Int']>;
    metadata?: Maybe<Scalars['JSON']>;
    name: Scalars['String'];
    type: DiscountType;
    updatedAt?: Maybe<Scalars['Date']>;
};
export type DiscountCoupon = {
    __typename?: 'DiscountCoupon';
    code: Scalars['String'];
    createdAt?: Maybe<Scalars['Date']>;
    discount: Discount;
    id: Scalars['ID'];
    periodsLeft?: Maybe<Scalars['Int']>;
    redemptionDate?: Maybe<Scalars['Date']>;
    subscription?: Maybe<Subscription>;
    updatedAt?: Maybe<Scalars['Date']>;
};
export type DiscountCouponList = {
    __typename?: 'DiscountCouponList';
    count: Scalars['Int'];
    cursor?: Maybe<Scalars['String']>;
    items: Array<DiscountCoupon>;
    total: Scalars['Int'];
};
export type DiscountList = {
    __typename?: 'DiscountList';
    count: Scalars['Int'];
    cursor?: Maybe<Scalars['String']>;
    items: Array<Discount>;
    total: Scalars['Int'];
};
export declare enum DiscountType {
    Fixed = "FIXED",
    Percentage = "PERCENTAGE"
}
export type DowngradeSubscriptionInput = {
    applyProratedChargesNow?: InputMaybe<Scalars['Boolean']>;
    productId: Scalars['ID'];
};
export declare enum EndReason {
    Cancelled = "CANCELLED",
    Downgraded = "DOWNGRADED",
    Expired = "EXPIRED",
    Upgraded = "UPGRADED"
}
export type Event = {
    __typename?: 'Event';
    content?: Maybe<Scalars['JSON']>;
    createdAt?: Maybe<Scalars['Date']>;
    eventName: Scalars['String'];
    eventSource: Scalars['String'];
    expiresAt?: Maybe<Scalars['Date']>;
    id: Scalars['ID'];
    previousContent?: Maybe<Scalars['JSON']>;
};
export type EventList = {
    __typename?: 'EventList';
    count: Scalars['Int'];
    cursor?: Maybe<Scalars['String']>;
    items: Array<Event>;
    total: Scalars['Int'];
};
export type FilterInput = {
    cursor?: InputMaybe<Scalars['String']>;
    filters?: InputMaybe<Scalars['JSON']>;
    keywords?: InputMaybe<Scalars['String']>;
    limit?: InputMaybe<Scalars['Int']>;
    sort?: InputMaybe<SortOrder>;
};
export type GetUploadUrlInput = {
    fileName: Scalars['String'];
    metadata?: InputMaybe<Scalars['JSON']>;
    type: UploadType;
};
export type InstallAppInput = {
    config?: InputMaybe<Scalars['JSON']>;
};
export type InviteMemberInput = {
    customerId?: InputMaybe<Scalars['ID']>;
    email: Scalars['String'];
    role: MemberRole;
};
export type Invoice = {
    __typename?: 'Invoice';
    billingPeriodEnd: Scalars['Date'];
    billingPeriodStart: Scalars['Date'];
    buyer: Billing;
    createdAt?: Maybe<Scalars['Date']>;
    creditNotes: CreditNoteList;
    currency: Scalars['Currency'];
    customer: Customer;
    discount?: Maybe<InvoiceDiscount>;
    dueDate: Scalars['Date'];
    file: Scalars['String'];
    fileFormat: InvoiceFormat;
    id: Scalars['ID'];
    items: Array<InvoiceItem>;
    locale?: Maybe<Scalars['String']>;
    metadata?: Maybe<Scalars['JSON']>;
    number: Scalars['String'];
    paymentDate?: Maybe<Scalars['Date']>;
    paymentTermDays?: Maybe<Scalars['Int']>;
    pdfFile?: Maybe<Scalars['String']>;
    seller: Billing;
    subscription?: Maybe<Subscription>;
    subtotal: Scalars['Float'];
    taxes?: Maybe<Array<InvoiceTaxItem>>;
    total: Scalars['Float'];
    transactions: TransactionList;
    updatedAt?: Maybe<Scalars['Date']>;
};
export type InvoiceDiscount = {
    __typename?: 'InvoiceDiscount';
    amount: Scalars['Float'];
    description: Scalars['String'];
};
export type InvoiceExport = {
    __typename?: 'InvoiceExport';
    content: Scalars['String'];
};
export type InvoiceExportInput = {
    ids: Array<Scalars['ID']>;
};
export declare enum InvoiceFormat {
    Pdf = "PDF",
    Xrechnung = "XRECHNUNG",
    Zugferd = "ZUGFERD"
}
export type InvoiceItem = {
    __typename?: 'InvoiceItem';
    description: Scalars['String'];
    price: Scalars['Float'];
    quantity: Scalars['Float'];
    unitPrice: Scalars['Float'];
};
export type InvoiceItemInput = {
    description: Scalars['String'];
    price: Scalars['Float'];
    quantity: Scalars['Float'];
    unitPrice: Scalars['Float'];
};
export type InvoiceList = {
    __typename?: 'InvoiceList';
    count: Scalars['Int'];
    cursor?: Maybe<Scalars['String']>;
    items: Array<InvoiceListItem>;
    total: Scalars['Int'];
};
export type InvoiceListItem = {
    __typename?: 'InvoiceListItem';
    billingPeriodEnd: Scalars['Date'];
    billingPeriodStart: Scalars['Date'];
    buyer: Billing;
    createdAt?: Maybe<Scalars['Date']>;
    creditNotes: CreditNoteList;
    currency: Scalars['Currency'];
    customer: Customer;
    discount?: Maybe<InvoiceDiscount>;
    dueDate: Scalars['Date'];
    fileFormat: InvoiceFormat;
    id: Scalars['ID'];
    items: Array<InvoiceItem>;
    locale?: Maybe<Scalars['String']>;
    metadata?: Maybe<Scalars['JSON']>;
    number: Scalars['String'];
    paymentDate?: Maybe<Scalars['Date']>;
    paymentTermDays?: Maybe<Scalars['Int']>;
    seller: Billing;
    subscription?: Maybe<Subscription>;
    subtotal: Scalars['Float'];
    taxes?: Maybe<Array<InvoiceTaxItem>>;
    total: Scalars['Float'];
    transactions: TransactionList;
    updatedAt?: Maybe<Scalars['Date']>;
};
export type InvoicePreview = {
    __typename?: 'InvoicePreview';
    content: Scalars['String'];
};
export type InvoiceTaxItem = {
    __typename?: 'InvoiceTaxItem';
    amount: Scalars['Float'];
    description: Scalars['String'];
    rate: Scalars['Float'];
};
export type InvoiceTaxItemInput = {
    amount: Scalars['Float'];
    description: Scalars['String'];
    rate: Scalars['Float'];
};
export type License = {
    __typename?: 'License';
    activations?: Maybe<Scalars['Int']>;
    activationsLeft?: Maybe<Scalars['Int']>;
    code?: Maybe<Scalars['String']>;
    createdAt?: Maybe<Scalars['Date']>;
    customer: Customer;
    expirationDate?: Maybe<Scalars['Date']>;
    id: Scalars['ID'];
    licenseUser?: Maybe<LicenseUser>;
    metadata?: Maybe<Scalars['JSON']>;
    status: LicenseStatus;
    subscription: Subscription;
    units?: Maybe<Array<Scalars['String']>>;
    updatedAt?: Maybe<Scalars['Date']>;
};
export type LicenseList = {
    __typename?: 'LicenseList';
    count: Scalars['Int'];
    cursor?: Maybe<Scalars['String']>;
    items: Array<License>;
    total: Scalars['Int'];
};
export declare enum LicenseStatus {
    Active = "ACTIVE",
    Completed = "COMPLETED",
    Expired = "EXPIRED",
    Inactive = "INACTIVE",
    PendingCode = "PENDING_CODE",
    Unassigned = "UNASSIGNED"
}
export declare enum LicenseStatusInput {
    Active = "ACTIVE",
    Completed = "COMPLETED",
    Inactive = "INACTIVE"
}
export type LicenseUser = {
    __typename?: 'LicenseUser';
    createdAt?: Maybe<Scalars['Date']>;
    customer: Customer;
    id: Scalars['ID'];
    licenses: LicenseList;
    metadata?: Maybe<Scalars['JSON']>;
    name: Scalars['String'];
    updatedAt?: Maybe<Scalars['Date']>;
};
export type LicenseUserList = {
    __typename?: 'LicenseUserList';
    count: Scalars['Int'];
    cursor?: Maybe<Scalars['String']>;
    items: Array<LicenseUser>;
    total: Scalars['Int'];
};
export type Licensing = {
    __typename?: 'Licensing';
    codeLength?: Maybe<Scalars['Int']>;
    codeStrategy: LicensingCodeStrategy;
    expirationDate?: Maybe<Scalars['Date']>;
    isActive?: Maybe<Scalars['Boolean']>;
    maxActivations?: Maybe<Scalars['Int']>;
    maxDuration?: Maybe<Timeframe>;
};
export declare enum LicensingCodeStrategy {
    Alphanumeric = "ALPHANUMERIC",
    None = "NONE",
    Numeric = "NUMERIC"
}
export type LicensingInput = {
    codeLength?: InputMaybe<Scalars['Int']>;
    codeStrategy: LicensingCodeStrategy;
    expirationDate?: InputMaybe<Scalars['Date']>;
    isActive?: InputMaybe<Scalars['Boolean']>;
    maxActivations?: InputMaybe<Scalars['Int']>;
    maxDuration?: InputMaybe<TimeframeInput>;
};
export type Member = {
    __typename?: 'Member';
    account: Account;
    customer?: Maybe<Customer>;
    email?: Maybe<Scalars['String']>;
    id: Scalars['ID'];
    name: Scalars['String'];
    role: MemberRole;
};
export type MemberInvite = {
    __typename?: 'MemberInvite';
    customer?: Maybe<Customer>;
    email: Scalars['String'];
    role: MemberRole;
};
export type MemberInviteList = {
    __typename?: 'MemberInviteList';
    count: Scalars['Int'];
    cursor?: Maybe<Scalars['String']>;
    items: Array<MemberInvite>;
    total: Scalars['Int'];
};
export type MemberList = {
    __typename?: 'MemberList';
    count: Scalars['Int'];
    cursor?: Maybe<Scalars['String']>;
    items: Array<Member>;
    total: Scalars['Int'];
};
export declare enum MemberRole {
    Admin = "ADMIN",
    Customer = "CUSTOMER"
}
export type Mutation = {
    __typename?: 'Mutation';
    acceptMemberInvite: Member;
    activateLicense: License;
    addAccountDomain: AccountDomainSettings;
    addDiscountCoupon: Discount;
    addPaymentMethod: PaymentMethod;
    addPaymentProvider: PaymentProvider;
    cancelSubscription: Subscription;
    createAccount: Account;
    createAnalyticsSessionToken: AnalyticsSessionToken;
    createApp: App;
    createCreditNote: CreditNote;
    createCustomer: Customer;
    createCustomerSession: CustomerSession;
    createDiscount: Discount;
    createInvoice: Invoice;
    createLicense: License;
    createLicenseUser: LicenseUser;
    createProduct: Product;
    createSubscription: Subscription;
    createTransaction: Transaction;
    downgradeSubscription: Subscription;
    exportCreditNotes: CreditNoteExport;
    exportInvoices: InvoiceExport;
    getUploadUrl: UploadUrl;
    installApp: AppInstance;
    inviteMember: MemberInvite;
    redeemDiscountCoupon: Discount;
    removeAccountDomain: AccountDomainSettings;
    removeDiscountCoupon: Discount;
    removeLicenseUser: LicenseUser;
    removeMember: Member;
    removePaymentMethod: PaymentMethod;
    removePaymentProvider: PaymentProvider;
    removeTransaction: Transaction;
    requestBankTransactionSync: BankTransactionSync;
    uninstallApp: AppInstance;
    updateAccount: Account;
    updateApp: App;
    updateBankTransaction: BankTransaction;
    updateCreditNote: CreditNote;
    updateCustomer: Customer;
    updateCustomerSession: CustomerSession;
    updateDiscount: Discount;
    updateInvoice: Invoice;
    updateLicense: License;
    updateLicenseUser: LicenseUser;
    updatePaymentProvider: PaymentProvider;
    updateProduct: Product;
    updateSubscription: Subscription;
    updateUser: User;
    upgradeSubscription: Subscription;
};
export type MutationAcceptMemberInviteArgs = {
    id: Scalars['ID'];
    input: AcceptMemberInviteInput;
};
export type MutationActivateLicenseArgs = {
    input: ActivateLicenseInput;
};
export type MutationAddAccountDomainArgs = {
    input?: InputMaybe<AddAccountDomainInput>;
};
export type MutationAddDiscountCouponArgs = {
    input: AddDiscountCouponInput;
};
export type MutationAddPaymentMethodArgs = {
    input: AddPaymentMethodInput;
};
export type MutationAddPaymentProviderArgs = {
    input: PaymentProviderInput;
};
export type MutationCancelSubscriptionArgs = {
    id: Scalars['ID'];
    input: CancelSubscriptionInput;
};
export type MutationCreateAccountArgs = {
    input: CreateAccountInput;
};
export type MutationCreateAppArgs = {
    input: CreateAppInput;
};
export type MutationCreateCreditNoteArgs = {
    input: CreateCreditNoteInput;
};
export type MutationCreateCustomerArgs = {
    input: CreateCustomerInput;
};
export type MutationCreateCustomerSessionArgs = {
    input?: InputMaybe<CreateCustomerSessionInput>;
};
export type MutationCreateDiscountArgs = {
    input: CreateDiscountInput;
};
export type MutationCreateInvoiceArgs = {
    input: CreateInvoiceInput;
};
export type MutationCreateLicenseArgs = {
    input: CreateLicenseInput;
};
export type MutationCreateLicenseUserArgs = {
    input: CreateLicenseUserInput;
};
export type MutationCreateProductArgs = {
    input: CreateProductInput;
};
export type MutationCreateSubscriptionArgs = {
    input: CreateSubscriptionInput;
};
export type MutationCreateTransactionArgs = {
    input: CreateTransactionInput;
};
export type MutationDowngradeSubscriptionArgs = {
    id: Scalars['ID'];
    input: DowngradeSubscriptionInput;
};
export type MutationExportCreditNotesArgs = {
    input?: InputMaybe<CreditNoteExportInput>;
};
export type MutationExportInvoicesArgs = {
    input?: InputMaybe<InvoiceExportInput>;
};
export type MutationGetUploadUrlArgs = {
    input: GetUploadUrlInput;
};
export type MutationInstallAppArgs = {
    id: Scalars['ID'];
    input?: InputMaybe<InstallAppInput>;
};
export type MutationInviteMemberArgs = {
    input: InviteMemberInput;
};
export type MutationRedeemDiscountCouponArgs = {
    input: RedeemDiscountCouponInput;
};
export type MutationRemoveDiscountCouponArgs = {
    id: Scalars['ID'];
};
export type MutationRemoveLicenseUserArgs = {
    id: Scalars['ID'];
};
export type MutationRemoveMemberArgs = {
    id: Scalars['ID'];
};
export type MutationRemovePaymentMethodArgs = {
    input: RemovePaymentMethodInput;
};
export type MutationRemovePaymentProviderArgs = {
    name: PaymentProviderName;
};
export type MutationRemoveTransactionArgs = {
    id: Scalars['ID'];
};
export type MutationUninstallAppArgs = {
    id: Scalars['ID'];
};
export type MutationUpdateAccountArgs = {
    input: UpdateAccountInput;
};
export type MutationUpdateAppArgs = {
    id: Scalars['ID'];
    input: UpdateAppInput;
};
export type MutationUpdateBankTransactionArgs = {
    id: Scalars['ID'];
    input: UpdateBankTransactionInput;
};
export type MutationUpdateCreditNoteArgs = {
    id: Scalars['ID'];
    input: UpdateCreditNoteInput;
};
export type MutationUpdateCustomerArgs = {
    id: Scalars['ID'];
    input: UpdateCustomerInput;
};
export type MutationUpdateCustomerSessionArgs = {
    id: Scalars['ID'];
    input?: InputMaybe<UpdateCustomerSessionInput>;
};
export type MutationUpdateDiscountArgs = {
    id: Scalars['ID'];
    input: UpdateDiscountInput;
};
export type MutationUpdateInvoiceArgs = {
    id: Scalars['ID'];
    input: UpdateInvoiceInput;
};
export type MutationUpdateLicenseArgs = {
    id: Scalars['ID'];
    input: UpdateLicenseInput;
};
export type MutationUpdateLicenseUserArgs = {
    id: Scalars['ID'];
    input: UpdateLicenseUserInput;
};
export type MutationUpdatePaymentProviderArgs = {
    input: PaymentProviderInput;
};
export type MutationUpdateProductArgs = {
    id: Scalars['ID'];
    input: UpdateProductInput;
};
export type MutationUpdateSubscriptionArgs = {
    id: Scalars['ID'];
    input: UpdateSubscriptionInput;
};
export type MutationUpdateUserArgs = {
    input: UpdateUserInput;
};
export type MutationUpgradeSubscriptionArgs = {
    id: Scalars['ID'];
    input: UpgradeSubscriptionInput;
};
export type PaymentMethod = {
    __typename?: 'PaymentMethod';
    externalId?: Maybe<Scalars['String']>;
    lastDigits?: Maybe<Scalars['String']>;
    metadata?: Maybe<Scalars['JSON']>;
    providerName?: Maybe<PaymentProviderName>;
    type: PaymentMethodType;
};
export declare enum PaymentMethodType {
    Card = "CARD",
    Cash = "CASH",
    SepaMandate = "SEPA_MANDATE",
    WireTransfer = "WIRE_TRANSFER"
}
export type PaymentProvider = {
    __typename?: 'PaymentProvider';
    config?: Maybe<Scalars['JSON']>;
    name: PaymentProviderName;
};
export type PaymentProviderInput = {
    config?: InputMaybe<Scalars['JSON']>;
    name: PaymentProviderName;
};
export declare enum PaymentProviderName {
    Banking = "BANKING",
    Manual = "MANUAL",
    Stripe = "STRIPE"
}
export type PaymentSession = {
    __typename?: 'PaymentSession';
    stripe?: Maybe<StripePaymentSession>;
};
export type Person = {
    __typename?: 'Person';
    email: Scalars['String'];
    firstName: Scalars['String'];
    lastName: Scalars['String'];
    metadata?: Maybe<Scalars['JSON']>;
    phoneNumber?: Maybe<Scalars['String']>;
    settings?: Maybe<PersonSettings>;
};
export type PersonCustomerPortalSettings = {
    __typename?: 'PersonCustomerPortalSettings';
    isActive?: Maybe<Scalars['Boolean']>;
};
export type PersonCustomerPortalSettingsInput = {
    isActive?: InputMaybe<Scalars['Boolean']>;
};
export type PersonEmailSettings = {
    __typename?: 'PersonEmailSettings';
    invoices?: Maybe<Scalars['Boolean']>;
    payments?: Maybe<Scalars['Boolean']>;
};
export type PersonEmailSettingsInput = {
    invoices?: InputMaybe<Scalars['Boolean']>;
    payments?: InputMaybe<Scalars['Boolean']>;
};
export type PersonInput = {
    email: Scalars['String'];
    firstName: Scalars['String'];
    lastName: Scalars['String'];
    metadata?: InputMaybe<Scalars['JSON']>;
    phoneNumber?: InputMaybe<Scalars['String']>;
    settings?: InputMaybe<PersonSettingsInput>;
};
export type PersonSettings = {
    __typename?: 'PersonSettings';
    customerPortal?: Maybe<PersonCustomerPortalSettings>;
    email?: Maybe<PersonEmailSettings>;
};
export type PersonSettingsInput = {
    customerPortal?: InputMaybe<PersonCustomerPortalSettingsInput>;
    email?: InputMaybe<PersonEmailSettingsInput>;
};
export type Plan = {
    __typename?: 'Plan';
    billingDay?: Maybe<Scalars['Int']>;
    billingTerms?: Maybe<BillingTerms>;
    cancellationNotice?: Maybe<Timeframe>;
    freeTrial?: Maybe<Timeframe>;
    maxDuration?: Maybe<Timeframe>;
    paymentTerms?: Maybe<Timeframe>;
    recurrency: Timeframe;
};
export type PlanInput = {
    billingDay?: InputMaybe<Scalars['Int']>;
    billingTerms?: InputMaybe<BillingTerms>;
    cancellationNotice?: InputMaybe<TimeframeInput>;
    endDate?: InputMaybe<Scalars['Date']>;
    freeTrial?: InputMaybe<TimeframeInput>;
    maxDuration?: InputMaybe<TimeframeInput>;
    paymentTerms?: InputMaybe<TimeframeInput>;
    recurrency?: InputMaybe<TimeframeInput>;
    startDate?: InputMaybe<Scalars['Date']>;
};
export type PriceEstimation = {
    __typename?: 'PriceEstimation';
    couponCode?: Maybe<Scalars['String']>;
    currency: Scalars['Currency'];
    discountAmount: Scalars['Float'];
    subtotalAmount: Scalars['Float'];
    taxAmount: Scalars['Float'];
    totalAmount: Scalars['Float'];
};
export type PriceEstimationInput = {
    applyProratedChargesNow?: InputMaybe<Scalars['Boolean']>;
    couponCode?: InputMaybe<Scalars['String']>;
    customerId: Scalars['ID'];
    productId?: InputMaybe<Scalars['ID']>;
    subscriptionId?: InputMaybe<Scalars['ID']>;
    usage?: InputMaybe<Array<SubscriptionUsageInput>>;
};
export type Pricing = {
    __typename?: 'Pricing';
    chargeOnce?: Maybe<Scalars['Boolean']>;
    description?: Maybe<Scalars['String']>;
    price?: Maybe<Scalars['Float']>;
    strategy: PricingStrategy;
    tiers: Array<PricingTier>;
    type: PricingType;
    unit?: Maybe<Scalars['String']>;
};
export type PricingInput = {
    chargeOnce?: InputMaybe<Scalars['Boolean']>;
    description?: InputMaybe<Scalars['String']>;
    price?: InputMaybe<Scalars['Float']>;
    strategy?: InputMaybe<PricingStrategy>;
    tiers?: InputMaybe<Array<TierInput>>;
    type: PricingType;
    unit?: InputMaybe<Scalars['String']>;
};
export declare enum PricingStrategy {
    Gradual = "GRADUAL",
    Simple = "SIMPLE",
    Volume = "VOLUME"
}
export type PricingTier = {
    __typename?: 'PricingTier';
    from: Scalars['Float'];
    price: Scalars['Float'];
    to?: Maybe<Scalars['Int']>;
};
export declare enum PricingType {
    Fixed = "FIXED",
    Usage = "USAGE"
}
export type Product = {
    __typename?: 'Product';
    addons: ProductList;
    canDowngradeTo: ProductList;
    canUpgradeTo: ProductList;
    capabilities?: Maybe<Array<ProductCapability>>;
    createdAt?: Maybe<Scalars['Date']>;
    currency: Scalars['Currency'];
    id: Scalars['ID'];
    isActive: Scalars['Boolean'];
    licensing?: Maybe<Licensing>;
    metadata?: Maybe<Scalars['JSON']>;
    name: Scalars['String'];
    nextProduct?: Maybe<Product>;
    plan: Plan;
    pricing: Array<Pricing>;
    sku: Scalars['String'];
    subscriptions: SubscriptionList;
    taxRateCode?: Maybe<TaxRateCode>;
    updatedAt?: Maybe<Scalars['Date']>;
};
export type ProductCapability = {
    __typename?: 'ProductCapability';
    isActive: Scalars['Boolean'];
    name: Scalars['String'];
    usageLimit?: Maybe<Array<Maybe<SubscriptionUsage>>>;
};
export type ProductCapabilityInput = {
    isActive: Scalars['Boolean'];
    name: Scalars['String'];
    usageLimit?: InputMaybe<Array<InputMaybe<SubscriptionUsageInput>>>;
};
export type ProductCapabilitySettings = {
    __typename?: 'ProductCapabilitySettings';
    description: Scalars['String'];
    name: Scalars['String'];
    type: Scalars['String'];
};
export type ProductCapabilitySettingsInput = {
    description: Scalars['String'];
    name: Scalars['String'];
    type: Scalars['String'];
};
export type ProductList = {
    __typename?: 'ProductList';
    count: Scalars['Int'];
    cursor?: Maybe<Scalars['String']>;
    items: Array<Product>;
    total: Scalars['Int'];
};
export type PublicApp = {
    __typename?: 'PublicApp';
    categories?: Maybe<Array<Scalars['String']>>;
    createdAt?: Maybe<Scalars['Date']>;
    description?: Maybe<Scalars['String']>;
    events?: Maybe<Array<Scalars['String']>>;
    id: Scalars['ID'];
    isInstalled: Scalars['Boolean'];
    logoUrl?: Maybe<Scalars['String']>;
    name: Scalars['String'];
    pageContent?: Maybe<Scalars['String']>;
    privacyUrl?: Maybe<Scalars['String']>;
    scopes?: Maybe<Array<Scope>>;
    tosUrl?: Maybe<Scalars['String']>;
};
export type PublicAppList = {
    __typename?: 'PublicAppList';
    count: Scalars['Int'];
    cursor?: Maybe<Scalars['String']>;
    items: Array<PublicApp>;
    total: Scalars['Int'];
};
export type Query = {
    __typename?: 'Query';
    account: Account;
    app: App;
    apps: AppList;
    bankAccounts: BankAccountList;
    bankTransactions: BankTransactionList;
    banks: BankList;
    creditNote: CreditNote;
    creditNotePreview: CreditNotePreview;
    creditNotes: CreditNoteList;
    customer: Customer;
    customers: CustomerList;
    discount: Discount;
    discounts: DiscountList;
    estimatePrice: PriceEstimation;
    events: EventList;
    installedApps: AppInstanceList;
    invoice: Invoice;
    invoicePreview: InvoicePreview;
    invoices: InvoiceList;
    license: License;
    licenseUser: LicenseUser;
    licenseUsers: LicenseUserList;
    licenses: LicenseList;
    memberInvites: MemberInviteList;
    members: MemberList;
    product: Product;
    products: ProductList;
    publicApp: PublicApp;
    publicApps: PublicAppList;
    subscription: Subscription;
    subscriptions: SubscriptionList;
    transaction: Transaction;
    transactions: TransactionList;
    user: User;
};
export type QueryAppArgs = {
    id?: InputMaybe<Scalars['ID']>;
};
export type QueryAppsArgs = {
    filters?: InputMaybe<FilterInput>;
};
export type QueryBankTransactionsArgs = {
    filters?: InputMaybe<FilterInput>;
};
export type QueryBanksArgs = {
    countryCode: Scalars['String'];
};
export type QueryCreditNoteArgs = {
    id: Scalars['ID'];
};
export type QueryCreditNotePreviewArgs = {
    id: Scalars['ID'];
};
export type QueryCreditNotesArgs = {
    filters?: InputMaybe<FilterInput>;
};
export type QueryCustomerArgs = {
    id: Scalars['ID'];
};
export type QueryCustomersArgs = {
    filters?: InputMaybe<FilterInput>;
};
export type QueryDiscountArgs = {
    id: Scalars['ID'];
};
export type QueryDiscountsArgs = {
    filters?: InputMaybe<FilterInput>;
};
export type QueryEstimatePriceArgs = {
    input?: InputMaybe<PriceEstimationInput>;
};
export type QueryEventsArgs = {
    filters?: InputMaybe<FilterInput>;
};
export type QueryInstalledAppsArgs = {
    filters?: InputMaybe<FilterInput>;
};
export type QueryInvoiceArgs = {
    id: Scalars['ID'];
};
export type QueryInvoicePreviewArgs = {
    id: Scalars['ID'];
};
export type QueryInvoicesArgs = {
    filters?: InputMaybe<FilterInput>;
};
export type QueryLicenseArgs = {
    id: Scalars['ID'];
};
export type QueryLicenseUserArgs = {
    id: Scalars['ID'];
};
export type QueryLicenseUsersArgs = {
    filters?: InputMaybe<FilterInput>;
};
export type QueryLicensesArgs = {
    filters?: InputMaybe<FilterInput>;
};
export type QueryMemberInvitesArgs = {
    filters?: InputMaybe<FilterInput>;
};
export type QueryMembersArgs = {
    filters?: InputMaybe<FilterInput>;
};
export type QueryProductArgs = {
    id: Scalars['ID'];
};
export type QueryProductsArgs = {
    filters?: InputMaybe<FilterInput>;
};
export type QueryPublicAppArgs = {
    id: Scalars['ID'];
};
export type QueryPublicAppsArgs = {
    filters?: InputMaybe<FilterInput>;
};
export type QuerySubscriptionArgs = {
    id: Scalars['ID'];
};
export type QuerySubscriptionsArgs = {
    filters?: InputMaybe<FilterInput>;
};
export type QueryTransactionArgs = {
    id: Scalars['ID'];
};
export type QueryTransactionsArgs = {
    filters?: InputMaybe<FilterInput>;
};
export type RedeemDiscountCouponInput = {
    code: Scalars['String'];
    subscriptionId: Scalars['ID'];
};
export type RemovePaymentMethodInput = {
    customerId: Scalars['ID'];
};
export declare enum Scope {
    BankingRead = "BANKING_READ",
    BankingWrite = "BANKING_WRITE",
    CustomerRead = "CUSTOMER_READ",
    CustomerWrite = "CUSTOMER_WRITE",
    DiscountRead = "DISCOUNT_READ",
    DiscountWrite = "DISCOUNT_WRITE",
    FullAccess = "FULL_ACCESS",
    InvoicingRead = "INVOICING_READ",
    InvoicingWrite = "INVOICING_WRITE",
    LicenseActivate = "LICENSE_ACTIVATE",
    LicenseRead = "LICENSE_READ",
    LicenseUserRead = "LICENSE_USER_READ",
    LicenseUserWrite = "LICENSE_USER_WRITE",
    LicenseWrite = "LICENSE_WRITE",
    OfflineAccess = "OFFLINE_ACCESS",
    Openid = "OPENID",
    ProductRead = "PRODUCT_READ",
    ProductWrite = "PRODUCT_WRITE",
    Profile = "PROFILE",
    SubscriptionRead = "SUBSCRIPTION_READ",
    SubscriptionWrite = "SUBSCRIPTION_WRITE",
    TransactionRead = "TRANSACTION_READ",
    TransactionWrite = "TRANSACTION_WRITE"
}
export declare enum SortOrder {
    Ascending = "ASCENDING",
    Descending = "DESCENDING"
}
export type StripePaymentSession = {
    __typename?: 'StripePaymentSession';
    clientSecret: Scalars['String'];
    publishableKey: Scalars['String'];
    stripeAccountId: Scalars['String'];
    stripeCustomerId: Scalars['String'];
};
export type Subscription = {
    __typename?: 'Subscription';
    billing?: Maybe<Billing>;
    createdAt?: Maybe<Scalars['Dat