@vendure/payments-plugin 1.4.7 → 1.5.2

package/package/mollie/graphql/generated-shop-types.d.ts

@@ -0,0 +1,2894 @@
+export declare type Maybe<T> = T | null;
+export declare type Exact<T extends {
+    [key: string]: unknown;
+}> = {
+    [K in keyof T]: T[K];
+};
+export declare type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]?: Maybe<T[SubKey]>;
+};
+export declare type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]: Maybe<T[SubKey]>;
+};
+/** All built-in and custom scalars, mapped to their actual values */
+export declare type Scalars = {
+    ID: string;
+    String: string;
+    Boolean: boolean;
+    Int: number;
+    Float: number;
+    /** A date-time string at UTC, such as 2007-12-03T10:15:30Z, compliant with the `date-time` format outlined in section 5.6 of the RFC 3339 profile of the ISO 8601 standard for representation of dates and times using the Gregorian calendar. */
+    DateTime: any;
+    /** The `JSON` scalar type represents JSON values as specified by [ECMA-404](http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf). */
+    JSON: any;
+    /** The `Upload` scalar type represents a file upload. */
+    Upload: any;
+};
+export declare type ActiveOrderResult = Order | NoActiveOrderError;
+export declare type AddPaymentToOrderResult = Order | OrderPaymentStateError | IneligiblePaymentMethodError | PaymentFailedError | PaymentDeclinedError | OrderStateTransitionError | NoActiveOrderError;
+export declare type Address = Node & {
+    __typename?: 'Address';
+    id: Scalars['ID'];
+    createdAt: Scalars['DateTime'];
+    updatedAt: Scalars['DateTime'];
+    fullName?: Maybe<Scalars['String']>;
+    company?: Maybe<Scalars['String']>;
+    streetLine1: Scalars['String'];
+    streetLine2?: Maybe<Scalars['String']>;
+    city?: Maybe<Scalars['String']>;
+    province?: Maybe<Scalars['String']>;
+    postalCode?: Maybe<Scalars['String']>;
+    country: Country;
+    phoneNumber?: Maybe<Scalars['String']>;
+    defaultShippingAddress?: Maybe<Scalars['Boolean']>;
+    defaultBillingAddress?: Maybe<Scalars['Boolean']>;
+    customFields?: Maybe<Scalars['JSON']>;
+};
+export declare type Adjustment = {
+    __typename?: 'Adjustment';
+    adjustmentSource: Scalars['String'];
+    type: AdjustmentType;
+    description: Scalars['String'];
+    amount: Scalars['Int'];
+};
+export declare enum AdjustmentType {
+    PROMOTION = "PROMOTION",
+    DISTRIBUTED_ORDER_PROMOTION = "DISTRIBUTED_ORDER_PROMOTION",
+    OTHER = "OTHER"
+}
+/** Returned when attempting to set the Customer for an Order when already logged in. */
+export declare type AlreadyLoggedInError = ErrorResult & {
+    __typename?: 'AlreadyLoggedInError';
+    errorCode: ErrorCode;
+    message: Scalars['String'];
+};
+export declare type ApplyCouponCodeResult = Order | CouponCodeExpiredError | CouponCodeInvalidError | CouponCodeLimitError;
+export declare type Asset = Node & {
+    __typename?: 'Asset';
+    id: Scalars['ID'];
+    createdAt: Scalars['DateTime'];
+    updatedAt: Scalars['DateTime'];
+    name: Scalars['String'];
+    type: AssetType;
+    fileSize: Scalars['Int'];
+    mimeType: Scalars['String'];
+    width: Scalars['Int'];
+    height: Scalars['Int'];
+    source: Scalars['String'];
+    preview: Scalars['String'];
+    focalPoint?: Maybe<Coordinate>;
+    customFields?: Maybe<Scalars['JSON']>;
+};
+export declare type AssetList = PaginatedList & {
+    __typename?: 'AssetList';
+    items: Array<Asset>;
+    totalItems: Scalars['Int'];
+};
+export declare enum AssetType {
+    IMAGE = "IMAGE",
+    VIDEO = "VIDEO",
+    BINARY = "BINARY"
+}
+export declare type AuthenticationInput = {
+    native?: Maybe<NativeAuthInput>;
+};
+export declare type AuthenticationMethod = Node & {
+    __typename?: 'AuthenticationMethod';
+    id: Scalars['ID'];
+    createdAt: Scalars['DateTime'];
+    updatedAt: Scalars['DateTime'];
+    strategy: Scalars['String'];
+};
+export declare type AuthenticationResult = CurrentUser | InvalidCredentialsError | NotVerifiedError;
+export declare type BooleanCustomFieldConfig = CustomField & {
+    __typename?: 'BooleanCustomFieldConfig';
+    name: Scalars['String'];
+    type: Scalars['String'];
+    list: Scalars['Boolean'];
+    label?: Maybe<Array<LocalizedString>>;
+    description?: Maybe<Array<LocalizedString>>;
+    readonly?: Maybe<Scalars['Boolean']>;
+    internal?: Maybe<Scalars['Boolean']>;
+    nullable?: Maybe<Scalars['Boolean']>;
+    ui?: Maybe<Scalars['JSON']>;
+};
+/** Operators for filtering on a list of Boolean fields */
+export declare type BooleanListOperators = {
+    inList: Scalars['Boolean'];
+};
+/** Operators for filtering on a Boolean field */
+export declare type BooleanOperators = {
+    eq?: Maybe<Scalars['Boolean']>;
+};
+export declare type Channel = Node & {
+    __typename?: 'Channel';
+    id: Scalars['ID'];
+    createdAt: Scalars['DateTime'];
+    updatedAt: Scalars['DateTime'];
+    code: Scalars['String'];
+    token: Scalars['String'];
+    defaultTaxZone?: Maybe<Zone>;
+    defaultShippingZone?: Maybe<Zone>;
+    defaultLanguageCode: LanguageCode;
+    currencyCode: CurrencyCode;
+    pricesIncludeTax: Scalars['Boolean'];
+    customFields?: Maybe<Scalars['JSON']>;
+};
+export declare type Collection = Node & {
+    __typename?: 'Collection';
+    id: Scalars['ID'];
+    createdAt: Scalars['DateTime'];
+    updatedAt: Scalars['DateTime'];
+    languageCode?: Maybe<LanguageCode>;
+    name: Scalars['String'];
+    slug: Scalars['String'];
+    breadcrumbs: Array<CollectionBreadcrumb>;
+    position: Scalars['Int'];
+    description: Scalars['String'];
+    featuredAsset?: Maybe<Asset>;
+    assets: Array<Asset>;
+    parent?: Maybe<Collection>;
+    children?: Maybe<Array<Collection>>;
+    filters: Array<ConfigurableOperation>;
+    translations: Array<CollectionTranslation>;
+    productVariants: ProductVariantList;
+    customFields?: Maybe<Scalars['JSON']>;
+};
+export declare type CollectionProductVariantsArgs = {
+    options?: Maybe<ProductVariantListOptions>;
+};
+export declare type CollectionBreadcrumb = {
+    __typename?: 'CollectionBreadcrumb';
+    id: Scalars['ID'];
+    name: Scalars['String'];
+    slug: Scalars['String'];
+};
+export declare type CollectionFilterParameter = {
+    id?: Maybe<IdOperators>;
+    createdAt?: Maybe<DateOperators>;
+    updatedAt?: Maybe<DateOperators>;
+    languageCode?: Maybe<StringOperators>;
+    name?: Maybe<StringOperators>;
+    slug?: Maybe<StringOperators>;
+    position?: Maybe<NumberOperators>;
+    description?: Maybe<StringOperators>;
+};
+export declare type CollectionList = PaginatedList & {
+    __typename?: 'CollectionList';
+    items: Array<Collection>;
+    totalItems: Scalars['Int'];
+};
+export declare type CollectionListOptions = {
+    /** Skips the first n results, for use in pagination */
+    skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
+    take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
+    sort?: Maybe<CollectionSortParameter>;
+    /** Allows the results to be filtered */
+    filter?: Maybe<CollectionFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
+};
+/**
+ * Which Collections are present in the products returned
+ * by the search, and in what quantity.
+ */
+export declare type CollectionResult = {
+    __typename?: 'CollectionResult';
+    collection: Collection;
+    count: Scalars['Int'];
+};
+export declare type CollectionSortParameter = {
+    id?: Maybe<SortOrder>;
+    createdAt?: Maybe<SortOrder>;
+    updatedAt?: Maybe<SortOrder>;
+    name?: Maybe<SortOrder>;
+    slug?: Maybe<SortOrder>;
+    position?: Maybe<SortOrder>;
+    description?: Maybe<SortOrder>;
+};
+export declare type CollectionTranslation = {
+    __typename?: 'CollectionTranslation';
+    id: Scalars['ID'];
+    createdAt: Scalars['DateTime'];
+    updatedAt: Scalars['DateTime'];
+    languageCode: LanguageCode;
+    name: Scalars['String'];
+    slug: Scalars['String'];
+    description: Scalars['String'];
+};
+export declare type ConfigArg = {
+    __typename?: 'ConfigArg';
+    name: Scalars['String'];
+    value: Scalars['String'];
+};
+export declare type ConfigArgDefinition = {
+    __typename?: 'ConfigArgDefinition';
+    name: Scalars['String'];
+    type: Scalars['String'];
+    list: Scalars['Boolean'];
+    required: Scalars['Boolean'];
+    defaultValue?: Maybe<Scalars['JSON']>;
+    label?: Maybe<Scalars['String']>;
+    description?: Maybe<Scalars['String']>;
+    ui?: Maybe<Scalars['JSON']>;
+};
+export declare type ConfigArgInput = {
+    name: Scalars['String'];
+    /** A JSON stringified representation of the actual value */
+    value: Scalars['String'];
+};
+export declare type ConfigurableOperation = {
+    __typename?: 'ConfigurableOperation';
+    code: Scalars['String'];
+    args: Array<ConfigArg>;
+};
+export declare type ConfigurableOperationDefinition = {
+    __typename?: 'ConfigurableOperationDefinition';
+    code: Scalars['String'];
+    args: Array<ConfigArgDefinition>;
+    description: Scalars['String'];
+};
+export declare type ConfigurableOperationInput = {
+    code: Scalars['String'];
+    arguments: Array<ConfigArgInput>;
+};
+export declare type Coordinate = {
+    __typename?: 'Coordinate';
+    x: Scalars['Float'];
+    y: Scalars['Float'];
+};
+export declare type Country = Node & {
+    __typename?: 'Country';
+    id: Scalars['ID'];
+    createdAt: Scalars['DateTime'];
+    updatedAt: Scalars['DateTime'];
+    languageCode: LanguageCode;
+    code: Scalars['String'];
+    name: Scalars['String'];
+    enabled: Scalars['Boolean'];
+    translations: Array<CountryTranslation>;
+    customFields?: Maybe<Scalars['JSON']>;
+};
+export declare type CountryList = PaginatedList & {
+    __typename?: 'CountryList';
+    items: Array<Country>;
+    totalItems: Scalars['Int'];
+};
+export declare type CountryTranslation = {
+    __typename?: 'CountryTranslation';
+    id: Scalars['ID'];
+    createdAt: Scalars['DateTime'];
+    updatedAt: Scalars['DateTime'];
+    languageCode: LanguageCode;
+    name: Scalars['String'];
+};
+/** Returned if the provided coupon code is invalid */
+export declare type CouponCodeExpiredError = ErrorResult & {
+    __typename?: 'CouponCodeExpiredError';
+    errorCode: ErrorCode;
+    message: Scalars['String'];
+    couponCode: Scalars['String'];
+};
+/** Returned if the provided coupon code is invalid */
+export declare type CouponCodeInvalidError = ErrorResult & {
+    __typename?: 'CouponCodeInvalidError';
+    errorCode: ErrorCode;
+    message: Scalars['String'];
+    couponCode: Scalars['String'];
+};
+/** Returned if the provided coupon code is invalid */
+export declare type CouponCodeLimitError = ErrorResult & {
+    __typename?: 'CouponCodeLimitError';
+    errorCode: ErrorCode;
+    message: Scalars['String'];
+    couponCode: Scalars['String'];
+    limit: Scalars['Int'];
+};
+export declare type CreateAddressInput = {
+    fullName?: Maybe<Scalars['String']>;
+    company?: Maybe<Scalars['String']>;
+    streetLine1: Scalars['String'];
+    streetLine2?: Maybe<Scalars['String']>;
+    city?: Maybe<Scalars['String']>;
+    province?: Maybe<Scalars['String']>;
+    postalCode?: Maybe<Scalars['String']>;
+    countryCode: Scalars['String'];
+    phoneNumber?: Maybe<Scalars['String']>;
+    defaultShippingAddress?: Maybe<Scalars['Boolean']>;
+    defaultBillingAddress?: Maybe<Scalars['Boolean']>;
+    customFields?: Maybe<Scalars['JSON']>;
+};
+export declare type CreateCustomerInput = {
+    title?: Maybe<Scalars['String']>;
+    firstName: Scalars['String'];
+    lastName: Scalars['String'];
+    phoneNumber?: Maybe<Scalars['String']>;
+    emailAddress: Scalars['String'];
+    customFields?: Maybe<Scalars['JSON']>;
+};
+/**
+ * @description
+ * ISO 4217 currency code
+ *
+ * @docsCategory common
+ */
+export declare enum CurrencyCode {
+    /** United Arab Emirates dirham */
+    AED = "AED",
+    /** Afghan afghani */
+    AFN = "AFN",
+    /** Albanian lek */
+    ALL = "ALL",
+    /** Armenian dram */
+    AMD = "AMD",
+    /** Netherlands Antillean guilder */
+    ANG = "ANG",
+    /** Angolan kwanza */
+    AOA = "AOA",
+    /** Argentine peso */
+    ARS = "ARS",
+    /** Australian dollar */
+    AUD = "AUD",
+    /** Aruban florin */
+    AWG = "AWG",
+    /** Azerbaijani manat */
+    AZN = "AZN",
+    /** Bosnia and Herzegovina convertible mark */
+    BAM = "BAM",
+    /** Barbados dollar */
+    BBD = "BBD",
+    /** Bangladeshi taka */
+    BDT = "BDT",
+    /** Bulgarian lev */
+    BGN = "BGN",
+    /** Bahraini dinar */
+    BHD = "BHD",
+    /** Burundian franc */
+    BIF = "BIF",
+    /** Bermudian dollar */
+    BMD = "BMD",
+    /** Brunei dollar */
+    BND = "BND",
+    /** Boliviano */
+    BOB = "BOB",
+    /** Brazilian real */
+    BRL = "BRL",
+    /** Bahamian dollar */
+    BSD = "BSD",
+    /** Bhutanese ngultrum */
+    BTN = "BTN",
+    /** Botswana pula */
+    BWP = "BWP",
+    /** Belarusian ruble */
+    BYN = "BYN",
+    /** Belize dollar */
+    BZD = "BZD",
+    /** Canadian dollar */
+    CAD = "CAD",
+    /** Congolese franc */
+    CDF = "CDF",
+    /** Swiss franc */
+    CHF = "CHF",
+    /** Chilean peso */
+    CLP = "CLP",
+    /** Renminbi (Chinese) yuan */
+    CNY = "CNY",
+    /** Colombian peso */
+    COP = "COP",
+    /** Costa Rican colon */
+    CRC = "CRC",
+    /** Cuban convertible peso */
+    CUC = "CUC",
+    /** Cuban peso */
+    CUP = "CUP",
+    /** Cape Verde escudo */
+    CVE = "CVE",
+    /** Czech koruna */
+    CZK = "CZK",
+    /** Djiboutian franc */
+    DJF = "DJF",
+    /** Danish krone */
+    DKK = "DKK",
+    /** Dominican peso */
+    DOP = "DOP",
+    /** Algerian dinar */
+    DZD = "DZD",
+    /** Egyptian pound */
+    EGP = "EGP",
+    /** Eritrean nakfa */
+    ERN = "ERN",
+    /** Ethiopian birr */
+    ETB = "ETB",
+    /** Euro */
+    EUR = "EUR",
+    /** Fiji dollar */
+    FJD = "FJD",
+    /** Falkland Islands pound */
+    FKP = "FKP",
+    /** Pound sterling */
+    GBP = "GBP",
+    /** Georgian lari */
+    GEL = "GEL",
+    /** Ghanaian cedi */
+    GHS = "GHS",
+    /** Gibraltar pound */
+    GIP = "GIP",
+    /** Gambian dalasi */
+    GMD = "GMD",
+    /** Guinean franc */
+    GNF = "GNF",
+    /** Guatemalan quetzal */
+    GTQ = "GTQ",
+    /** Guyanese dollar */
+    GYD = "GYD",
+    /** Hong Kong dollar */
+    HKD = "HKD",
+    /** Honduran lempira */
+    HNL = "HNL",
+    /** Croatian kuna */
+    HRK = "HRK",
+    /** Haitian gourde */
+    HTG = "HTG",
+    /** Hungarian forint */
+    HUF = "HUF",
+    /** Indonesian rupiah */
+    IDR = "IDR",
+    /** Israeli new shekel */
+    ILS = "ILS",
+    /** Indian rupee */
+    INR = "INR",
+    /** Iraqi dinar */
+    IQD = "IQD",
+    /** Iranian rial */
+    IRR = "IRR",
+    /** Icelandic króna */
+    ISK = "ISK",
+    /** Jamaican dollar */
+    JMD = "JMD",
+    /** Jordanian dinar */
+    JOD = "JOD",
+    /** Japanese yen */
+    JPY = "JPY",
+    /** Kenyan shilling */
+    KES = "KES",
+    /** Kyrgyzstani som */
+    KGS = "KGS",
+    /** Cambodian riel */
+    KHR = "KHR",
+    /** Comoro franc */
+    KMF = "KMF",
+    /** North Korean won */
+    KPW = "KPW",
+    /** South Korean won */
+    KRW = "KRW",
+    /** Kuwaiti dinar */
+    KWD = "KWD",
+    /** Cayman Islands dollar */
+    KYD = "KYD",
+    /** Kazakhstani tenge */
+    KZT = "KZT",
+    /** Lao kip */
+    LAK = "LAK",
+    /** Lebanese pound */
+    LBP = "LBP",
+    /** Sri Lankan rupee */
+    LKR = "LKR",
+    /** Liberian dollar */
+    LRD = "LRD",
+    /** Lesotho loti */
+    LSL = "LSL",
+    /** Libyan dinar */
+    LYD = "LYD",
+    /** Moroccan dirham */
+    MAD = "MAD",
+    /** Moldovan leu */
+    MDL = "MDL",
+    /** Malagasy ariary */
+    MGA = "MGA",
+    /** Macedonian denar */
+    MKD = "MKD",
+    /** Myanmar kyat */
+    MMK = "MMK",
+    /** Mongolian tögrög */
+    MNT = "MNT",
+    /** Macanese pataca */
+    MOP = "MOP",
+    /** Mauritanian ouguiya */
+    MRU = "MRU",
+    /** Mauritian rupee */
+    MUR = "MUR",
+    /** Maldivian rufiyaa */
+    MVR = "MVR",
+    /** Malawian kwacha */
+    MWK = "MWK",
+    /** Mexican peso */
+    MXN = "MXN",
+    /** Malaysian ringgit */
+    MYR = "MYR",
+    /** Mozambican metical */
+    MZN = "MZN",
+    /** Namibian dollar */
+    NAD = "NAD",
+    /** Nigerian naira */
+    NGN = "NGN",
+    /** Nicaraguan córdoba */
+    NIO = "NIO",
+    /** Norwegian krone */
+    NOK = "NOK",
+    /** Nepalese rupee */
+    NPR = "NPR",
+    /** New Zealand dollar */
+    NZD = "NZD",
+    /** Omani rial */
+    OMR = "OMR",
+    /** Panamanian balboa */
+    PAB = "PAB",
+    /** Peruvian sol */
+    PEN = "PEN",
+    /** Papua New Guinean kina */
+    PGK = "PGK",
+    /** Philippine peso */
+    PHP = "PHP",
+    /** Pakistani rupee */
+    PKR = "PKR",
+    /** Polish złoty */
+    PLN = "PLN",
+    /** Paraguayan guaraní */
+    PYG = "PYG",
+    /** Qatari riyal */
+    QAR = "QAR",
+    /** Romanian leu */
+    RON = "RON",
+    /** Serbian dinar */
+    RSD = "RSD",
+    /** Russian ruble */
+    RUB = "RUB",
+    /** Rwandan franc */
+    RWF = "RWF",
+    /** Saudi riyal */
+    SAR = "SAR",
+    /** Solomon Islands dollar */
+    SBD = "SBD",
+    /** Seychelles rupee */
+    SCR = "SCR",
+    /** Sudanese pound */
+    SDG = "SDG",
+    /** Swedish krona/kronor */
+    SEK = "SEK",
+    /** Singapore dollar */
+    SGD = "SGD",
+    /** Saint Helena pound */
+    SHP = "SHP",
+    /** Sierra Leonean leone */
+    SLL = "SLL",
+    /** Somali shilling */
+    SOS = "SOS",
+    /** Surinamese dollar */
+    SRD = "SRD",
+    /** South Sudanese pound */
+    SSP = "SSP",
+    /** São Tomé and Príncipe dobra */
+    STN = "STN",
+    /** Salvadoran colón */
+    SVC = "SVC",
+    /** Syrian pound */
+    SYP = "SYP",
+    /** Swazi lilangeni */
+    SZL = "SZL",
+    /** Thai baht */
+    THB = "THB",
+    /** Tajikistani somoni */
+    TJS = "TJS",
+    /** Turkmenistan manat */
+    TMT = "TMT",
+    /** Tunisian dinar */
+    TND = "TND",
+    /** Tongan paʻanga */
+    TOP = "TOP",
+    /** Turkish lira */
+    TRY = "TRY",
+    /** Trinidad and Tobago dollar */
+    TTD = "TTD",
+    /** New Taiwan dollar */
+    TWD = "TWD",
+    /** Tanzanian shilling */
+    TZS = "TZS",
+    /** Ukrainian hryvnia */
+    UAH = "UAH",
+    /** Ugandan shilling */
+    UGX = "UGX",
+    /** United States dollar */
+    USD = "USD",
+    /** Uruguayan peso */
+    UYU = "UYU",
+    /** Uzbekistan som */
+    UZS = "UZS",
+    /** Venezuelan bolívar soberano */
+    VES = "VES",
+    /** Vietnamese đồng */
+    VND = "VND",
+    /** Vanuatu vatu */
+    VUV = "VUV",
+    /** Samoan tala */
+    WST = "WST",
+    /** CFA franc BEAC */
+    XAF = "XAF",
+    /** East Caribbean dollar */
+    XCD = "XCD",
+    /** CFA franc BCEAO */
+    XOF = "XOF",
+    /** CFP franc (franc Pacifique) */
+    XPF = "XPF",
+    /** Yemeni rial */
+    YER = "YER",
+    /** South African rand */
+    ZAR = "ZAR",
+    /** Zambian kwacha */
+    ZMW = "ZMW",
+    /** Zimbabwean dollar */
+    ZWL = "ZWL"
+}
+export declare type CurrentUser = {
+    __typename?: 'CurrentUser';
+    id: Scalars['ID'];
+    identifier: Scalars['String'];
+    channels: Array<CurrentUserChannel>;
+};
+export declare type CurrentUserChannel = {
+    __typename?: 'CurrentUserChannel';
+    id: Scalars['ID'];
+    token: Scalars['String'];
+    code: Scalars['String'];
+    permissions: Array<Permission>;
+};
+export declare type CustomField = {
+    name: Scalars['String'];
+    type: Scalars['String'];
+    list: Scalars['Boolean'];
+    label?: Maybe<Array<LocalizedString>>;
+    description?: Maybe<Array<LocalizedString>>;
+    readonly?: Maybe<Scalars['Boolean']>;
+    internal?: Maybe<Scalars['Boolean']>;
+    nullable?: Maybe<Scalars['Boolean']>;
+    ui?: Maybe<Scalars['JSON']>;
+};
+export declare type CustomFieldConfig = StringCustomFieldConfig | LocaleStringCustomFieldConfig | IntCustomFieldConfig | FloatCustomFieldConfig | BooleanCustomFieldConfig | DateTimeCustomFieldConfig | RelationCustomFieldConfig | TextCustomFieldConfig;
+export declare type Customer = Node & {
+    __typename?: 'Customer';
+    id: Scalars['ID'];
+    createdAt: Scalars['DateTime'];
+    updatedAt: Scalars['DateTime'];
+    title?: Maybe<Scalars['String']>;
+    firstName: Scalars['String'];
+    lastName: Scalars['String'];
+    phoneNumber?: Maybe<Scalars['String']>;
+    emailAddress: Scalars['String'];
+    addresses?: Maybe<Array<Address>>;
+    orders: OrderList;
+    user?: Maybe<User>;
+    customFields?: Maybe<Scalars['JSON']>;
+};
+export declare type CustomerOrdersArgs = {
+    options?: Maybe<OrderListOptions>;
+};
+export declare type CustomerFilterParameter = {
+    id?: Maybe<IdOperators>;
+    createdAt?: Maybe<DateOperators>;
+    updatedAt?: Maybe<DateOperators>;
+    title?: Maybe<StringOperators>;
+    firstName?: Maybe<StringOperators>;
+    lastName?: Maybe<StringOperators>;
+    phoneNumber?: Maybe<StringOperators>;
+    emailAddress?: Maybe<StringOperators>;
+};
+export declare type CustomerGroup = Node & {
+    __typename?: 'CustomerGroup';
+    id: Scalars['ID'];
+    createdAt: Scalars['DateTime'];
+    updatedAt: Scalars['DateTime'];
+    name: Scalars['String'];
+    customers: CustomerList;
+    customFields?: Maybe<Scalars['JSON']>;
+};
+export declare type CustomerGroupCustomersArgs = {
+    options?: Maybe<CustomerListOptions>;
+};
+export declare type CustomerList = PaginatedList & {
+    __typename?: 'CustomerList';
+    items: Array<Customer>;
+    totalItems: Scalars['Int'];
+};
+export declare type CustomerListOptions = {
+    /** Skips the first n results, for use in pagination */
+    skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
+    take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
+    sort?: Maybe<CustomerSortParameter>;
+    /** Allows the results to be filtered */
+    filter?: Maybe<CustomerFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
+};
+export declare type CustomerSortParameter = {
+    id?: Maybe<SortOrder>;
+    createdAt?: Maybe<SortOrder>;
+    updatedAt?: Maybe<SortOrder>;
+    title?: Maybe<SortOrder>;
+    firstName?: Maybe<SortOrder>;
+    lastName?: Maybe<SortOrder>;
+    phoneNumber?: Maybe<SortOrder>;
+    emailAddress?: Maybe<SortOrder>;
+};
+/** Operators for filtering on a list of Date fields */
+export declare type DateListOperators = {
+    inList: Scalars['DateTime'];
+};
+/** Operators for filtering on a DateTime field */
+export declare type DateOperators = {
+    eq?: Maybe<Scalars['DateTime']>;
+    before?: Maybe<Scalars['DateTime']>;
+    after?: Maybe<Scalars['DateTime']>;
+    between?: Maybe<DateRange>;
+};
+export declare type DateRange = {
+    start: Scalars['DateTime'];
+    end: Scalars['DateTime'];
+};
+/**
+ * Expects the same validation formats as the `<input type="datetime-local">` HTML element.
+ * See https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input/datetime-local#Additional_attributes
+ */
+export declare type DateTimeCustomFieldConfig = CustomField & {
+    __typename?: 'DateTimeCustomFieldConfig';
+    name: Scalars['String'];
+    type: Scalars['String'];
+    list: Scalars['Boolean'];
+    label?: Maybe<Array<LocalizedString>>;
+    description?: Maybe<Array<LocalizedString>>;
+    readonly?: Maybe<Scalars['Boolean']>;
+    internal?: Maybe<Scalars['Boolean']>;
+    nullable?: Maybe<Scalars['Boolean']>;
+    min?: Maybe<Scalars['String']>;
+    max?: Maybe<Scalars['String']>;
+    step?: Maybe<Scalars['Int']>;
+    ui?: Maybe<Scalars['JSON']>;
+};
+export declare type DeletionResponse = {
+    __typename?: 'DeletionResponse';
+    result: DeletionResult;
+    message?: Maybe<Scalars['String']>;
+};
+export declare enum DeletionResult {
+    /** The entity was successfully deleted */
+    DELETED = "DELETED",
+    /** Deletion did not take place, reason given in message */
+    NOT_DELETED = "NOT_DELETED"
+}
+export declare type Discount = {
+    __typename?: 'Discount';
+    adjustmentSource: Scalars['String'];
+    type: AdjustmentType;
+    description: Scalars['String'];
+    amount: Scalars['Int'];
+    amountWithTax: Scalars['Int'];
+};
+/** Returned when attempting to create a Customer with an email address already registered to an existing User. */
+export declare type EmailAddressConflictError = ErrorResult & {
+    __typename?: 'EmailAddressConflictError';
+    errorCode: ErrorCode;
+    message: Scalars['String'];
+};
+export declare enum ErrorCode {
+    UNKNOWN_ERROR = "UNKNOWN_ERROR",
+    NATIVE_AUTH_STRATEGY_ERROR = "NATIVE_AUTH_STRATEGY_ERROR",
+    INVALID_CREDENTIALS_ERROR = "INVALID_CREDENTIALS_ERROR",
+    ORDER_STATE_TRANSITION_ERROR = "ORDER_STATE_TRANSITION_ERROR",
+    EMAIL_ADDRESS_CONFLICT_ERROR = "EMAIL_ADDRESS_CONFLICT_ERROR",
+    ORDER_LIMIT_ERROR = "ORDER_LIMIT_ERROR",
+    NEGATIVE_QUANTITY_ERROR = "NEGATIVE_QUANTITY_ERROR",
+    INSUFFICIENT_STOCK_ERROR = "INSUFFICIENT_STOCK_ERROR",
+    COUPON_CODE_INVALID_ERROR = "COUPON_CODE_INVALID_ERROR",
+    COUPON_CODE_EXPIRED_ERROR = "COUPON_CODE_EXPIRED_ERROR",
+    COUPON_CODE_LIMIT_ERROR = "COUPON_CODE_LIMIT_ERROR",
+    ORDER_MODIFICATION_ERROR = "ORDER_MODIFICATION_ERROR",
+    INELIGIBLE_SHIPPING_METHOD_ERROR = "INELIGIBLE_SHIPPING_METHOD_ERROR",
+    ORDER_PAYMENT_STATE_ERROR = "ORDER_PAYMENT_STATE_ERROR",
+    INELIGIBLE_PAYMENT_METHOD_ERROR = "INELIGIBLE_PAYMENT_METHOD_ERROR",
+    PAYMENT_FAILED_ERROR = "PAYMENT_FAILED_ERROR",
+    PAYMENT_DECLINED_ERROR = "PAYMENT_DECLINED_ERROR",
+    ALREADY_LOGGED_IN_ERROR = "ALREADY_LOGGED_IN_ERROR",
+    MISSING_PASSWORD_ERROR = "MISSING_PASSWORD_ERROR",
+    PASSWORD_VALIDATION_ERROR = "PASSWORD_VALIDATION_ERROR",
+    PASSWORD_ALREADY_SET_ERROR = "PASSWORD_ALREADY_SET_ERROR",
+    VERIFICATION_TOKEN_INVALID_ERROR = "VERIFICATION_TOKEN_INVALID_ERROR",
+    VERIFICATION_TOKEN_EXPIRED_ERROR = "VERIFICATION_TOKEN_EXPIRED_ERROR",
+    IDENTIFIER_CHANGE_TOKEN_INVALID_ERROR = "IDENTIFIER_CHANGE_TOKEN_INVALID_ERROR",
+    IDENTIFIER_CHANGE_TOKEN_EXPIRED_ERROR = "IDENTIFIER_CHANGE_TOKEN_EXPIRED_ERROR",
+    PASSWORD_RESET_TOKEN_INVALID_ERROR = "PASSWORD_RESET_TOKEN_INVALID_ERROR",
+    PASSWORD_RESET_TOKEN_EXPIRED_ERROR = "PASSWORD_RESET_TOKEN_EXPIRED_ERROR",
+    NOT_VERIFIED_ERROR = "NOT_VERIFIED_ERROR",
+    NO_ACTIVE_ORDER_ERROR = "NO_ACTIVE_ORDER_ERROR"
+}
+export declare type ErrorResult = {
+    errorCode: ErrorCode;
+    message: Scalars['String'];
+};
+export declare type Facet = Node & {
+    __typename?: 'Facet';
+    id: Scalars['ID'];
+    createdAt: Scalars['DateTime'];
+    updatedAt: Scalars['DateTime'];
+    languageCode: LanguageCode;
+    name: Scalars['String'];
+    code: Scalars['String'];
+    values: Array<FacetValue>;
+    translations: Array<FacetTranslation>;
+    customFields?: Maybe<Scalars['JSON']>;
+};
+export declare type FacetFilterParameter = {
+    id?: Maybe<IdOperators>;
+    createdAt?: Maybe<DateOperators>;
+    updatedAt?: Maybe<DateOperators>;
+    languageCode?: Maybe<StringOperators>;
+    name?: Maybe<StringOperators>;
+    code?: Maybe<StringOperators>;
+};
+export declare type FacetList = PaginatedList & {
+    __typename?: 'FacetList';
+    items: Array<Facet>;
+    totalItems: Scalars['Int'];
+};
+export declare type FacetListOptions = {
+    /** Skips the first n results, for use in pagination */
+    skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
+    take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
+    sort?: Maybe<FacetSortParameter>;
+    /** Allows the results to be filtered */
+    filter?: Maybe<FacetFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
+};
+export declare type FacetSortParameter = {
+    id?: Maybe<SortOrder>;
+    createdAt?: Maybe<SortOrder>;
+    updatedAt?: Maybe<SortOrder>;
+    name?: Maybe<SortOrder>;
+    code?: Maybe<SortOrder>;
+};
+export declare type FacetTranslation = {
+    __typename?: 'FacetTranslation';
+    id: Scalars['ID'];
+    createdAt: Scalars['DateTime'];
+    updatedAt: Scalars['DateTime'];
+    languageCode: LanguageCode;
+    name: Scalars['String'];
+};
+export declare type FacetValue = Node & {
+    __typename?: 'FacetValue';
+    id: Scalars['ID'];
+    createdAt: Scalars['DateTime'];
+    updatedAt: Scalars['DateTime'];
+    languageCode: LanguageCode;
+    facet: Facet;
+    name: Scalars['String'];
+    code: Scalars['String'];
+    translations: Array<FacetValueTranslation>;
+    customFields?: Maybe<Scalars['JSON']>;
+};
+/**
+ * Used to construct boolean expressions for filtering search results
+ * by FacetValue ID. Examples:
+ *
+ * * ID=1 OR ID=2: `{ facetValueFilters: [{ or: [1,2] }] }`
+ * * ID=1 AND ID=2: `{ facetValueFilters: [{ and: 1 }, { and: 2 }] }`
+ * * ID=1 AND (ID=2 OR ID=3): `{ facetValueFilters: [{ and: 1 }, { or: [2,3] }] }`
+ */
+export declare type FacetValueFilterInput = {
+    and?: Maybe<Scalars['ID']>;
+    or?: Maybe<Array<Scalars['ID']>>;
+};
+/**
+ * Which FacetValues are present in the products returned
+ * by the search, and in what quantity.
+ */
+export declare type FacetValueResult = {
+    __typename?: 'FacetValueResult';
+    facetValue: FacetValue;
+    count: Scalars['Int'];
+};
+export declare type FacetValueTranslation = {
+    __typename?: 'FacetValueTranslation';
+    id: Scalars['ID'];
+    createdAt: Scalars['DateTime'];
+    updatedAt: Scalars['DateTime'];
+    languageCode: LanguageCode;
+    name: Scalars['String'];
+};
+export declare type FloatCustomFieldConfig = CustomField & {
+    __typename?: 'FloatCustomFieldConfig';
+    name: Scalars['String'];
+    type: Scalars['String'];
+    list: Scalars['Boolean'];
+    label?: Maybe<Array<LocalizedString>>;
+    description?: Maybe<Array<LocalizedString>>;
+    readonly?: Maybe<Scalars['Boolean']>;
+    internal?: Maybe<Scalars['Boolean']>;
+    nullable?: Maybe<Scalars['Boolean']>;
+    min?: Maybe<Scalars['Float']>;
+    max?: Maybe<Scalars['Float']>;
+    step?: Maybe<Scalars['Float']>;
+    ui?: Maybe<Scalars['JSON']>;
+};
+export declare type Fulfillment = Node & {
+    __typename?: 'Fulfillment';
+    id: Scalars['ID'];
+    createdAt: Scalars['DateTime'];
+    updatedAt: Scalars['DateTime'];
+    orderItems: Array<OrderItem>;
+    state: Scalars['String'];
+    method: Scalars['String'];
+    trackingCode?: Maybe<Scalars['String']>;
+    customFields?: Maybe<Scalars['JSON']>;
+};
+export declare enum GlobalFlag {
+    TRUE = "TRUE",
+    FALSE = "FALSE",
+    INHERIT = "INHERIT"
+}
+export declare type HistoryEntry = Node & {
+    __typename?: 'HistoryEntry';
+    id: Scalars['ID'];
+    createdAt: Scalars['DateTime'];
+    updatedAt: Scalars['DateTime'];
+    type: HistoryEntryType;
+    data: Scalars['JSON'];
+};
+export declare type HistoryEntryFilterParameter = {
+    id?: Maybe<IdOperators>;
+    createdAt?: Maybe<DateOperators>;
+    updatedAt?: Maybe<DateOperators>;
+    type?: Maybe<StringOperators>;
+};
+export declare type HistoryEntryList = PaginatedList & {
+    __typename?: 'HistoryEntryList';
+    items: Array<HistoryEntry>;
+    totalItems: Scalars['Int'];
+};
+export declare type HistoryEntryListOptions = {
+    /** Skips the first n results, for use in pagination */
+    skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
+    take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
+    sort?: Maybe<HistoryEntrySortParameter>;
+    /** Allows the results to be filtered */
+    filter?: Maybe<HistoryEntryFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
+};
+export declare type HistoryEntrySortParameter = {
+    id?: Maybe<SortOrder>;
+    createdAt?: Maybe<SortOrder>;
+    updatedAt?: Maybe<SortOrder>;
+};
+export declare enum HistoryEntryType {
+    CUSTOMER_REGISTERED = "CUSTOMER_REGISTERED",
+    CUSTOMER_VERIFIED = "CUSTOMER_VERIFIED",
+    CUSTOMER_DETAIL_UPDATED = "CUSTOMER_DETAIL_UPDATED",
+    CUSTOMER_ADDED_TO_GROUP = "CUSTOMER_ADDED_TO_GROUP",
+    CUSTOMER_REMOVED_FROM_GROUP = "CUSTOMER_REMOVED_FROM_GROUP",
+    CUSTOMER_ADDRESS_CREATED = "CUSTOMER_ADDRESS_CREATED",
+    CUSTOMER_ADDRESS_UPDATED = "CUSTOMER_ADDRESS_UPDATED",
+    CUSTOMER_ADDRESS_DELETED = "CUSTOMER_ADDRESS_DELETED",
+    CUSTOMER_PASSWORD_UPDATED = "CUSTOMER_PASSWORD_UPDATED",
+    CUSTOMER_PASSWORD_RESET_REQUESTED = "CUSTOMER_PASSWORD_RESET_REQUESTED",
+    CUSTOMER_PASSWORD_RESET_VERIFIED = "CUSTOMER_PASSWORD_RESET_VERIFIED",
+    CUSTOMER_EMAIL_UPDATE_REQUESTED = "CUSTOMER_EMAIL_UPDATE_REQUESTED",
+    CUSTOMER_EMAIL_UPDATE_VERIFIED = "CUSTOMER_EMAIL_UPDATE_VERIFIED",
+    CUSTOMER_NOTE = "CUSTOMER_NOTE",
+    ORDER_STATE_TRANSITION = "ORDER_STATE_TRANSITION",
+    ORDER_PAYMENT_TRANSITION = "ORDER_PAYMENT_TRANSITION",
+    ORDER_FULFILLMENT = "ORDER_FULFILLMENT",
+    ORDER_CANCELLATION = "ORDER_CANCELLATION",
+    ORDER_REFUND_TRANSITION = "ORDER_REFUND_TRANSITION",
+    ORDER_FULFILLMENT_TRANSITION = "ORDER_FULFILLMENT_TRANSITION",
+    ORDER_NOTE = "ORDER_NOTE",
+    ORDER_COUPON_APPLIED = "ORDER_COUPON_APPLIED",
+    ORDER_COUPON_REMOVED = "ORDER_COUPON_REMOVED",
+    ORDER_MODIFIED = "ORDER_MODIFIED"
+}
+/** Operators for filtering on a list of ID fields */
+export declare type IdListOperators = {
+    inList: Scalars['ID'];
+};
+/** Operators for filtering on an ID field */
+export declare type IdOperators = {
+    eq?: Maybe<Scalars['String']>;
+    notEq?: Maybe<Scalars['String']>;
+    in?: Maybe<Array<Scalars['String']>>;
+    notIn?: Maybe<Array<Scalars['String']>>;
+};
+/**
+ * Returned if the token used to change a Customer's email address is valid, but has
+ * expired according to the `verificationTokenDuration` setting in the AuthOptions.
+ */
+export declare type IdentifierChangeTokenExpiredError = ErrorResult & {
+    __typename?: 'IdentifierChangeTokenExpiredError';
+    errorCode: ErrorCode;
+    message: Scalars['String'];
+};
+/**
+ * Returned if the token used to change a Customer's email address is either
+ * invalid or does not match any expected tokens.
+ */
+export declare type IdentifierChangeTokenInvalidError = ErrorResult & {
+    __typename?: 'IdentifierChangeTokenInvalidError';
+    errorCode: ErrorCode;
+    message: Scalars['String'];
+};
+/** Returned when attempting to add a Payment using a PaymentMethod for which the Order is not eligible. */
+export declare type IneligiblePaymentMethodError = ErrorResult & {
+    __typename?: 'IneligiblePaymentMethodError';
+    errorCode: ErrorCode;
+    message: Scalars['String'];
+    eligibilityCheckerMessage?: Maybe<Scalars['String']>;
+};
+/** Returned when attempting to set a ShippingMethod for which the Order is not eligible */
+export declare type IneligibleShippingMethodError = ErrorResult & {
+    __typename?: 'IneligibleShippingMethodError';
+    errorCode: ErrorCode;
+    message: Scalars['String'];
+};
+/** Returned when attempting to add more items to the Order than are available */
+export declare type InsufficientStockError = ErrorResult & {
+    __typename?: 'InsufficientStockError';
+    errorCode: ErrorCode;
+    message: Scalars['String'];
+    quantityAvailable: Scalars['Int'];
+    order: Order;
+};
+export declare type IntCustomFieldConfig = CustomField & {
+    __typename?: 'IntCustomFieldConfig';
+    name: Scalars['String'];
+    type: Scalars['String'];
+    list: Scalars['Boolean'];
+    label?: Maybe<Array<LocalizedString>>;
+    description?: Maybe<Array<LocalizedString>>;
+    readonly?: Maybe<Scalars['Boolean']>;
+    internal?: Maybe<Scalars['Boolean']>;
+    nullable?: Maybe<Scalars['Boolean']>;
+    min?: Maybe<Scalars['Int']>;
+    max?: Maybe<Scalars['Int']>;
+    step?: Maybe<Scalars['Int']>;
+    ui?: Maybe<Scalars['JSON']>;
+};
+/** Returned if the user authentication credentials are not valid */
+export declare type InvalidCredentialsError = ErrorResult & {
+    __typename?: 'InvalidCredentialsError';
+    errorCode: ErrorCode;
+    message: Scalars['String'];
+    authenticationError: Scalars['String'];
+};
+/**
+ * @description
+ * Languages in the form of a ISO 639-1 language code with optional
+ * region or script modifier (e.g. de_AT). The selection available is based
+ * on the [Unicode CLDR summary list](https://unicode-org.github.io/cldr-staging/charts/37/summary/root.html)
+ * and includes the major spoken languages of the world and any widely-used variants.
+ *
+ * @docsCategory common
+ */
+export declare enum LanguageCode {
+    /** Afrikaans */
+    af = "af",
+    /** Akan */
+    ak = "ak",
+    /** Albanian */
+    sq = "sq",
+    /** Amharic */
+    am = "am",
+    /** Arabic */
+    ar = "ar",
+    /** Armenian */
+    hy = "hy",
+    /** Assamese */
+    as = "as",
+    /** Azerbaijani */
+    az = "az",
+    /** Bambara */
+    bm = "bm",
+    /** Bangla */
+    bn = "bn",
+    /** Basque */
+    eu = "eu",
+    /** Belarusian */
+    be = "be",
+    /** Bosnian */
+    bs = "bs",
+    /** Breton */
+    br = "br",
+    /** Bulgarian */
+    bg = "bg",
+    /** Burmese */
+    my = "my",
+    /** Catalan */
+    ca = "ca",
+    /** Chechen */
+    ce = "ce",
+    /** Chinese */
+    zh = "zh",
+    /** Simplified Chinese */
+    zh_Hans = "zh_Hans",
+    /** Traditional Chinese */
+    zh_Hant = "zh_Hant",
+    /** Church Slavic */
+    cu = "cu",
+    /** Cornish */
+    kw = "kw",
+    /** Corsican */
+    co = "co",
+    /** Croatian */
+    hr = "hr",
+    /** Czech */
+    cs = "cs",
+    /** Danish */
+    da = "da",
+    /** Dutch */
+    nl = "nl",
+    /** Flemish */
+    nl_BE = "nl_BE",
+    /** Dzongkha */
+    dz = "dz",
+    /** English */
+    en = "en",
+    /** Australian English */
+    en_AU = "en_AU",
+    /** Canadian English */
+    en_CA = "en_CA",
+    /** British English */
+    en_GB = "en_GB",
+    /** American English */
+    en_US = "en_US",
+    /** Esperanto */
+    eo = "eo",
+    /** Estonian */
+    et = "et",
+    /** Ewe */
+    ee = "ee",
+    /** Faroese */
+    fo = "fo",
+    /** Finnish */
+    fi = "fi",
+    /** French */
+    fr = "fr",
+    /** Canadian French */
+    fr_CA = "fr_CA",
+    /** Swiss French */
+    fr_CH = "fr_CH",
+    /** Fulah */
+    ff = "ff",
+    /** Galician */
+    gl = "gl",
+    /** Ganda */
+    lg = "lg",
+    /** Georgian */
+    ka = "ka",
+    /** German */
+    de = "de",
+    /** Austrian German */
+    de_AT = "de_AT",
+    /** Swiss High German */
+    de_CH = "de_CH",
+    /** Greek */
+    el = "el",
+    /** Gujarati */
+    gu = "gu",
+    /** Haitian Creole */
+    ht = "ht",
+    /** Hausa */
+    ha = "ha",
+    /** Hebrew */
+    he = "he",
+    /** Hindi */
+    hi = "hi",
+    /** Hungarian */
+    hu = "hu",
+    /** Icelandic */
+    is = "is",
+    /** Igbo */
+    ig = "ig",
+    /** Indonesian */
+    id = "id",
+    /** Interlingua */
+    ia = "ia",
+    /** Irish */
+    ga = "ga",
+    /** Italian */
+    it = "it",
+    /** Japanese */
+    ja = "ja",
+    /** Javanese */
+    jv = "jv",
+    /** Kalaallisut */
+    kl = "kl",
+    /** Kannada */
+    kn = "kn",
+    /** Kashmiri */
+    ks = "ks",
+    /** Kazakh */
+    kk = "kk",
+    /** Khmer */
+    km = "km",
+    /** Kikuyu */
+    ki = "ki",
+    /** Kinyarwanda */
+    rw = "rw",
+    /** Korean */
+    ko = "ko",
+    /** Kurdish */
+    ku = "ku",
+    /** Kyrgyz */
+    ky = "ky",
+    /** Lao */
+    lo = "lo",
+    /** Latin */
+    la = "la",
+    /** Latvian */
+    lv = "lv",
+    /** Lingala */
+    ln = "ln",
+    /** Lithuanian */
+    lt = "lt",
+    /** Luba-Katanga */
+    lu = "lu",
+    /** Luxembourgish */
+    lb = "lb",
+    /** Macedonian */
+    mk = "mk",
+    /** Malagasy */
+    mg = "mg",
+    /** Malay */
+    ms = "ms",
+    /** Malayalam */
+    ml = "ml",
+    /** Maltese */
+    mt = "mt",
+    /** Manx */
+    gv = "gv",
+    /** Maori */
+    mi = "mi",
+    /** Marathi */
+    mr = "mr",
+    /** Mongolian */
+    mn = "mn",
+    /** Nepali */
+    ne = "ne",
+    /** North Ndebele */
+    nd = "nd",
+    /** Northern Sami */
+    se = "se",
+    /** Norwegian Bokmål */
+    nb = "nb",
+    /** Norwegian Nynorsk */
+    nn = "nn",
+    /** Nyanja */
+    ny = "ny",
+    /** Odia */
+    or = "or",
+    /** Oromo */
+    om = "om",
+    /** Ossetic */
+    os = "os",
+    /** Pashto */
+    ps = "ps",
+    /** Persian */
+    fa = "fa",
+    /** Dari */
+    fa_AF = "fa_AF",
+    /** Polish */
+    pl = "pl",
+    /** Portuguese */
+    pt = "pt",
+    /** Brazilian Portuguese */
+    pt_BR = "pt_BR",
+    /** European Portuguese */
+    pt_PT = "pt_PT",
+    /** Punjabi */
+    pa = "pa",
+    /** Quechua */
+    qu = "qu",
+    /** Romanian */
+    ro = "ro",
+    /** Moldavian */
+    ro_MD = "ro_MD",
+    /** Romansh */
+    rm = "rm",
+    /** Rundi */
+    rn = "rn",
+    /** Russian */
+    ru = "ru",
+    /** Samoan */
+    sm = "sm",
+    /** Sango */
+    sg = "sg",
+    /** Sanskrit */
+    sa = "sa",
+    /** Scottish Gaelic */
+    gd = "gd",
+    /** Serbian */
+    sr = "sr",
+    /** Shona */
+    sn = "sn",
+    /** Sichuan Yi */
+    ii = "ii",
+    /** Sindhi */
+    sd = "sd",
+    /** Sinhala */
+    si = "si",
+    /** Slovak */
+    sk = "sk",
+    /** Slovenian */
+    sl = "sl",
+    /** Somali */
+    so = "so",
+    /** Southern Sotho */
+    st = "st",
+    /** Spanish */
+    es = "es",
+    /** European Spanish */
+    es_ES = "es_ES",
+    /** Mexican Spanish */
+    es_MX = "es_MX",
+    /** Sundanese */
+    su = "su",
+    /** Swahili */
+    sw = "sw",
+    /** Congo Swahili */
+    sw_CD = "sw_CD",
+    /** Swedish */
+    sv = "sv",
+    /** Tajik */
+    tg = "tg",
+    /** Tamil */
+    ta = "ta",
+    /** Tatar */
+    tt = "tt",
+    /** Telugu */
+    te = "te",
+    /** Thai */
+    th = "th",
+    /** Tibetan */
+    bo = "bo",
+    /** Tigrinya */
+    ti = "ti",
+    /** Tongan */
+    to = "to",
+    /** Turkish */
+    tr = "tr",
+    /** Turkmen */
+    tk = "tk",
+    /** Ukrainian */
+    uk = "uk",
+    /** Urdu */
+    ur = "ur",
+    /** Uyghur */
+    ug = "ug",
+    /** Uzbek */
+    uz = "uz",
+    /** Vietnamese */
+    vi = "vi",
+    /** Volapük */
+    vo = "vo",
+    /** Welsh */
+    cy = "cy",
+    /** Western Frisian */
+    fy = "fy",
+    /** Wolof */
+    wo = "wo",
+    /** Xhosa */
+    xh = "xh",
+    /** Yiddish */
+    yi = "yi",
+    /** Yoruba */
+    yo = "yo",
+    /** Zulu */
+    zu = "zu"
+}
+export declare type LocaleStringCustomFieldConfig = CustomField & {
+    __typename?: 'LocaleStringCustomFieldConfig';
+    name: Scalars['String'];
+    type: Scalars['String'];
+    list: Scalars['Boolean'];
+    length?: Maybe<Scalars['Int']>;
+    label?: Maybe<Array<LocalizedString>>;
+    description?: Maybe<Array<LocalizedString>>;
+    readonly?: Maybe<Scalars['Boolean']>;
+    internal?: Maybe<Scalars['Boolean']>;
+    nullable?: Maybe<Scalars['Boolean']>;
+    pattern?: Maybe<Scalars['String']>;
+    ui?: Maybe<Scalars['JSON']>;
+};
+export declare type LocalizedString = {
+    __typename?: 'LocalizedString';
+    languageCode: LanguageCode;
+    value: Scalars['String'];
+};
+export declare enum LogicalOperator {
+    AND = "AND",
+    OR = "OR"
+}
+/** Returned when attempting to register or verify a customer account without a password, when one is required. */
+export declare type MissingPasswordError = ErrorResult & {
+    __typename?: 'MissingPasswordError';
+    errorCode: ErrorCode;
+    message: Scalars['String'];
+};
+export declare type MolliePaymentIntent = {
+    __typename?: 'MolliePaymentIntent';
+    url: Scalars['String'];
+};
+export declare type MolliePaymentIntentError = ErrorResult & {
+    __typename?: 'MolliePaymentIntentError';
+    errorCode: ErrorCode;
+    message: Scalars['String'];
+};
+export declare type MolliePaymentIntentInput = {
+    paymentMethodCode: Scalars['String'];
+};
+export declare type MolliePaymentIntentResult = MolliePaymentIntent | MolliePaymentIntentError;
+export declare type Mutation = {
+    __typename?: 'Mutation';
+    /** Adds an item to the order. If custom fields are defined on the OrderLine entity, a third argument 'customFields' will be available. */
+    addItemToOrder: UpdateOrderItemsResult;
+    /** Add a Payment to the Order */
+    addPaymentToOrder: AddPaymentToOrderResult;
+    /** Adjusts an OrderLine. If custom fields are defined on the OrderLine entity, a third argument 'customFields' of type `OrderLineCustomFieldsInput` will be available. */
+    adjustOrderLine: UpdateOrderItemsResult;
+    /** Applies the given coupon code to the active Order */
+    applyCouponCode: ApplyCouponCodeResult;
+    /** Authenticates the user using a named authentication strategy */
+    authenticate: AuthenticationResult;
+    /** Create a new Customer Address */
+    createCustomerAddress: Address;
+    createMolliePaymentIntent: MolliePaymentIntentResult;
+    /** Delete an existing Address */
+    deleteCustomerAddress: Success;
+    /** Authenticates the user using the native authentication strategy. This mutation is an alias for `authenticate({ native: { ... }})` */
+    login: NativeAuthenticationResult;
+    /** End the current authenticated session */
+    logout: Success;
+    /** Regenerate and send a verification token for a new Customer registration. Only applicable if `authOptions.requireVerification` is set to true. */
+    refreshCustomerVerification: RefreshCustomerVerificationResult;
+    /**
+     * Register a Customer account with the given credentials. There are three possible registration flows:
+     *
+     * _If `authOptions.requireVerification` is set to `true`:_
+     *
+     * 1. **The Customer is registered _with_ a password**. A verificationToken will be created (and typically emailed to the Customer). That
+     *    verificationToken would then be passed to the `verifyCustomerAccount` mutation _without_ a password. The Customer is then
+     *    verified and authenticated in one step.
+     * 2. **The Customer is registered _without_ a password**. A verificationToken will be created (and typically emailed to the Customer). That
+     *    verificationToken would then be passed to the `verifyCustomerAccount` mutation _with_ the chosen password of the Customer. The Customer is then
+     *    verified and authenticated in one step.
+     *
+     * _If `authOptions.requireVerification` is set to `false`:_
+     *
+     * 3. The Customer _must_ be registered _with_ a password. No further action is needed - the Customer is able to authenticate immediately.
+     */
+    registerCustomerAccount: RegisterCustomerAccountResult;
+    /** Remove all OrderLine from the Order */
+    removeAllOrderLines: RemoveOrderItemsResult;
+    /** Removes the given coupon code from the active Order */
+    removeCouponCode?: Maybe<Order>;
+    /** Remove an OrderLine from the Order */
+    removeOrderLine: RemoveOrderItemsResult;
+    /** Requests a password reset email to be sent */
+    requestPasswordReset?: Maybe<RequestPasswordResetResult>;
+    /**
+     * Request to update the emailAddress of the active Customer. If `authOptions.requireVerification` is enabled
+     * (as is the default), then the `identifierChangeToken` will be assigned to the current User and
+     * a IdentifierChangeRequestEvent will be raised. This can then be used e.g. by the EmailPlugin to email
+     * that verification token to the Customer, which is then used to verify the change of email address.
+     */
+    requestUpdateCustomerEmailAddress: RequestUpdateCustomerEmailAddressResult;
+    /** Resets a Customer's password based on the provided token */
+    resetPassword: ResetPasswordResult;
+    /** Set the Customer for the Order. Required only if the Customer is not currently logged in */
+    setCustomerForOrder: SetCustomerForOrderResult;
+    /** Sets the billing address for this order */
+    setOrderBillingAddress: ActiveOrderResult;
+    /** Allows any custom fields to be set for the active order */
+    setOrderCustomFields: ActiveOrderResult;
+    /** Sets the shipping address for this order */
+    setOrderShippingAddress: ActiveOrderResult;
+    /** Sets the shipping method by id, which can be obtained with the `eligibleShippingMethods` query */
+    setOrderShippingMethod: SetOrderShippingMethodResult;
+    /** Transitions an Order to a new state. Valid next states can be found by querying `nextOrderStates` */
+    transitionOrderToState?: Maybe<TransitionOrderToStateResult>;
+    /** Update an existing Customer */
+    updateCustomer: Customer;
+    /** Update an existing Address */
+    updateCustomerAddress: Address;
+    /**
+     * Confirm the update of the emailAddress with the provided token, which has been generated by the
+     * `requestUpdateCustomerEmailAddress` mutation.
+     */
+    updateCustomerEmailAddress: UpdateCustomerEmailAddressResult;
+    /** Update the password of the active Customer */
+    updateCustomerPassword: UpdateCustomerPasswordResult;
+    /**
+     * Verify a Customer email address with the token sent to that address. Only applicable if `authOptions.requireVerification` is set to true.
+     *
+     * If the Customer was not registered with a password in the `registerCustomerAccount` mutation, the password _must_ be
+     * provided here.
+     */
+    verifyCustomerAccount: VerifyCustomerAccountResult;
+};
+export declare type MutationAddItemToOrderArgs = {
+    productVariantId: Scalars['ID'];
+    quantity: Scalars['Int'];
+};
+export declare type MutationAddPaymentToOrderArgs = {
+    input: PaymentInput;
+};
+export declare type MutationAdjustOrderLineArgs = {
+    orderLineId: Scalars['ID'];
+    quantity: Scalars['Int'];
+};
+export declare type MutationApplyCouponCodeArgs = {
+    couponCode: Scalars['String'];
+};
+export declare type MutationAuthenticateArgs = {
+    input: AuthenticationInput;
+    rememberMe?: Maybe<Scalars['Boolean']>;
+};
+export declare type MutationCreateCustomerAddressArgs = {
+    input: CreateAddressInput;
+};
+export declare type MutationCreateMolliePaymentIntentArgs = {
+    input: MolliePaymentIntentInput;
+};
+export declare type MutationDeleteCustomerAddressArgs = {
+    id: Scalars['ID'];
+};
+export declare type MutationLoginArgs = {
+    username: Scalars['String'];
+    password: Scalars['String'];
+    rememberMe?: Maybe<Scalars['Boolean']>;
+};
+export declare type MutationRefreshCustomerVerificationArgs = {
+    emailAddress: Scalars['String'];
+};
+export declare type MutationRegisterCustomerAccountArgs = {
+    input: RegisterCustomerInput;
+};
+export declare type MutationRemoveCouponCodeArgs = {
+    couponCode: Scalars['String'];
+};
+export declare type MutationRemoveOrderLineArgs = {
+    orderLineId: Scalars['ID'];
+};
+export declare type MutationRequestPasswordResetArgs = {
+    emailAddress: Scalars['String'];
+};
+export declare type MutationRequestUpdateCustomerEmailAddressArgs = {
+    password: Scalars['String'];
+    newEmailAddress: Scalars['String'];
+};
+export declare type MutationResetPasswordArgs = {
+    token: Scalars['String'];
+    password: Scalars['String'];
+};
+export declare type MutationSetCustomerForOrderArgs = {
+    input: CreateCustomerInput;
+};
+export declare type MutationSetOrderBillingAddressArgs = {
+    input: CreateAddressInput;
+};
+export declare type MutationSetOrderCustomFieldsArgs = {
+    input: UpdateOrderInput;
+};
+export declare type MutationSetOrderShippingAddressArgs = {
+    input: CreateAddressInput;
+};
+export declare type MutationSetOrderShippingMethodArgs = {
+    shippingMethodId: Scalars['ID'];
+};
+export declare type MutationTransitionOrderToStateArgs = {
+    state: Scalars['String'];
+};
+export declare type MutationUpdateCustomerArgs = {
+    input: UpdateCustomerInput;
+};
+export declare type MutationUpdateCustomerAddressArgs = {
+    input: UpdateAddressInput;
+};
+export declare type MutationUpdateCustomerEmailAddressArgs = {
+    token: Scalars['String'];
+};
+export declare type MutationUpdateCustomerPasswordArgs = {
+    currentPassword: Scalars['String'];
+    newPassword: Scalars['String'];
+};
+export declare type MutationVerifyCustomerAccountArgs = {
+    token: Scalars['String'];
+    password?: Maybe<Scalars['String']>;
+};
+export declare type NativeAuthInput = {
+    username: Scalars['String'];
+    password: Scalars['String'];
+};
+/** Returned when attempting an operation that relies on the NativeAuthStrategy, if that strategy is not configured. */
+export declare type NativeAuthStrategyError = ErrorResult & {
+    __typename?: 'NativeAuthStrategyError';
+    errorCode: ErrorCode;
+    message: Scalars['String'];
+};
+export declare type NativeAuthenticationResult = CurrentUser | InvalidCredentialsError | NotVerifiedError | NativeAuthStrategyError;
+/** Returned when attempting to set a negative OrderLine quantity. */
+export declare type NegativeQuantityError = ErrorResult & {
+    __typename?: 'NegativeQuantityError';
+    errorCode: ErrorCode;
+    message: Scalars['String'];
+};
+/**
+ * Returned when invoking a mutation which depends on there being an active Order on the
+ * current session.
+ */
+export declare type NoActiveOrderError = ErrorResult & {
+    __typename?: 'NoActiveOrderError';
+    errorCode: ErrorCode;
+    message: Scalars['String'];
+};
+export declare type Node = {
+    id: Scalars['ID'];
+};
+/**
+ * Returned if `authOptions.requireVerification` is set to `true` (which is the default)
+ * and an unverified user attempts to authenticate.
+ */
+export declare type NotVerifiedError = ErrorResult & {
+    __typename?: 'NotVerifiedError';
+    errorCode: ErrorCode;
+    message: Scalars['String'];
+};
+/** Operators for filtering on a list of Number fields */
+export declare type NumberListOperators = {
+    inList: Scalars['Float'];
+};
+/** Operators for filtering on a Int or Float field */
+export declare type NumberOperators = {
+    eq?: Maybe<Scalars['Float']>;
+    lt?: Maybe<Scalars['Float']>;
+    lte?: Maybe<Scalars['Float']>;
+    gt?: Maybe<Scalars['Float']>;
+    gte?: Maybe<Scalars['Float']>;
+    between?: Maybe<NumberRange>;
+};
+export declare type NumberRange = {
+    start: Scalars['Float'];
+    end: Scalars['Float'];
+};
+export declare type Order = Node & {
+    __typename?: 'Order';
+    id: Scalars['ID'];
+    createdAt: Scalars['DateTime'];
+    updatedAt: Scalars['DateTime'];
+    /**
+     * The date & time that the Order was placed, i.e. the Customer
+     * completed the checkout and the Order is no longer "active"
+     */
+    orderPlacedAt?: Maybe<Scalars['DateTime']>;
+    /** A unique code for the Order */
+    code: Scalars['String'];
+    state: Scalars['String'];
+    /** An order is active as long as the payment process has not been completed */
+    active: Scalars['Boolean'];
+    customer?: Maybe<Customer>;
+    shippingAddress?: Maybe<OrderAddress>;
+    billingAddress?: Maybe<OrderAddress>;
+    lines: Array<OrderLine>;
+    /**
+     * Surcharges are arbitrary modifications to the Order total which are neither
+     * ProductVariants nor discounts resulting from applied Promotions. For example,
+     * one-off discounts based on customer interaction, or surcharges based on payment
+     * methods.
+     */
+    surcharges: Array<Surcharge>;
+    discounts: Array<Discount>;
+    /** An array of all coupon codes applied to the Order */
+    couponCodes: Array<Scalars['String']>;
+    /** Promotions applied to the order. Only gets populated after the payment process has completed. */
+    promotions: Array<Promotion>;
+    payments?: Maybe<Array<Payment>>;
+    fulfillments?: Maybe<Array<Fulfillment>>;
+    totalQuantity: Scalars['Int'];
+    /**
+     * The subTotal is the total of all OrderLines in the Order. This figure also includes any Order-level
+     * discounts which have been prorated (proportionally distributed) amongst the OrderItems.
+     * To get a total of all OrderLines which does not account for prorated discounts, use the
+     * sum of `OrderLine.discountedLinePrice` values.
+     */
+    subTotal: Scalars['Int'];
+    /** Same as subTotal, but inclusive of tax */
+    subTotalWithTax: Scalars['Int'];
+    currencyCode: CurrencyCode;
+    shippingLines: Array<ShippingLine>;
+    shipping: Scalars['Int'];
+    shippingWithTax: Scalars['Int'];
+    /** Equal to subTotal plus shipping */
+    total: Scalars['Int'];
+    /** The final payable amount. Equal to subTotalWithTax plus shippingWithTax */
+    totalWithTax: Scalars['Int'];
+    /** A summary of the taxes being applied to this Order */
+    taxSummary: Array<OrderTaxSummary>;
+    history: HistoryEntryList;
+    customFields?: Maybe<Scalars['JSON']>;
+};
+export declare type OrderHistoryArgs = {
+    options?: Maybe<HistoryEntryListOptions>;
+};
+export declare type OrderAddress = {
+    __typename?: 'OrderAddress';
+    fullName?: Maybe<Scalars['String']>;
+    company?: Maybe<Scalars['String']>;
+    streetLine1?: Maybe<Scalars['String']>;
+    streetLine2?: Maybe<Scalars['String']>;
+    city?: Maybe<Scalars['String']>;
+    province?: Maybe<Scalars['String']>;
+    postalCode?: Maybe<Scalars['String']>;
+    country?: Maybe<Scalars['String']>;
+    countryCode?: Maybe<Scalars['String']>;
+    phoneNumber?: Maybe<Scalars['String']>;
+    customFields?: Maybe<Scalars['JSON']>;
+};
+export declare type OrderFilterParameter = {
+    id?: Maybe<IdOperators>;
+    createdAt?: Maybe<DateOperators>;
+    updatedAt?: Maybe<DateOperators>;
+    orderPlacedAt?: Maybe<DateOperators>;
+    code?: Maybe<StringOperators>;
+    state?: Maybe<StringOperators>;
+    active?: Maybe<BooleanOperators>;
+    totalQuantity?: Maybe<NumberOperators>;
+    subTotal?: Maybe<NumberOperators>;
+    subTotalWithTax?: Maybe<NumberOperators>;
+    currencyCode?: Maybe<StringOperators>;
+    shipping?: Maybe<NumberOperators>;
+    shippingWithTax?: Maybe<NumberOperators>;
+    total?: Maybe<NumberOperators>;
+    totalWithTax?: Maybe<NumberOperators>;
+};
+export declare type OrderItem = Node & {
+    __typename?: 'OrderItem';
+    id: Scalars['ID'];
+    createdAt: Scalars['DateTime'];
+    updatedAt: Scalars['DateTime'];
+    cancelled: Scalars['Boolean'];
+    /** The price of a single unit, excluding tax and discounts */
+    unitPrice: Scalars['Int'];
+    /** The price of a single unit, including tax but excluding discounts */
+    unitPriceWithTax: Scalars['Int'];
+    /**
+     * The price of a single unit including discounts, excluding tax.
+     *
+     * If Order-level discounts have been applied, this will not be the
+     * actual taxable unit price (see `proratedUnitPrice`), but is generally the
+     * correct price to display to customers to avoid confusion
+     * about the internal handling of distributed Order-level discounts.
+     */
+    discountedUnitPrice: Scalars['Int'];
+    /** The price of a single unit including discounts and tax */
+    discountedUnitPriceWithTax: Scalars['Int'];
+    /**
+     * The actual unit price, taking into account both item discounts _and_ prorated (proportionally-distributed)
+     * Order-level discounts. This value is the true economic value of the OrderItem, and is used in tax
+     * and refund calculations.
+     */
+    proratedUnitPrice: Scalars['Int'];
+    /** The proratedUnitPrice including tax */
+    proratedUnitPriceWithTax: Scalars['Int'];
+    unitTax: Scalars['Int'];
+    taxRate: Scalars['Float'];
+    adjustments: Array<Adjustment>;
+    taxLines: Array<TaxLine>;
+    fulfillment?: Maybe<Fulfillment>;
+    refundId?: Maybe<Scalars['ID']>;
+};
+/** Returned when the maximum order size limit has been reached. */
+export declare type OrderLimitError = ErrorResult & {
+    __typename?: 'OrderLimitError';
+    errorCode: ErrorCode;
+    message: Scalars['String'];
+    maxItems: Scalars['Int'];
+};
+export declare type OrderLine = Node & {
+    __typename?: 'OrderLine';
+    id: Scalars['ID'];
+    createdAt: Scalars['DateTime'];
+    updatedAt: Scalars['DateTime'];
+    productVariant: ProductVariant;
+    featuredAsset?: Maybe<Asset>;
+    /** The price of a single unit, excluding tax and discounts */
+    unitPrice: Scalars['Int'];
+    /** The price of a single unit, including tax but excluding discounts */
+    unitPriceWithTax: Scalars['Int'];
+    /** Non-zero if the unitPrice has changed since it was initially added to Order */
+    unitPriceChangeSinceAdded: Scalars['Int'];
+    /** Non-zero if the unitPriceWithTax has changed since it was initially added to Order */
+    unitPriceWithTaxChangeSinceAdded: Scalars['Int'];
+    /**
+     * The price of a single unit including discounts, excluding tax.
+     *
+     * If Order-level discounts have been applied, this will not be the
+     * actual taxable unit price (see `proratedUnitPrice`), but is generally the
+     * correct price to display to customers to avoid confusion
+     * about the internal handling of distributed Order-level discounts.
+     */
+    discountedUnitPrice: Scalars['Int'];
+    /** The price of a single unit including discounts and tax */
+    discountedUnitPriceWithTax: Scalars['Int'];
+    /**
+     * The actual unit price, taking into account both item discounts _and_ prorated (proportionally-distributed)
+     * Order-level discounts. This value is the true economic value of the OrderItem, and is used in tax
+     * and refund calculations.
+     */
+    proratedUnitPrice: Scalars['Int'];
+    /** The proratedUnitPrice including tax */
+    proratedUnitPriceWithTax: Scalars['Int'];
+    quantity: Scalars['Int'];
+    items: Array<OrderItem>;
+    taxRate: Scalars['Float'];
+    /** The total price of the line excluding tax and discounts. */
+    linePrice: Scalars['Int'];
+    /** The total price of the line including tax but excluding discounts. */
+    linePriceWithTax: Scalars['Int'];
+    /** The price of the line including discounts, excluding tax */
+    discountedLinePrice: Scalars['Int'];
+    /** The price of the line including discounts and tax */
+    discountedLinePriceWithTax: Scalars['Int'];
+    /**
+     * The actual line price, taking into account both item discounts _and_ prorated (proportionally-distributed)
+     * Order-level discounts. This value is the true economic value of the OrderLine, and is used in tax
+     * and refund calculations.
+     */
+    proratedLinePrice: Scalars['Int'];
+    /** The proratedLinePrice including tax */
+    proratedLinePriceWithTax: Scalars['Int'];
+    /** The total tax on this line */
+    lineTax: Scalars['Int'];
+    discounts: Array<Discount>;
+    taxLines: Array<TaxLine>;
+    order: Order;
+    customFields?: Maybe<Scalars['JSON']>;
+};
+export declare type OrderList = PaginatedList & {
+    __typename?: 'OrderList';
+    items: Array<Order>;
+    totalItems: Scalars['Int'];
+};
+export declare type OrderListOptions = {
+    /** Skips the first n results, for use in pagination */
+    skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
+    take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
+    sort?: Maybe<OrderSortParameter>;
+    /** Allows the results to be filtered */
+    filter?: Maybe<OrderFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
+};
+/** Returned when attempting to modify the contents of an Order that is not in the `AddingItems` state. */
+export declare type OrderModificationError = ErrorResult & {
+    __typename?: 'OrderModificationError';
+    errorCode: ErrorCode;
+    message: Scalars['String'];
+};
+/** Returned when attempting to add a Payment to an Order that is not in the `ArrangingPayment` state. */
+export declare type OrderPaymentStateError = ErrorResult & {
+    __typename?: 'OrderPaymentStateError';
+    errorCode: ErrorCode;
+    message: Scalars['String'];
+};
+export declare type OrderSortParameter = {
+    id?: Maybe<SortOrder>;
+    createdAt?: Maybe<SortOrder>;
+    updatedAt?: Maybe<SortOrder>;
+    orderPlacedAt?: Maybe<SortOrder>;
+    code?: Maybe<SortOrder>;
+    state?: Maybe<SortOrder>;
+    totalQuantity?: Maybe<SortOrder>;
+    subTotal?: Maybe<SortOrder>;
+    subTotalWithTax?: Maybe<SortOrder>;
+    shipping?: Maybe<SortOrder>;
+    shippingWithTax?: Maybe<SortOrder>;
+    total?: Maybe<SortOrder>;
+    totalWithTax?: Maybe<SortOrder>;
+};
+/** Returned if there is an error in transitioning the Order state */
+export declare type OrderStateTransitionError = ErrorResult & {
+    __typename?: 'OrderStateTransitionError';
+    errorCode: ErrorCode;
+    message: Scalars['String'];
+    transitionError: Scalars['String'];
+    fromState: Scalars['String'];
+    toState: Scalars['String'];
+};
+/**
+ * A summary of the taxes being applied to this order, grouped
+ * by taxRate.
+ */
+export declare type OrderTaxSummary = {
+    __typename?: 'OrderTaxSummary';
+    /** A description of this tax */
+    description: Scalars['String'];
+    /** The taxRate as a percentage */
+    taxRate: Scalars['Float'];
+    /** The total net price or OrderItems to which this taxRate applies */
+    taxBase: Scalars['Int'];
+    /** The total tax being applied to the Order at this taxRate */
+    taxTotal: Scalars['Int'];
+};
+export declare type PaginatedList = {
+    items: Array<Node>;
+    totalItems: Scalars['Int'];
+};
+/** Returned when attempting to verify a customer account with a password, when a password has already been set. */
+export declare type PasswordAlreadySetError = ErrorResult & {
+    __typename?: 'PasswordAlreadySetError';
+    errorCode: ErrorCode;
+    message: Scalars['String'];
+};
+/**
+ * Returned if the token used to reset a Customer's password is valid, but has
+ * expired according to the `verificationTokenDuration` setting in the AuthOptions.
+ */
+export declare type PasswordResetTokenExpiredError = ErrorResult & {
+    __typename?: 'PasswordResetTokenExpiredError';
+    errorCode: ErrorCode;
+    message: Scalars['String'];
+};
+/**
+ * Returned if the token used to reset a Customer's password is either
+ * invalid or does not match any expected tokens.
+ */
+export declare type PasswordResetTokenInvalidError = ErrorResult & {
+    __typename?: 'PasswordResetTokenInvalidError';
+    errorCode: ErrorCode;
+    message: Scalars['String'];
+};
+/** Returned when attempting to register or verify a customer account where the given password fails password validation. */
+export declare type PasswordValidationError = ErrorResult & {
+    __typename?: 'PasswordValidationError';
+    errorCode: ErrorCode;
+    message: Scalars['String'];
+    validationErrorMessage: Scalars['String'];
+};
+export declare type Payment = Node & {
+    __typename?: 'Payment';
+    id: Scalars['ID'];
+    createdAt: Scalars['DateTime'];
+    updatedAt: Scalars['DateTime'];
+    method: Scalars['String'];
+    amount: Scalars['Int'];
+    state: Scalars['String'];
+    transactionId?: Maybe<Scalars['String']>;
+    errorMessage?: Maybe<Scalars['String']>;
+    refunds: Array<Refund>;
+    metadata?: Maybe<Scalars['JSON']>;
+};
+/** Returned when a Payment is declined by the payment provider. */
+export declare type PaymentDeclinedError = ErrorResult & {
+    __typename?: 'PaymentDeclinedError';
+    errorCode: ErrorCode;
+    message: Scalars['String'];
+    paymentErrorMessage: Scalars['String'];
+};
+/** Returned when a Payment fails due to an error. */
+export declare type PaymentFailedError = ErrorResult & {
+    __typename?: 'PaymentFailedError';
+    errorCode: ErrorCode;
+    message: Scalars['String'];
+    paymentErrorMessage: Scalars['String'];
+};
+/** Passed as input to the `addPaymentToOrder` mutation. */
+export declare type PaymentInput = {
+    /** This field should correspond to the `code` property of a PaymentMethod. */
+    method: Scalars['String'];
+    /**
+     * This field should contain arbitrary data passed to the specified PaymentMethodHandler's `createPayment()` method
+     * as the "metadata" argument. For example, it could contain an ID for the payment and other
+     * data generated by the payment provider.
+     */
+    metadata: Scalars['JSON'];
+};
+export declare type PaymentMethod = Node & {
+    __typename?: 'PaymentMethod';
+    id: Scalars['ID'];
+    createdAt: Scalars['DateTime'];
+    updatedAt: Scalars['DateTime'];
+    name: Scalars['String'];
+    code: Scalars['String'];
+    description: Scalars['String'];
+    enabled: Scalars['Boolean'];
+    checker?: Maybe<ConfigurableOperation>;
+    handler: ConfigurableOperation;
+    customFields?: Maybe<Scalars['JSON']>;
+};
+export declare type PaymentMethodQuote = {
+    __typename?: 'PaymentMethodQuote';
+    id: Scalars['ID'];
+    code: Scalars['String'];
+    name: Scalars['String'];
+    description: Scalars['String'];
+    isEligible: Scalars['Boolean'];
+    eligibilityMessage?: Maybe<Scalars['String']>;
+    customFields?: Maybe<Scalars['JSON']>;
+};
+/**
+ * @description
+ * Permissions for administrators and customers. Used to control access to
+ * GraphQL resolvers via the {@link Allow} decorator.
+ *
+ * ## Understanding Permission.Owner
+ *
+ * `Permission.Owner` is a special permission which is used in some of the Vendure resolvers to indicate that that resolver should only
+ * be accessible to the "owner" of that resource.
+ *
+ * For example, the Shop API `activeCustomer` query resolver should only return the Customer object for the "owner" of that Customer, i.e.
+ * based on the activeUserId of the current session. As a result, the resolver code looks like this:
+ *
+ * @example
+ * ```TypeScript
+ * \@Query()
+ * \@Allow(Permission.Owner)
+ * async activeCustomer(\@Ctx() ctx: RequestContext): Promise<Customer | undefined> {
+ *   const userId = ctx.activeUserId;
+ *   if (userId) {
+ *     return this.customerService.findOneByUserId(ctx, userId);
+ *   }
+ * }
+ * ```
+ *
+ * Here we can see that the "ownership" must be enforced by custom logic inside the resolver. Since "ownership" cannot be defined generally
+ * nor statically encoded at build-time, any resolvers using `Permission.Owner` **must** include logic to enforce that only the owner
+ * of the resource has access. If not, then it is the equivalent of using `Permission.Public`.
+ *
+ *
+ * @docsCategory common
+ */
+export declare enum Permission {
+    /** Authenticated means simply that the user is logged in */
+    Authenticated = "Authenticated",
+    /** SuperAdmin has unrestricted access to all operations */
+    SuperAdmin = "SuperAdmin",
+    /** Owner means the user owns this entity, e.g. a Customer's own Order */
+    Owner = "Owner",
+    /** Public means any unauthenticated user may perform the operation */
+    Public = "Public",
+    /** Grants permission to update GlobalSettings */
+    UpdateGlobalSettings = "UpdateGlobalSettings",
+    /** Grants permission to create Products, Facets, Assets, Collections */
+    CreateCatalog = "CreateCatalog",
+    /** Grants permission to read Products, Facets, Assets, Collections */
+    ReadCatalog = "ReadCatalog",
+    /** Grants permission to update Products, Facets, Assets, Collections */
+    UpdateCatalog = "UpdateCatalog",
+    /** Grants permission to delete Products, Facets, Assets, Collections */
+    DeleteCatalog = "DeleteCatalog",
+    /** Grants permission to create PaymentMethods, ShippingMethods, TaxCategories, TaxRates, Zones, Countries, System & GlobalSettings */
+    CreateSettings = "CreateSettings",
+    /** Grants permission to read PaymentMethods, ShippingMethods, TaxCategories, TaxRates, Zones, Countries, System & GlobalSettings */
+    ReadSettings = "ReadSettings",
+    /** Grants permission to update PaymentMethods, ShippingMethods, TaxCategories, TaxRates, Zones, Countries, System & GlobalSettings */
+    UpdateSettings = "UpdateSettings",
+    /** Grants permission to delete PaymentMethods, ShippingMethods, TaxCategories, TaxRates, Zones, Countries, System & GlobalSettings */
+    DeleteSettings = "DeleteSettings",
+    /** Grants permission to create Administrator */
+    CreateAdministrator = "CreateAdministrator",
+    /** Grants permission to read Administrator */
+    ReadAdministrator = "ReadAdministrator",
+    /** Grants permission to update Administrator */
+    UpdateAdministrator = "UpdateAdministrator",
+    /** Grants permission to delete Administrator */
+    DeleteAdministrator = "DeleteAdministrator",
+    /** Grants permission to create Asset */
+    CreateAsset = "CreateAsset",
+    /** Grants permission to read Asset */
+    ReadAsset = "ReadAsset",
+    /** Grants permission to update Asset */
+    UpdateAsset = "UpdateAsset",
+    /** Grants permission to delete Asset */
+    DeleteAsset = "DeleteAsset",
+    /** Grants permission to create Channel */
+    CreateChannel = "CreateChannel",
+    /** Grants permission to read Channel */
+    ReadChannel = "ReadChannel",
+    /** Grants permission to update Channel */
+    UpdateChannel = "UpdateChannel",
+    /** Grants permission to delete Channel */
+    DeleteChannel = "DeleteChannel",
+    /** Grants permission to create Collection */
+    CreateCollection = "CreateCollection",
+    /** Grants permission to read Collection */
+    ReadCollection = "ReadCollection",
+    /** Grants permission to update Collection */
+    UpdateCollection = "UpdateCollection",
+    /** Grants permission to delete Collection */
+    DeleteCollection = "DeleteCollection",
+    /** Grants permission to create Country */
+    CreateCountry = "CreateCountry",
+    /** Grants permission to read Country */
+    ReadCountry = "ReadCountry",
+    /** Grants permission to update Country */
+    UpdateCountry = "UpdateCountry",
+    /** Grants permission to delete Country */
+    DeleteCountry = "DeleteCountry",
+    /** Grants permission to create Customer */
+    CreateCustomer = "CreateCustomer",
+    /** Grants permission to read Customer */
+    ReadCustomer = "ReadCustomer",
+    /** Grants permission to update Customer */
+    UpdateCustomer = "UpdateCustomer",
+    /** Grants permission to delete Customer */
+    DeleteCustomer = "DeleteCustomer",
+    /** Grants permission to create CustomerGroup */
+    CreateCustomerGroup = "CreateCustomerGroup",
+    /** Grants permission to read CustomerGroup */
+    ReadCustomerGroup = "ReadCustomerGroup",
+    /** Grants permission to update CustomerGroup */
+    UpdateCustomerGroup = "UpdateCustomerGroup",
+    /** Grants permission to delete CustomerGroup */
+    DeleteCustomerGroup = "DeleteCustomerGroup",
+    /** Grants permission to create Facet */
+    CreateFacet = "CreateFacet",
+    /** Grants permission to read Facet */
+    ReadFacet = "ReadFacet",
+    /** Grants permission to update Facet */
+    UpdateFacet = "UpdateFacet",
+    /** Grants permission to delete Facet */
+    DeleteFacet = "DeleteFacet",
+    /** Grants permission to create Order */
+    CreateOrder = "CreateOrder",
+    /** Grants permission to read Order */
+    ReadOrder = "ReadOrder",
+    /** Grants permission to update Order */
+    UpdateOrder = "UpdateOrder",
+    /** Grants permission to delete Order */
+    DeleteOrder = "DeleteOrder",
+    /** Grants permission to create PaymentMethod */
+    CreatePaymentMethod = "CreatePaymentMethod",
+    /** Grants permission to read PaymentMethod */
+    ReadPaymentMethod = "ReadPaymentMethod",
+    /** Grants permission to update PaymentMethod */
+    UpdatePaymentMethod = "UpdatePaymentMethod",
+    /** Grants permission to delete PaymentMethod */
+    DeletePaymentMethod = "DeletePaymentMethod",
+    /** Grants permission to create Product */
+    CreateProduct = "CreateProduct",
+    /** Grants permission to read Product */
+    ReadProduct = "ReadProduct",
+    /** Grants permission to update Product */
+    UpdateProduct = "UpdateProduct",
+    /** Grants permission to delete Product */
+    DeleteProduct = "DeleteProduct",
+    /** Grants permission to create Promotion */
+    CreatePromotion = "CreatePromotion",
+    /** Grants permission to read Promotion */
+    ReadPromotion = "ReadPromotion",
+    /** Grants permission to update Promotion */
+    UpdatePromotion = "UpdatePromotion",
+    /** Grants permission to delete Promotion */
+    DeletePromotion = "DeletePromotion",
+    /** Grants permission to create ShippingMethod */
+    CreateShippingMethod = "CreateShippingMethod",
+    /** Grants permission to read ShippingMethod */
+    ReadShippingMethod = "ReadShippingMethod",
+    /** Grants permission to update ShippingMethod */
+    UpdateShippingMethod = "UpdateShippingMethod",
+    /** Grants permission to delete ShippingMethod */
+    DeleteShippingMethod = "DeleteShippingMethod",
+    /** Grants permission to create Tag */
+    CreateTag = "CreateTag",
+    /** Grants permission to read Tag */
+    ReadTag = "ReadTag",
+    /** Grants permission to update Tag */
+    UpdateTag = "UpdateTag",
+    /** Grants permission to delete Tag */
+    DeleteTag = "DeleteTag",
+    /** Grants permission to create TaxCategory */
+    CreateTaxCategory = "CreateTaxCategory",
+    /** Grants permission to read TaxCategory */
+    ReadTaxCategory = "ReadTaxCategory",
+    /** Grants permission to update TaxCategory */
+    UpdateTaxCategory = "UpdateTaxCategory",
+    /** Grants permission to delete TaxCategory */
+    DeleteTaxCategory = "DeleteTaxCategory",
+    /** Grants permission to create TaxRate */
+    CreateTaxRate = "CreateTaxRate",
+    /** Grants permission to read TaxRate */
+    ReadTaxRate = "ReadTaxRate",
+    /** Grants permission to update TaxRate */
+    UpdateTaxRate = "UpdateTaxRate",
+    /** Grants permission to delete TaxRate */
+    DeleteTaxRate = "DeleteTaxRate",
+    /** Grants permission to create System */
+    CreateSystem = "CreateSystem",
+    /** Grants permission to read System */
+    ReadSystem = "ReadSystem",
+    /** Grants permission to update System */
+    UpdateSystem = "UpdateSystem",
+    /** Grants permission to delete System */
+    DeleteSystem = "DeleteSystem",
+    /** Grants permission to create Zone */
+    CreateZone = "CreateZone",
+    /** Grants permission to read Zone */
+    ReadZone = "ReadZone",
+    /** Grants permission to update Zone */
+    UpdateZone = "UpdateZone",
+    /** Grants permission to delete Zone */
+    DeleteZone = "DeleteZone"
+}
+/** The price range where the result has more than one price */
+export declare type PriceRange = {
+    __typename?: 'PriceRange';
+    min: Scalars['Int'];
+    max: Scalars['Int'];
+};
+export declare type Product = Node & {
+    __typename?: 'Product';
+    id: Scalars['ID'];
+    createdAt: Scalars['DateTime'];
+    updatedAt: Scalars['DateTime'];
+    languageCode: LanguageCode;
+    name: Scalars['String'];
+    slug: Scalars['String'];
+    description: Scalars['String'];
+    featuredAsset?: Maybe<Asset>;
+    assets: Array<Asset>;
+    /** Returns all ProductVariants */
+    variants: Array<ProductVariant>;
+    /** Returns a paginated, sortable, filterable list of ProductVariants */
+    variantList: ProductVariantList;
+    optionGroups: Array<ProductOptionGroup>;
+    facetValues: Array<FacetValue>;
+    translations: Array<ProductTranslation>;
+    collections: Array<Collection>;
+    customFields?: Maybe<Scalars['JSON']>;
+};
+export declare type ProductVariantListArgs = {
+    options?: Maybe<ProductVariantListOptions>;
+};
+export declare type ProductFilterParameter = {
+    id?: Maybe<IdOperators>;
+    createdAt?: Maybe<DateOperators>;
+    updatedAt?: Maybe<DateOperators>;
+    languageCode?: Maybe<StringOperators>;
+    name?: Maybe<StringOperators>;
+    slug?: Maybe<StringOperators>;
+    description?: Maybe<StringOperators>;
+};
+export declare type ProductList = PaginatedList & {
+    __typename?: 'ProductList';
+    items: Array<Product>;
+    totalItems: Scalars['Int'];
+};
+export declare type ProductListOptions = {
+    /** Skips the first n results, for use in pagination */
+    skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
+    take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
+    sort?: Maybe<ProductSortParameter>;
+    /** Allows the results to be filtered */
+    filter?: Maybe<ProductFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
+};
+export declare type ProductOption = Node & {
+    __typename?: 'ProductOption';
+    id: Scalars['ID'];
+    createdAt: Scalars['DateTime'];
+    updatedAt: Scalars['DateTime'];
+    languageCode: LanguageCode;
+    code: Scalars['String'];
+    name: Scalars['String'];
+    groupId: Scalars['ID'];
+    group: ProductOptionGroup;
+    translations: Array<ProductOptionTranslation>;
+    customFields?: Maybe<Scalars['JSON']>;
+};
+export declare type ProductOptionGroup = Node & {
+    __typename?: 'ProductOptionGroup';
+    id: Scalars['ID'];
+    createdAt: Scalars['DateTime'];
+    updatedAt: Scalars['DateTime'];
+    languageCode: LanguageCode;
+    code: Scalars['String'];
+    name: Scalars['String'];
+    options: Array<ProductOption>;
+    translations: Array<ProductOptionGroupTranslation>;
+    customFields?: Maybe<Scalars['JSON']>;
+};
+export declare type ProductOptionGroupTranslation = {
+    __typename?: 'ProductOptionGroupTranslation';
+    id: Scalars['ID'];
+    createdAt: Scalars['DateTime'];
+    updatedAt: Scalars['DateTime'];
+    languageCode: LanguageCode;
+    name: Scalars['String'];
+};
+export declare type ProductOptionTranslation = {
+    __typename?: 'ProductOptionTranslation';
+    id: Scalars['ID'];
+    createdAt: Scalars['DateTime'];
+    updatedAt: Scalars['DateTime'];
+    languageCode: LanguageCode;
+    name: Scalars['String'];
+};
+export declare type ProductSortParameter = {
+    id?: Maybe<SortOrder>;
+    createdAt?: Maybe<SortOrder>;
+    updatedAt?: Maybe<SortOrder>;
+    name?: Maybe<SortOrder>;
+    slug?: Maybe<SortOrder>;
+    description?: Maybe<SortOrder>;
+};
+export declare type ProductTranslation = {
+    __typename?: 'ProductTranslation';
+    id: Scalars['ID'];
+    createdAt: Scalars['DateTime'];
+    updatedAt: Scalars['DateTime'];
+    languageCode: LanguageCode;
+    name: Scalars['String'];
+    slug: Scalars['String'];
+    description: Scalars['String'];
+};
+export declare type ProductVariant = Node & {
+    __typename?: 'ProductVariant';
+    id: Scalars['ID'];
+    product: Product;
+    productId: Scalars['ID'];
+    createdAt: Scalars['DateTime'];
+    updatedAt: Scalars['DateTime'];
+    languageCode: LanguageCode;
+    sku: Scalars['String'];
+    name: Scalars['String'];
+    featuredAsset?: Maybe<Asset>;
+    assets: Array<Asset>;
+    price: Scalars['Int'];
+    currencyCode: CurrencyCode;
+    priceWithTax: Scalars['Int'];
+    stockLevel: Scalars['String'];
+    taxRateApplied: TaxRate;
+    taxCategory: TaxCategory;
+    options: Array<ProductOption>;
+    facetValues: Array<FacetValue>;
+    translations: Array<ProductVariantTranslation>;
+    customFields?: Maybe<Scalars['JSON']>;
+};
+export declare type ProductVariantFilterParameter = {
+    id?: Maybe<IdOperators>;
+    productId?: Maybe<IdOperators>;
+    createdAt?: Maybe<DateOperators>;
+    updatedAt?: Maybe<DateOperators>;
+    languageCode?: Maybe<StringOperators>;
+    sku?: Maybe<StringOperators>;
+    name?: Maybe<StringOperators>;
+    price?: Maybe<NumberOperators>;
+    currencyCode?: Maybe<StringOperators>;
+    priceWithTax?: Maybe<NumberOperators>;
+    stockLevel?: Maybe<StringOperators>;
+};
+export declare type ProductVariantList = PaginatedList & {
+    __typename?: 'ProductVariantList';
+    items: Array<ProductVariant>;
+    totalItems: Scalars['Int'];
+};
+export declare type ProductVariantListOptions = {
+    /** Skips the first n results, for use in pagination */
+    skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
+    take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
+    sort?: Maybe<ProductVariantSortParameter>;
+    /** Allows the results to be filtered */
+    filter?: Maybe<ProductVariantFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
+};
+export declare type ProductVariantSortParameter = {
+    id?: Maybe<SortOrder>;
+    productId?: Maybe<SortOrder>;
+    createdAt?: Maybe<SortOrder>;
+    updatedAt?: Maybe<SortOrder>;
+    sku?: Maybe<SortOrder>;
+    name?: Maybe<SortOrder>;
+    price?: Maybe<SortOrder>;
+    priceWithTax?: Maybe<SortOrder>;
+    stockLevel?: Maybe<SortOrder>;
+};
+export declare type ProductVariantTranslation = {
+    __typename?: 'ProductVariantTranslation';
+    id: Scalars['ID'];
+    createdAt: Scalars['DateTime'];
+    updatedAt: Scalars['DateTime'];
+    languageCode: LanguageCode;
+    name: Scalars['String'];
+};
+export declare type Promotion = Node & {
+    __typename?: 'Promotion';
+    id: Scalars['ID'];
+    createdAt: Scalars['DateTime'];
+    updatedAt: Scalars['DateTime'];
+    startsAt?: Maybe<Scalars['DateTime']>;
+    endsAt?: Maybe<Scalars['DateTime']>;
+    couponCode?: Maybe<Scalars['String']>;
+    perCustomerUsageLimit?: Maybe<Scalars['Int']>;
+    name: Scalars['String'];
+    enabled: Scalars['Boolean'];
+    conditions: Array<ConfigurableOperation>;
+    actions: Array<ConfigurableOperation>;
+    customFields?: Maybe<Scalars['JSON']>;
+};
+export declare type PromotionList = PaginatedList & {
+    __typename?: 'PromotionList';
+    items: Array<Promotion>;
+    totalItems: Scalars['Int'];
+};
+export declare type Query = {
+    __typename?: 'Query';
+    /** The active Channel */
+    activeChannel: Channel;
+    /** The active Customer */
+    activeCustomer?: Maybe<Customer>;
+    /**
+     * The active Order. Will be `null` until an Order is created via `addItemToOrder`. Once an Order reaches the
+     * state of `PaymentAuthorized` or `PaymentSettled`, then that Order is no longer considered "active" and this
+     * query will once again return `null`.
+     */
+    activeOrder?: Maybe<Order>;
+    /** An array of supported Countries */
+    availableCountries: Array<Country>;
+    /** A list of Collections available to the shop */
+    collections: CollectionList;
+    /** Returns a Collection either by its id or slug. If neither 'id' nor 'slug' is specified, an error will result. */
+    collection?: Maybe<Collection>;
+    /** Returns a list of eligible shipping methods based on the current active Order */
+    eligibleShippingMethods: Array<ShippingMethodQuote>;
+    /** Returns a list of payment methods and their eligibility based on the current active Order */
+    eligiblePaymentMethods: Array<PaymentMethodQuote>;
+    /** A list of Facets available to the shop */
+    facets: FacetList;
+    /** Returns a Facet by its id */
+    facet?: Maybe<Facet>;
+    /** Returns information about the current authenticated User */
+    me?: Maybe<CurrentUser>;
+    /** Returns the possible next states that the activeOrder can transition to */
+    nextOrderStates: Array<Scalars['String']>;
+    /**
+     * Returns an Order based on the id. Note that in the Shop API, only orders belonging to the
+     * currently-authenticated User may be queried.
+     */
+    order?: Maybe<Order>;
+    /**
+     * Returns an Order based on the order `code`. For guest Orders (i.e. Orders placed by non-authenticated Customers)
+     * this query will only return the Order within 2 hours of the Order being placed. This allows an Order confirmation
+     * screen to be shown immediately after completion of a guest checkout, yet prevents security risks of allowing
+     * general anonymous access to Order data.
+     */
+    orderByCode?: Maybe<Order>;
+    /** Get a Product either by id or slug. If neither 'id' nor 'slug' is specified, an error will result. */
+    product?: Maybe<Product>;
+    /** Get a list of Products */
+    products: ProductList;
+    /** Search Products based on the criteria set by the `SearchInput` */
+    search: SearchResponse;
+};
+export declare type QueryCollectionsArgs = {
+    options?: Maybe<CollectionListOptions>;
+};
+export declare type QueryCollectionArgs = {
+    id?: Maybe<Scalars['ID']>;
+    slug?: Maybe<Scalars['String']>;
+};
+export declare type QueryFacetsArgs = {
+    options?: Maybe<FacetListOptions>;
+};
+export declare type QueryFacetArgs = {
+    id: Scalars['ID'];
+};
+export declare type QueryOrderArgs = {
+    id: Scalars['ID'];
+};
+export declare type QueryOrderByCodeArgs = {
+    code: Scalars['String'];
+};
+export declare type QueryProductArgs = {
+    id?: Maybe<Scalars['ID']>;
+    slug?: Maybe<Scalars['String']>;
+};
+export declare type QueryProductsArgs = {
+    options?: Maybe<ProductListOptions>;
+};
+export declare type QuerySearchArgs = {
+    input: SearchInput;
+};
+export declare type RefreshCustomerVerificationResult = Success | NativeAuthStrategyError;
+export declare type Refund = Node & {
+    __typename?: 'Refund';
+    id: Scalars['ID'];
+    createdAt: Scalars['DateTime'];
+    updatedAt: Scalars['DateTime'];
+    items: Scalars['Int'];
+    shipping: Scalars['Int'];
+    adjustment: Scalars['Int'];
+    total: Scalars['Int'];
+    method?: Maybe<Scalars['String']>;
+    state: Scalars['String'];
+    transactionId?: Maybe<Scalars['String']>;
+    reason?: Maybe<Scalars['String']>;
+    orderItems: Array<OrderItem>;
+    paymentId: Scalars['ID'];
+    metadata?: Maybe<Scalars['JSON']>;
+};
+export declare type RegisterCustomerAccountResult = Success | MissingPasswordError | PasswordValidationError | NativeAuthStrategyError;
+export declare type RegisterCustomerInput = {
+    emailAddress: Scalars['String'];
+    title?: Maybe<Scalars['String']>;
+    firstName?: Maybe<Scalars['String']>;
+    lastName?: Maybe<Scalars['String']>;
+    phoneNumber?: Maybe<Scalars['String']>;
+    password?: Maybe<Scalars['String']>;
+};
+export declare type RelationCustomFieldConfig = CustomField & {
+    __typename?: 'RelationCustomFieldConfig';
+    name: Scalars['String'];
+    type: Scalars['String'];
+    list: Scalars['Boolean'];
+    label?: Maybe<Array<LocalizedString>>;
+    description?: Maybe<Array<LocalizedString>>;
+    readonly?: Maybe<Scalars['Boolean']>;
+    internal?: Maybe<Scalars['Boolean']>;
+    nullable?: Maybe<Scalars['Boolean']>;
+    entity: Scalars['String'];
+    scalarFields: Array<Scalars['String']>;
+    ui?: Maybe<Scalars['JSON']>;
+};
+export declare type RemoveOrderItemsResult = Order | OrderModificationError;
+export declare type RequestPasswordResetResult = Success | NativeAuthStrategyError;
+export declare type RequestUpdateCustomerEmailAddressResult = Success | InvalidCredentialsError | EmailAddressConflictError | NativeAuthStrategyError;
+export declare type ResetPasswordResult = CurrentUser | PasswordResetTokenInvalidError | PasswordResetTokenExpiredError | PasswordValidationError | NativeAuthStrategyError | NotVerifiedError;
+export declare type Role = Node & {
+    __typename?: 'Role';
+    id: Scalars['ID'];
+    createdAt: Scalars['DateTime'];
+    updatedAt: Scalars['DateTime'];
+    code: Scalars['String'];
+    description: Scalars['String'];
+    permissions: Array<Permission>;
+    channels: Array<Channel>;
+};
+export declare type RoleList = PaginatedList & {
+    __typename?: 'RoleList';
+    items: Array<Role>;
+    totalItems: Scalars['Int'];
+};
+export declare type SearchInput = {
+    term?: Maybe<Scalars['String']>;
+    facetValueIds?: Maybe<Array<Scalars['ID']>>;
+    facetValueOperator?: Maybe<LogicalOperator>;
+    facetValueFilters?: Maybe<Array<FacetValueFilterInput>>;
+    collectionId?: Maybe<Scalars['ID']>;
+    collectionSlug?: Maybe<Scalars['String']>;
+    groupByProduct?: Maybe<Scalars['Boolean']>;
+    take?: Maybe<Scalars['Int']>;
+    skip?: Maybe<Scalars['Int']>;
+    sort?: Maybe<SearchResultSortParameter>;
+};
+export declare type SearchReindexResponse = {
+    __typename?: 'SearchReindexResponse';
+    success: Scalars['Boolean'];
+};
+export declare type SearchResponse = {
+    __typename?: 'SearchResponse';
+    items: Array<SearchResult>;
+    totalItems: Scalars['Int'];
+    facetValues: Array<FacetValueResult>;
+    collections: Array<CollectionResult>;
+};
+export declare type SearchResult = {
+    __typename?: 'SearchResult';
+    sku: Scalars['String'];
+    slug: Scalars['String'];
+    productId: Scalars['ID'];
+    productName: Scalars['String'];
+    productAsset?: Maybe<SearchResultAsset>;
+    productVariantId: Scalars['ID'];
+    productVariantName: Scalars['String'];
+    productVariantAsset?: Maybe<SearchResultAsset>;
+    price: SearchResultPrice;
+    priceWithTax: SearchResultPrice;
+    currencyCode: CurrencyCode;
+    description: Scalars['String'];
+    facetIds: Array<Scalars['ID']>;
+    facetValueIds: Array<Scalars['ID']>;
+    /** An array of ids of the Collections in which this result appears */
+    collectionIds: Array<Scalars['ID']>;
+    /** A relevance score for the result. Differs between database implementations */
+    score: Scalars['Float'];
+};
+export declare type SearchResultAsset = {
+    __typename?: 'SearchResultAsset';
+    id: Scalars['ID'];
+    preview: Scalars['String'];
+    focalPoint?: Maybe<Coordinate>;
+};
+/** The price of a search result product, either as a range or as a single price */
+export declare type SearchResultPrice = PriceRange | SinglePrice;
+export declare type SearchResultSortParameter = {
+    name?: Maybe<SortOrder>;
+    price?: Maybe<SortOrder>;
+};
+export declare type SetCustomerForOrderResult = Order | AlreadyLoggedInError | EmailAddressConflictError | NoActiveOrderError;
+export declare type SetOrderShippingMethodResult = Order | OrderModificationError | IneligibleShippingMethodError | NoActiveOrderError;
+export declare type ShippingLine = {
+    __typename?: 'ShippingLine';
+    shippingMethod: ShippingMethod;
+    price: Scalars['Int'];
+    priceWithTax: Scalars['Int'];
+    discountedPrice: Scalars['Int'];
+    discountedPriceWithTax: Scalars['Int'];
+    discounts: Array<Discount>;
+};
+export declare type ShippingMethod = Node & {
+    __typename?: 'ShippingMethod';
+    id: Scalars['ID'];
+    createdAt: Scalars['DateTime'];
+    updatedAt: Scalars['DateTime'];
+    code: Scalars['String'];
+    name: Scalars['String'];
+    description: Scalars['String'];
+    fulfillmentHandlerCode: Scalars['String'];
+    checker: ConfigurableOperation;
+    calculator: ConfigurableOperation;
+    translations: Array<ShippingMethodTranslation>;
+    customFields?: Maybe<Scalars['JSON']>;
+};
+export declare type ShippingMethodList = PaginatedList & {
+    __typename?: 'ShippingMethodList';
+    items: Array<ShippingMethod>;
+    totalItems: Scalars['Int'];
+};
+export declare type ShippingMethodQuote = {
+    __typename?: 'ShippingMethodQuote';
+    id: Scalars['ID'];
+    price: Scalars['Int'];
+    priceWithTax: Scalars['Int'];
+    code: Scalars['String'];
+    name: Scalars['String'];
+    description: Scalars['String'];
+    /** Any optional metadata returned by the ShippingCalculator in the ShippingCalculationResult */
+    metadata?: Maybe<Scalars['JSON']>;
+    customFields?: Maybe<Scalars['JSON']>;
+};
+export declare type ShippingMethodTranslation = {
+    __typename?: 'ShippingMethodTranslation';
+    id: Scalars['ID'];
+    createdAt: Scalars['DateTime'];
+    updatedAt: Scalars['DateTime'];
+    languageCode: LanguageCode;
+    name: Scalars['String'];
+    description: Scalars['String'];
+};
+/** The price value where the result has a single price */
+export declare type SinglePrice = {
+    __typename?: 'SinglePrice';
+    value: Scalars['Int'];
+};
+export declare enum SortOrder {
+    ASC = "ASC",
+    DESC = "DESC"
+}
+export declare type StringCustomFieldConfig = CustomField & {
+    __typename?: 'StringCustomFieldConfig';
+    name: Scalars['String'];
+    type: Scalars['String'];
+    list: Scalars['Boolean'];
+    length?: Maybe<Scalars['Int']>;
+    label?: Maybe<Array<LocalizedString>>;
+    description?: Maybe<Array<LocalizedString>>;
+    readonly?: Maybe<Scalars['Boolean']>;
+    internal?: Maybe<Scalars['Boolean']>;
+    nullable?: Maybe<Scalars['Boolean']>;
+    pattern?: Maybe<Scalars['String']>;
+    options?: Maybe<Array<StringFieldOption>>;
+    ui?: Maybe<Scalars['JSON']>;
+};
+export declare type StringFieldOption = {
+    __typename?: 'StringFieldOption';
+    value: Scalars['String'];
+    label?: Maybe<Array<LocalizedString>>;
+};
+/** Operators for filtering on a list of String fields */
+export declare type StringListOperators = {
+    inList: Scalars['String'];
+};
+/** Operators for filtering on a String field */
+export declare type StringOperators = {
+    eq?: Maybe<Scalars['String']>;
+    notEq?: Maybe<Scalars['String']>;
+    contains?: Maybe<Scalars['String']>;
+    notContains?: Maybe<Scalars['String']>;
+    in?: Maybe<Array<Scalars['String']>>;
+    notIn?: Maybe<Array<Scalars['String']>>;
+    regex?: Maybe<Scalars['String']>;
+};
+/** Indicates that an operation succeeded, where we do not want to return any more specific information. */
+export declare type Success = {
+    __typename?: 'Success';
+    success: Scalars['Boolean'];
+};
+export declare type Surcharge = Node & {
+    __typename?: 'Surcharge';
+    id: Scalars['ID'];
+    createdAt: Scalars['DateTime'];
+    updatedAt: Scalars['DateTime'];
+    description: Scalars['String'];
+    sku?: Maybe<Scalars['String']>;
+    taxLines: Array<TaxLine>;
+    price: Scalars['Int'];
+    priceWithTax: Scalars['Int'];
+    taxRate: Scalars['Float'];
+};
+export declare type Tag = Node & {
+    __typename?: 'Tag';
+    id: Scalars['ID'];
+    createdAt: Scalars['DateTime'];
+    updatedAt: Scalars['DateTime'];
+    value: Scalars['String'];
+};
+export declare type TagList = PaginatedList & {
+    __typename?: 'TagList';
+    items: Array<Tag>;
+    totalItems: Scalars['Int'];
+};
+export declare type TaxCategory = Node & {
+    __typename?: 'TaxCategory';
+    id: Scalars['ID'];
+    createdAt: Scalars['DateTime'];
+    updatedAt: Scalars['DateTime'];
+    name: Scalars['String'];
+    isDefault: Scalars['Boolean'];
+    customFields?: Maybe<Scalars['JSON']>;
+};
+export declare type TaxLine = {
+    __typename?: 'TaxLine';
+    description: Scalars['String'];
+    taxRate: Scalars['Float'];
+};
+export declare type TaxRate = Node & {
+    __typename?: 'TaxRate';
+    id: Scalars['ID'];
+    createdAt: Scalars['DateTime'];
+    updatedAt: Scalars['DateTime'];
+    name: Scalars['String'];
+    enabled: Scalars['Boolean'];
+    value: Scalars['Float'];
+    category: TaxCategory;
+    zone: Zone;
+    customerGroup?: Maybe<CustomerGroup>;
+    customFields?: Maybe<Scalars['JSON']>;
+};
+export declare type TaxRateList = PaginatedList & {
+    __typename?: 'TaxRateList';
+    items: Array<TaxRate>;
+    totalItems: Scalars['Int'];
+};
+export declare type TextCustomFieldConfig = CustomField & {
+    __typename?: 'TextCustomFieldConfig';
+    name: Scalars['String'];
+    type: Scalars['String'];
+    list: Scalars['Boolean'];
+    label?: Maybe<Array<LocalizedString>>;
+    description?: Maybe<Array<LocalizedString>>;
+    readonly?: Maybe<Scalars['Boolean']>;
+    internal?: Maybe<Scalars['Boolean']>;
+    nullable?: Maybe<Scalars['Boolean']>;
+    ui?: Maybe<Scalars['JSON']>;
+};
+export declare type TransitionOrderToStateResult = Order | OrderStateTransitionError;
+export declare type UpdateAddressInput = {
+    id: Scalars['ID'];
+    fullName?: Maybe<Scalars['String']>;
+    company?: Maybe<Scalars['String']>;
+    streetLine1?: Maybe<Scalars['String']>;
+    streetLine2?: Maybe<Scalars['String']>;
+    city?: Maybe<Scalars['String']>;
+    province?: Maybe<Scalars['String']>;
+    postalCode?: Maybe<Scalars['String']>;
+    countryCode?: Maybe<Scalars['String']>;
+    phoneNumber?: Maybe<Scalars['String']>;
+    defaultShippingAddress?: Maybe<Scalars['Boolean']>;
+    defaultBillingAddress?: Maybe<Scalars['Boolean']>;
+    customFields?: Maybe<Scalars['JSON']>;
+};
+export declare type UpdateCustomerEmailAddressResult = Success | IdentifierChangeTokenInvalidError | IdentifierChangeTokenExpiredError | NativeAuthStrategyError;
+export declare type UpdateCustomerInput = {
+    title?: Maybe<Scalars['String']>;
+    firstName?: Maybe<Scalars['String']>;
+    lastName?: Maybe<Scalars['String']>;
+    phoneNumber?: Maybe<Scalars['String']>;
+    customFields?: Maybe<Scalars['JSON']>;
+};
+export declare type UpdateCustomerPasswordResult = Success | InvalidCredentialsError | PasswordValidationError | NativeAuthStrategyError;
+export declare type UpdateOrderInput = {
+    customFields?: Maybe<Scalars['JSON']>;
+};
+export declare type UpdateOrderItemsResult = Order | OrderModificationError | OrderLimitError | NegativeQuantityError | InsufficientStockError;
+export declare type User = Node & {
+    __typename?: 'User';
+    id: Scalars['ID'];
+    createdAt: Scalars['DateTime'];
+    updatedAt: Scalars['DateTime'];
+    identifier: Scalars['String'];
+    verified: Scalars['Boolean'];
+    roles: Array<Role>;
+    lastLogin?: Maybe<Scalars['DateTime']>;
+    authenticationMethods: Array<AuthenticationMethod>;
+    customFields?: Maybe<Scalars['JSON']>;
+};
+/**
+ * Returned if the verification token (used to verify a Customer's email address) is valid, but has
+ * expired according to the `verificationTokenDuration` setting in the AuthOptions.
+ */
+export declare type VerificationTokenExpiredError = ErrorResult & {
+    __typename?: 'VerificationTokenExpiredError';
+    errorCode: ErrorCode;
+    message: Scalars['String'];
+};
+/**
+ * Returned if the verification token (used to verify a Customer's email address) is either
+ * invalid or does not match any expected tokens.
+ */
+export declare type VerificationTokenInvalidError = ErrorResult & {
+    __typename?: 'VerificationTokenInvalidError';
+    errorCode: ErrorCode;
+    message: Scalars['String'];
+};
+export declare type VerifyCustomerAccountResult = CurrentUser | VerificationTokenInvalidError | VerificationTokenExpiredError | MissingPasswordError | PasswordValidationError | PasswordAlreadySetError | NativeAuthStrategyError;
+export declare type Zone = Node & {
+    __typename?: 'Zone';
+    id: Scalars['ID'];
+    createdAt: Scalars['DateTime'];
+    updatedAt: Scalars['DateTime'];
+    name: Scalars['String'];
+    members: Array<Country>;
+    customFields?: Maybe<Scalars['JSON']>;
+};