chore: Update graphql-code-generator

admin-ui/src/app/catalog/providers/routing/product-category-resolver.ts

@@ -20,6 +20,7 @@ export class ProductCategoryResolver extends BaseEntityResolver<ProductCategory.
                 translations: [],
                 facetValues: [],
                 parent: {} as any,
+                children: null,
             },
             id => this.dataService.product.getProductCategory(id).mapStream(data => data.productCategory),
         );

admin-ui/src/app/customer/providers/routing/customer-resolver.ts

@@ -15,6 +15,9 @@ export class CustomerResolver extends BaseEntityResolver<Customer.Fragment> {
                 firstName: '',
                 lastName: '',
                 emailAddress: '',
+                phoneNumber: null,
+                addresses: null,
+                user: null,
             },
             id => this.dataService.customer.getCustomer(id).mapStream(data => data.customer),
         );

admin-ui/src/app/settings/providers/routing/tax-rate-resolver.ts

@@ -19,6 +19,7 @@ export class TaxRateResolver extends BaseEntityResolver<TaxRate.Fragment> {
                 enabled: true,
                 category: {} as any,
                 zone: {} as any,
+                customerGroup: null,
             },
             id => this.dataService.settings.getTaxRate(id).mapStream(data => data.taxRate),
         );

codegen/generate-graphql-types.ts

@@ -1,11 +1,12 @@
 import { generate } from 'graphql-code-generator';
+import { TypeScriptNamingConventionMap } from 'graphql-codegen-typescript-common';
 import path from 'path';
 
 import { API_PATH, API_PORT } from '../shared/shared-constants';
 
 import { downloadIntrospectionSchema } from './download-introspection-schema';
 
-const CLIENT_QUERY_FILES = path.join(__dirname, '../admin-ui/src/app/data/definitions/*.ts');
+const CLIENT_QUERY_FILES = path.join(__dirname, '../admin-ui/src/app/data/definitions/**/*.ts');
 const SCHEMA_OUTPUT_FILE = path.join(__dirname, '../schema.json');
 
 // tslint:disable:no-console
@@ -16,12 +17,24 @@ downloadIntrospectionSchema(SCHEMA_OUTPUT_FILE)
             console.log('Attempting to generate types from existing schema.json...');
         }
         return generate({
-            schema: SCHEMA_OUTPUT_FILE,
-            clientSchema: path.join(__dirname, 'client-schema.ts'),
-            template: 'typescript',
-            out: path.join(__dirname, '../shared/generated-types.ts'),
+            schema: [SCHEMA_OUTPUT_FILE, path.join(__dirname, 'client-schema.ts')],
             overwrite: true,
-            args: [CLIENT_QUERY_FILES],
+            documents: CLIENT_QUERY_FILES,
+            generates: {
+                [path.join(__dirname, '../shared/generated-types.ts')]: {
+                    plugins: [
+                        { add: '// tslint:disable' },
+                        'time',
+                        'typescript-common',
+                        'typescript-client',
+                        'typescript-server'],
+                    config: {
+                        namingConvention: {
+                            enumValues: 'keep',
+                        } as TypeScriptNamingConventionMap,
+                    },
+                },
+            },
         });
     })
     .then(

package.json

@@ -14,10 +14,15 @@
     "prepush": "yarn test && cd admin-ui && yarn build --prod"
   },
   "devDependencies": {
+    "@types/graphql": "^14.0.5",
     "@types/node": "^10.11.5",
-    "graphql": "^14.0.2",
-    "graphql-code-generator": "^0.12.6",
-    "graphql-codegen-typescript-template": "^0.12.6",
+    "graphql": "^14.1.1",
+    "graphql-code-generator": "^0.16.0",
+    "graphql-codegen-add": "^0.16.0",
+    "graphql-codegen-time": "^0.16.0",
+    "graphql-codegen-typescript-client": "^0.16.0",
+    "graphql-codegen-typescript-common": "^0.16.0",
+    "graphql-codegen-typescript-server": "^0.16.0",
     "graphql-tools": "^4.0.0",
     "husky": "^0.14.3",
     "lint-staged": "^7.2.0",

shared/generated-types.ts

@@ -1,7475 +1,6190 @@
-/* tslint:disable */
-import { GraphQLResolveInfo } from 'graphql';
-
-export type Resolver<Result, Parent = any, Context = any, Args = any> = (
-    parent: Parent,
-    args: Args,
-    context: Context,
-    info: GraphQLResolveInfo,
-) => Promise<Result> | Result;
-
-export type SubscriptionResolver<Result, Parent = any, Context = any, Args = any> = {
-    subscribe<R = Result, P = Parent>(
-        parent: P,
-        args: Args,
-        context: Context,
-        info: GraphQLResolveInfo,
-    ): AsyncIterator<R | Result>;
-    resolve?<R = Result, P = Parent>(
-        parent: P,
-        args: Args,
-        context: Context,
-        info: GraphQLResolveInfo,
-    ): R | Result | Promise<R | Result>;
-};
+// tslint:disable
+// Generated in 2019-01-25T15:42:49+01:00
+export type Maybe<T> = T | null;
 
-export type DateTime = any;
 
-export type Json = any;
+export interface AdministratorListOptions {
+  
+  take?: Maybe<number>;
+  
+  skip?: Maybe<number>;
+  
+  sort?: Maybe<AdministratorSortParameter>;
+  
+  filter?: Maybe<AdministratorFilterParameter>;
+}
 
-export type Upload = any;
+export interface AdministratorSortParameter {
+  
+  id?: Maybe<SortOrder>;
+  
+  createdAt?: Maybe<SortOrder>;
+  
+  updatedAt?: Maybe<SortOrder>;
+  
+  firstName?: Maybe<SortOrder>;
+  
+  lastName?: Maybe<SortOrder>;
+  
+  emailAddress?: Maybe<SortOrder>;
+}
 
-export interface PaginatedList {
-    items: Node[];
-    totalItems: number;
+export interface AdministratorFilterParameter {
+  
+  firstName?: Maybe<StringOperators>;
+  
+  lastName?: Maybe<StringOperators>;
+  
+  emailAddress?: Maybe<StringOperators>;
+  
+  createdAt?: Maybe<DateOperators>;
+  
+  updatedAt?: Maybe<DateOperators>;
 }
 
-export interface Node {
-    id: string;
+export interface StringOperators {
+  
+  eq?: Maybe<string>;
+  
+  contains?: Maybe<string>;
 }
 
-export interface Query {
-    administrators: AdministratorList;
-    administrator?: Administrator | null;
-    assets: AssetList;
-    asset?: Asset | null;
-    me?: CurrentUser | null;
-    channels: Channel[];
-    channel?: Channel | null;
-    activeChannel: Channel;
-    config: Config;
-    countries: CountryList;
-    country?: Country | null;
-    availableCountries: Country[];
-    customerGroups: CustomerGroup[];
-    customerGroup?: CustomerGroup | null;
-    customers: CustomerList;
-    customer?: Customer | null;
-    activeCustomer?: Customer | null;
-    facets: FacetList;
-    facet?: Facet | null;
-    globalSettings: GlobalSettings;
-    order?: Order | null;
-    activeOrder?: Order | null;
-    orderByCode?: Order | null;
-    nextOrderStates: string[];
-    orders: OrderList;
-    eligibleShippingMethods: ShippingMethodQuote[];
-    paymentMethods: PaymentMethodList;
-    paymentMethod?: PaymentMethod | null;
-    productCategories: ProductCategoryList;
-    productCategory?: ProductCategory | null;
-    productOptionGroups: ProductOptionGroup[];
-    productOptionGroup?: ProductOptionGroup | null;
-    products: ProductList;
-    product?: Product | null;
-    promotion?: Promotion | null;
-    promotions: PromotionList;
-    adjustmentOperations: AdjustmentOperations;
-    roles: RoleList;
-    role?: Role | null;
-    search: SearchResponse;
-    shippingMethods: ShippingMethodList;
-    shippingMethod?: ShippingMethod | null;
-    shippingEligibilityCheckers: AdjustmentOperation[];
-    shippingCalculators: AdjustmentOperation[];
-    taxCategories: TaxCategory[];
-    taxCategory?: TaxCategory | null;
-    taxRates: TaxRateList;
-    taxRate?: TaxRate | null;
-    zones: Zone[];
-    zone?: Zone | null;
-    temp__?: boolean | null;
-    networkStatus: NetworkStatus;
-    userStatus: UserStatus;
-    uiState: UiState;
+export interface DateOperators {
+  
+  eq?: Maybe<DateTime>;
+  
+  before?: Maybe<DateTime>;
+  
+  after?: Maybe<DateTime>;
+  
+  between?: Maybe<DateRange>;
 }
 
-export interface AdministratorList extends PaginatedList {
-    items: Administrator[];
-    totalItems: number;
+export interface DateRange {
+  
+  start: DateTime;
+  
+  end: DateTime;
 }
 
-export interface Administrator extends Node {
-    id: string;
-    createdAt: DateTime;
-    updatedAt: DateTime;
-    firstName: string;
-    lastName: string;
-    emailAddress: string;
-    user: User;
+export interface AssetListOptions {
+  
+  take?: Maybe<number>;
+  
+  skip?: Maybe<number>;
+  
+  sort?: Maybe<AssetSortParameter>;
+  
+  filter?: Maybe<AssetFilterParameter>;
 }
 
-export interface User extends Node {
-    id: string;
-    createdAt: DateTime;
-    updatedAt: DateTime;
-    identifier: string;
-    passwordHash: string;
-    verified: boolean;
-    roles: Role[];
-    lastLogin?: string | null;
-    customFields?: Json | null;
+export interface AssetSortParameter {
+  
+  id?: Maybe<SortOrder>;
+  
+  createdAt?: Maybe<SortOrder>;
+  
+  updatedAt?: Maybe<SortOrder>;
+  
+  name?: Maybe<SortOrder>;
+  
+  description?: Maybe<SortOrder>;
 }
 
-export interface Role extends Node {
-    id: string;
-    createdAt: DateTime;
-    updatedAt: DateTime;
-    code: string;
-    description: string;
-    permissions: Permission[];
-    channels: Channel[];
+export interface AssetFilterParameter {
+  
+  name?: Maybe<StringOperators>;
+  
+  description?: Maybe<StringOperators>;
+  
+  type?: Maybe<StringOperators>;
+  
+  createdAt?: Maybe<DateOperators>;
+  
+  updatedAt?: Maybe<DateOperators>;
 }
 
-export interface Channel extends Node {
-    id: string;
-    createdAt: DateTime;
-    updatedAt: DateTime;
-    code: string;
-    token: string;
-    defaultTaxZone?: Zone | null;
-    defaultShippingZone?: Zone | null;
-    defaultLanguageCode: LanguageCode;
-    currencyCode: CurrencyCode;
-    pricesIncludeTax: boolean;
+export interface CountryListOptions {
+  
+  take?: Maybe<number>;
+  
+  skip?: Maybe<number>;
+  
+  sort?: Maybe<CountrySortParameter>;
+  
+  filter?: Maybe<CountryFilterParameter>;
 }
 
-export interface Zone extends Node {
-    id: string;
-    createdAt: DateTime;
-    updatedAt: DateTime;
-    name: string;
-    members: Country[];
+export interface CountrySortParameter {
+  
+  id?: Maybe<SortOrder>;
+  
+  createdAt?: Maybe<SortOrder>;
+  
+  updatedAt?: Maybe<SortOrder>;
+  
+  code?: Maybe<SortOrder>;
+  
+  name?: Maybe<SortOrder>;
+  
+  enabled?: Maybe<SortOrder>;
 }
 
-export interface Country extends Node {
-    id: string;
-    languageCode: LanguageCode;
-    code: string;
-    name: string;
-    enabled: boolean;
-    translations: CountryTranslation[];
+export interface CountryFilterParameter {
+  
+  code?: Maybe<StringOperators>;
+  
+  name?: Maybe<StringOperators>;
+  
+  enabled?: Maybe<BooleanOperators>;
+  
+  createdAt?: Maybe<DateOperators>;
+  
+  updatedAt?: Maybe<DateOperators>;
 }
 
-export interface CountryTranslation {
-    id: string;
-    createdAt: DateTime;
-    updatedAt: DateTime;
-    languageCode: LanguageCode;
-    name: string;
+export interface BooleanOperators {
+  
+  eq?: Maybe<boolean>;
 }
 
-export interface AssetList extends PaginatedList {
-    items: Asset[];
-    totalItems: number;
+export interface CustomerListOptions {
+  
+  take?: Maybe<number>;
+  
+  skip?: Maybe<number>;
+  
+  sort?: Maybe<CustomerSortParameter>;
+  
+  filter?: Maybe<CustomerFilterParameter>;
 }
 
-export interface Asset extends Node {
-    id: string;
-    name: string;
-    type: AssetType;
-    fileSize: number;
-    mimeType: string;
-    source: string;
-    preview: string;
+export interface CustomerSortParameter {
+  
+  id?: Maybe<SortOrder>;
+  
+  createdAt?: Maybe<SortOrder>;
+  
+  updatedAt?: Maybe<SortOrder>;
+  
+  firstName?: Maybe<SortOrder>;
+  
+  lastName?: Maybe<SortOrder>;
+  
+  phoneNumber?: Maybe<SortOrder>;
+  
+  emailAddress?: Maybe<SortOrder>;
 }
 
-export interface CurrentUser {
-    id: string;
-    identifier: string;
-    channelTokens: string[];
+export interface CustomerFilterParameter {
+  
+  firstName?: Maybe<StringOperators>;
+  
+  lastName?: Maybe<StringOperators>;
+  
+  phoneNumber?: Maybe<StringOperators>;
+  
+  emailAddress?: Maybe<StringOperators>;
+  
+  createdAt?: Maybe<DateOperators>;
+  
+  updatedAt?: Maybe<DateOperators>;
 }
 
-export interface Config {
-    customFields?: Json | null;
+export interface OrderListOptions {
+  
+  take?: Maybe<number>;
+  
+  skip?: Maybe<number>;
+  
+  sort?: Maybe<OrderSortParameter>;
+  
+  filter?: Maybe<OrderFilterParameter>;
 }
 
-export interface CountryList extends PaginatedList {
-    items: Country[];
-    totalItems: number;
+export interface OrderSortParameter {
+  
+  id?: Maybe<SortOrder>;
+  
+  createdAt?: Maybe<SortOrder>;
+  
+  updatedAt?: Maybe<SortOrder>;
+  
+  code?: Maybe<SortOrder>;
 }
 
-export interface CustomerGroup extends Node {
-    id: string;
-    createdAt: DateTime;
-    updatedAt: DateTime;
-    name: string;
+export interface OrderFilterParameter {
+  
+  code?: Maybe<StringOperators>;
+  
+  createdAt?: Maybe<DateOperators>;
+  
+  updatedAt?: Maybe<DateOperators>;
 }
 
-export interface CustomerList extends PaginatedList {
-    items: Customer[];
-    totalItems: number;
+export interface FacetListOptions {
+  
+  take?: Maybe<number>;
+  
+  skip?: Maybe<number>;
+  
+  sort?: Maybe<FacetSortParameter>;
+  
+  filter?: Maybe<FacetFilterParameter>;
 }
 
-export interface Customer extends Node {
-    id: string;
-    createdAt: DateTime;
-    updatedAt: DateTime;
-    title?: string | null;
-    firstName: string;
-    lastName: string;
-    phoneNumber?: string | null;
-    emailAddress: string;
-    addresses?: Address[] | null;
-    orders: OrderList;
-    user?: User | null;
-    customFields?: Json | null;
+export interface FacetSortParameter {
+  
+  id?: Maybe<SortOrder>;
+  
+  createdAt?: Maybe<SortOrder>;
+  
+  updatedAt?: Maybe<SortOrder>;
+  
+  name?: Maybe<SortOrder>;
+  
+  code?: Maybe<SortOrder>;
 }
 
-export interface Address extends Node {
-    id: string;
-    createdAt: DateTime;
-    updatedAt: DateTime;
-    fullName?: string | null;
-    company?: string | null;
-    streetLine1: string;
-    streetLine2?: string | null;
-    city?: string | null;
-    province?: string | null;
-    postalCode?: string | null;
-    country: Country;
-    phoneNumber?: string | null;
-    defaultShippingAddress?: boolean | null;
-    defaultBillingAddress?: boolean | null;
-    customFields?: Json | null;
+export interface FacetFilterParameter {
+  
+  name?: Maybe<StringOperators>;
+  
+  code?: Maybe<StringOperators>;
+  
+  createdAt?: Maybe<DateOperators>;
+  
+  updatedAt?: Maybe<DateOperators>;
 }
 
-export interface OrderList extends PaginatedList {
-    items: Order[];
-    totalItems: number;
+export interface PaymentMethodListOptions {
+  
+  take?: Maybe<number>;
+  
+  skip?: Maybe<number>;
+  
+  sort?: Maybe<PaymentMethodSortParameter>;
+  
+  filter?: Maybe<PaymentMethodFilterParameter>;
 }
 
-export interface Order extends Node {
-    id: string;
-    createdAt: DateTime;
-    updatedAt: DateTime;
-    code: string;
-    state: string;
-    active: boolean;
-    customer?: Customer | null;
-    shippingAddress?: ShippingAddress | null;
-    billingAddress?: BillingAddress | null;
-    lines: OrderLine[];
-    adjustments: Adjustment[];
-    payments?: Payment[] | null;
-    subTotalBeforeTax: number;
-    subTotal: number;
-    currencyCode: CurrencyCode;
-    shipping: number;
-    shippingMethod?: ShippingMethod | null;
-    totalBeforeTax: number;
-    total: number;
+export interface PaymentMethodSortParameter {
+  
+  id?: Maybe<SortOrder>;
+  
+  createdAt?: Maybe<SortOrder>;
+  
+  updatedAt?: Maybe<SortOrder>;
+  
+  code?: Maybe<SortOrder>;
 }
 
-export interface ShippingAddress {
-    fullName?: string | null;
-    company?: string | null;
-    streetLine1?: string | null;
-    streetLine2?: string | null;
-    city?: string | null;
-    province?: string | null;
-    postalCode?: string | null;
-    country?: string | null;
-    countryCode?: string | null;
-    phoneNumber?: string | null;
+export interface PaymentMethodFilterParameter {
+  
+  code?: Maybe<StringOperators>;
+  
+  createdAt?: Maybe<DateOperators>;
+  
+  updatedAt?: Maybe<DateOperators>;
 }
 
-export interface BillingAddress {
-    fullName?: string | null;
-    company?: string | null;
-    streetLine1?: string | null;
-    streetLine2?: string | null;
-    city?: string | null;
-    province?: string | null;
-    postalCode?: string | null;
-    country?: string | null;
-    countryCode?: string | null;
-    phoneNumber?: string | null;
+export interface ProductCategoryListOptions {
+  
+  take?: Maybe<number>;
+  
+  skip?: Maybe<number>;
+  
+  sort?: Maybe<ProductCategorySortParameter>;
+  
+  filter?: Maybe<ProductCategoryFilterParameter>;
 }
 
-export interface OrderLine extends Node {
-    id: string;
-    createdAt: DateTime;
-    updatedAt: DateTime;
-    productVariant: ProductVariant;
-    featuredAsset?: Asset | null;
-    unitPrice: number;
-    unitPriceWithTax: number;
-    quantity: number;
-    items: OrderItem[];
-    totalPrice: number;
-    adjustments: Adjustment[];
-    order: Order;
+export interface ProductCategorySortParameter {
+  
+  id?: Maybe<SortOrder>;
+  
+  createdAt?: Maybe<SortOrder>;
+  
+  updatedAt?: Maybe<SortOrder>;
+  
+  name?: Maybe<SortOrder>;
+  
+  description?: Maybe<SortOrder>;
 }
 
-export interface ProductVariant extends Node {
-    id: string;
-    createdAt: DateTime;
-    updatedAt: DateTime;
-    languageCode: LanguageCode;
-    sku: string;
-    name: string;
-    featuredAsset?: Asset | null;
-    assets: Asset[];
-    price: number;
-    currencyCode: CurrencyCode;
-    priceIncludesTax: boolean;
-    priceWithTax: number;
-    taxRateApplied: TaxRate;
-    taxCategory: TaxCategory;
-    options: ProductOption[];
-    facetValues: FacetValue[];
-    translations: ProductVariantTranslation[];
-    customFields?: Json | null;
+export interface ProductCategoryFilterParameter {
+  
+  name?: Maybe<StringOperators>;
+  
+  description?: Maybe<StringOperators>;
+  
+  createdAt?: Maybe<DateOperators>;
+  
+  updatedAt?: Maybe<DateOperators>;
 }
 
-export interface TaxRate extends Node {
-    id: string;
-    createdAt: DateTime;
-    updatedAt: DateTime;
-    name: string;
-    enabled: boolean;
-    value: number;
-    category: TaxCategory;
-    zone: Zone;
-    customerGroup?: CustomerGroup | null;
+export interface ProductListOptions {
+  
+  take?: Maybe<number>;
+  
+  skip?: Maybe<number>;
+  
+  sort?: Maybe<ProductSortParameter>;
+  
+  filter?: Maybe<ProductFilterParameter>;
+  
+  categoryId?: Maybe<string>;
 }
 
-export interface TaxCategory extends Node {
-    id: string;
-    createdAt: DateTime;
-    updatedAt: DateTime;
-    name: string;
+export interface ProductSortParameter {
+  
+  id?: Maybe<SortOrder>;
+  
+  createdAt?: Maybe<SortOrder>;
+  
+  updatedAt?: Maybe<SortOrder>;
+  
+  name?: Maybe<SortOrder>;
+  
+  slug?: Maybe<SortOrder>;
+  
+  description?: Maybe<SortOrder>;
+  
+  image?: Maybe<SortOrder>;
 }
 
-export interface ProductOption extends Node {
-    id: string;
-    createdAt: DateTime;
-    updatedAt: DateTime;
-    languageCode?: LanguageCode | null;
-    code?: string | null;
-    name?: string | null;
-    translations: ProductOptionTranslation[];
-    customFields?: Json | null;
+export interface ProductFilterParameter {
+  
+  name?: Maybe<StringOperators>;
+  
+  slug?: Maybe<StringOperators>;
+  
+  description?: Maybe<StringOperators>;
+  
+  createdAt?: Maybe<DateOperators>;
+  
+  updatedAt?: Maybe<DateOperators>;
 }
 
-export interface ProductOptionTranslation {
-    id: string;
-    createdAt: DateTime;
-    updatedAt: DateTime;
-    languageCode: LanguageCode;
-    name: string;
+export interface PromotionListOptions {
+  
+  take?: Maybe<number>;
+  
+  skip?: Maybe<number>;
+  
+  sort?: Maybe<PromotionSortParameter>;
+  
+  filter?: Maybe<PromotionFilterParameter>;
 }
 
-export interface FacetValue extends Node {
-    id: string;
-    createdAt: DateTime;
-    updatedAt: DateTime;
-    languageCode: LanguageCode;
-    facet: Facet;
-    name: string;
-    code: string;
-    translations: FacetValueTranslation[];
-    customFields?: Json | null;
+export interface PromotionSortParameter {
+  
+  id?: Maybe<SortOrder>;
+  
+  createdAt?: Maybe<SortOrder>;
+  
+  updatedAt?: Maybe<SortOrder>;
+  
+  name?: Maybe<SortOrder>;
 }
 
-export interface Facet extends Node {
-    id: string;
-    createdAt: DateTime;
-    updatedAt: DateTime;
-    languageCode: LanguageCode;
-    name: string;
-    code: string;
-    values: FacetValue[];
-    translations: FacetTranslation[];
-    customFields?: Json | null;
+export interface PromotionFilterParameter {
+  
+  name?: Maybe<StringOperators>;
+  
+  createdAt?: Maybe<DateOperators>;
+  
+  updatedAt?: Maybe<DateOperators>;
+  
+  type?: Maybe<StringOperators>;
 }
 
-export interface FacetTranslation {
-    id: string;
-    createdAt: DateTime;
-    updatedAt: DateTime;
-    languageCode: LanguageCode;
-    name: string;
+export interface RoleListOptions {
+  
+  take?: Maybe<number>;
+  
+  skip?: Maybe<number>;
+  
+  sort?: Maybe<RoleSortParameter>;
+  
+  filter?: Maybe<RoleFilterParameter>;
 }
 
-export interface FacetValueTranslation {
-    id: string;
-    createdAt: DateTime;
-    updatedAt: DateTime;
-    languageCode: LanguageCode;
-    name: string;
+export interface RoleSortParameter {
+  
+  id?: Maybe<SortOrder>;
+  
+  createdAt?: Maybe<SortOrder>;
+  
+  updatedAt?: Maybe<SortOrder>;
+  
+  code?: Maybe<SortOrder>;
+  
+  description?: Maybe<SortOrder>;
 }
 
-export interface ProductVariantTranslation {
-    id: string;
-    createdAt: DateTime;
-    updatedAt: DateTime;
-    languageCode: LanguageCode;
-    name: string;
+export interface RoleFilterParameter {
+  
+  code?: Maybe<StringOperators>;
+  
+  description?: Maybe<StringOperators>;
+  
+  createdAt?: Maybe<DateOperators>;
+  
+  updatedAt?: Maybe<DateOperators>;
 }
 
-export interface OrderItem extends Node {
-    id: string;
-    createdAt: DateTime;
-    updatedAt: DateTime;
-    unitPrice: number;
-    unitPriceWithTax: number;
-    unitPriceIncludesTax: boolean;
-    taxRate: number;
-    adjustments: Adjustment[];
+export interface SearchInput {
+  
+  term?: Maybe<string>;
+  
+  facetIds?: Maybe<string[]>;
+  
+  groupByProduct?: Maybe<boolean>;
+  
+  take?: Maybe<number>;
+  
+  skip?: Maybe<number>;
 }
 
-export interface Adjustment {
-    adjustmentSource: string;
-    type: AdjustmentType;
-    description: string;
-    amount: number;
+export interface ShippingMethodListOptions {
+  
+  take?: Maybe<number>;
+  
+  skip?: Maybe<number>;
+  
+  sort?: Maybe<ShippingMethodSortParameter>;
+  
+  filter?: Maybe<ShippingMethodFilterParameter>;
 }
 
-export interface Payment extends Node {
-    id: string;
-    createdAt: DateTime;
-    updatedAt: DateTime;
-    method: string;
-    amount: number;
-    state: string;
-    transactionId?: string | null;
-    metadata?: Json | null;
+export interface ShippingMethodSortParameter {
+  
+  id?: Maybe<SortOrder>;
+  
+  createdAt?: Maybe<SortOrder>;
+  
+  updatedAt?: Maybe<SortOrder>;
+  
+  code?: Maybe<SortOrder>;
+  
+  description?: Maybe<SortOrder>;
 }
 
-export interface ShippingMethod extends Node {
-    id: string;
-    createdAt: DateTime;
-    updatedAt: DateTime;
-    code: string;
-    description: string;
-    checker: AdjustmentOperation;
-    calculator: AdjustmentOperation;
+export interface ShippingMethodFilterParameter {
+  
+  code?: Maybe<StringOperators>;
+  
+  description?: Maybe<StringOperators>;
+  
+  createdAt?: Maybe<DateOperators>;
+  
+  updatedAt?: Maybe<DateOperators>;
 }
 
-export interface AdjustmentOperation {
-    code: string;
-    args: ConfigArg[];
-    description: string;
+export interface TaxRateListOptions {
+  
+  take?: Maybe<number>;
+  
+  skip?: Maybe<number>;
+  
+  sort?: Maybe<TaxRateSortParameter>;
+  
+  filter?: Maybe<TaxRateFilterParameter>;
 }
 
-export interface ConfigArg {
-    name: string;
-    type: string;
-    value?: string | null;
+export interface TaxRateSortParameter {
+  
+  id?: Maybe<SortOrder>;
+  
+  createdAt?: Maybe<SortOrder>;
+  
+  updatedAt?: Maybe<SortOrder>;
+  
+  name?: Maybe<SortOrder>;
+  
+  enabled?: Maybe<SortOrder>;
 }
 
-export interface FacetList extends PaginatedList {
-    items: Facet[];
-    totalItems: number;
+export interface TaxRateFilterParameter {
+  
+  code?: Maybe<StringOperators>;
+  
+  name?: Maybe<StringOperators>;
+  
+  enabled?: Maybe<BooleanOperators>;
+  
+  createdAt?: Maybe<DateOperators>;
+  
+  updatedAt?: Maybe<DateOperators>;
 }
 
-export interface GlobalSettings {
-    id: string;
-    createdAt: DateTime;
-    updatedAt: DateTime;
-    availableLanguages: LanguageCode[];
-    serverConfig: ServerConfig;
-    customFields?: GlobalSettingsCustomFields | null;
+export interface CreateAdministratorInput {
+  
+  firstName: string;
+  
+  lastName: string;
+  
+  emailAddress: string;
+  
+  password: string;
+  
+  roleIds: string[];
 }
 
-export interface ServerConfig {
-    customFields?: Json | null;
+export interface UpdateAdministratorInput {
+  
+  id: string;
+  
+  firstName?: Maybe<string>;
+  
+  lastName?: Maybe<string>;
+  
+  emailAddress?: Maybe<string>;
+  
+  password?: Maybe<string>;
+  
+  roleIds?: Maybe<string[]>;
 }
 
-export interface GlobalSettingsCustomFields {
-    royalMailId?: string | null;
+export interface CreateAssetInput {
+  
+  file: Upload;
 }
 
-export interface ShippingMethodQuote {
-    id: string;
-    price: number;
-    description: string;
+export interface RegisterCustomerInput {
+  
+  emailAddress: string;
+  
+  title?: Maybe<string>;
+  
+  firstName?: Maybe<string>;
+  
+  lastName?: Maybe<string>;
 }
 
-export interface PaymentMethodList extends PaginatedList {
-    items: PaymentMethod[];
-    totalItems: number;
+export interface CreateChannelInput {
+  
+  code: string;
+  
+  token: string;
+  
+  defaultLanguageCode: LanguageCode;
+  
+  pricesIncludeTax: boolean;
+  
+  currencyCode: CurrencyCode;
+  
+  defaultTaxZoneId?: Maybe<string>;
+  
+  defaultShippingZoneId?: Maybe<string>;
 }
 
-export interface PaymentMethod extends Node {
-    id: string;
-    createdAt: DateTime;
-    updatedAt: DateTime;
-    code: string;
-    enabled: boolean;
-    configArgs: ConfigArg[];
+export interface UpdateChannelInput {
+  
+  id: string;
+  
+  code?: Maybe<string>;
+  
+  token?: Maybe<string>;
+  
+  defaultLanguageCode?: Maybe<LanguageCode>;
+  
+  pricesIncludeTax?: Maybe<boolean>;
+  
+  currencyCode?: Maybe<CurrencyCode>;
+  
+  defaultTaxZoneId?: Maybe<string>;
+  
+  defaultShippingZoneId?: Maybe<string>;
 }
 
-export interface ProductCategoryList extends PaginatedList {
-    items: ProductCategory[];
-    totalItems: number;
+export interface CreateCountryInput {
+  
+  code: string;
+  
+  translations: CountryTranslationInput[];
+  
+  enabled: boolean;
 }
 
-export interface ProductCategory extends Node {
-    id: string;
-    createdAt: DateTime;
-    updatedAt: DateTime;
-    languageCode?: LanguageCode | null;
-    name: string;
-    position: number;
-    description: string;
-    featuredAsset?: Asset | null;
-    assets: Asset[];
-    parent: ProductCategory;
-    children?: ProductCategory[] | null;
-    facetValues: FacetValue[];
-    descendantFacetValues: FacetValue[];
-    translations: ProductCategoryTranslation[];
-    customFields?: Json | null;
+export interface CountryTranslationInput {
+  
+  id?: Maybe<string>;
+  
+  languageCode: LanguageCode;
+  
+  name?: Maybe<string>;
 }
 
-export interface ProductCategoryTranslation {
-    id: string;
-    createdAt: DateTime;
-    updatedAt: DateTime;
-    languageCode: LanguageCode;
-    name: string;
-    description: string;
+export interface UpdateCountryInput {
+  
+  id: string;
+  
+  code?: Maybe<string>;
+  
+  translations?: Maybe<CountryTranslationInput[]>;
+  
+  enabled?: Maybe<boolean>;
 }
 
-export interface ProductOptionGroup extends Node {
-    id: string;
-    createdAt: DateTime;
-    updatedAt: DateTime;
-    languageCode: LanguageCode;
-    code: string;
-    name: string;
-    options: ProductOption[];
-    translations: ProductOptionGroupTranslation[];
-    customFields?: Json | null;
+export interface CreateCustomerGroupInput {
+  
+  name: string;
+  
+  customerIds?: Maybe<string[]>;
 }
 
-export interface ProductOptionGroupTranslation {
-    id: string;
-    createdAt: DateTime;
-    updatedAt: DateTime;
-    languageCode: LanguageCode;
-    name: string;
+export interface UpdateCustomerGroupInput {
+  
+  id: string;
+  
+  name?: Maybe<string>;
 }
 
-export interface ProductList extends PaginatedList {
-    items: Product[];
-    totalItems: number;
+export interface CreateCustomerInput {
+  
+  title?: Maybe<string>;
+  
+  firstName: string;
+  
+  lastName: string;
+  
+  phoneNumber?: Maybe<string>;
+  
+  emailAddress: string;
+  
+  customFields?: Maybe<Json>;
 }
 
-export interface Product extends Node {
-    id: string;
-    createdAt: DateTime;
-    updatedAt: DateTime;
-    languageCode: LanguageCode;
-    name: string;
-    slug: string;
-    description: string;
-    featuredAsset?: Asset | null;
-    assets: Asset[];
-    variants: ProductVariant[];
-    optionGroups: ProductOptionGroup[];
-    facetValues: FacetValue[];
-    translations: ProductTranslation[];
-    customFields?: Json | null;
+export interface UpdateCustomerInput {
+  
+  id: string;
+  
+  title?: Maybe<string>;
+  
+  firstName?: Maybe<string>;
+  
+  lastName?: Maybe<string>;
+  
+  phoneNumber?: Maybe<string>;
+  
+  emailAddress?: Maybe<string>;
+  
+  customFields?: Maybe<Json>;
 }
 
-export interface ProductTranslation {
-    id: string;
-    createdAt: DateTime;
-    updatedAt: DateTime;
-    languageCode: LanguageCode;
-    name: string;
-    slug: string;
-    description: string;
+export interface CreateAddressInput {
+  
+  fullName?: Maybe<string>;
+  
+  company?: Maybe<string>;
+  
+  streetLine1: string;
+  
+  streetLine2?: Maybe<string>;
+  
+  city?: Maybe<string>;
+  
+  province?: Maybe<string>;
+  
+  postalCode?: Maybe<string>;
+  
+  countryCode: string;
+  
+  phoneNumber?: Maybe<string>;
+  
+  defaultShippingAddress?: Maybe<boolean>;
+  
+  defaultBillingAddress?: Maybe<boolean>;
+  
+  customFields?: Maybe<Json>;
 }
 
-export interface Promotion extends Node {
-    id: string;
-    createdAt: DateTime;
-    updatedAt: DateTime;
-    name: string;
-    enabled: boolean;
-    conditions: AdjustmentOperation[];
-    actions: AdjustmentOperation[];
+export interface UpdateAddressInput {
+  
+  id: string;
+  
+  fullName?: Maybe<string>;
+  
+  company?: Maybe<string>;
+  
+  streetLine1?: Maybe<string>;
+  
+  streetLine2?: Maybe<string>;
+  
+  city?: Maybe<string>;
+  
+  province?: Maybe<string>;
+  
+  postalCode?: Maybe<string>;
+  
+  countryCode?: Maybe<string>;
+  
+  phoneNumber?: Maybe<string>;
+  
+  defaultShippingAddress?: Maybe<boolean>;
+  
+  defaultBillingAddress?: Maybe<boolean>;
+  
+  customFields?: Maybe<Json>;
 }
 
-export interface PromotionList extends PaginatedList {
-    items: Promotion[];
-    totalItems: number;
+export interface CreateFacetInput {
+  
+  code: string;
+  
+  translations: FacetTranslationInput[];
+  
+  values?: Maybe<CreateFacetValueWithFacetInput[]>;
+  
+  customFields?: Maybe<Json>;
 }
 
-export interface AdjustmentOperations {
-    conditions: AdjustmentOperation[];
-    actions: AdjustmentOperation[];
+export interface FacetTranslationInput {
+  
+  id?: Maybe<string>;
+  
+  languageCode: LanguageCode;
+  
+  name?: Maybe<string>;
+  
+  customFields?: Maybe<Json>;
 }
 
-export interface RoleList extends PaginatedList {
-    items: Role[];
-    totalItems: number;
+export interface CreateFacetValueWithFacetInput {
+  
+  code: string;
+  
+  translations: FacetValueTranslationInput[];
 }
 
-export interface SearchResponse {
-    items: SearchResult[];
-    totalItems: number;
-    facetValues: FacetValue[];
+export interface FacetValueTranslationInput {
+  
+  id?: Maybe<string>;
+  
+  languageCode: LanguageCode;
+  
+  name?: Maybe<string>;
+  
+  customFields?: Maybe<Json>;
 }
 
-export interface SearchResult {
-    sku: string;
-    productId: string;
-    productName: string;
-    productPreview: string;
-    productVariantId: string;
-    productVariantName: string;
-    productVariantPreview: string;
-    description: string;
-    facetIds: string[];
-    facetValueIds: string[];
-    score: number;
+export interface UpdateFacetInput {
+  
+  id: string;
+  
+  code?: Maybe<string>;
+  
+  translations?: Maybe<FacetTranslationInput[]>;
+  
+  customFields?: Maybe<Json>;
 }
 
-export interface ShippingMethodList extends PaginatedList {
-    items: ShippingMethod[];
-    totalItems: number;
+export interface CreateFacetValueInput {
+  
+  facetId: string;
+  
+  code: string;
+  
+  translations: FacetValueTranslationInput[];
+  
+  customFields?: Maybe<Json>;
 }
 
-export interface TaxRateList extends PaginatedList {
-    items: TaxRate[];
-    totalItems: number;
+export interface UpdateFacetValueInput {
+  
+  id: string;
+  
+  code?: Maybe<string>;
+  
+  translations?: Maybe<FacetValueTranslationInput[]>;
+  
+  customFields?: Maybe<Json>;
 }
 
-export interface NetworkStatus {
-    inFlightRequests: number;
+export interface UpdateGlobalSettingsInput {
+  
+  availableLanguages?: Maybe<LanguageCode[]>;
+  
+  customFields?: Maybe<UpdateGlobalSettingsCustomFieldsInput>;
 }
 
-export interface UserStatus {
-    username: string;
-    isLoggedIn: boolean;
-    loginTime: string;
+export interface UpdateGlobalSettingsCustomFieldsInput {
+  
+  royalMailId?: Maybe<string>;
 }
 
-export interface UiState {
-    language: LanguageCode;
+export interface PaymentInput {
+  
+  method: string;
+  
+  metadata: Json;
 }
 
-export interface Mutation {
-    createAdministrator: Administrator;
-    updateAdministrator: Administrator;
-    assignRoleToAdministrator: Administrator;
-    createAssets: Asset[];
-    login: LoginResult;
-    logout: boolean;
-    registerCustomerAccount: boolean;
-    verifyCustomerAccount: LoginResult;
-    refreshCustomerVerification: boolean;
-    createChannel: Channel;
-    updateChannel: Channel;
-    createCountry: Country;
-    updateCountry: Country;
-    deleteCountry: DeletionResponse;
-    createCustomerGroup: CustomerGroup;
-    updateCustomerGroup: CustomerGroup;
-    addCustomersToGroup: CustomerGroup;
-    removeCustomersFromGroup: CustomerGroup;
-    createCustomer: Customer;
-    updateCustomer: Customer;
-    deleteCustomer: DeletionResponse;
-    createCustomerAddress: Address;
-    updateCustomerAddress: Address;
-    createFacet: Facet;
-    updateFacet: Facet;
-    deleteFacet: DeletionResponse;
-    createFacetValues: FacetValue[];
-    updateFacetValues: FacetValue[];
-    deleteFacetValues: DeletionResponse[];
-    updateGlobalSettings: GlobalSettings;
-    importProducts?: ImportInfo | null;
-    addItemToOrder?: Order | null;
-    removeItemFromOrder?: Order | null;
-    adjustItemQuantity?: Order | null;
-    transitionOrderToState?: Order | null;
-    setOrderShippingAddress?: Order | null;
-    setOrderShippingMethod?: Order | null;
-    addPaymentToOrder?: Order | null;
-    setCustomerForOrder?: Order | null;
-    updatePaymentMethod: PaymentMethod;
-    createProductCategory: ProductCategory;
-    updateProductCategory: ProductCategory;
-    moveProductCategory: ProductCategory;
-    createProductOptionGroup: ProductOptionGroup;
-    updateProductOptionGroup: ProductOptionGroup;
-    createProduct: Product;
-    updateProduct: Product;
-    deleteProduct: DeletionResponse;
-    addOptionGroupToProduct: Product;
-    removeOptionGroupFromProduct: Product;
-    generateVariantsForProduct: Product;
-    updateProductVariants: (ProductVariant | null)[];
-    createPromotion: Promotion;
-    updatePromotion: Promotion;
-    deletePromotion: DeletionResponse;
-    createRole: Role;
-    updateRole: Role;
-    reindex: SearchReindexResponse;
-    createShippingMethod: ShippingMethod;
-    updateShippingMethod: ShippingMethod;
-    createTaxCategory: TaxCategory;
-    updateTaxCategory: TaxCategory;
-    createTaxRate: TaxRate;
-    updateTaxRate: TaxRate;
-    createZone: Zone;
-    updateZone: Zone;
-    deleteZone: DeletionResponse;
-    addMembersToZone: Zone;
-    removeMembersFromZone: Zone;
-    requestStarted: number;
-    requestCompleted: number;
-    setAsLoggedIn: UserStatus;
-    setAsLoggedOut: UserStatus;
-    setUiLanguage?: LanguageCode | null;
+export interface UpdatePaymentMethodInput {
+  
+  id: string;
+  
+  code?: Maybe<string>;
+  
+  enabled?: Maybe<boolean>;
+  
+  configArgs?: Maybe<ConfigArgInput[]>;
 }
 
-export interface LoginResult {
-    user: CurrentUser;
+export interface ConfigArgInput {
+  
+  name: string;
+  
+  value: string;
 }
 
-export interface DeletionResponse {
-    result: DeletionResult;
-    message?: string | null;
+export interface CreateProductCategoryInput {
+  
+  featuredAssetId?: Maybe<string>;
+  
+  assetIds?: Maybe<string[]>;
+  
+  parentId?: Maybe<string>;
+  
+  facetValueIds?: Maybe<string[]>;
+  
+  translations: ProductCategoryTranslationInput[];
+  
+  customFields?: Maybe<Json>;
 }
 
-export interface ImportInfo {
-    errors?: string[] | null;
-    processed: number;
-    imported: number;
+export interface ProductCategoryTranslationInput {
+  
+  id?: Maybe<string>;
+  
+  languageCode: LanguageCode;
+  
+  name?: Maybe<string>;
+  
+  description?: Maybe<string>;
+  
+  customFields?: Maybe<Json>;
 }
 
-export interface SearchReindexResponse {
-    success: boolean;
-    timeTaken: number;
-    indexedItemCount: number;
+export interface UpdateProductCategoryInput {
+  
+  id: string;
+  
+  featuredAssetId?: Maybe<string>;
+  
+  parentId?: Maybe<string>;
+  
+  assetIds?: Maybe<string[]>;
+  
+  facetValueIds?: Maybe<string[]>;
+  
+  translations: ProductCategoryTranslationInput[];
+  
+  customFields?: Maybe<Json>;
 }
 
-export interface AdministratorListOptions {
-    take?: number | null;
-    skip?: number | null;
-    sort?: AdministratorSortParameter | null;
-    filter?: AdministratorFilterParameter | null;
+export interface MoveProductCategoryInput {
+  
+  categoryId: string;
+  
+  parentId: string;
+  
+  index: number;
 }
 
-export interface AdministratorSortParameter {
-    id?: SortOrder | null;
-    createdAt?: SortOrder | null;
-    updatedAt?: SortOrder | null;
-    firstName?: SortOrder | null;
-    lastName?: SortOrder | null;
-    emailAddress?: SortOrder | null;
+export interface CreateProductOptionGroupInput {
+  
+  code: string;
+  
+  translations: ProductOptionGroupTranslationInput[];
+  
+  options: CreateProductOptionInput[];
+  
+  customFields?: Maybe<Json>;
 }
 
-export interface AdministratorFilterParameter {
-    firstName?: StringOperators | null;
-    lastName?: StringOperators | null;
-    emailAddress?: StringOperators | null;
-    createdAt?: DateOperators | null;
-    updatedAt?: DateOperators | null;
+export interface ProductOptionGroupTranslationInput {
+  
+  id?: Maybe<string>;
+  
+  languageCode: LanguageCode;
+  
+  name?: Maybe<string>;
+  
+  customFields?: Maybe<Json>;
 }
 
-export interface StringOperators {
-    eq?: string | null;
-    contains?: string | null;
+export interface CreateProductOptionInput {
+  
+  code: string;
+  
+  translations: ProductOptionGroupTranslationInput[];
+  
+  customFields?: Maybe<Json>;
 }
 
-export interface DateOperators {
-    eq?: DateTime | null;
-    before?: DateTime | null;
-    after?: DateTime | null;
-    between?: DateRange | null;
+export interface UpdateProductOptionGroupInput {
+  
+  id: string;
+  
+  code?: Maybe<string>;
+  
+  translations?: Maybe<ProductOptionGroupTranslationInput[]>;
+  
+  customFields?: Maybe<Json>;
 }
 
-export interface DateRange {
-    start: DateTime;
-    end: DateTime;
+export interface CreateProductInput {
+  
+  featuredAssetId?: Maybe<string>;
+  
+  assetIds?: Maybe<string[]>;
+  
+  facetValueIds?: Maybe<string[]>;
+  
+  translations: ProductTranslationInput[];
+  
+  customFields?: Maybe<Json>;
 }
 
-export interface AssetListOptions {
-    take?: number | null;
-    skip?: number | null;
-    sort?: AssetSortParameter | null;
-    filter?: AssetFilterParameter | null;
+export interface ProductTranslationInput {
+  
+  id?: Maybe<string>;
+  
+  languageCode: LanguageCode;
+  
+  name?: Maybe<string>;
+  
+  slug?: Maybe<string>;
+  
+  description?: Maybe<string>;
+  
+  customFields?: Maybe<Json>;
 }
 
-export interface AssetSortParameter {
-    id?: SortOrder | null;
-    createdAt?: SortOrder | null;
-    updatedAt?: SortOrder | null;
-    name?: SortOrder | null;
-    description?: SortOrder | null;
+export interface UpdateProductInput {
+  
+  id: string;
+  
+  featuredAssetId?: Maybe<string>;
+  
+  assetIds?: Maybe<string[]>;
+  
+  facetValueIds?: Maybe<string[]>;
+  
+  translations?: Maybe<ProductTranslationInput[]>;
+  
+  customFields?: Maybe<Json>;
 }
 
-export interface AssetFilterParameter {
-    name?: StringOperators | null;
-    description?: StringOperators | null;
-    type?: StringOperators | null;
-    createdAt?: DateOperators | null;
-    updatedAt?: DateOperators | null;
+export interface UpdateProductVariantInput {
+  
+  id: string;
+  
+  translations?: Maybe<ProductVariantTranslationInput[]>;
+  
+  facetValueIds?: Maybe<string[]>;
+  
+  sku?: Maybe<string>;
+  
+  taxCategoryId?: Maybe<string>;
+  
+  price?: Maybe<number>;
+  
+  featuredAssetId?: Maybe<string>;
+  
+  assetIds?: Maybe<string[]>;
+  
+  customFields?: Maybe<Json>;
 }
 
-export interface CountryListOptions {
-    take?: number | null;
-    skip?: number | null;
-    sort?: CountrySortParameter | null;
-    filter?: CountryFilterParameter | null;
+export interface ProductVariantTranslationInput {
+  
+  id?: Maybe<string>;
+  
+  languageCode: LanguageCode;
+  
+  name?: Maybe<string>;
+  
+  customFields?: Maybe<Json>;
 }
 
-export interface CountrySortParameter {
-    id?: SortOrder | null;
-    createdAt?: SortOrder | null;
-    updatedAt?: SortOrder | null;
-    code?: SortOrder | null;
-    name?: SortOrder | null;
-    enabled?: SortOrder | null;
+export interface CreatePromotionInput {
+  
+  name: string;
+  
+  enabled: boolean;
+  
+  conditions: AdjustmentOperationInput[];
+  
+  actions: AdjustmentOperationInput[];
 }
 
-export interface CountryFilterParameter {
-    code?: StringOperators | null;
-    name?: StringOperators | null;
-    enabled?: BooleanOperators | null;
-    createdAt?: DateOperators | null;
-    updatedAt?: DateOperators | null;
+export interface AdjustmentOperationInput {
+  
+  code: string;
+  
+  arguments: ConfigArgInput[];
 }
 
-export interface BooleanOperators {
-    eq?: boolean | null;
+export interface UpdatePromotionInput {
+  
+  id: string;
+  
+  name?: Maybe<string>;
+  
+  enabled?: Maybe<boolean>;
+  
+  conditions?: Maybe<AdjustmentOperationInput[]>;
+  
+  actions?: Maybe<AdjustmentOperationInput[]>;
 }
 
-export interface CustomerListOptions {
-    take?: number | null;
-    skip?: number | null;
-    sort?: CustomerSortParameter | null;
-    filter?: CustomerFilterParameter | null;
+export interface CreateRoleInput {
+  
+  code: string;
+  
+  description: string;
+  
+  permissions: Permission[];
 }
 
-export interface CustomerSortParameter {
-    id?: SortOrder | null;
-    createdAt?: SortOrder | null;
-    updatedAt?: SortOrder | null;
-    firstName?: SortOrder | null;
-    lastName?: SortOrder | null;
-    phoneNumber?: SortOrder | null;
-    emailAddress?: SortOrder | null;
+export interface UpdateRoleInput {
+  
+  id: string;
+  
+  code?: Maybe<string>;
+  
+  description?: Maybe<string>;
+  
+  permissions?: Maybe<Permission[]>;
 }
 
-export interface CustomerFilterParameter {
-    firstName?: StringOperators | null;
-    lastName?: StringOperators | null;
-    phoneNumber?: StringOperators | null;
-    emailAddress?: StringOperators | null;
-    createdAt?: DateOperators | null;
-    updatedAt?: DateOperators | null;
+export interface CreateShippingMethodInput {
+  
+  code: string;
+  
+  description: string;
+  
+  checker: AdjustmentOperationInput;
+  
+  calculator: AdjustmentOperationInput;
 }
 
-export interface OrderListOptions {
-    take?: number | null;
-    skip?: number | null;
-    sort?: OrderSortParameter | null;
-    filter?: OrderFilterParameter | null;
+export interface UpdateShippingMethodInput {
+  
+  id: string;
+  
+  code?: Maybe<string>;
+  
+  description?: Maybe<string>;
+  
+  checker?: Maybe<AdjustmentOperationInput>;
+  
+  calculator?: Maybe<AdjustmentOperationInput>;
 }
 
-export interface OrderSortParameter {
-    id?: SortOrder | null;
-    createdAt?: SortOrder | null;
-    updatedAt?: SortOrder | null;
-    code?: SortOrder | null;
+export interface CreateTaxCategoryInput {
+  
+  name: string;
 }
 
-export interface OrderFilterParameter {
-    code?: StringOperators | null;
-    createdAt?: DateOperators | null;
-    updatedAt?: DateOperators | null;
+export interface UpdateTaxCategoryInput {
+  
+  id: string;
+  
+  name?: Maybe<string>;
 }
 
-export interface FacetListOptions {
-    take?: number | null;
-    skip?: number | null;
-    sort?: FacetSortParameter | null;
-    filter?: FacetFilterParameter | null;
+export interface CreateTaxRateInput {
+  
+  name: string;
+  
+  enabled: boolean;
+  
+  value: number;
+  
+  categoryId: string;
+  
+  zoneId: string;
+  
+  customerGroupId?: Maybe<string>;
 }
 
-export interface FacetSortParameter {
-    id?: SortOrder | null;
-    createdAt?: SortOrder | null;
-    updatedAt?: SortOrder | null;
-    name?: SortOrder | null;
-    code?: SortOrder | null;
+export interface UpdateTaxRateInput {
+  
+  id: string;
+  
+  name?: Maybe<string>;
+  
+  value?: Maybe<number>;
+  
+  enabled?: Maybe<boolean>;
+  
+  categoryId?: Maybe<string>;
+  
+  zoneId?: Maybe<string>;
+  
+  customerGroupId?: Maybe<string>;
 }
 
-export interface FacetFilterParameter {
-    name?: StringOperators | null;
-    code?: StringOperators | null;
-    createdAt?: DateOperators | null;
-    updatedAt?: DateOperators | null;
+export interface CreateZoneInput {
+  
+  name: string;
+  
+  memberIds?: Maybe<string[]>;
 }
 
-export interface PaymentMethodListOptions {
-    take?: number | null;
-    skip?: number | null;
-    sort?: PaymentMethodSortParameter | null;
-    filter?: PaymentMethodFilterParameter | null;
+export interface UpdateZoneInput {
+  
+  id: string;
+  
+  name?: Maybe<string>;
 }
 
-export interface PaymentMethodSortParameter {
-    id?: SortOrder | null;
-    createdAt?: SortOrder | null;
-    updatedAt?: SortOrder | null;
-    code?: SortOrder | null;
+export interface CreateProductVariantInput {
+  
+  translations: ProductVariantTranslationInput[];
+  
+  facetValueIds?: Maybe<string[]>;
+  
+  sku: string;
+  
+  price?: Maybe<number>;
+  
+  taxCategoryId: string;
+  
+  optionIds?: Maybe<string[]>;
+  
+  featuredAssetId?: Maybe<string>;
+  
+  assetIds?: Maybe<string[]>;
+  
+  customFields?: Maybe<Json>;
 }
 
-export interface PaymentMethodFilterParameter {
-    code?: StringOperators | null;
-    createdAt?: DateOperators | null;
-    updatedAt?: DateOperators | null;
+export interface NumberOperators {
+  
+  eq?: Maybe<number>;
+  
+  lt?: Maybe<number>;
+  
+  lte?: Maybe<number>;
+  
+  gt?: Maybe<number>;
+  
+  gte?: Maybe<number>;
+  
+  between?: Maybe<NumberRange>;
 }
 
-export interface ProductCategoryListOptions {
-    take?: number | null;
-    skip?: number | null;
-    sort?: ProductCategorySortParameter | null;
-    filter?: ProductCategoryFilterParameter | null;
+export interface NumberRange {
+  
+  start: number;
+  
+  end: number;
 }
 
-export interface ProductCategorySortParameter {
-    id?: SortOrder | null;
-    createdAt?: SortOrder | null;
-    updatedAt?: SortOrder | null;
-    name?: SortOrder | null;
-    description?: SortOrder | null;
-}
+export interface ProductOptionTranslationInput {
+  
+  id?: Maybe<string>;
+  
+  languageCode: LanguageCode;
+  
+  name?: Maybe<string>;
+  
+  customFields?: Maybe<Json>;
+}
+
+  export enum SortOrder {
+    ASC = "ASC",
+    DESC = "DESC",
+  }
+/** Permissions for administrators and customers */
+  export enum Permission {
+    Authenticated = "Authenticated",
+    SuperAdmin = "SuperAdmin",
+    Owner = "Owner",
+    Public = "Public",
+    CreateCatalog = "CreateCatalog",
+    ReadCatalog = "ReadCatalog",
+    UpdateCatalog = "UpdateCatalog",
+    DeleteCatalog = "DeleteCatalog",
+    CreateCustomer = "CreateCustomer",
+    ReadCustomer = "ReadCustomer",
+    UpdateCustomer = "UpdateCustomer",
+    DeleteCustomer = "DeleteCustomer",
+    CreateAdministrator = "CreateAdministrator",
+    ReadAdministrator = "ReadAdministrator",
+    UpdateAdministrator = "UpdateAdministrator",
+    DeleteAdministrator = "DeleteAdministrator",
+    CreateOrder = "CreateOrder",
+    ReadOrder = "ReadOrder",
+    UpdateOrder = "UpdateOrder",
+    DeleteOrder = "DeleteOrder",
+    CreateSettings = "CreateSettings",
+    ReadSettings = "ReadSettings",
+    UpdateSettings = "UpdateSettings",
+    DeleteSettings = "DeleteSettings",
+  }
+/** ISO 639-1 language code */
+  export enum LanguageCode {
+    aa = "aa",
+    ab = "ab",
+    af = "af",
+    ak = "ak",
+    sq = "sq",
+    am = "am",
+    ar = "ar",
+    an = "an",
+    hy = "hy",
+    as = "as",
+    av = "av",
+    ae = "ae",
+    ay = "ay",
+    az = "az",
+    ba = "ba",
+    bm = "bm",
+    eu = "eu",
+    be = "be",
+    bn = "bn",
+    bh = "bh",
+    bi = "bi",
+    bs = "bs",
+    br = "br",
+    bg = "bg",
+    my = "my",
+    ca = "ca",
+    ch = "ch",
+    ce = "ce",
+    zh = "zh",
+    cu = "cu",
+    cv = "cv",
+    kw = "kw",
+    co = "co",
+    cr = "cr",
+    cs = "cs",
+    da = "da",
+    dv = "dv",
+    nl = "nl",
+    dz = "dz",
+    en = "en",
+    eo = "eo",
+    et = "et",
+    ee = "ee",
+    fo = "fo",
+    fj = "fj",
+    fi = "fi",
+    fr = "fr",
+    fy = "fy",
+    ff = "ff",
+    ka = "ka",
+    de = "de",
+    gd = "gd",
+    ga = "ga",
+    gl = "gl",
+    gv = "gv",
+    el = "el",
+    gn = "gn",
+    gu = "gu",
+    ht = "ht",
+    ha = "ha",
+    he = "he",
+    hz = "hz",
+    hi = "hi",
+    ho = "ho",
+    hr = "hr",
+    hu = "hu",
+    ig = "ig",
+    is = "is",
+    io = "io",
+    ii = "ii",
+    iu = "iu",
+    ie = "ie",
+    ia = "ia",
+    id = "id",
+    ik = "ik",
+    it = "it",
+    jv = "jv",
+    ja = "ja",
+    kl = "kl",
+    kn = "kn",
+    ks = "ks",
+    kr = "kr",
+    kk = "kk",
+    km = "km",
+    ki = "ki",
+    rw = "rw",
+    ky = "ky",
+    kv = "kv",
+    kg = "kg",
+    ko = "ko",
+    kj = "kj",
+    ku = "ku",
+    lo = "lo",
+    la = "la",
+    lv = "lv",
+    li = "li",
+    ln = "ln",
+    lt = "lt",
+    lb = "lb",
+    lu = "lu",
+    lg = "lg",
+    mk = "mk",
+    mh = "mh",
+    ml = "ml",
+    mi = "mi",
+    mr = "mr",
+    ms = "ms",
+    mg = "mg",
+    mt = "mt",
+    mn = "mn",
+    na = "na",
+    nv = "nv",
+    nr = "nr",
+    nd = "nd",
+    ng = "ng",
+    ne = "ne",
+    nn = "nn",
+    nb = "nb",
+    no = "no",
+    ny = "ny",
+    oc = "oc",
+    oj = "oj",
+    or = "or",
+    om = "om",
+    os = "os",
+    pa = "pa",
+    fa = "fa",
+    pi = "pi",
+    pl = "pl",
+    pt = "pt",
+    ps = "ps",
+    qu = "qu",
+    rm = "rm",
+    ro = "ro",
+    rn = "rn",
+    ru = "ru",
+    sg = "sg",
+    sa = "sa",
+    si = "si",
+    sk = "sk",
+    sl = "sl",
+    se = "se",
+    sm = "sm",
+    sn = "sn",
+    sd = "sd",
+    so = "so",
+    st = "st",
+    es = "es",
+    sc = "sc",
+    sr = "sr",
+    ss = "ss",
+    su = "su",
+    sw = "sw",
+    sv = "sv",
+    ty = "ty",
+    ta = "ta",
+    tt = "tt",
+    te = "te",
+    tg = "tg",
+    tl = "tl",
+    th = "th",
+    bo = "bo",
+    ti = "ti",
+    to = "to",
+    tn = "tn",
+    ts = "ts",
+    tk = "tk",
+    tr = "tr",
+    tw = "tw",
+    ug = "ug",
+    uk = "uk",
+    ur = "ur",
+    uz = "uz",
+    ve = "ve",
+    vi = "vi",
+    vo = "vo",
+    cy = "cy",
+    wa = "wa",
+    wo = "wo",
+    xh = "xh",
+    yi = "yi",
+    yo = "yo",
+    za = "za",
+    zu = "zu",
+  }
+/** ISO 4217 currency code */
+  export enum CurrencyCode {
+    AED = "AED",
+    AFN = "AFN",
+    ALL = "ALL",
+    AMD = "AMD",
+    ANG = "ANG",
+    AOA = "AOA",
+    ARS = "ARS",
+    AUD = "AUD",
+    AWG = "AWG",
+    AZN = "AZN",
+    BAM = "BAM",
+    BBD = "BBD",
+    BDT = "BDT",
+    BGN = "BGN",
+    BHD = "BHD",
+    BIF = "BIF",
+    BMD = "BMD",
+    BND = "BND",
+    BOB = "BOB",
+    BRL = "BRL",
+    BSD = "BSD",
+    BTN = "BTN",
+    BWP = "BWP",
+    BYN = "BYN",
+    BZD = "BZD",
+    CAD = "CAD",
+    CHE = "CHE",
+    CHW = "CHW",
+    CLP = "CLP",
+    CNY = "CNY",
+    COP = "COP",
+    CRC = "CRC",
+    CUC = "CUC",
+    CUP = "CUP",
+    CVE = "CVE",
+    CZK = "CZK",
+    DJF = "DJF",
+    DKK = "DKK",
+    DOP = "DOP",
+    DZD = "DZD",
+    EGP = "EGP",
+    ERN = "ERN",
+    ETB = "ETB",
+    EUR = "EUR",
+    FJD = "FJD",
+    FKP = "FKP",
+    GBP = "GBP",
+    GEL = "GEL",
+    GHS = "GHS",
+    GIP = "GIP",
+    GMD = "GMD",
+    GNF = "GNF",
+    GTQ = "GTQ",
+    GYD = "GYD",
+    HKD = "HKD",
+    HNL = "HNL",
+    HRK = "HRK",
+    HTG = "HTG",
+    HUF = "HUF",
+    IDR = "IDR",
+    ILS = "ILS",
+    INR = "INR",
+    IQD = "IQD",
+    IRR = "IRR",
+    ISK = "ISK",
+    JMD = "JMD",
+    JOD = "JOD",
+    JPY = "JPY",
+    KES = "KES",
+    KGS = "KGS",
+    KHR = "KHR",
+    KMF = "KMF",
+    KPW = "KPW",
+    KRW = "KRW",
+    KWD = "KWD",
+    KYD = "KYD",
+    KZT = "KZT",
+    LAK = "LAK",
+    LBP = "LBP",
+    LKR = "LKR",
+    LRD = "LRD",
+    LSL = "LSL",
+    LYD = "LYD",
+    MAD = "MAD",
+    MDL = "MDL",
+    MGA = "MGA",
+    MKD = "MKD",
+    MMK = "MMK",
+    MNT = "MNT",
+    MOP = "MOP",
+    MRU = "MRU",
+    MUR = "MUR",
+    MVR = "MVR",
+    MWK = "MWK",
+    MXN = "MXN",
+    MYR = "MYR",
+    MZN = "MZN",
+    NAD = "NAD",
+    NGN = "NGN",
+    NIO = "NIO",
+    NOK = "NOK",
+    NPR = "NPR",
+    NZD = "NZD",
+    OMR = "OMR",
+    PAB = "PAB",
+    PEN = "PEN",
+    PGK = "PGK",
+    PHP = "PHP",
+    PKR = "PKR",
+    PLN = "PLN",
+    PYG = "PYG",
+    QAR = "QAR",
+    RON = "RON",
+    RSD = "RSD",
+    RUB = "RUB",
+    RWF = "RWF",
+    SAR = "SAR",
+    SBD = "SBD",
+    SCR = "SCR",
+    SDG = "SDG",
+    SEK = "SEK",
+    SGD = "SGD",
+    SHP = "SHP",
+    SLL = "SLL",
+    SOS = "SOS",
+    SRD = "SRD",
+    SSP = "SSP",
+    STN = "STN",
+    SVC = "SVC",
+    SYP = "SYP",
+    SZL = "SZL",
+    THB = "THB",
+    TJS = "TJS",
+    TMT = "TMT",
+    TND = "TND",
+    TOP = "TOP",
+    TRY = "TRY",
+    TTD = "TTD",
+    TWD = "TWD",
+    TZS = "TZS",
+    UAH = "UAH",
+    UGX = "UGX",
+    USD = "USD",
+    UYU = "UYU",
+    UZS = "UZS",
+    VES = "VES",
+    VND = "VND",
+    VUV = "VUV",
+    WST = "WST",
+    XAF = "XAF",
+    XCD = "XCD",
+    XOF = "XOF",
+    XPF = "XPF",
+    YER = "YER",
+    ZAR = "ZAR",
+    ZMW = "ZMW",
+    ZWL = "ZWL",
+  }
+
+  export enum AssetType {
+    IMAGE = "IMAGE",
+    VIDEO = "VIDEO",
+    BINARY = "BINARY",
+  }
+
+  export enum AdjustmentType {
+    TAX = "TAX",
+    PROMOTION = "PROMOTION",
+    SHIPPING = "SHIPPING",
+    REFUND = "REFUND",
+    TAX_REFUND = "TAX_REFUND",
+    PROMOTION_REFUND = "PROMOTION_REFUND",
+    SHIPPING_REFUND = "SHIPPING_REFUND",
+  }
+
+  export enum DeletionResult {
+    DELETED = "DELETED",
+    NOT_DELETED = "NOT_DELETED",
+  }
+
+/** 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. */
+export type DateTime = any;
 
-export interface ProductCategoryFilterParameter {
-    name?: StringOperators | null;
-    description?: StringOperators | null;
-    createdAt?: DateOperators | null;
-    updatedAt?: DateOperators | null;
-}
+/** The `JSON` scalar type represents JSON values as specified by [ECMA-404](http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf). */
+export type Json = any;
 
-export interface ProductListOptions {
-    take?: number | null;
-    skip?: number | null;
-    sort?: ProductSortParameter | null;
-    filter?: ProductFilterParameter | null;
-    categoryId?: string | null;
-}
+/** The `Upload` scalar type represents a file upload. */
+export type Upload = any;
 
-export interface ProductSortParameter {
-    id?: SortOrder | null;
-    createdAt?: SortOrder | null;
-    updatedAt?: SortOrder | null;
-    name?: SortOrder | null;
-    slug?: SortOrder | null;
-    description?: SortOrder | null;
-    image?: SortOrder | null;
-}
 
-export interface ProductFilterParameter {
-    name?: StringOperators | null;
-    slug?: StringOperators | null;
-    description?: StringOperators | null;
-    createdAt?: DateOperators | null;
-    updatedAt?: DateOperators | null;
-}
+// ====================================================
+// Documents
+// ====================================================
 
-export interface PromotionListOptions {
-    take?: number | null;
-    skip?: number | null;
-    sort?: PromotionSortParameter | null;
-    filter?: PromotionFilterParameter | null;
-}
 
-export interface PromotionSortParameter {
-    id?: SortOrder | null;
-    createdAt?: SortOrder | null;
-    updatedAt?: SortOrder | null;
-    name?: SortOrder | null;
-}
 
-export interface PromotionFilterParameter {
-    name?: StringOperators | null;
-    createdAt?: DateOperators | null;
-    updatedAt?: DateOperators | null;
-    type?: StringOperators | null;
-}
+export namespace GetAdministrators {
+  export type Variables = {
+    options?: Maybe<AdministratorListOptions>;
+  }
+
+  export type Query = {
+    __typename?: "Query";
+    
+    administrators: Administrators;
+  }
+
+  export type Administrators = {
+    __typename?: "AdministratorList";
+    
+    items: Items[];
+    
+    totalItems: number;
+  } 
 
-export interface RoleListOptions {
-    take?: number | null;
-    skip?: number | null;
-    sort?: RoleSortParameter | null;
-    filter?: RoleFilterParameter | null;
+  export type Items = Administrator.Fragment
 }
 
-export interface RoleSortParameter {
-    id?: SortOrder | null;
-    createdAt?: SortOrder | null;
-    updatedAt?: SortOrder | null;
-    code?: SortOrder | null;
-    description?: SortOrder | null;
-}
+export namespace GetAdministrator {
+  export type Variables = {
+    id: string;
+  }
 
-export interface RoleFilterParameter {
-    code?: StringOperators | null;
-    description?: StringOperators | null;
-    createdAt?: DateOperators | null;
-    updatedAt?: DateOperators | null;
-}
+  export type Query = {
+    __typename?: "Query";
+    
+    administrator: Maybe<Administrator>;
+  }
 
-export interface SearchInput {
-    term?: string | null;
-    facetIds?: string[] | null;
-    groupByProduct?: boolean | null;
-    take?: number | null;
-    skip?: number | null;
+  export type Administrator = Administrator.Fragment
 }
 
-export interface ShippingMethodListOptions {
-    take?: number | null;
-    skip?: number | null;
-    sort?: ShippingMethodSortParameter | null;
-    filter?: ShippingMethodFilterParameter | null;
-}
+export namespace CreateAdministrator {
+  export type Variables = {
+    input: CreateAdministratorInput;
+  }
 
-export interface ShippingMethodSortParameter {
-    id?: SortOrder | null;
-    createdAt?: SortOrder | null;
-    updatedAt?: SortOrder | null;
-    code?: SortOrder | null;
-    description?: SortOrder | null;
-}
+  export type Mutation = {
+    __typename?: "Mutation";
+    
+    createAdministrator: CreateAdministrator;
+  }
 
-export interface ShippingMethodFilterParameter {
-    code?: StringOperators | null;
-    description?: StringOperators | null;
-    createdAt?: DateOperators | null;
-    updatedAt?: DateOperators | null;
+  export type CreateAdministrator = Administrator.Fragment
 }
 
-export interface TaxRateListOptions {
-    take?: number | null;
-    skip?: number | null;
-    sort?: TaxRateSortParameter | null;
-    filter?: TaxRateFilterParameter | null;
-}
+export namespace UpdateAdministrator {
+  export type Variables = {
+    input: UpdateAdministratorInput;
+  }
 
-export interface TaxRateSortParameter {
-    id?: SortOrder | null;
-    createdAt?: SortOrder | null;
-    updatedAt?: SortOrder | null;
-    name?: SortOrder | null;
-    enabled?: SortOrder | null;
+  export type Mutation = {
+    __typename?: "Mutation";
+    
+    updateAdministrator: UpdateAdministrator;
+  }
+
+  export type UpdateAdministrator = Administrator.Fragment
 }
 
-export interface TaxRateFilterParameter {
-    code?: StringOperators | null;
-    name?: StringOperators | null;
-    enabled?: BooleanOperators | null;
-    createdAt?: DateOperators | null;
-    updatedAt?: DateOperators | null;
+export namespace GetRoles {
+  export type Variables = {
+    options?: Maybe<RoleListOptions>;
+  }
+
+  export type Query = {
+    __typename?: "Query";
+    
+    roles: Roles;
+  }
+
+  export type Roles = {
+    __typename?: "RoleList";
+    
+    items: Items[];
+    
+    totalItems: number;
+  } 
+
+  export type Items = Role.Fragment
 }
 
-export interface CreateAdministratorInput {
-    firstName: string;
-    lastName: string;
-    emailAddress: string;
-    password: string;
-    roleIds: string[];
-}
-
-export interface UpdateAdministratorInput {
+export namespace GetRole {
+  export type Variables = {
     id: string;
-    firstName?: string | null;
-    lastName?: string | null;
-    emailAddress?: string | null;
-    password?: string | null;
-    roleIds?: string[] | null;
-}
+  }
 
-export interface CreateAssetInput {
-    file: Upload;
-}
+  export type Query = {
+    __typename?: "Query";
+    
+    role: Maybe<Role>;
+  }
 
-export interface RegisterCustomerInput {
-    emailAddress: string;
-    title?: string | null;
-    firstName?: string | null;
-    lastName?: string | null;
+  export type Role = Role.Fragment
 }
 
-export interface CreateChannelInput {
-    code: string;
-    token: string;
-    defaultLanguageCode: LanguageCode;
-    pricesIncludeTax: boolean;
-    currencyCode: CurrencyCode;
-    defaultTaxZoneId?: string | null;
-    defaultShippingZoneId?: string | null;
-}
+export namespace CreateRole {
+  export type Variables = {
+    input: CreateRoleInput;
+  }
 
-export interface UpdateChannelInput {
-    id: string;
-    code?: string | null;
-    token?: string | null;
-    defaultLanguageCode?: LanguageCode | null;
-    pricesIncludeTax?: boolean | null;
-    currencyCode?: CurrencyCode | null;
-    defaultTaxZoneId?: string | null;
-    defaultShippingZoneId?: string | null;
-}
+  export type Mutation = {
+    __typename?: "Mutation";
+    
+    createRole: CreateRole;
+  }
 
-export interface CreateCountryInput {
-    code: string;
-    translations: CountryTranslationInput[];
-    enabled: boolean;
+  export type CreateRole = Role.Fragment
 }
 
-export interface CountryTranslationInput {
-    id?: string | null;
-    languageCode: LanguageCode;
-    name?: string | null;
-}
+export namespace UpdateRole {
+  export type Variables = {
+    input: UpdateRoleInput;
+  }
 
-export interface UpdateCountryInput {
-    id: string;
-    code?: string | null;
-    translations?: CountryTranslationInput[] | null;
-    enabled?: boolean | null;
-}
+  export type Mutation = {
+    __typename?: "Mutation";
+    
+    updateRole: UpdateRole;
+  }
 
-export interface CreateCustomerGroupInput {
-    name: string;
-    customerIds?: string[] | null;
+  export type UpdateRole = Role.Fragment
 }
 
-export interface UpdateCustomerGroupInput {
-    id: string;
-    name?: string | null;
-}
+export namespace AssignRoleToAdministrator {
+  export type Variables = {
+    administratorId: string;
+    roleId: string;
+  }
 
-export interface CreateCustomerInput {
-    title?: string | null;
-    firstName: string;
-    lastName: string;
-    phoneNumber?: string | null;
-    emailAddress: string;
-    customFields?: Json | null;
-}
+  export type Mutation = {
+    __typename?: "Mutation";
+    
+    assignRoleToAdministrator: AssignRoleToAdministrator;
+  }
 
-export interface UpdateCustomerInput {
-    id: string;
-    title?: string | null;
-    firstName?: string | null;
-    lastName?: string | null;
-    phoneNumber?: string | null;
-    emailAddress?: string | null;
-    customFields?: Json | null;
+  export type AssignRoleToAdministrator = Administrator.Fragment
 }
 
-export interface CreateAddressInput {
-    fullName?: string | null;
-    company?: string | null;
-    streetLine1: string;
-    streetLine2?: string | null;
-    city?: string | null;
-    province?: string | null;
-    postalCode?: string | null;
-    countryCode: string;
-    phoneNumber?: string | null;
-    defaultShippingAddress?: boolean | null;
-    defaultBillingAddress?: boolean | null;
-    customFields?: Json | null;
-}
+export namespace AttemptLogin {
+  export type Variables = {
+    username: string;
+    password: string;
+    rememberMe: boolean;
+  }
+
+  export type Mutation = {
+    __typename?: "Mutation";
+    
+    login: Login;
+  }
+
+  export type Login = {
+    __typename?: "LoginResult";
+    
+    user: User;
+  } 
 
-export interface UpdateAddressInput {
-    id: string;
-    fullName?: string | null;
-    company?: string | null;
-    streetLine1?: string | null;
-    streetLine2?: string | null;
-    city?: string | null;
-    province?: string | null;
-    postalCode?: string | null;
-    countryCode?: string | null;
-    phoneNumber?: string | null;
-    defaultShippingAddress?: boolean | null;
-    defaultBillingAddress?: boolean | null;
-    customFields?: Json | null;
+  export type User = CurrentUser.Fragment
 }
 
-export interface CreateFacetInput {
-    code: string;
-    translations: FacetTranslationInput[];
-    values?: CreateFacetValueWithFacetInput[] | null;
-    customFields?: Json | null;
-}
+export namespace LogOut {
+  export type Variables = {
+  }
 
-export interface FacetTranslationInput {
-    id?: string | null;
-    languageCode: LanguageCode;
-    name?: string | null;
-    customFields?: Json | null;
+  export type Mutation = {
+    __typename?: "Mutation";
+    
+    logout: boolean;
+  }
 }
 
-export interface CreateFacetValueWithFacetInput {
-    code: string;
-    translations: FacetValueTranslationInput[];
-}
+export namespace GetCurrentUser {
+  export type Variables = {
+  }
 
-export interface FacetValueTranslationInput {
-    id?: string | null;
-    languageCode: LanguageCode;
-    name?: string | null;
-    customFields?: Json | null;
-}
+  export type Query = {
+    __typename?: "Query";
+    
+    me: Maybe<Me>;
+  }
 
-export interface UpdateFacetInput {
-    id: string;
-    code?: string | null;
-    translations?: FacetTranslationInput[] | null;
-    customFields?: Json | null;
+  export type Me = CurrentUser.Fragment
 }
 
-export interface CreateFacetValueInput {
-    facetId: string;
-    code: string;
-    translations: FacetValueTranslationInput[];
-    customFields?: Json | null;
-}
+export namespace RequestStarted {
+  export type Variables = {
+  }
 
-export interface UpdateFacetValueInput {
-    id: string;
-    code?: string | null;
-    translations?: FacetValueTranslationInput[] | null;
-    customFields?: Json | null;
+  export type Mutation = {
+    __typename?: "Mutation";
+    
+    requestStarted: number;
+  }
 }
 
-export interface UpdateGlobalSettingsInput {
-    availableLanguages?: LanguageCode[] | null;
-    customFields?: UpdateGlobalSettingsCustomFieldsInput | null;
-}
+export namespace RequestCompleted {
+  export type Variables = {
+  }
 
-export interface UpdateGlobalSettingsCustomFieldsInput {
-    royalMailId?: string | null;
+  export type Mutation = {
+    __typename?: "Mutation";
+    
+    requestCompleted: number;
+  }
 }
 
-export interface PaymentInput {
-    method: string;
-    metadata: Json;
-}
+export namespace SetAsLoggedIn {
+  export type Variables = {
+    username: string;
+    loginTime: string;
+  }
 
-export interface UpdatePaymentMethodInput {
-    id: string;
-    code?: string | null;
-    enabled?: boolean | null;
-    configArgs?: ConfigArgInput[] | null;
-}
+  export type Mutation = {
+    __typename?: "Mutation";
+    
+    setAsLoggedIn: SetAsLoggedIn;
+  }
 
-export interface ConfigArgInput {
-    name: string;
-    value: string;
+  export type SetAsLoggedIn = {
+    __typename?: "UserStatus";
+    
+    username: string;
+    
+    isLoggedIn: boolean;
+    
+    loginTime: string;
+  } 
 }
 
-export interface CreateProductCategoryInput {
-    featuredAssetId?: string | null;
-    assetIds?: string[] | null;
-    parentId?: string | null;
-    facetValueIds?: string[] | null;
-    translations: ProductCategoryTranslationInput[];
-    customFields?: Json | null;
+export namespace SetAsLoggedOut {
+  export type Variables = {
+  }
+
+  export type Mutation = {
+    __typename?: "Mutation";
+    
+    setAsLoggedOut: SetAsLoggedOut;
+  }
+
+  export type SetAsLoggedOut = {
+    __typename?: "UserStatus";
+    
+    username: string;
+    
+    isLoggedIn: boolean;
+    
+    loginTime: string;
+  } 
 }
 
-export interface ProductCategoryTranslationInput {
-    id?: string | null;
+export namespace SetUiLanguage {
+  export type Variables = {
     languageCode: LanguageCode;
-    name?: string | null;
-    description?: string | null;
-    customFields?: Json | null;
-}
+  }
 
-export interface UpdateProductCategoryInput {
-    id: string;
-    featuredAssetId?: string | null;
-    parentId?: string | null;
-    assetIds?: string[] | null;
-    facetValueIds?: string[] | null;
-    translations: ProductCategoryTranslationInput[];
-    customFields?: Json | null;
+  export type Mutation = {
+    __typename?: "Mutation";
+    
+    setUiLanguage: Maybe<LanguageCode>;
+  }
 }
 
-export interface MoveProductCategoryInput {
-    categoryId: string;
-    parentId: string;
-    index: number;
-}
+export namespace GetNetworkStatus {
+  export type Variables = {
+  }
 
-export interface CreateProductOptionGroupInput {
-    code: string;
-    translations: ProductOptionGroupTranslationInput[];
-    options: CreateProductOptionInput[];
-    customFields?: Json | null;
+  export type Query = {
+    __typename?: "Query";
+    
+    networkStatus: NetworkStatus;
+  }
+
+  export type NetworkStatus = {
+    __typename?: "NetworkStatus";
+    
+    inFlightRequests: number;
+  } 
 }
 
-export interface ProductOptionGroupTranslationInput {
-    id?: string | null;
-    languageCode: LanguageCode;
-    name?: string | null;
-    customFields?: Json | null;
+export namespace GetUserStatus {
+  export type Variables = {
+  }
+
+  export type Query = {
+    __typename?: "Query";
+    
+    userStatus: UserStatus;
+  }
+
+  export type UserStatus = {
+    __typename?: "UserStatus";
+    
+    username: string;
+    
+    isLoggedIn: boolean;
+    
+    loginTime: string;
+  } 
 }
 
-export interface CreateProductOptionInput {
-    code: string;
-    translations: ProductOptionGroupTranslationInput[];
-    customFields?: Json | null;
+export namespace GetUiState {
+  export type Variables = {
+  }
+
+  export type Query = {
+    __typename?: "Query";
+    
+    uiState: UiState;
+  }
+
+  export type UiState = {
+    __typename?: "UiState";
+    
+    language: LanguageCode;
+  } 
 }
 
-export interface UpdateProductOptionGroupInput {
+export namespace GetCustomerList {
+  export type Variables = {
+    options?: Maybe<CustomerListOptions>;
+  }
+
+  export type Query = {
+    __typename?: "Query";
+    
+    customers: Customers;
+  }
+
+  export type Customers = {
+    __typename?: "CustomerList";
+    
+    items: Items[];
+    
+    totalItems: number;
+  } 
+
+  export type Items = {
+    __typename?: "Customer";
+    
     id: string;
-    code?: string | null;
-    translations?: ProductOptionGroupTranslationInput[] | null;
-    customFields?: Json | null;
-}
+    
+    title: Maybe<string>;
+    
+    firstName: string;
+    
+    lastName: string;
+    
+    emailAddress: string;
+    
+    user: Maybe<User>;
+  } 
 
-export interface CreateProductInput {
-    featuredAssetId?: string | null;
-    assetIds?: string[] | null;
-    facetValueIds?: string[] | null;
-    translations: ProductTranslationInput[];
-    customFields?: Json | null;
+  export type User = {
+    __typename?: "User";
+    
+    id: string;
+    
+    verified: boolean;
+  } 
 }
 
-export interface ProductTranslationInput {
-    id?: string | null;
-    languageCode: LanguageCode;
-    name?: string | null;
-    slug?: string | null;
-    description?: string | null;
-    customFields?: Json | null;
-}
+export namespace GetCustomer {
+  export type Variables = {
+    id: string;
+    orderListOptions?: Maybe<OrderListOptions>;
+  }
+
+  export type Query = {
+    __typename?: "Query";
+    
+    customer: Maybe<Customer>;
+  }
+
+  export type Customer = {
+    __typename?: "Customer";
+    
+    orders: Orders;
+  }  & Customer.Fragment
+
+  export type Orders = {
+    __typename?: "OrderList";
+    
+    items: Items[];
+    
+    totalItems: number;
+  } 
 
-export interface UpdateProductInput {
+  export type Items = {
+    __typename?: "Order";
+    
     id: string;
-    featuredAssetId?: string | null;
-    assetIds?: string[] | null;
-    facetValueIds?: string[] | null;
-    translations?: ProductTranslationInput[] | null;
-    customFields?: Json | null;
+    
+    code: string;
+    
+    state: string;
+    
+    total: number;
+    
+    currencyCode: CurrencyCode;
+    
+    updatedAt: DateTime;
+  } 
 }
 
-export interface UpdateProductVariantInput {
-    id: string;
-    translations?: ProductVariantTranslationInput[] | null;
-    facetValueIds?: string[] | null;
-    sku?: string | null;
-    taxCategoryId?: string | null;
-    price?: number | null;
-    featuredAssetId?: string | null;
-    assetIds?: string[] | null;
-    customFields?: Json | null;
+export namespace CreateCustomer {
+  export type Variables = {
+    input: CreateCustomerInput;
+    password?: Maybe<string>;
+  }
+
+  export type Mutation = {
+    __typename?: "Mutation";
+    
+    createCustomer: CreateCustomer;
+  }
+
+  export type CreateCustomer = Customer.Fragment
 }
 
-export interface ProductVariantTranslationInput {
-    id?: string | null;
-    languageCode: LanguageCode;
-    name?: string | null;
-    customFields?: Json | null;
+export namespace UpdateCustomer {
+  export type Variables = {
+    input: UpdateCustomerInput;
+  }
+
+  export type Mutation = {
+    __typename?: "Mutation";
+    
+    updateCustomer: UpdateCustomer;
+  }
+
+  export type UpdateCustomer = Customer.Fragment
 }
 
-export interface CreatePromotionInput {
-    name: string;
-    enabled: boolean;
-    conditions: AdjustmentOperationInput[];
-    actions: AdjustmentOperationInput[];
+export namespace CreateCustomerAddress {
+  export type Variables = {
+    customerId: string;
+    input: CreateAddressInput;
+  }
+
+  export type Mutation = {
+    __typename?: "Mutation";
+    
+    createCustomerAddress: CreateCustomerAddress;
+  }
+
+  export type CreateCustomerAddress = Address.Fragment
 }
 
-export interface AdjustmentOperationInput {
-    code: string;
-    arguments: ConfigArgInput[];
+export namespace UpdateCustomerAddress {
+  export type Variables = {
+    input: UpdateAddressInput;
+  }
+
+  export type Mutation = {
+    __typename?: "Mutation";
+    
+    updateCustomerAddress: UpdateCustomerAddress;
+  }
+
+  export type UpdateCustomerAddress = Address.Fragment
 }
 
-export interface UpdatePromotionInput {
-    id: string;
-    name?: string | null;
-    enabled?: boolean | null;
-    conditions?: AdjustmentOperationInput[] | null;
-    actions?: AdjustmentOperationInput[] | null;
+export namespace CreateFacet {
+  export type Variables = {
+    input: CreateFacetInput;
+  }
+
+  export type Mutation = {
+    __typename?: "Mutation";
+    
+    createFacet: CreateFacet;
+  }
+
+  export type CreateFacet = FacetWithValues.Fragment
 }
 
-export interface CreateRoleInput {
-    code: string;
-    description: string;
-    permissions: Permission[];
+export namespace UpdateFacet {
+  export type Variables = {
+    input: UpdateFacetInput;
+  }
+
+  export type Mutation = {
+    __typename?: "Mutation";
+    
+    updateFacet: UpdateFacet;
+  }
+
+  export type UpdateFacet = FacetWithValues.Fragment
 }
 
-export interface UpdateRoleInput {
+export namespace DeleteFacet {
+  export type Variables = {
     id: string;
-    code?: string | null;
-    description?: string | null;
-    permissions?: Permission[] | null;
+    force?: Maybe<boolean>;
+  }
+
+  export type Mutation = {
+    __typename?: "Mutation";
+    
+    deleteFacet: DeleteFacet;
+  }
+
+  export type DeleteFacet = {
+    __typename?: "DeletionResponse";
+    
+    result: DeletionResult;
+    
+    message: Maybe<string>;
+  } 
 }
 
-export interface CreateShippingMethodInput {
-    code: string;
-    description: string;
-    checker: AdjustmentOperationInput;
-    calculator: AdjustmentOperationInput;
-}
+export namespace CreateFacetValues {
+  export type Variables = {
+    input: CreateFacetValueInput[];
+  }
 
-export interface UpdateShippingMethodInput {
-    id: string;
-    code?: string | null;
-    description?: string | null;
-    checker?: AdjustmentOperationInput | null;
-    calculator?: AdjustmentOperationInput | null;
+  export type Mutation = {
+    __typename?: "Mutation";
+    
+    createFacetValues: CreateFacetValues[];
+  }
+
+  export type CreateFacetValues = FacetValue.Fragment
 }
 
-export interface CreateTaxCategoryInput {
-    name: string;
+export namespace UpdateFacetValues {
+  export type Variables = {
+    input: UpdateFacetValueInput[];
+  }
+
+  export type Mutation = {
+    __typename?: "Mutation";
+    
+    updateFacetValues: UpdateFacetValues[];
+  }
+
+  export type UpdateFacetValues = FacetValue.Fragment
 }
 
-export interface UpdateTaxCategoryInput {
-    id: string;
-    name?: string | null;
+export namespace DeleteFacetValues {
+  export type Variables = {
+    ids: string[];
+    force?: Maybe<boolean>;
+  }
+
+  export type Mutation = {
+    __typename?: "Mutation";
+    
+    deleteFacetValues: DeleteFacetValues[];
+  }
+
+  export type DeleteFacetValues = {
+    __typename?: "DeletionResponse";
+    
+    result: DeletionResult;
+    
+    message: Maybe<string>;
+  } 
 }
 
-export interface CreateTaxRateInput {
-    name: string;
-    enabled: boolean;
-    value: number;
-    categoryId: string;
-    zoneId: string;
-    customerGroupId?: string | null;
+export namespace GetFacetList {
+  export type Variables = {
+    options?: Maybe<FacetListOptions>;
+    languageCode?: Maybe<LanguageCode>;
+  }
+
+  export type Query = {
+    __typename?: "Query";
+    
+    facets: Facets;
+  }
+
+  export type Facets = {
+    __typename?: "FacetList";
+    
+    items: Items[];
+    
+    totalItems: number;
+  } 
+
+  export type Items = FacetWithValues.Fragment
 }
 
-export interface UpdateTaxRateInput {
+export namespace GetFacetWithValues {
+  export type Variables = {
     id: string;
-    name?: string | null;
-    value?: number | null;
-    enabled?: boolean | null;
-    categoryId?: string | null;
-    zoneId?: string | null;
-    customerGroupId?: string | null;
+    languageCode?: Maybe<LanguageCode>;
+  }
+
+  export type Query = {
+    __typename?: "Query";
+    
+    facet: Maybe<Facet>;
+  }
+
+  export type Facet = FacetWithValues.Fragment
 }
 
-export interface CreateZoneInput {
-    name: string;
-    memberIds?: string[] | null;
+export namespace GetOrderList {
+  export type Variables = {
+    options?: Maybe<OrderListOptions>;
+  }
+
+  export type Query = {
+    __typename?: "Query";
+    
+    orders: Orders;
+  }
+
+  export type Orders = {
+    __typename?: "OrderList";
+    
+    items: Items[];
+    
+    totalItems: number;
+  } 
+
+  export type Items = Order.Fragment
 }
 
-export interface UpdateZoneInput {
+export namespace GetOrder {
+  export type Variables = {
     id: string;
-    name?: string | null;
-}
+  }
 
-export interface CreateProductVariantInput {
-    translations: ProductVariantTranslationInput[];
-    facetValueIds?: string[] | null;
-    sku: string;
-    price?: number | null;
-    taxCategoryId: string;
-    optionIds?: string[] | null;
-    featuredAssetId?: string | null;
-    assetIds?: string[] | null;
-    customFields?: Json | null;
+  export type Query = {
+    __typename?: "Query";
+    
+    order: Maybe<Order>;
+  }
+
+  export type Order = OrderWithLines.Fragment
 }
 
-export interface NumberOperators {
-    eq?: number | null;
-    lt?: number | null;
-    lte?: number | null;
-    gt?: number | null;
-    gte?: number | null;
-    between?: NumberRange | null;
+export namespace UpdateProduct {
+  export type Variables = {
+    input: UpdateProductInput;
+  }
+
+  export type Mutation = {
+    __typename?: "Mutation";
+    
+    updateProduct: UpdateProduct;
+  }
+
+  export type UpdateProduct = ProductWithVariants.Fragment
 }
 
-export interface NumberRange {
-    start: number;
-    end: number;
+export namespace CreateProduct {
+  export type Variables = {
+    input: CreateProductInput;
+  }
+
+  export type Mutation = {
+    __typename?: "Mutation";
+    
+    createProduct: CreateProduct;
+  }
+
+  export type CreateProduct = ProductWithVariants.Fragment
 }
 
-export interface ProductOptionTranslationInput {
-    id?: string | null;
-    languageCode: LanguageCode;
-    name?: string | null;
-    customFields?: Json | null;
-}
-export interface AdministratorsQueryArgs {
-    options?: AdministratorListOptions | null;
-}
-export interface AdministratorQueryArgs {
+export namespace DeleteProduct {
+  export type Variables = {
     id: string;
+  }
+
+  export type Mutation = {
+    __typename?: "Mutation";
+    
+    deleteProduct: DeleteProduct;
+  }
+
+  export type DeleteProduct = {
+    __typename?: "DeletionResponse";
+    
+    result: DeletionResult;
+    
+    message: Maybe<string>;
+  } 
 }
-export interface AssetsQueryArgs {
-    options?: AssetListOptions | null;
-}
-export interface AssetQueryArgs {
-    id: string;
+
+export namespace GenerateProductVariants {
+  export type Variables = {
+    productId: string;
+    defaultTaxCategoryId?: Maybe<string>;
+    defaultPrice?: Maybe<number>;
+    defaultSku?: Maybe<string>;
+  }
+
+  export type Mutation = {
+    __typename?: "Mutation";
+    
+    generateVariantsForProduct: GenerateVariantsForProduct;
+  }
+
+  export type GenerateVariantsForProduct = ProductWithVariants.Fragment
 }
-export interface ChannelQueryArgs {
-    id: string;
+
+export namespace UpdateProductVariants {
+  export type Variables = {
+    input: UpdateProductVariantInput[];
+  }
+
+  export type Mutation = {
+    __typename?: "Mutation";
+    
+    updateProductVariants: (Maybe<UpdateProductVariants>)[];
+  }
+
+  export type UpdateProductVariants = ProductVariant.Fragment
 }
-export interface CountriesQueryArgs {
-    options?: CountryListOptions | null;
+
+export namespace CreateProductOptionGroup {
+  export type Variables = {
+    input: CreateProductOptionGroupInput;
+  }
+
+  export type Mutation = {
+    __typename?: "Mutation";
+    
+    createProductOptionGroup: CreateProductOptionGroup;
+  }
+
+  export type CreateProductOptionGroup = ProductOptionGroup.Fragment
 }
-export interface CountryQueryArgs {
+
+export namespace AddOptionGroupToProduct {
+  export type Variables = {
+    productId: string;
+    optionGroupId: string;
+  }
+
+  export type Mutation = {
+    __typename?: "Mutation";
+    
+    addOptionGroupToProduct: AddOptionGroupToProduct;
+  }
+
+  export type AddOptionGroupToProduct = {
+    __typename?: "Product";
+    
     id: string;
-}
-export interface CustomerGroupQueryArgs {
+    
+    optionGroups: OptionGroups[];
+  } 
+
+  export type OptionGroups = {
+    __typename?: "ProductOptionGroup";
+    
     id: string;
-}
-export interface CustomersQueryArgs {
-    options?: CustomerListOptions | null;
-}
-export interface CustomerQueryArgs {
+    
+    code: string;
+    
+    options: Options[];
+  } 
+
+  export type Options = {
+    __typename?: "ProductOption";
+    
     id: string;
+    
+    code: Maybe<string>;
+  } 
 }
-export interface FacetsQueryArgs {
-    languageCode?: LanguageCode | null;
-    options?: FacetListOptions | null;
-}
-export interface FacetQueryArgs {
+
+export namespace RemoveOptionGroupFromProduct {
+  export type Variables = {
+    productId: string;
+    optionGroupId: string;
+  }
+
+  export type Mutation = {
+    __typename?: "Mutation";
+    
+    removeOptionGroupFromProduct: RemoveOptionGroupFromProduct;
+  }
+
+  export type RemoveOptionGroupFromProduct = {
+    __typename?: "Product";
+    
     id: string;
-    languageCode?: LanguageCode | null;
-}
-export interface OrderQueryArgs {
+    
+    optionGroups: OptionGroups[];
+  } 
+
+  export type OptionGroups = {
+    __typename?: "ProductOptionGroup";
+    
     id: string;
-}
-export interface OrderByCodeQueryArgs {
+    
     code: string;
-}
-export interface OrdersQueryArgs {
-    options?: OrderListOptions | null;
-}
-export interface PaymentMethodsQueryArgs {
-    options?: PaymentMethodListOptions | null;
-}
-export interface PaymentMethodQueryArgs {
+    
+    options: Options[];
+  } 
+
+  export type Options = {
+    __typename?: "ProductOption";
+    
     id: string;
+    
+    code: Maybe<string>;
+  } 
 }
-export interface ProductCategoriesQueryArgs {
-    languageCode?: LanguageCode | null;
-    options?: ProductCategoryListOptions | null;
-}
-export interface ProductCategoryQueryArgs {
+
+export namespace GetProductWithVariants {
+  export type Variables = {
     id: string;
-    languageCode?: LanguageCode | null;
-}
-export interface ProductOptionGroupsQueryArgs {
-    languageCode?: LanguageCode | null;
-    filterTerm?: string | null;
+    languageCode?: Maybe<LanguageCode>;
+  }
+
+  export type Query = {
+    __typename?: "Query";
+    
+    product: Maybe<Product>;
+  }
+
+  export type Product = ProductWithVariants.Fragment
 }
-export interface ProductOptionGroupQueryArgs {
+
+export namespace GetProductList {
+  export type Variables = {
+    options?: Maybe<ProductListOptions>;
+    languageCode?: Maybe<LanguageCode>;
+  }
+
+  export type Query = {
+    __typename?: "Query";
+    
+    products: Products;
+  }
+
+  export type Products = {
+    __typename?: "ProductList";
+    
+    items: Items[];
+    
+    totalItems: number;
+  } 
+
+  export type Items = {
+    __typename?: "Product";
+    
     id: string;
-    languageCode?: LanguageCode | null;
-}
-export interface ProductsQueryArgs {
-    languageCode?: LanguageCode | null;
-    options?: ProductListOptions | null;
-}
-export interface ProductQueryArgs {
+    
+    languageCode: LanguageCode;
+    
+    name: string;
+    
+    slug: string;
+    
+    featuredAsset: Maybe<FeaturedAsset>;
+  } 
+
+  export type FeaturedAsset = {
+    __typename?: "Asset";
+    
     id: string;
-    languageCode?: LanguageCode | null;
+    
+    preview: string;
+  } 
 }
-export interface PromotionQueryArgs {
+
+export namespace GetProductOptionGroups {
+  export type Variables = {
+    filterTerm?: Maybe<string>;
+    languageCode?: Maybe<LanguageCode>;
+  }
+
+  export type Query = {
+    __typename?: "Query";
+    
+    productOptionGroups: ProductOptionGroups[];
+  }
+
+  export type ProductOptionGroups = {
+    __typename?: "ProductOptionGroup";
+    
     id: string;
-}
-export interface PromotionsQueryArgs {
-    options?: PromotionListOptions | null;
-}
-export interface RolesQueryArgs {
-    options?: RoleListOptions | null;
-}
-export interface RoleQueryArgs {
+    
+    languageCode: LanguageCode;
+    
+    code: string;
+    
+    name: string;
+    
+    options: Options[];
+  } 
+
+  export type Options = {
+    __typename?: "ProductOption";
+    
     id: string;
+    
+    languageCode: Maybe<LanguageCode>;
+    
+    code: Maybe<string>;
+    
+    name: Maybe<string>;
+  } 
 }
-export interface SearchQueryArgs {
-    input: SearchInput;
+
+export namespace GetAssetList {
+  export type Variables = {
+    options?: Maybe<AssetListOptions>;
+  }
+
+  export type Query = {
+    __typename?: "Query";
+    
+    assets: Assets;
+  }
+
+  export type Assets = {
+    __typename?: "AssetList";
+    
+    items: Items[];
+    
+    totalItems: number;
+  } 
+
+  export type Items = Asset.Fragment
 }
-export interface ShippingMethodsQueryArgs {
-    options?: ShippingMethodListOptions | null;
+
+export namespace CreateAssets {
+  export type Variables = {
+    input: CreateAssetInput[];
+  }
+
+  export type Mutation = {
+    __typename?: "Mutation";
+    
+    createAssets: CreateAssets[];
+  }
+
+  export type CreateAssets = Asset.Fragment
 }
-export interface ShippingMethodQueryArgs {
+
+export namespace GetProductCategoryList {
+  export type Variables = {
+    options?: Maybe<ProductCategoryListOptions>;
+    languageCode?: Maybe<LanguageCode>;
+  }
+
+  export type Query = {
+    __typename?: "Query";
+    
+    productCategories: ProductCategories;
+  }
+
+  export type ProductCategories = {
+    __typename?: "ProductCategoryList";
+    
+    items: Items[];
+    
+    totalItems: number;
+  } 
+
+  export type Items = {
+    __typename?: "ProductCategory";
+    
     id: string;
-}
-export interface TaxCategoryQueryArgs {
+    
+    name: string;
+    
+    description: string;
+    
+    featuredAsset: Maybe<FeaturedAsset>;
+    
+    facetValues: FacetValues[];
+    
+    parent: Parent;
+  } 
+
+  export type FeaturedAsset = Asset.Fragment
+
+  export type FacetValues = {
+    __typename?: "FacetValue";
+    
     id: string;
-}
-export interface TaxRatesQueryArgs {
-    options?: TaxRateListOptions | null;
-}
-export interface TaxRateQueryArgs {
+    
+    code: string;
+    
+    name: string;
+    
+    facet: Facet;
+  } 
+
+  export type Facet = {
+    __typename?: "Facet";
+    
+    id: string;
+    
+    name: string;
+  } 
+
+  export type Parent = {
+    __typename?: "ProductCategory";
+    
     id: string;
+  } 
 }
-export interface ZoneQueryArgs {
+
+export namespace GetProductCategory {
+  export type Variables = {
     id: string;
+    languageCode?: Maybe<LanguageCode>;
+  }
+
+  export type Query = {
+    __typename?: "Query";
+    
+    productCategory: Maybe<ProductCategory>;
+  }
+
+  export type ProductCategory = ProductCategory.Fragment
 }
-export interface OrdersCustomerArgs {
-    options?: OrderListOptions | null;
+
+export namespace CreateProductCategory {
+  export type Variables = {
+    input: CreateProductCategoryInput;
+  }
+
+  export type Mutation = {
+    __typename?: "Mutation";
+    
+    createProductCategory: CreateProductCategory;
+  }
+
+  export type CreateProductCategory = ProductCategory.Fragment
 }
-export interface CreateAdministratorMutationArgs {
-    input: CreateAdministratorInput;
+
+export namespace UpdateProductCategory {
+  export type Variables = {
+    input: UpdateProductCategoryInput;
+  }
+
+  export type Mutation = {
+    __typename?: "Mutation";
+    
+    updateProductCategory: UpdateProductCategory;
+  }
+
+  export type UpdateProductCategory = ProductCategory.Fragment
 }
-export interface UpdateAdministratorMutationArgs {
-    input: UpdateAdministratorInput;
+
+export namespace MoveProductCategory {
+  export type Variables = {
+    input: MoveProductCategoryInput;
+  }
+
+  export type Mutation = {
+    __typename?: "Mutation";
+    
+    moveProductCategory: MoveProductCategory;
+  }
+
+  export type MoveProductCategory = ProductCategory.Fragment
 }
-export interface AssignRoleToAdministratorMutationArgs {
-    administratorId: string;
-    roleId: string;
+
+export namespace SearchProducts {
+  export type Variables = {
+    input: SearchInput;
+  }
+
+  export type Query = {
+    __typename?: "Query";
+    
+    search: Search;
+  }
+
+  export type Search = {
+    __typename?: "SearchResponse";
+    
+    totalItems: number;
+    
+    items: Items[];
+  } 
+
+  export type Items = {
+    __typename?: "SearchResult";
+    
+    productId: string;
+    
+    productName: string;
+    
+    productPreview: string;
+    
+    productVariantId: string;
+    
+    productVariantName: string;
+    
+    productVariantPreview: string;
+    
+    sku: string;
+  } 
 }
-export interface CreateAssetsMutationArgs {
-    input: CreateAssetInput[];
+
+export namespace GetPromotionList {
+  export type Variables = {
+    options?: Maybe<PromotionListOptions>;
+  }
+
+  export type Query = {
+    __typename?: "Query";
+    
+    promotions: Promotions;
+  }
+
+  export type Promotions = {
+    __typename?: "PromotionList";
+    
+    items: Items[];
+    
+    totalItems: number;
+  } 
+
+  export type Items = Promotion.Fragment
 }
-export interface LoginMutationArgs {
-    username: string;
-    password: string;
-    rememberMe?: boolean | null;
+
+export namespace GetPromotion {
+  export type Variables = {
+    id: string;
+  }
+
+  export type Query = {
+    __typename?: "Query";
+    
+    promotion: Maybe<Promotion>;
+  }
+
+  export type Promotion = Promotion.Fragment
 }
-export interface RegisterCustomerAccountMutationArgs {
-    input: RegisterCustomerInput;
+
+export namespace GetAdjustmentOperations {
+  export type Variables = {
+  }
+
+  export type Query = {
+    __typename?: "Query";
+    
+    adjustmentOperations: AdjustmentOperations;
+  }
+
+  export type AdjustmentOperations = {
+    __typename?: "AdjustmentOperations";
+    
+    actions: Actions[];
+    
+    conditions: Conditions[];
+  } 
+
+  export type Actions = AdjustmentOperation.Fragment
+
+  export type Conditions = AdjustmentOperation.Fragment
 }
-export interface VerifyCustomerAccountMutationArgs {
-    token: string;
-    password: string;
+
+export namespace CreatePromotion {
+  export type Variables = {
+    input: CreatePromotionInput;
+  }
+
+  export type Mutation = {
+    __typename?: "Mutation";
+    
+    createPromotion: CreatePromotion;
+  }
+
+  export type CreatePromotion = Promotion.Fragment
 }
-export interface RefreshCustomerVerificationMutationArgs {
-    emailAddress: string;
+
+export namespace UpdatePromotion {
+  export type Variables = {
+    input: UpdatePromotionInput;
+  }
+
+  export type Mutation = {
+    __typename?: "Mutation";
+    
+    updatePromotion: UpdatePromotion;
+  }
+
+  export type UpdatePromotion = Promotion.Fragment
 }
-export interface CreateChannelMutationArgs {
-    input: CreateChannelInput;
+
+export namespace GetCountryList {
+  export type Variables = {
+    options?: Maybe<CountryListOptions>;
+  }
+
+  export type Query = {
+    __typename?: "Query";
+    
+    countries: Countries;
+  }
+
+  export type Countries = {
+    __typename?: "CountryList";
+    
+    items: Items[];
+    
+    totalItems: number;
+  } 
+
+  export type Items = {
+    __typename?: "Country";
+    
+    id: string;
+    
+    code: string;
+    
+    name: string;
+    
+    enabled: boolean;
+  } 
 }
-export interface UpdateChannelMutationArgs {
-    input: UpdateChannelInput;
+
+export namespace GetAvailableCountries {
+  export type Variables = {
+  }
+
+  export type Query = {
+    __typename?: "Query";
+    
+    availableCountries: AvailableCountries[];
+  }
+
+  export type AvailableCountries = {
+    __typename?: "Country";
+    
+    id: string;
+    
+    code: string;
+    
+    name: string;
+    
+    enabled: boolean;
+  } 
 }
-export interface CreateCountryMutationArgs {
+
+export namespace GetCountry {
+  export type Variables = {
+    id: string;
+  }
+
+  export type Query = {
+    __typename?: "Query";
+    
+    country: Maybe<Country>;
+  }
+
+  export type Country = Country.Fragment
+}
+
+export namespace CreateCountry {
+  export type Variables = {
     input: CreateCountryInput;
+  }
+
+  export type Mutation = {
+    __typename?: "Mutation";
+    
+    createCountry: CreateCountry;
+  }
+
+  export type CreateCountry = Country.Fragment
 }
-export interface UpdateCountryMutationArgs {
+
+export namespace UpdateCountry {
+  export type Variables = {
     input: UpdateCountryInput;
+  }
+
+  export type Mutation = {
+    __typename?: "Mutation";
+    
+    updateCountry: UpdateCountry;
+  }
+
+  export type UpdateCountry = Country.Fragment
 }
-export interface DeleteCountryMutationArgs {
+
+export namespace DeleteCountry {
+  export type Variables = {
     id: string;
+  }
+
+  export type Mutation = {
+    __typename?: "Mutation";
+    
+    deleteCountry: DeleteCountry;
+  }
+
+  export type DeleteCountry = {
+    __typename?: "DeletionResponse";
+    
+    result: DeletionResult;
+    
+    message: Maybe<string>;
+  } 
 }
-export interface CreateCustomerGroupMutationArgs {
-    input: CreateCustomerGroupInput;
-}
-export interface UpdateCustomerGroupMutationArgs {
-    input: UpdateCustomerGroupInput;
-}
-export interface AddCustomersToGroupMutationArgs {
-    customerGroupId: string;
-    customerIds: string[];
-}
-export interface RemoveCustomersFromGroupMutationArgs {
-    customerGroupId: string;
-    customerIds: string[];
-}
-export interface CreateCustomerMutationArgs {
-    input: CreateCustomerInput;
-    password?: string | null;
-}
-export interface UpdateCustomerMutationArgs {
-    input: UpdateCustomerInput;
-}
-export interface DeleteCustomerMutationArgs {
+
+export namespace GetZones {
+  export type Variables = {
+  }
+
+  export type Query = {
+    __typename?: "Query";
+    
+    zones: Zones[];
+  }
+
+  export type Zones = {
+    __typename?: "Zone";
+    
     id: string;
-}
-export interface CreateCustomerAddressMutationArgs {
-    customerId: string;
-    input: CreateAddressInput;
-}
-export interface UpdateCustomerAddressMutationArgs {
-    input: UpdateAddressInput;
-}
-export interface CreateFacetMutationArgs {
-    input: CreateFacetInput;
-}
-export interface UpdateFacetMutationArgs {
-    input: UpdateFacetInput;
-}
-export interface DeleteFacetMutationArgs {
+    
+    name: string;
+    
+    members: Members[];
+  } 
+
+  export type Members = {
+    __typename?: "Country";
+    
     id: string;
-    force?: boolean | null;
-}
-export interface CreateFacetValuesMutationArgs {
-    input: CreateFacetValueInput[];
-}
-export interface UpdateFacetValuesMutationArgs {
-    input: UpdateFacetValueInput[];
-}
-export interface DeleteFacetValuesMutationArgs {
-    ids: string[];
-    force?: boolean | null;
-}
-export interface UpdateGlobalSettingsMutationArgs {
-    input: UpdateGlobalSettingsInput;
-}
-export interface ImportProductsMutationArgs {
-    csvFile: Upload;
-}
-export interface AddItemToOrderMutationArgs {
-    productVariantId: string;
-    quantity: number;
-}
-export interface RemoveItemFromOrderMutationArgs {
-    orderItemId: string;
-}
-export interface AdjustItemQuantityMutationArgs {
-    orderItemId: string;
-    quantity: number;
-}
-export interface TransitionOrderToStateMutationArgs {
-    state: string;
-}
-export interface SetOrderShippingAddressMutationArgs {
-    input: CreateAddressInput;
-}
-export interface SetOrderShippingMethodMutationArgs {
-    shippingMethodId: string;
-}
-export interface AddPaymentToOrderMutationArgs {
-    input: PaymentInput;
-}
-export interface SetCustomerForOrderMutationArgs {
-    input: CreateCustomerInput;
-}
-export interface UpdatePaymentMethodMutationArgs {
-    input: UpdatePaymentMethodInput;
-}
-export interface CreateProductCategoryMutationArgs {
-    input: CreateProductCategoryInput;
-}
-export interface UpdateProductCategoryMutationArgs {
-    input: UpdateProductCategoryInput;
-}
-export interface MoveProductCategoryMutationArgs {
-    input: MoveProductCategoryInput;
-}
-export interface CreateProductOptionGroupMutationArgs {
-    input: CreateProductOptionGroupInput;
-}
-export interface UpdateProductOptionGroupMutationArgs {
-    input: UpdateProductOptionGroupInput;
-}
-export interface CreateProductMutationArgs {
-    input: CreateProductInput;
-}
-export interface UpdateProductMutationArgs {
-    input: UpdateProductInput;
+    
+    name: string;
+    
+    code: string;
+  } 
 }
-export interface DeleteProductMutationArgs {
+
+export namespace GetZone {
+  export type Variables = {
     id: string;
+  }
+
+  export type Query = {
+    __typename?: "Query";
+    
+    zone: Maybe<Zone>;
+  }
+
+  export type Zone = Zone.Fragment
 }
-export interface AddOptionGroupToProductMutationArgs {
-    productId: string;
-    optionGroupId: string;
-}
-export interface RemoveOptionGroupFromProductMutationArgs {
-    productId: string;
-    optionGroupId: string;
+
+export namespace CreateZone {
+  export type Variables = {
+    input: CreateZoneInput;
+  }
+
+  export type Mutation = {
+    __typename?: "Mutation";
+    
+    createZone: CreateZone;
+  }
+
+  export type CreateZone = Zone.Fragment
 }
-export interface GenerateVariantsForProductMutationArgs {
-    productId: string;
-    defaultTaxCategoryId?: string | null;
-    defaultPrice?: number | null;
-    defaultSku?: string | null;
+
+export namespace UpdateZone {
+  export type Variables = {
+    input: UpdateZoneInput;
+  }
+
+  export type Mutation = {
+    __typename?: "Mutation";
+    
+    updateZone: UpdateZone;
+  }
+
+  export type UpdateZone = Zone.Fragment
 }
-export interface UpdateProductVariantsMutationArgs {
-    input: UpdateProductVariantInput[];
+
+export namespace AddMembersToZone {
+  export type Variables = {
+    zoneId: string;
+    memberIds: string[];
+  }
+
+  export type Mutation = {
+    __typename?: "Mutation";
+    
+    addMembersToZone: AddMembersToZone;
+  }
+
+  export type AddMembersToZone = Zone.Fragment
 }
-export interface CreatePromotionMutationArgs {
-    input: CreatePromotionInput;
+
+export namespace RemoveMembersFromZone {
+  export type Variables = {
+    zoneId: string;
+    memberIds: string[];
+  }
+
+  export type Mutation = {
+    __typename?: "Mutation";
+    
+    removeMembersFromZone: RemoveMembersFromZone;
+  }
+
+  export type RemoveMembersFromZone = Zone.Fragment
 }
-export interface UpdatePromotionMutationArgs {
-    input: UpdatePromotionInput;
+
+export namespace GetTaxCategories {
+  export type Variables = {
+  }
+
+  export type Query = {
+    __typename?: "Query";
+    
+    taxCategories: TaxCategories[];
+  }
+
+  export type TaxCategories = TaxCategory.Fragment
 }
-export interface DeletePromotionMutationArgs {
+
+export namespace GetTaxCategory {
+  export type Variables = {
     id: string;
+  }
+
+  export type Query = {
+    __typename?: "Query";
+    
+    taxCategory: Maybe<TaxCategory>;
+  }
+
+  export type TaxCategory = TaxCategory.Fragment
 }
-export interface CreateRoleMutationArgs {
-    input: CreateRoleInput;
-}
-export interface UpdateRoleMutationArgs {
-    input: UpdateRoleInput;
-}
-export interface CreateShippingMethodMutationArgs {
-    input: CreateShippingMethodInput;
-}
-export interface UpdateShippingMethodMutationArgs {
-    input: UpdateShippingMethodInput;
-}
-export interface CreateTaxCategoryMutationArgs {
+
+export namespace CreateTaxCategory {
+  export type Variables = {
     input: CreateTaxCategoryInput;
+  }
+
+  export type Mutation = {
+    __typename?: "Mutation";
+    
+    createTaxCategory: CreateTaxCategory;
+  }
+
+  export type CreateTaxCategory = TaxCategory.Fragment
 }
-export interface UpdateTaxCategoryMutationArgs {
+
+export namespace UpdateTaxCategory {
+  export type Variables = {
     input: UpdateTaxCategoryInput;
+  }
+
+  export type Mutation = {
+    __typename?: "Mutation";
+    
+    updateTaxCategory: UpdateTaxCategory;
+  }
+
+  export type UpdateTaxCategory = TaxCategory.Fragment
 }
-export interface CreateTaxRateMutationArgs {
+
+export namespace GetTaxRateList {
+  export type Variables = {
+    options?: Maybe<TaxRateListOptions>;
+  }
+
+  export type Query = {
+    __typename?: "Query";
+    
+    taxRates: TaxRates;
+  }
+
+  export type TaxRates = {
+    __typename?: "TaxRateList";
+    
+    items: Items[];
+    
+    totalItems: number;
+  } 
+
+  export type Items = TaxRate.Fragment
+}
+
+export namespace GetTaxRate {
+  export type Variables = {
+    id: string;
+  }
+
+  export type Query = {
+    __typename?: "Query";
+    
+    taxRate: Maybe<TaxRate>;
+  }
+
+  export type TaxRate = TaxRate.Fragment
+}
+
+export namespace CreateTaxRate {
+  export type Variables = {
     input: CreateTaxRateInput;
+  }
+
+  export type Mutation = {
+    __typename?: "Mutation";
+    
+    createTaxRate: CreateTaxRate;
+  }
+
+  export type CreateTaxRate = TaxRate.Fragment
 }
-export interface UpdateTaxRateMutationArgs {
+
+export namespace UpdateTaxRate {
+  export type Variables = {
     input: UpdateTaxRateInput;
+  }
+
+  export type Mutation = {
+    __typename?: "Mutation";
+    
+    updateTaxRate: UpdateTaxRate;
+  }
+
+  export type UpdateTaxRate = TaxRate.Fragment
 }
-export interface CreateZoneMutationArgs {
-    input: CreateZoneInput;
-}
-export interface UpdateZoneMutationArgs {
-    input: UpdateZoneInput;
+
+export namespace GetChannels {
+  export type Variables = {
+  }
+
+  export type Query = {
+    __typename?: "Query";
+    
+    channels: Channels[];
+  }
+
+  export type Channels = Channel.Fragment
 }
-export interface DeleteZoneMutationArgs {
+
+export namespace GetChannel {
+  export type Variables = {
     id: string;
+  }
+
+  export type Query = {
+    __typename?: "Query";
+    
+    channel: Maybe<Channel>;
+  }
+
+  export type Channel = Channel.Fragment
 }
-export interface AddMembersToZoneMutationArgs {
-    zoneId: string;
-    memberIds: string[];
+
+export namespace GetActiveChannel {
+  export type Variables = {
+  }
+
+  export type Query = {
+    __typename?: "Query";
+    
+    activeChannel: ActiveChannel;
+  }
+
+  export type ActiveChannel = Channel.Fragment
 }
-export interface RemoveMembersFromZoneMutationArgs {
-    zoneId: string;
-    memberIds: string[];
+
+export namespace CreateChannel {
+  export type Variables = {
+    input: CreateChannelInput;
+  }
+
+  export type Mutation = {
+    __typename?: "Mutation";
+    
+    createChannel: CreateChannel;
+  }
+
+  export type CreateChannel = Channel.Fragment
 }
-export interface SetAsLoggedInMutationArgs {
-    username: string;
-    loginTime: string;
+
+export namespace UpdateChannel {
+  export type Variables = {
+    input: UpdateChannelInput;
+  }
+
+  export type Mutation = {
+    __typename?: "Mutation";
+    
+    updateChannel: UpdateChannel;
+  }
+
+  export type UpdateChannel = Channel.Fragment
 }
-export interface SetUiLanguageMutationArgs {
-    languageCode?: LanguageCode | null;
-}
-
-export enum SortOrder {
-    ASC = 'ASC',
-    DESC = 'DESC',
-}
-
-export enum Permission {
-    Authenticated = 'Authenticated',
-    SuperAdmin = 'SuperAdmin',
-    Owner = 'Owner',
-    Public = 'Public',
-    CreateCatalog = 'CreateCatalog',
-    ReadCatalog = 'ReadCatalog',
-    UpdateCatalog = 'UpdateCatalog',
-    DeleteCatalog = 'DeleteCatalog',
-    CreateCustomer = 'CreateCustomer',
-    ReadCustomer = 'ReadCustomer',
-    UpdateCustomer = 'UpdateCustomer',
-    DeleteCustomer = 'DeleteCustomer',
-    CreateAdministrator = 'CreateAdministrator',
-    ReadAdministrator = 'ReadAdministrator',
-    UpdateAdministrator = 'UpdateAdministrator',
-    DeleteAdministrator = 'DeleteAdministrator',
-    CreateOrder = 'CreateOrder',
-    ReadOrder = 'ReadOrder',
-    UpdateOrder = 'UpdateOrder',
-    DeleteOrder = 'DeleteOrder',
-    CreateSettings = 'CreateSettings',
-    ReadSettings = 'ReadSettings',
-    UpdateSettings = 'UpdateSettings',
-    DeleteSettings = 'DeleteSettings',
-}
-
-export enum LanguageCode {
-    aa = 'aa',
-    ab = 'ab',
-    af = 'af',
-    ak = 'ak',
-    sq = 'sq',
-    am = 'am',
-    ar = 'ar',
-    an = 'an',
-    hy = 'hy',
-    as = 'as',
-    av = 'av',
-    ae = 'ae',
-    ay = 'ay',
-    az = 'az',
-    ba = 'ba',
-    bm = 'bm',
-    eu = 'eu',
-    be = 'be',
-    bn = 'bn',
-    bh = 'bh',
-    bi = 'bi',
-    bs = 'bs',
-    br = 'br',
-    bg = 'bg',
-    my = 'my',
-    ca = 'ca',
-    ch = 'ch',
-    ce = 'ce',
-    zh = 'zh',
-    cu = 'cu',
-    cv = 'cv',
-    kw = 'kw',
-    co = 'co',
-    cr = 'cr',
-    cs = 'cs',
-    da = 'da',
-    dv = 'dv',
-    nl = 'nl',
-    dz = 'dz',
-    en = 'en',
-    eo = 'eo',
-    et = 'et',
-    ee = 'ee',
-    fo = 'fo',
-    fj = 'fj',
-    fi = 'fi',
-    fr = 'fr',
-    fy = 'fy',
-    ff = 'ff',
-    ka = 'ka',
-    de = 'de',
-    gd = 'gd',
-    ga = 'ga',
-    gl = 'gl',
-    gv = 'gv',
-    el = 'el',
-    gn = 'gn',
-    gu = 'gu',
-    ht = 'ht',
-    ha = 'ha',
-    he = 'he',
-    hz = 'hz',
-    hi = 'hi',
-    ho = 'ho',
-    hr = 'hr',
-    hu = 'hu',
-    ig = 'ig',
-    is = 'is',
-    io = 'io',
-    ii = 'ii',
-    iu = 'iu',
-    ie = 'ie',
-    ia = 'ia',
-    id = 'id',
-    ik = 'ik',
-    it = 'it',
-    jv = 'jv',
-    ja = 'ja',
-    kl = 'kl',
-    kn = 'kn',
-    ks = 'ks',
-    kr = 'kr',
-    kk = 'kk',
-    km = 'km',
-    ki = 'ki',
-    rw = 'rw',
-    ky = 'ky',
-    kv = 'kv',
-    kg = 'kg',
-    ko = 'ko',
-    kj = 'kj',
-    ku = 'ku',
-    lo = 'lo',
-    la = 'la',
-    lv = 'lv',
-    li = 'li',
-    ln = 'ln',
-    lt = 'lt',
-    lb = 'lb',
-    lu = 'lu',
-    lg = 'lg',
-    mk = 'mk',
-    mh = 'mh',
-    ml = 'ml',
-    mi = 'mi',
-    mr = 'mr',
-    ms = 'ms',
-    mg = 'mg',
-    mt = 'mt',
-    mn = 'mn',
-    na = 'na',
-    nv = 'nv',
-    nr = 'nr',
-    nd = 'nd',
-    ng = 'ng',
-    ne = 'ne',
-    nn = 'nn',
-    nb = 'nb',
-    no = 'no',
-    ny = 'ny',
-    oc = 'oc',
-    oj = 'oj',
-    or = 'or',
-    om = 'om',
-    os = 'os',
-    pa = 'pa',
-    fa = 'fa',
-    pi = 'pi',
-    pl = 'pl',
-    pt = 'pt',
-    ps = 'ps',
-    qu = 'qu',
-    rm = 'rm',
-    ro = 'ro',
-    rn = 'rn',
-    ru = 'ru',
-    sg = 'sg',
-    sa = 'sa',
-    si = 'si',
-    sk = 'sk',
-    sl = 'sl',
-    se = 'se',
-    sm = 'sm',
-    sn = 'sn',
-    sd = 'sd',
-    so = 'so',
-    st = 'st',
-    es = 'es',
-    sc = 'sc',
-    sr = 'sr',
-    ss = 'ss',
-    su = 'su',
-    sw = 'sw',
-    sv = 'sv',
-    ty = 'ty',
-    ta = 'ta',
-    tt = 'tt',
-    te = 'te',
-    tg = 'tg',
-    tl = 'tl',
-    th = 'th',
-    bo = 'bo',
-    ti = 'ti',
-    to = 'to',
-    tn = 'tn',
-    ts = 'ts',
-    tk = 'tk',
-    tr = 'tr',
-    tw = 'tw',
-    ug = 'ug',
-    uk = 'uk',
-    ur = 'ur',
-    uz = 'uz',
-    ve = 've',
-    vi = 'vi',
-    vo = 'vo',
-    cy = 'cy',
-    wa = 'wa',
-    wo = 'wo',
-    xh = 'xh',
-    yi = 'yi',
-    yo = 'yo',
-    za = 'za',
-    zu = 'zu',
-}
-
-export enum CurrencyCode {
-    AED = 'AED',
-    AFN = 'AFN',
-    ALL = 'ALL',
-    AMD = 'AMD',
-    ANG = 'ANG',
-    AOA = 'AOA',
-    ARS = 'ARS',
-    AUD = 'AUD',
-    AWG = 'AWG',
-    AZN = 'AZN',
-    BAM = 'BAM',
-    BBD = 'BBD',
-    BDT = 'BDT',
-    BGN = 'BGN',
-    BHD = 'BHD',
-    BIF = 'BIF',
-    BMD = 'BMD',
-    BND = 'BND',
-    BOB = 'BOB',
-    BRL = 'BRL',
-    BSD = 'BSD',
-    BTN = 'BTN',
-    BWP = 'BWP',
-    BYN = 'BYN',
-    BZD = 'BZD',
-    CAD = 'CAD',
-    CHE = 'CHE',
-    CHW = 'CHW',
-    CLP = 'CLP',
-    CNY = 'CNY',
-    COP = 'COP',
-    CRC = 'CRC',
-    CUC = 'CUC',
-    CUP = 'CUP',
-    CVE = 'CVE',
-    CZK = 'CZK',
-    DJF = 'DJF',
-    DKK = 'DKK',
-    DOP = 'DOP',
-    DZD = 'DZD',
-    EGP = 'EGP',
-    ERN = 'ERN',
-    ETB = 'ETB',
-    EUR = 'EUR',
-    FJD = 'FJD',
-    FKP = 'FKP',
-    GBP = 'GBP',
-    GEL = 'GEL',
-    GHS = 'GHS',
-    GIP = 'GIP',
-    GMD = 'GMD',
-    GNF = 'GNF',
-    GTQ = 'GTQ',
-    GYD = 'GYD',
-    HKD = 'HKD',
-    HNL = 'HNL',
-    HRK = 'HRK',
-    HTG = 'HTG',
-    HUF = 'HUF',
-    IDR = 'IDR',
-    ILS = 'ILS',
-    INR = 'INR',
-    IQD = 'IQD',
-    IRR = 'IRR',
-    ISK = 'ISK',
-    JMD = 'JMD',
-    JOD = 'JOD',
-    JPY = 'JPY',
-    KES = 'KES',
-    KGS = 'KGS',
-    KHR = 'KHR',
-    KMF = 'KMF',
-    KPW = 'KPW',
-    KRW = 'KRW',
-    KWD = 'KWD',
-    KYD = 'KYD',
-    KZT = 'KZT',
-    LAK = 'LAK',
-    LBP = 'LBP',
-    LKR = 'LKR',
-    LRD = 'LRD',
-    LSL = 'LSL',
-    LYD = 'LYD',
-    MAD = 'MAD',
-    MDL = 'MDL',
-    MGA = 'MGA',
-    MKD = 'MKD',
-    MMK = 'MMK',
-    MNT = 'MNT',
-    MOP = 'MOP',
-    MRU = 'MRU',
-    MUR = 'MUR',
-    MVR = 'MVR',
-    MWK = 'MWK',
-    MXN = 'MXN',
-    MYR = 'MYR',
-    MZN = 'MZN',
-    NAD = 'NAD',
-    NGN = 'NGN',
-    NIO = 'NIO',
-    NOK = 'NOK',
-    NPR = 'NPR',
-    NZD = 'NZD',
-    OMR = 'OMR',
-    PAB = 'PAB',
-    PEN = 'PEN',
-    PGK = 'PGK',
-    PHP = 'PHP',
-    PKR = 'PKR',
-    PLN = 'PLN',
-    PYG = 'PYG',
-    QAR = 'QAR',
-    RON = 'RON',
-    RSD = 'RSD',
-    RUB = 'RUB',
-    RWF = 'RWF',
-    SAR = 'SAR',
-    SBD = 'SBD',
-    SCR = 'SCR',
-    SDG = 'SDG',
-    SEK = 'SEK',
-    SGD = 'SGD',
-    SHP = 'SHP',
-    SLL = 'SLL',
-    SOS = 'SOS',
-    SRD = 'SRD',
-    SSP = 'SSP',
-    STN = 'STN',
-    SVC = 'SVC',
-    SYP = 'SYP',
-    SZL = 'SZL',
-    THB = 'THB',
-    TJS = 'TJS',
-    TMT = 'TMT',
-    TND = 'TND',
-    TOP = 'TOP',
-    TRY = 'TRY',
-    TTD = 'TTD',
-    TWD = 'TWD',
-    TZS = 'TZS',
-    UAH = 'UAH',
-    UGX = 'UGX',
-    USD = 'USD',
-    UYU = 'UYU',
-    UZS = 'UZS',
-    VES = 'VES',
-    VND = 'VND',
-    VUV = 'VUV',
-    WST = 'WST',
-    XAF = 'XAF',
-    XCD = 'XCD',
-    XOF = 'XOF',
-    XPF = 'XPF',
-    YER = 'YER',
-    ZAR = 'ZAR',
-    ZMW = 'ZMW',
-    ZWL = 'ZWL',
-}
-
-export enum AssetType {
-    IMAGE = 'IMAGE',
-    VIDEO = 'VIDEO',
-    BINARY = 'BINARY',
-}
-
-export enum AdjustmentType {
-    TAX = 'TAX',
-    PROMOTION = 'PROMOTION',
-    SHIPPING = 'SHIPPING',
-    REFUND = 'REFUND',
-    TAX_REFUND = 'TAX_REFUND',
-    PROMOTION_REFUND = 'PROMOTION_REFUND',
-    SHIPPING_REFUND = 'SHIPPING_REFUND',
-}
-
-export enum DeletionResult {
-    DELETED = 'DELETED',
-    NOT_DELETED = 'NOT_DELETED',
-}
-
-export namespace QueryResolvers {
-    export interface Resolvers<Context = any> {
-        administrators?: AdministratorsResolver<AdministratorList, any, Context>;
-        administrator?: AdministratorResolver<Administrator | null, any, Context>;
-        assets?: AssetsResolver<AssetList, any, Context>;
-        asset?: AssetResolver<Asset | null, any, Context>;
-        me?: MeResolver<CurrentUser | null, any, Context>;
-        channels?: ChannelsResolver<Channel[], any, Context>;
-        channel?: ChannelResolver<Channel | null, any, Context>;
-        activeChannel?: ActiveChannelResolver<Channel, any, Context>;
-        config?: ConfigResolver<Config, any, Context>;
-        countries?: CountriesResolver<CountryList, any, Context>;
-        country?: CountryResolver<Country | null, any, Context>;
-        availableCountries?: AvailableCountriesResolver<Country[], any, Context>;
-        customerGroups?: CustomerGroupsResolver<CustomerGroup[], any, Context>;
-        customerGroup?: CustomerGroupResolver<CustomerGroup | null, any, Context>;
-        customers?: CustomersResolver<CustomerList, any, Context>;
-        customer?: CustomerResolver<Customer | null, any, Context>;
-        activeCustomer?: ActiveCustomerResolver<Customer | null, any, Context>;
-        facets?: FacetsResolver<FacetList, any, Context>;
-        facet?: FacetResolver<Facet | null, any, Context>;
-        globalSettings?: GlobalSettingsResolver<GlobalSettings, any, Context>;
-        order?: OrderResolver<Order | null, any, Context>;
-        activeOrder?: ActiveOrderResolver<Order | null, any, Context>;
-        orderByCode?: OrderByCodeResolver<Order | null, any, Context>;
-        nextOrderStates?: NextOrderStatesResolver<string[], any, Context>;
-        orders?: OrdersResolver<OrderList, any, Context>;
-        eligibleShippingMethods?: EligibleShippingMethodsResolver<ShippingMethodQuote[], any, Context>;
-        paymentMethods?: PaymentMethodsResolver<PaymentMethodList, any, Context>;
-        paymentMethod?: PaymentMethodResolver<PaymentMethod | null, any, Context>;
-        productCategories?: ProductCategoriesResolver<ProductCategoryList, any, Context>;
-        productCategory?: ProductCategoryResolver<ProductCategory | null, any, Context>;
-        productOptionGroups?: ProductOptionGroupsResolver<ProductOptionGroup[], any, Context>;
-        productOptionGroup?: ProductOptionGroupResolver<ProductOptionGroup | null, any, Context>;
-        products?: ProductsResolver<ProductList, any, Context>;
-        product?: ProductResolver<Product | null, any, Context>;
-        promotion?: PromotionResolver<Promotion | null, any, Context>;
-        promotions?: PromotionsResolver<PromotionList, any, Context>;
-        adjustmentOperations?: AdjustmentOperationsResolver<AdjustmentOperations, any, Context>;
-        roles?: RolesResolver<RoleList, any, Context>;
-        role?: RoleResolver<Role | null, any, Context>;
-        search?: SearchResolver<SearchResponse, any, Context>;
-        shippingMethods?: ShippingMethodsResolver<ShippingMethodList, any, Context>;
-        shippingMethod?: ShippingMethodResolver<ShippingMethod | null, any, Context>;
-        shippingEligibilityCheckers?: ShippingEligibilityCheckersResolver<
-            AdjustmentOperation[],
-            any,
-            Context
-        >;
-        shippingCalculators?: ShippingCalculatorsResolver<AdjustmentOperation[], any, Context>;
-        taxCategories?: TaxCategoriesResolver<TaxCategory[], any, Context>;
-        taxCategory?: TaxCategoryResolver<TaxCategory | null, any, Context>;
-        taxRates?: TaxRatesResolver<TaxRateList, any, Context>;
-        taxRate?: TaxRateResolver<TaxRate | null, any, Context>;
-        zones?: ZonesResolver<Zone[], any, Context>;
-        zone?: ZoneResolver<Zone | null, any, Context>;
-        temp__?: TempResolver<boolean | null, any, Context>;
-        networkStatus?: NetworkStatusResolver<NetworkStatus, any, Context>;
-        userStatus?: UserStatusResolver<UserStatus, any, Context>;
-        uiState?: UiStateResolver<UiState, any, Context>;
-    }
-
-    export type AdministratorsResolver<R = AdministratorList, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        AdministratorsArgs
-    >;
-    export interface AdministratorsArgs {
-        options?: AdministratorListOptions | null;
-    }
-
-    export type AdministratorResolver<R = Administrator | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        AdministratorArgs
-    >;
-    export interface AdministratorArgs {
-        id: string;
-    }
-
-    export type AssetsResolver<R = AssetList, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        AssetsArgs
-    >;
-    export interface AssetsArgs {
-        options?: AssetListOptions | null;
-    }
-
-    export type AssetResolver<R = Asset | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        AssetArgs
-    >;
-    export interface AssetArgs {
-        id: string;
-    }
-
-    export type MeResolver<R = CurrentUser | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type ChannelsResolver<R = Channel[], Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type ChannelResolver<R = Channel | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        ChannelArgs
-    >;
-    export interface ChannelArgs {
-        id: string;
-    }
-
-    export type ActiveChannelResolver<R = Channel, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type ConfigResolver<R = Config, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type CountriesResolver<R = CountryList, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        CountriesArgs
-    >;
-    export interface CountriesArgs {
-        options?: CountryListOptions | null;
-    }
-
-    export type CountryResolver<R = Country | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        CountryArgs
-    >;
-    export interface CountryArgs {
-        id: string;
-    }
-
-    export type AvailableCountriesResolver<R = Country[], Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type CustomerGroupsResolver<R = CustomerGroup[], Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type CustomerGroupResolver<R = CustomerGroup | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        CustomerGroupArgs
-    >;
-    export interface CustomerGroupArgs {
-        id: string;
-    }
-
-    export type CustomersResolver<R = CustomerList, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        CustomersArgs
-    >;
-    export interface CustomersArgs {
-        options?: CustomerListOptions | null;
-    }
-
-    export type CustomerResolver<R = Customer | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        CustomerArgs
-    >;
-    export interface CustomerArgs {
-        id: string;
-    }
-
-    export type ActiveCustomerResolver<R = Customer | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type FacetsResolver<R = FacetList, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        FacetsArgs
-    >;
-    export interface FacetsArgs {
-        languageCode?: LanguageCode | null;
-        options?: FacetListOptions | null;
-    }
-
-    export type FacetResolver<R = Facet | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        FacetArgs
-    >;
-    export interface FacetArgs {
-        id: string;
-        languageCode?: LanguageCode | null;
-    }
-
-    export type GlobalSettingsResolver<R = GlobalSettings, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type OrderResolver<R = Order | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        OrderArgs
-    >;
-    export interface OrderArgs {
-        id: string;
-    }
-
-    export type ActiveOrderResolver<R = Order | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type OrderByCodeResolver<R = Order | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        OrderByCodeArgs
-    >;
-    export interface OrderByCodeArgs {
-        code: string;
-    }
-
-    export type NextOrderStatesResolver<R = string[], Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type OrdersResolver<R = OrderList, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        OrdersArgs
-    >;
-    export interface OrdersArgs {
-        options?: OrderListOptions | null;
-    }
-
-    export type EligibleShippingMethodsResolver<
-        R = ShippingMethodQuote[],
-        Parent = any,
-        Context = any
-    > = Resolver<R, Parent, Context>;
-    export type PaymentMethodsResolver<R = PaymentMethodList, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        PaymentMethodsArgs
-    >;
-    export interface PaymentMethodsArgs {
-        options?: PaymentMethodListOptions | null;
-    }
-
-    export type PaymentMethodResolver<R = PaymentMethod | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        PaymentMethodArgs
-    >;
-    export interface PaymentMethodArgs {
-        id: string;
-    }
-
-    export type ProductCategoriesResolver<R = ProductCategoryList, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        ProductCategoriesArgs
-    >;
-    export interface ProductCategoriesArgs {
-        languageCode?: LanguageCode | null;
-        options?: ProductCategoryListOptions | null;
-    }
-
-    export type ProductCategoryResolver<R = ProductCategory | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        ProductCategoryArgs
-    >;
-    export interface ProductCategoryArgs {
-        id: string;
-        languageCode?: LanguageCode | null;
-    }
-
-    export type ProductOptionGroupsResolver<R = ProductOptionGroup[], Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        ProductOptionGroupsArgs
-    >;
-    export interface ProductOptionGroupsArgs {
-        languageCode?: LanguageCode | null;
-        filterTerm?: string | null;
-    }
-
-    export type ProductOptionGroupResolver<
-        R = ProductOptionGroup | null,
-        Parent = any,
-        Context = any
-    > = Resolver<R, Parent, Context, ProductOptionGroupArgs>;
-    export interface ProductOptionGroupArgs {
-        id: string;
-        languageCode?: LanguageCode | null;
-    }
-
-    export type ProductsResolver<R = ProductList, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        ProductsArgs
-    >;
-    export interface ProductsArgs {
-        languageCode?: LanguageCode | null;
-        options?: ProductListOptions | null;
-    }
-
-    export type ProductResolver<R = Product | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        ProductArgs
-    >;
-    export interface ProductArgs {
-        id: string;
-        languageCode?: LanguageCode | null;
-    }
-
-    export type PromotionResolver<R = Promotion | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        PromotionArgs
-    >;
-    export interface PromotionArgs {
-        id: string;
-    }
-
-    export type PromotionsResolver<R = PromotionList, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        PromotionsArgs
-    >;
-    export interface PromotionsArgs {
-        options?: PromotionListOptions | null;
-    }
-
-    export type AdjustmentOperationsResolver<
-        R = AdjustmentOperations,
-        Parent = any,
-        Context = any
-    > = Resolver<R, Parent, Context>;
-    export type RolesResolver<R = RoleList, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        RolesArgs
-    >;
-    export interface RolesArgs {
-        options?: RoleListOptions | null;
-    }
-
-    export type RoleResolver<R = Role | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        RoleArgs
-    >;
-    export interface RoleArgs {
-        id: string;
-    }
-
-    export type SearchResolver<R = SearchResponse, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        SearchArgs
-    >;
-    export interface SearchArgs {
-        input: SearchInput;
-    }
-
-    export type ShippingMethodsResolver<R = ShippingMethodList, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        ShippingMethodsArgs
-    >;
-    export interface ShippingMethodsArgs {
-        options?: ShippingMethodListOptions | null;
-    }
-
-    export type ShippingMethodResolver<R = ShippingMethod | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        ShippingMethodArgs
-    >;
-    export interface ShippingMethodArgs {
-        id: string;
-    }
-
-    export type ShippingEligibilityCheckersResolver<
-        R = AdjustmentOperation[],
-        Parent = any,
-        Context = any
-    > = Resolver<R, Parent, Context>;
-    export type ShippingCalculatorsResolver<
-        R = AdjustmentOperation[],
-        Parent = any,
-        Context = any
-    > = Resolver<R, Parent, Context>;
-    export type TaxCategoriesResolver<R = TaxCategory[], Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type TaxCategoryResolver<R = TaxCategory | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        TaxCategoryArgs
-    >;
-    export interface TaxCategoryArgs {
-        id: string;
-    }
-
-    export type TaxRatesResolver<R = TaxRateList, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        TaxRatesArgs
-    >;
-    export interface TaxRatesArgs {
-        options?: TaxRateListOptions | null;
-    }
-
-    export type TaxRateResolver<R = TaxRate | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        TaxRateArgs
-    >;
-    export interface TaxRateArgs {
-        id: string;
-    }
-
-    export type ZonesResolver<R = Zone[], Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type ZoneResolver<R = Zone | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        ZoneArgs
-    >;
-    export interface ZoneArgs {
-        id: string;
-    }
-
-    export type TempResolver<R = boolean | null, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type NetworkStatusResolver<R = NetworkStatus, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type UserStatusResolver<R = UserStatus, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type UiStateResolver<R = UiState, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-}
-
-export namespace AdministratorListResolvers {
-    export interface Resolvers<Context = any> {
-        items?: ItemsResolver<Administrator[], any, Context>;
-        totalItems?: TotalItemsResolver<number, any, Context>;
-    }
-
-    export type ItemsResolver<R = Administrator[], Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type TotalItemsResolver<R = number, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-}
-
-export namespace AdministratorResolvers {
-    export interface Resolvers<Context = any> {
-        id?: IdResolver<string, any, Context>;
-        createdAt?: CreatedAtResolver<DateTime, any, Context>;
-        updatedAt?: UpdatedAtResolver<DateTime, any, Context>;
-        firstName?: FirstNameResolver<string, any, Context>;
-        lastName?: LastNameResolver<string, any, Context>;
-        emailAddress?: EmailAddressResolver<string, any, Context>;
-        user?: UserResolver<User, any, Context>;
-    }
-
-    export type IdResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type CreatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type UpdatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type FirstNameResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type LastNameResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type EmailAddressResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type UserResolver<R = User, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-}
-
-export namespace UserResolvers {
-    export interface Resolvers<Context = any> {
-        id?: IdResolver<string, any, Context>;
-        createdAt?: CreatedAtResolver<DateTime, any, Context>;
-        updatedAt?: UpdatedAtResolver<DateTime, any, Context>;
-        identifier?: IdentifierResolver<string, any, Context>;
-        passwordHash?: PasswordHashResolver<string, any, Context>;
-        verified?: VerifiedResolver<boolean, any, Context>;
-        roles?: RolesResolver<Role[], any, Context>;
-        lastLogin?: LastLoginResolver<string | null, any, Context>;
-        customFields?: CustomFieldsResolver<Json | null, any, Context>;
-    }
-
-    export type IdResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type CreatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type UpdatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type IdentifierResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type PasswordHashResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type VerifiedResolver<R = boolean, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type RolesResolver<R = Role[], Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type LastLoginResolver<R = string | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type CustomFieldsResolver<R = Json | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-}
-
-export namespace RoleResolvers {
-    export interface Resolvers<Context = any> {
-        id?: IdResolver<string, any, Context>;
-        createdAt?: CreatedAtResolver<DateTime, any, Context>;
-        updatedAt?: UpdatedAtResolver<DateTime, any, Context>;
-        code?: CodeResolver<string, any, Context>;
-        description?: DescriptionResolver<string, any, Context>;
-        permissions?: PermissionsResolver<Permission[], any, Context>;
-        channels?: ChannelsResolver<Channel[], any, Context>;
-    }
-
-    export type IdResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type CreatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type UpdatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type CodeResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type DescriptionResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type PermissionsResolver<R = Permission[], Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type ChannelsResolver<R = Channel[], Parent = any, Context = any> = Resolver<R, Parent, Context>;
-}
-
-export namespace ChannelResolvers {
-    export interface Resolvers<Context = any> {
-        id?: IdResolver<string, any, Context>;
-        createdAt?: CreatedAtResolver<DateTime, any, Context>;
-        updatedAt?: UpdatedAtResolver<DateTime, any, Context>;
-        code?: CodeResolver<string, any, Context>;
-        token?: TokenResolver<string, any, Context>;
-        defaultTaxZone?: DefaultTaxZoneResolver<Zone | null, any, Context>;
-        defaultShippingZone?: DefaultShippingZoneResolver<Zone | null, any, Context>;
-        defaultLanguageCode?: DefaultLanguageCodeResolver<LanguageCode, any, Context>;
-        currencyCode?: CurrencyCodeResolver<CurrencyCode, any, Context>;
-        pricesIncludeTax?: PricesIncludeTaxResolver<boolean, any, Context>;
-    }
-
-    export type IdResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type CreatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type UpdatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type CodeResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type TokenResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type DefaultTaxZoneResolver<R = Zone | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type DefaultShippingZoneResolver<R = Zone | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type DefaultLanguageCodeResolver<R = LanguageCode, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type CurrencyCodeResolver<R = CurrencyCode, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type PricesIncludeTaxResolver<R = boolean, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-}
-
-export namespace ZoneResolvers {
-    export interface Resolvers<Context = any> {
-        id?: IdResolver<string, any, Context>;
-        createdAt?: CreatedAtResolver<DateTime, any, Context>;
-        updatedAt?: UpdatedAtResolver<DateTime, any, Context>;
-        name?: NameResolver<string, any, Context>;
-        members?: MembersResolver<Country[], any, Context>;
-    }
-
-    export type IdResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type CreatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type UpdatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type NameResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type MembersResolver<R = Country[], Parent = any, Context = any> = Resolver<R, Parent, Context>;
-}
-
-export namespace CountryResolvers {
-    export interface Resolvers<Context = any> {
-        id?: IdResolver<string, any, Context>;
-        languageCode?: LanguageCodeResolver<LanguageCode, any, Context>;
-        code?: CodeResolver<string, any, Context>;
-        name?: NameResolver<string, any, Context>;
-        enabled?: EnabledResolver<boolean, any, Context>;
-        translations?: TranslationsResolver<CountryTranslation[], any, Context>;
-    }
-
-    export type IdResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type LanguageCodeResolver<R = LanguageCode, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type CodeResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type NameResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type EnabledResolver<R = boolean, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type TranslationsResolver<R = CountryTranslation[], Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-}
-
-export namespace CountryTranslationResolvers {
-    export interface Resolvers<Context = any> {
-        id?: IdResolver<string, any, Context>;
-        createdAt?: CreatedAtResolver<DateTime, any, Context>;
-        updatedAt?: UpdatedAtResolver<DateTime, any, Context>;
-        languageCode?: LanguageCodeResolver<LanguageCode, any, Context>;
-        name?: NameResolver<string, any, Context>;
-    }
-
-    export type IdResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type CreatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type UpdatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type LanguageCodeResolver<R = LanguageCode, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type NameResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-}
-
-export namespace AssetListResolvers {
-    export interface Resolvers<Context = any> {
-        items?: ItemsResolver<Asset[], any, Context>;
-        totalItems?: TotalItemsResolver<number, any, Context>;
-    }
-
-    export type ItemsResolver<R = Asset[], Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type TotalItemsResolver<R = number, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-}
-
-export namespace AssetResolvers {
-    export interface Resolvers<Context = any> {
-        id?: IdResolver<string, any, Context>;
-        name?: NameResolver<string, any, Context>;
-        type?: TypeResolver<AssetType, any, Context>;
-        fileSize?: FileSizeResolver<number, any, Context>;
-        mimeType?: MimeTypeResolver<string, any, Context>;
-        source?: SourceResolver<string, any, Context>;
-        preview?: PreviewResolver<string, any, Context>;
-    }
-
-    export type IdResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type NameResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type TypeResolver<R = AssetType, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type FileSizeResolver<R = number, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type MimeTypeResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type SourceResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type PreviewResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-}
-
-export namespace CurrentUserResolvers {
-    export interface Resolvers<Context = any> {
-        id?: IdResolver<string, any, Context>;
-        identifier?: IdentifierResolver<string, any, Context>;
-        channelTokens?: ChannelTokensResolver<string[], any, Context>;
-    }
-
-    export type IdResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type IdentifierResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type ChannelTokensResolver<R = string[], Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-}
-
-export namespace ConfigResolvers {
-    export interface Resolvers<Context = any> {
-        customFields?: CustomFieldsResolver<Json | null, any, Context>;
-    }
-
-    export type CustomFieldsResolver<R = Json | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-}
-
-export namespace CountryListResolvers {
-    export interface Resolvers<Context = any> {
-        items?: ItemsResolver<Country[], any, Context>;
-        totalItems?: TotalItemsResolver<number, any, Context>;
-    }
-
-    export type ItemsResolver<R = Country[], Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type TotalItemsResolver<R = number, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-}
-
-export namespace CustomerGroupResolvers {
-    export interface Resolvers<Context = any> {
-        id?: IdResolver<string, any, Context>;
-        createdAt?: CreatedAtResolver<DateTime, any, Context>;
-        updatedAt?: UpdatedAtResolver<DateTime, any, Context>;
-        name?: NameResolver<string, any, Context>;
-    }
-
-    export type IdResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type CreatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type UpdatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type NameResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-}
-
-export namespace CustomerListResolvers {
-    export interface Resolvers<Context = any> {
-        items?: ItemsResolver<Customer[], any, Context>;
-        totalItems?: TotalItemsResolver<number, any, Context>;
-    }
-
-    export type ItemsResolver<R = Customer[], Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type TotalItemsResolver<R = number, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-}
-
-export namespace CustomerResolvers {
-    export interface Resolvers<Context = any> {
-        id?: IdResolver<string, any, Context>;
-        createdAt?: CreatedAtResolver<DateTime, any, Context>;
-        updatedAt?: UpdatedAtResolver<DateTime, any, Context>;
-        title?: TitleResolver<string | null, any, Context>;
-        firstName?: FirstNameResolver<string, any, Context>;
-        lastName?: LastNameResolver<string, any, Context>;
-        phoneNumber?: PhoneNumberResolver<string | null, any, Context>;
-        emailAddress?: EmailAddressResolver<string, any, Context>;
-        addresses?: AddressesResolver<Address[] | null, any, Context>;
-        orders?: OrdersResolver<OrderList, any, Context>;
-        user?: UserResolver<User | null, any, Context>;
-        customFields?: CustomFieldsResolver<Json | null, any, Context>;
-    }
-
-    export type IdResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type CreatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type UpdatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type TitleResolver<R = string | null, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type FirstNameResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type LastNameResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type PhoneNumberResolver<R = string | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type EmailAddressResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type AddressesResolver<R = Address[] | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type OrdersResolver<R = OrderList, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        OrdersArgs
-    >;
-    export interface OrdersArgs {
-        options?: OrderListOptions | null;
-    }
-
-    export type UserResolver<R = User | null, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type CustomFieldsResolver<R = Json | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-}
-
-export namespace AddressResolvers {
-    export interface Resolvers<Context = any> {
-        id?: IdResolver<string, any, Context>;
-        createdAt?: CreatedAtResolver<DateTime, any, Context>;
-        updatedAt?: UpdatedAtResolver<DateTime, any, Context>;
-        fullName?: FullNameResolver<string | null, any, Context>;
-        company?: CompanyResolver<string | null, any, Context>;
-        streetLine1?: StreetLine1Resolver<string, any, Context>;
-        streetLine2?: StreetLine2Resolver<string | null, any, Context>;
-        city?: CityResolver<string | null, any, Context>;
-        province?: ProvinceResolver<string | null, any, Context>;
-        postalCode?: PostalCodeResolver<string | null, any, Context>;
-        country?: CountryResolver<Country, any, Context>;
-        phoneNumber?: PhoneNumberResolver<string | null, any, Context>;
-        defaultShippingAddress?: DefaultShippingAddressResolver<boolean | null, any, Context>;
-        defaultBillingAddress?: DefaultBillingAddressResolver<boolean | null, any, Context>;
-        customFields?: CustomFieldsResolver<Json | null, any, Context>;
-    }
-
-    export type IdResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type CreatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type UpdatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type FullNameResolver<R = string | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type CompanyResolver<R = string | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type StreetLine1Resolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type StreetLine2Resolver<R = string | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type CityResolver<R = string | null, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type ProvinceResolver<R = string | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type PostalCodeResolver<R = string | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type CountryResolver<R = Country, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type PhoneNumberResolver<R = string | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type DefaultShippingAddressResolver<R = boolean | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type DefaultBillingAddressResolver<R = boolean | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type CustomFieldsResolver<R = Json | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-}
-
-export namespace OrderListResolvers {
-    export interface Resolvers<Context = any> {
-        items?: ItemsResolver<Order[], any, Context>;
-        totalItems?: TotalItemsResolver<number, any, Context>;
-    }
-
-    export type ItemsResolver<R = Order[], Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type TotalItemsResolver<R = number, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-}
-
-export namespace OrderResolvers {
-    export interface Resolvers<Context = any> {
-        id?: IdResolver<string, any, Context>;
-        createdAt?: CreatedAtResolver<DateTime, any, Context>;
-        updatedAt?: UpdatedAtResolver<DateTime, any, Context>;
-        code?: CodeResolver<string, any, Context>;
-        state?: StateResolver<string, any, Context>;
-        active?: ActiveResolver<boolean, any, Context>;
-        customer?: CustomerResolver<Customer | null, any, Context>;
-        shippingAddress?: ShippingAddressResolver<ShippingAddress | null, any, Context>;
-        billingAddress?: BillingAddressResolver<BillingAddress | null, any, Context>;
-        lines?: LinesResolver<OrderLine[], any, Context>;
-        adjustments?: AdjustmentsResolver<Adjustment[], any, Context>;
-        payments?: PaymentsResolver<Payment[] | null, any, Context>;
-        subTotalBeforeTax?: SubTotalBeforeTaxResolver<number, any, Context>;
-        subTotal?: SubTotalResolver<number, any, Context>;
-        currencyCode?: CurrencyCodeResolver<CurrencyCode, any, Context>;
-        shipping?: ShippingResolver<number, any, Context>;
-        shippingMethod?: ShippingMethodResolver<ShippingMethod | null, any, Context>;
-        totalBeforeTax?: TotalBeforeTaxResolver<number, any, Context>;
-        total?: TotalResolver<number, any, Context>;
-    }
-
-    export type IdResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type CreatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type UpdatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type CodeResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type StateResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type ActiveResolver<R = boolean, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type CustomerResolver<R = Customer | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type ShippingAddressResolver<R = ShippingAddress | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type BillingAddressResolver<R = BillingAddress | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type LinesResolver<R = OrderLine[], Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type AdjustmentsResolver<R = Adjustment[], Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type PaymentsResolver<R = Payment[] | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type SubTotalBeforeTaxResolver<R = number, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type SubTotalResolver<R = number, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type CurrencyCodeResolver<R = CurrencyCode, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type ShippingResolver<R = number, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type ShippingMethodResolver<R = ShippingMethod | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type TotalBeforeTaxResolver<R = number, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type TotalResolver<R = number, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-}
-
-export namespace ShippingAddressResolvers {
-    export interface Resolvers<Context = any> {
-        fullName?: FullNameResolver<string | null, any, Context>;
-        company?: CompanyResolver<string | null, any, Context>;
-        streetLine1?: StreetLine1Resolver<string | null, any, Context>;
-        streetLine2?: StreetLine2Resolver<string | null, any, Context>;
-        city?: CityResolver<string | null, any, Context>;
-        province?: ProvinceResolver<string | null, any, Context>;
-        postalCode?: PostalCodeResolver<string | null, any, Context>;
-        country?: CountryResolver<string | null, any, Context>;
-        countryCode?: CountryCodeResolver<string | null, any, Context>;
-        phoneNumber?: PhoneNumberResolver<string | null, any, Context>;
-    }
-
-    export type FullNameResolver<R = string | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type CompanyResolver<R = string | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type StreetLine1Resolver<R = string | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type StreetLine2Resolver<R = string | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type CityResolver<R = string | null, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type ProvinceResolver<R = string | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type PostalCodeResolver<R = string | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type CountryResolver<R = string | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type CountryCodeResolver<R = string | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type PhoneNumberResolver<R = string | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-}
-
-export namespace BillingAddressResolvers {
-    export interface Resolvers<Context = any> {
-        fullName?: FullNameResolver<string | null, any, Context>;
-        company?: CompanyResolver<string | null, any, Context>;
-        streetLine1?: StreetLine1Resolver<string | null, any, Context>;
-        streetLine2?: StreetLine2Resolver<string | null, any, Context>;
-        city?: CityResolver<string | null, any, Context>;
-        province?: ProvinceResolver<string | null, any, Context>;
-        postalCode?: PostalCodeResolver<string | null, any, Context>;
-        country?: CountryResolver<string | null, any, Context>;
-        countryCode?: CountryCodeResolver<string | null, any, Context>;
-        phoneNumber?: PhoneNumberResolver<string | null, any, Context>;
-    }
-
-    export type FullNameResolver<R = string | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type CompanyResolver<R = string | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type StreetLine1Resolver<R = string | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type StreetLine2Resolver<R = string | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type CityResolver<R = string | null, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type ProvinceResolver<R = string | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type PostalCodeResolver<R = string | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type CountryResolver<R = string | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type CountryCodeResolver<R = string | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type PhoneNumberResolver<R = string | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-}
-
-export namespace OrderLineResolvers {
-    export interface Resolvers<Context = any> {
-        id?: IdResolver<string, any, Context>;
-        createdAt?: CreatedAtResolver<DateTime, any, Context>;
-        updatedAt?: UpdatedAtResolver<DateTime, any, Context>;
-        productVariant?: ProductVariantResolver<ProductVariant, any, Context>;
-        featuredAsset?: FeaturedAssetResolver<Asset | null, any, Context>;
-        unitPrice?: UnitPriceResolver<number, any, Context>;
-        unitPriceWithTax?: UnitPriceWithTaxResolver<number, any, Context>;
-        quantity?: QuantityResolver<number, any, Context>;
-        items?: ItemsResolver<OrderItem[], any, Context>;
-        totalPrice?: TotalPriceResolver<number, any, Context>;
-        adjustments?: AdjustmentsResolver<Adjustment[], any, Context>;
-        order?: OrderResolver<Order, any, Context>;
-    }
-
-    export type IdResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type CreatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type UpdatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type ProductVariantResolver<R = ProductVariant, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type FeaturedAssetResolver<R = Asset | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type UnitPriceResolver<R = number, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type UnitPriceWithTaxResolver<R = number, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type QuantityResolver<R = number, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type ItemsResolver<R = OrderItem[], Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type TotalPriceResolver<R = number, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type AdjustmentsResolver<R = Adjustment[], Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type OrderResolver<R = Order, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-}
-
-export namespace ProductVariantResolvers {
-    export interface Resolvers<Context = any> {
-        id?: IdResolver<string, any, Context>;
-        createdAt?: CreatedAtResolver<DateTime, any, Context>;
-        updatedAt?: UpdatedAtResolver<DateTime, any, Context>;
-        languageCode?: LanguageCodeResolver<LanguageCode, any, Context>;
-        sku?: SkuResolver<string, any, Context>;
-        name?: NameResolver<string, any, Context>;
-        featuredAsset?: FeaturedAssetResolver<Asset | null, any, Context>;
-        assets?: AssetsResolver<Asset[], any, Context>;
-        price?: PriceResolver<number, any, Context>;
-        currencyCode?: CurrencyCodeResolver<CurrencyCode, any, Context>;
-        priceIncludesTax?: PriceIncludesTaxResolver<boolean, any, Context>;
-        priceWithTax?: PriceWithTaxResolver<number, any, Context>;
-        taxRateApplied?: TaxRateAppliedResolver<TaxRate, any, Context>;
-        taxCategory?: TaxCategoryResolver<TaxCategory, any, Context>;
-        options?: OptionsResolver<ProductOption[], any, Context>;
-        facetValues?: FacetValuesResolver<FacetValue[], any, Context>;
-        translations?: TranslationsResolver<ProductVariantTranslation[], any, Context>;
-        customFields?: CustomFieldsResolver<Json | null, any, Context>;
-    }
-
-    export type IdResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type CreatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type UpdatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type LanguageCodeResolver<R = LanguageCode, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type SkuResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type NameResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type FeaturedAssetResolver<R = Asset | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type AssetsResolver<R = Asset[], Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type PriceResolver<R = number, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type CurrencyCodeResolver<R = CurrencyCode, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type PriceIncludesTaxResolver<R = boolean, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type PriceWithTaxResolver<R = number, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type TaxRateAppliedResolver<R = TaxRate, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type TaxCategoryResolver<R = TaxCategory, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type OptionsResolver<R = ProductOption[], Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type FacetValuesResolver<R = FacetValue[], Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type TranslationsResolver<R = ProductVariantTranslation[], Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type CustomFieldsResolver<R = Json | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-}
-
-export namespace TaxRateResolvers {
-    export interface Resolvers<Context = any> {
-        id?: IdResolver<string, any, Context>;
-        createdAt?: CreatedAtResolver<DateTime, any, Context>;
-        updatedAt?: UpdatedAtResolver<DateTime, any, Context>;
-        name?: NameResolver<string, any, Context>;
-        enabled?: EnabledResolver<boolean, any, Context>;
-        value?: ValueResolver<number, any, Context>;
-        category?: CategoryResolver<TaxCategory, any, Context>;
-        zone?: ZoneResolver<Zone, any, Context>;
-        customerGroup?: CustomerGroupResolver<CustomerGroup | null, any, Context>;
-    }
-
-    export type IdResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type CreatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type UpdatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type NameResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type EnabledResolver<R = boolean, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type ValueResolver<R = number, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type CategoryResolver<R = TaxCategory, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type ZoneResolver<R = Zone, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type CustomerGroupResolver<R = CustomerGroup | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-}
-
-export namespace TaxCategoryResolvers {
-    export interface Resolvers<Context = any> {
-        id?: IdResolver<string, any, Context>;
-        createdAt?: CreatedAtResolver<DateTime, any, Context>;
-        updatedAt?: UpdatedAtResolver<DateTime, any, Context>;
-        name?: NameResolver<string, any, Context>;
-    }
-
-    export type IdResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type CreatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type UpdatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type NameResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-}
-
-export namespace ProductOptionResolvers {
-    export interface Resolvers<Context = any> {
-        id?: IdResolver<string, any, Context>;
-        createdAt?: CreatedAtResolver<DateTime, any, Context>;
-        updatedAt?: UpdatedAtResolver<DateTime, any, Context>;
-        languageCode?: LanguageCodeResolver<LanguageCode | null, any, Context>;
-        code?: CodeResolver<string | null, any, Context>;
-        name?: NameResolver<string | null, any, Context>;
-        translations?: TranslationsResolver<ProductOptionTranslation[], any, Context>;
-        customFields?: CustomFieldsResolver<Json | null, any, Context>;
-    }
-
-    export type IdResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type CreatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type UpdatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type LanguageCodeResolver<R = LanguageCode | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type CodeResolver<R = string | null, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type NameResolver<R = string | null, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type TranslationsResolver<R = ProductOptionTranslation[], Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type CustomFieldsResolver<R = Json | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-}
-
-export namespace ProductOptionTranslationResolvers {
-    export interface Resolvers<Context = any> {
-        id?: IdResolver<string, any, Context>;
-        createdAt?: CreatedAtResolver<DateTime, any, Context>;
-        updatedAt?: UpdatedAtResolver<DateTime, any, Context>;
-        languageCode?: LanguageCodeResolver<LanguageCode, any, Context>;
-        name?: NameResolver<string, any, Context>;
-    }
-
-    export type IdResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type CreatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type UpdatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type LanguageCodeResolver<R = LanguageCode, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type NameResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-}
-
-export namespace FacetValueResolvers {
-    export interface Resolvers<Context = any> {
-        id?: IdResolver<string, any, Context>;
-        createdAt?: CreatedAtResolver<DateTime, any, Context>;
-        updatedAt?: UpdatedAtResolver<DateTime, any, Context>;
-        languageCode?: LanguageCodeResolver<LanguageCode, any, Context>;
-        facet?: FacetResolver<Facet, any, Context>;
-        name?: NameResolver<string, any, Context>;
-        code?: CodeResolver<string, any, Context>;
-        translations?: TranslationsResolver<FacetValueTranslation[], any, Context>;
-        customFields?: CustomFieldsResolver<Json | null, any, Context>;
-    }
-
-    export type IdResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type CreatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type UpdatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type LanguageCodeResolver<R = LanguageCode, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type FacetResolver<R = Facet, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type NameResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type CodeResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type TranslationsResolver<R = FacetValueTranslation[], Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type CustomFieldsResolver<R = Json | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-}
-
-export namespace FacetResolvers {
-    export interface Resolvers<Context = any> {
-        id?: IdResolver<string, any, Context>;
-        createdAt?: CreatedAtResolver<DateTime, any, Context>;
-        updatedAt?: UpdatedAtResolver<DateTime, any, Context>;
-        languageCode?: LanguageCodeResolver<LanguageCode, any, Context>;
-        name?: NameResolver<string, any, Context>;
-        code?: CodeResolver<string, any, Context>;
-        values?: ValuesResolver<FacetValue[], any, Context>;
-        translations?: TranslationsResolver<FacetTranslation[], any, Context>;
-        customFields?: CustomFieldsResolver<Json | null, any, Context>;
-    }
-
-    export type IdResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type CreatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type UpdatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type LanguageCodeResolver<R = LanguageCode, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type NameResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type CodeResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type ValuesResolver<R = FacetValue[], Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type TranslationsResolver<R = FacetTranslation[], Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type CustomFieldsResolver<R = Json | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-}
-
-export namespace FacetTranslationResolvers {
-    export interface Resolvers<Context = any> {
-        id?: IdResolver<string, any, Context>;
-        createdAt?: CreatedAtResolver<DateTime, any, Context>;
-        updatedAt?: UpdatedAtResolver<DateTime, any, Context>;
-        languageCode?: LanguageCodeResolver<LanguageCode, any, Context>;
-        name?: NameResolver<string, any, Context>;
-    }
-
-    export type IdResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type CreatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type UpdatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type LanguageCodeResolver<R = LanguageCode, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type NameResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-}
-
-export namespace FacetValueTranslationResolvers {
-    export interface Resolvers<Context = any> {
-        id?: IdResolver<string, any, Context>;
-        createdAt?: CreatedAtResolver<DateTime, any, Context>;
-        updatedAt?: UpdatedAtResolver<DateTime, any, Context>;
-        languageCode?: LanguageCodeResolver<LanguageCode, any, Context>;
-        name?: NameResolver<string, any, Context>;
-    }
-
-    export type IdResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type CreatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type UpdatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type LanguageCodeResolver<R = LanguageCode, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type NameResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-}
-
-export namespace ProductVariantTranslationResolvers {
-    export interface Resolvers<Context = any> {
-        id?: IdResolver<string, any, Context>;
-        createdAt?: CreatedAtResolver<DateTime, any, Context>;
-        updatedAt?: UpdatedAtResolver<DateTime, any, Context>;
-        languageCode?: LanguageCodeResolver<LanguageCode, any, Context>;
-        name?: NameResolver<string, any, Context>;
-    }
-
-    export type IdResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type CreatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type UpdatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type LanguageCodeResolver<R = LanguageCode, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type NameResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-}
-
-export namespace OrderItemResolvers {
-    export interface Resolvers<Context = any> {
-        id?: IdResolver<string, any, Context>;
-        createdAt?: CreatedAtResolver<DateTime, any, Context>;
-        updatedAt?: UpdatedAtResolver<DateTime, any, Context>;
-        unitPrice?: UnitPriceResolver<number, any, Context>;
-        unitPriceWithTax?: UnitPriceWithTaxResolver<number, any, Context>;
-        unitPriceIncludesTax?: UnitPriceIncludesTaxResolver<boolean, any, Context>;
-        taxRate?: TaxRateResolver<number, any, Context>;
-        adjustments?: AdjustmentsResolver<Adjustment[], any, Context>;
-    }
-
-    export type IdResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type CreatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type UpdatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type UnitPriceResolver<R = number, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type UnitPriceWithTaxResolver<R = number, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type UnitPriceIncludesTaxResolver<R = boolean, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type TaxRateResolver<R = number, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type AdjustmentsResolver<R = Adjustment[], Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-}
-
-export namespace AdjustmentResolvers {
-    export interface Resolvers<Context = any> {
-        adjustmentSource?: AdjustmentSourceResolver<string, any, Context>;
-        type?: TypeResolver<AdjustmentType, any, Context>;
-        description?: DescriptionResolver<string, any, Context>;
-        amount?: AmountResolver<number, any, Context>;
-    }
-
-    export type AdjustmentSourceResolver<R = string, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type TypeResolver<R = AdjustmentType, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type DescriptionResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type AmountResolver<R = number, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-}
-
-export namespace PaymentResolvers {
-    export interface Resolvers<Context = any> {
-        id?: IdResolver<string, any, Context>;
-        createdAt?: CreatedAtResolver<DateTime, any, Context>;
-        updatedAt?: UpdatedAtResolver<DateTime, any, Context>;
-        method?: MethodResolver<string, any, Context>;
-        amount?: AmountResolver<number, any, Context>;
-        state?: StateResolver<string, any, Context>;
-        transactionId?: TransactionIdResolver<string | null, any, Context>;
-        metadata?: MetadataResolver<Json | null, any, Context>;
-    }
-
-    export type IdResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type CreatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type UpdatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type MethodResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type AmountResolver<R = number, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type StateResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type TransactionIdResolver<R = string | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type MetadataResolver<R = Json | null, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-}
-
-export namespace ShippingMethodResolvers {
-    export interface Resolvers<Context = any> {
-        id?: IdResolver<string, any, Context>;
-        createdAt?: CreatedAtResolver<DateTime, any, Context>;
-        updatedAt?: UpdatedAtResolver<DateTime, any, Context>;
-        code?: CodeResolver<string, any, Context>;
-        description?: DescriptionResolver<string, any, Context>;
-        checker?: CheckerResolver<AdjustmentOperation, any, Context>;
-        calculator?: CalculatorResolver<AdjustmentOperation, any, Context>;
-    }
-
-    export type IdResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type CreatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type UpdatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type CodeResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type DescriptionResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type CheckerResolver<R = AdjustmentOperation, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type CalculatorResolver<R = AdjustmentOperation, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-}
-
-export namespace AdjustmentOperationResolvers {
-    export interface Resolvers<Context = any> {
-        code?: CodeResolver<string, any, Context>;
-        args?: ArgsResolver<ConfigArg[], any, Context>;
-        description?: DescriptionResolver<string, any, Context>;
-    }
-
-    export type CodeResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type ArgsResolver<R = ConfigArg[], Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type DescriptionResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-}
-
-export namespace ConfigArgResolvers {
-    export interface Resolvers<Context = any> {
-        name?: NameResolver<string, any, Context>;
-        type?: TypeResolver<string, any, Context>;
-        value?: ValueResolver<string | null, any, Context>;
-    }
-
-    export type NameResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type TypeResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type ValueResolver<R = string | null, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-}
-
-export namespace FacetListResolvers {
-    export interface Resolvers<Context = any> {
-        items?: ItemsResolver<Facet[], any, Context>;
-        totalItems?: TotalItemsResolver<number, any, Context>;
-    }
-
-    export type ItemsResolver<R = Facet[], Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type TotalItemsResolver<R = number, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-}
-
-export namespace GlobalSettingsResolvers {
-    export interface Resolvers<Context = any> {
-        id?: IdResolver<string, any, Context>;
-        createdAt?: CreatedAtResolver<DateTime, any, Context>;
-        updatedAt?: UpdatedAtResolver<DateTime, any, Context>;
-        availableLanguages?: AvailableLanguagesResolver<LanguageCode[], any, Context>;
-        serverConfig?: ServerConfigResolver<ServerConfig, any, Context>;
-        customFields?: CustomFieldsResolver<GlobalSettingsCustomFields | null, any, Context>;
-    }
-
-    export type IdResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type CreatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type UpdatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type AvailableLanguagesResolver<R = LanguageCode[], Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type ServerConfigResolver<R = ServerConfig, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type CustomFieldsResolver<
-        R = GlobalSettingsCustomFields | null,
-        Parent = any,
-        Context = any
-    > = Resolver<R, Parent, Context>;
-}
-
-export namespace ServerConfigResolvers {
-    export interface Resolvers<Context = any> {
-        customFields?: CustomFieldsResolver<Json | null, any, Context>;
-    }
-
-    export type CustomFieldsResolver<R = Json | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-}
-
-export namespace GlobalSettingsCustomFieldsResolvers {
-    export interface Resolvers<Context = any> {
-        royalMailId?: RoyalMailIdResolver<string | null, any, Context>;
-    }
-
-    export type RoyalMailIdResolver<R = string | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-}
-
-export namespace ShippingMethodQuoteResolvers {
-    export interface Resolvers<Context = any> {
-        id?: IdResolver<string, any, Context>;
-        price?: PriceResolver<number, any, Context>;
-        description?: DescriptionResolver<string, any, Context>;
-    }
-
-    export type IdResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type PriceResolver<R = number, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type DescriptionResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-}
-
-export namespace PaymentMethodListResolvers {
-    export interface Resolvers<Context = any> {
-        items?: ItemsResolver<PaymentMethod[], any, Context>;
-        totalItems?: TotalItemsResolver<number, any, Context>;
-    }
-
-    export type ItemsResolver<R = PaymentMethod[], Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type TotalItemsResolver<R = number, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-}
-
-export namespace PaymentMethodResolvers {
-    export interface Resolvers<Context = any> {
-        id?: IdResolver<string, any, Context>;
-        createdAt?: CreatedAtResolver<DateTime, any, Context>;
-        updatedAt?: UpdatedAtResolver<DateTime, any, Context>;
-        code?: CodeResolver<string, any, Context>;
-        enabled?: EnabledResolver<boolean, any, Context>;
-        configArgs?: ConfigArgsResolver<ConfigArg[], any, Context>;
-    }
-
-    export type IdResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type CreatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type UpdatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type CodeResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type EnabledResolver<R = boolean, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type ConfigArgsResolver<R = ConfigArg[], Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-}
-
-export namespace ProductCategoryListResolvers {
-    export interface Resolvers<Context = any> {
-        items?: ItemsResolver<ProductCategory[], any, Context>;
-        totalItems?: TotalItemsResolver<number, any, Context>;
-    }
-
-    export type ItemsResolver<R = ProductCategory[], Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type TotalItemsResolver<R = number, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-}
-
-export namespace ProductCategoryResolvers {
-    export interface Resolvers<Context = any> {
-        id?: IdResolver<string, any, Context>;
-        createdAt?: CreatedAtResolver<DateTime, any, Context>;
-        updatedAt?: UpdatedAtResolver<DateTime, any, Context>;
-        languageCode?: LanguageCodeResolver<LanguageCode | null, any, Context>;
-        name?: NameResolver<string, any, Context>;
-        position?: PositionResolver<number, any, Context>;
-        description?: DescriptionResolver<string, any, Context>;
-        featuredAsset?: FeaturedAssetResolver<Asset | null, any, Context>;
-        assets?: AssetsResolver<Asset[], any, Context>;
-        parent?: ParentResolver<ProductCategory, any, Context>;
-        children?: ChildrenResolver<ProductCategory[] | null, any, Context>;
-        facetValues?: FacetValuesResolver<FacetValue[], any, Context>;
-        descendantFacetValues?: DescendantFacetValuesResolver<FacetValue[], any, Context>;
-        translations?: TranslationsResolver<ProductCategoryTranslation[], any, Context>;
-        customFields?: CustomFieldsResolver<Json | null, any, Context>;
-    }
-
-    export type IdResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type CreatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type UpdatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type LanguageCodeResolver<R = LanguageCode | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type NameResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type PositionResolver<R = number, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type DescriptionResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type FeaturedAssetResolver<R = Asset | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type AssetsResolver<R = Asset[], Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type ParentResolver<R = ProductCategory, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type ChildrenResolver<R = ProductCategory[] | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type FacetValuesResolver<R = FacetValue[], Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type DescendantFacetValuesResolver<R = FacetValue[], Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type TranslationsResolver<
-        R = ProductCategoryTranslation[],
-        Parent = any,
-        Context = any
-    > = Resolver<R, Parent, Context>;
-    export type CustomFieldsResolver<R = Json | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-}
-
-export namespace ProductCategoryTranslationResolvers {
-    export interface Resolvers<Context = any> {
-        id?: IdResolver<string, any, Context>;
-        createdAt?: CreatedAtResolver<DateTime, any, Context>;
-        updatedAt?: UpdatedAtResolver<DateTime, any, Context>;
-        languageCode?: LanguageCodeResolver<LanguageCode, any, Context>;
-        name?: NameResolver<string, any, Context>;
-        description?: DescriptionResolver<string, any, Context>;
-    }
-
-    export type IdResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type CreatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type UpdatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type LanguageCodeResolver<R = LanguageCode, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type NameResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type DescriptionResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-}
-
-export namespace ProductOptionGroupResolvers {
-    export interface Resolvers<Context = any> {
-        id?: IdResolver<string, any, Context>;
-        createdAt?: CreatedAtResolver<DateTime, any, Context>;
-        updatedAt?: UpdatedAtResolver<DateTime, any, Context>;
-        languageCode?: LanguageCodeResolver<LanguageCode, any, Context>;
-        code?: CodeResolver<string, any, Context>;
-        name?: NameResolver<string, any, Context>;
-        options?: OptionsResolver<ProductOption[], any, Context>;
-        translations?: TranslationsResolver<ProductOptionGroupTranslation[], any, Context>;
-        customFields?: CustomFieldsResolver<Json | null, any, Context>;
-    }
-
-    export type IdResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type CreatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type UpdatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type LanguageCodeResolver<R = LanguageCode, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type CodeResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type NameResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type OptionsResolver<R = ProductOption[], Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type TranslationsResolver<
-        R = ProductOptionGroupTranslation[],
-        Parent = any,
-        Context = any
-    > = Resolver<R, Parent, Context>;
-    export type CustomFieldsResolver<R = Json | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-}
-
-export namespace ProductOptionGroupTranslationResolvers {
-    export interface Resolvers<Context = any> {
-        id?: IdResolver<string, any, Context>;
-        createdAt?: CreatedAtResolver<DateTime, any, Context>;
-        updatedAt?: UpdatedAtResolver<DateTime, any, Context>;
-        languageCode?: LanguageCodeResolver<LanguageCode, any, Context>;
-        name?: NameResolver<string, any, Context>;
-    }
-
-    export type IdResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type CreatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type UpdatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type LanguageCodeResolver<R = LanguageCode, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type NameResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-}
-
-export namespace ProductListResolvers {
-    export interface Resolvers<Context = any> {
-        items?: ItemsResolver<Product[], any, Context>;
-        totalItems?: TotalItemsResolver<number, any, Context>;
-    }
-
-    export type ItemsResolver<R = Product[], Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type TotalItemsResolver<R = number, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-}
-
-export namespace ProductResolvers {
-    export interface Resolvers<Context = any> {
-        id?: IdResolver<string, any, Context>;
-        createdAt?: CreatedAtResolver<DateTime, any, Context>;
-        updatedAt?: UpdatedAtResolver<DateTime, any, Context>;
-        languageCode?: LanguageCodeResolver<LanguageCode, any, Context>;
-        name?: NameResolver<string, any, Context>;
-        slug?: SlugResolver<string, any, Context>;
-        description?: DescriptionResolver<string, any, Context>;
-        featuredAsset?: FeaturedAssetResolver<Asset | null, any, Context>;
-        assets?: AssetsResolver<Asset[], any, Context>;
-        variants?: VariantsResolver<ProductVariant[], any, Context>;
-        optionGroups?: OptionGroupsResolver<ProductOptionGroup[], any, Context>;
-        facetValues?: FacetValuesResolver<FacetValue[], any, Context>;
-        translations?: TranslationsResolver<ProductTranslation[], any, Context>;
-        customFields?: CustomFieldsResolver<Json | null, any, Context>;
-    }
-
-    export type IdResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type CreatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type UpdatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type LanguageCodeResolver<R = LanguageCode, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type NameResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type SlugResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type DescriptionResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type FeaturedAssetResolver<R = Asset | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type AssetsResolver<R = Asset[], Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type VariantsResolver<R = ProductVariant[], Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type OptionGroupsResolver<R = ProductOptionGroup[], Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type FacetValuesResolver<R = FacetValue[], Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type TranslationsResolver<R = ProductTranslation[], Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type CustomFieldsResolver<R = Json | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-}
-
-export namespace ProductTranslationResolvers {
-    export interface Resolvers<Context = any> {
-        id?: IdResolver<string, any, Context>;
-        createdAt?: CreatedAtResolver<DateTime, any, Context>;
-        updatedAt?: UpdatedAtResolver<DateTime, any, Context>;
-        languageCode?: LanguageCodeResolver<LanguageCode, any, Context>;
-        name?: NameResolver<string, any, Context>;
-        slug?: SlugResolver<string, any, Context>;
-        description?: DescriptionResolver<string, any, Context>;
-    }
-
-    export type IdResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type CreatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type UpdatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type LanguageCodeResolver<R = LanguageCode, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type NameResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type SlugResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type DescriptionResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-}
-
-export namespace PromotionResolvers {
-    export interface Resolvers<Context = any> {
-        id?: IdResolver<string, any, Context>;
-        createdAt?: CreatedAtResolver<DateTime, any, Context>;
-        updatedAt?: UpdatedAtResolver<DateTime, any, Context>;
-        name?: NameResolver<string, any, Context>;
-        enabled?: EnabledResolver<boolean, any, Context>;
-        conditions?: ConditionsResolver<AdjustmentOperation[], any, Context>;
-        actions?: ActionsResolver<AdjustmentOperation[], any, Context>;
-    }
-
-    export type IdResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type CreatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type UpdatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type NameResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type EnabledResolver<R = boolean, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type ConditionsResolver<R = AdjustmentOperation[], Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type ActionsResolver<R = AdjustmentOperation[], Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-}
-
-export namespace PromotionListResolvers {
-    export interface Resolvers<Context = any> {
-        items?: ItemsResolver<Promotion[], any, Context>;
-        totalItems?: TotalItemsResolver<number, any, Context>;
-    }
-
-    export type ItemsResolver<R = Promotion[], Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type TotalItemsResolver<R = number, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-}
-
-export namespace AdjustmentOperationsResolvers {
-    export interface Resolvers<Context = any> {
-        conditions?: ConditionsResolver<AdjustmentOperation[], any, Context>;
-        actions?: ActionsResolver<AdjustmentOperation[], any, Context>;
-    }
-
-    export type ConditionsResolver<R = AdjustmentOperation[], Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type ActionsResolver<R = AdjustmentOperation[], Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-}
-
-export namespace RoleListResolvers {
-    export interface Resolvers<Context = any> {
-        items?: ItemsResolver<Role[], any, Context>;
-        totalItems?: TotalItemsResolver<number, any, Context>;
-    }
-
-    export type ItemsResolver<R = Role[], Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type TotalItemsResolver<R = number, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-}
-
-export namespace SearchResponseResolvers {
-    export interface Resolvers<Context = any> {
-        items?: ItemsResolver<SearchResult[], any, Context>;
-        totalItems?: TotalItemsResolver<number, any, Context>;
-        facetValues?: FacetValuesResolver<FacetValue[], any, Context>;
-    }
-
-    export type ItemsResolver<R = SearchResult[], Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type TotalItemsResolver<R = number, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type FacetValuesResolver<R = FacetValue[], Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-}
-
-export namespace SearchResultResolvers {
-    export interface Resolvers<Context = any> {
-        sku?: SkuResolver<string, any, Context>;
-        productId?: ProductIdResolver<string, any, Context>;
-        productName?: ProductNameResolver<string, any, Context>;
-        productPreview?: ProductPreviewResolver<string, any, Context>;
-        productVariantId?: ProductVariantIdResolver<string, any, Context>;
-        productVariantName?: ProductVariantNameResolver<string, any, Context>;
-        productVariantPreview?: ProductVariantPreviewResolver<string, any, Context>;
-        description?: DescriptionResolver<string, any, Context>;
-        facetIds?: FacetIdsResolver<string[], any, Context>;
-        facetValueIds?: FacetValueIdsResolver<string[], any, Context>;
-        score?: ScoreResolver<number, any, Context>;
-    }
-
-    export type SkuResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type ProductIdResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type ProductNameResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type ProductPreviewResolver<R = string, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type ProductVariantIdResolver<R = string, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type ProductVariantNameResolver<R = string, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type ProductVariantPreviewResolver<R = string, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type DescriptionResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type FacetIdsResolver<R = string[], Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type FacetValueIdsResolver<R = string[], Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type ScoreResolver<R = number, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-}
-
-export namespace ShippingMethodListResolvers {
-    export interface Resolvers<Context = any> {
-        items?: ItemsResolver<ShippingMethod[], any, Context>;
-        totalItems?: TotalItemsResolver<number, any, Context>;
-    }
-
-    export type ItemsResolver<R = ShippingMethod[], Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type TotalItemsResolver<R = number, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-}
-
-export namespace TaxRateListResolvers {
-    export interface Resolvers<Context = any> {
-        items?: ItemsResolver<TaxRate[], any, Context>;
-        totalItems?: TotalItemsResolver<number, any, Context>;
-    }
-
-    export type ItemsResolver<R = TaxRate[], Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type TotalItemsResolver<R = number, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-}
-
-export namespace NetworkStatusResolvers {
-    export interface Resolvers<Context = any> {
-        inFlightRequests?: InFlightRequestsResolver<number, any, Context>;
-    }
-
-    export type InFlightRequestsResolver<R = number, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-}
-
-export namespace UserStatusResolvers {
-    export interface Resolvers<Context = any> {
-        username?: UsernameResolver<string, any, Context>;
-        isLoggedIn?: IsLoggedInResolver<boolean, any, Context>;
-        loginTime?: LoginTimeResolver<string, any, Context>;
-    }
-
-    export type UsernameResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type IsLoggedInResolver<R = boolean, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type LoginTimeResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-}
-
-export namespace UiStateResolvers {
-    export interface Resolvers<Context = any> {
-        language?: LanguageResolver<LanguageCode, any, Context>;
-    }
-
-    export type LanguageResolver<R = LanguageCode, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-}
-
-export namespace MutationResolvers {
-    export interface Resolvers<Context = any> {
-        createAdministrator?: CreateAdministratorResolver<Administrator, any, Context>;
-        updateAdministrator?: UpdateAdministratorResolver<Administrator, any, Context>;
-        assignRoleToAdministrator?: AssignRoleToAdministratorResolver<Administrator, any, Context>;
-        createAssets?: CreateAssetsResolver<Asset[], any, Context>;
-        login?: LoginResolver<LoginResult, any, Context>;
-        logout?: LogoutResolver<boolean, any, Context>;
-        registerCustomerAccount?: RegisterCustomerAccountResolver<boolean, any, Context>;
-        verifyCustomerAccount?: VerifyCustomerAccountResolver<LoginResult, any, Context>;
-        refreshCustomerVerification?: RefreshCustomerVerificationResolver<boolean, any, Context>;
-        createChannel?: CreateChannelResolver<Channel, any, Context>;
-        updateChannel?: UpdateChannelResolver<Channel, any, Context>;
-        createCountry?: CreateCountryResolver<Country, any, Context>;
-        updateCountry?: UpdateCountryResolver<Country, any, Context>;
-        deleteCountry?: DeleteCountryResolver<DeletionResponse, any, Context>;
-        createCustomerGroup?: CreateCustomerGroupResolver<CustomerGroup, any, Context>;
-        updateCustomerGroup?: UpdateCustomerGroupResolver<CustomerGroup, any, Context>;
-        addCustomersToGroup?: AddCustomersToGroupResolver<CustomerGroup, any, Context>;
-        removeCustomersFromGroup?: RemoveCustomersFromGroupResolver<CustomerGroup, any, Context>;
-        createCustomer?: CreateCustomerResolver<Customer, any, Context>;
-        updateCustomer?: UpdateCustomerResolver<Customer, any, Context>;
-        deleteCustomer?: DeleteCustomerResolver<DeletionResponse, any, Context>;
-        createCustomerAddress?: CreateCustomerAddressResolver<Address, any, Context>;
-        updateCustomerAddress?: UpdateCustomerAddressResolver<Address, any, Context>;
-        createFacet?: CreateFacetResolver<Facet, any, Context>;
-        updateFacet?: UpdateFacetResolver<Facet, any, Context>;
-        deleteFacet?: DeleteFacetResolver<DeletionResponse, any, Context>;
-        createFacetValues?: CreateFacetValuesResolver<FacetValue[], any, Context>;
-        updateFacetValues?: UpdateFacetValuesResolver<FacetValue[], any, Context>;
-        deleteFacetValues?: DeleteFacetValuesResolver<DeletionResponse[], any, Context>;
-        updateGlobalSettings?: UpdateGlobalSettingsResolver<GlobalSettings, any, Context>;
-        importProducts?: ImportProductsResolver<ImportInfo | null, any, Context>;
-        addItemToOrder?: AddItemToOrderResolver<Order | null, any, Context>;
-        removeItemFromOrder?: RemoveItemFromOrderResolver<Order | null, any, Context>;
-        adjustItemQuantity?: AdjustItemQuantityResolver<Order | null, any, Context>;
-        transitionOrderToState?: TransitionOrderToStateResolver<Order | null, any, Context>;
-        setOrderShippingAddress?: SetOrderShippingAddressResolver<Order | null, any, Context>;
-        setOrderShippingMethod?: SetOrderShippingMethodResolver<Order | null, any, Context>;
-        addPaymentToOrder?: AddPaymentToOrderResolver<Order | null, any, Context>;
-        setCustomerForOrder?: SetCustomerForOrderResolver<Order | null, any, Context>;
-        updatePaymentMethod?: UpdatePaymentMethodResolver<PaymentMethod, any, Context>;
-        createProductCategory?: CreateProductCategoryResolver<ProductCategory, any, Context>;
-        updateProductCategory?: UpdateProductCategoryResolver<ProductCategory, any, Context>;
-        moveProductCategory?: MoveProductCategoryResolver<ProductCategory, any, Context>;
-        createProductOptionGroup?: CreateProductOptionGroupResolver<ProductOptionGroup, any, Context>;
-        updateProductOptionGroup?: UpdateProductOptionGroupResolver<ProductOptionGroup, any, Context>;
-        createProduct?: CreateProductResolver<Product, any, Context>;
-        updateProduct?: UpdateProductResolver<Product, any, Context>;
-        deleteProduct?: DeleteProductResolver<DeletionResponse, any, Context>;
-        addOptionGroupToProduct?: AddOptionGroupToProductResolver<Product, any, Context>;
-        removeOptionGroupFromProduct?: RemoveOptionGroupFromProductResolver<Product, any, Context>;
-        generateVariantsForProduct?: GenerateVariantsForProductResolver<Product, any, Context>;
-        updateProductVariants?: UpdateProductVariantsResolver<(ProductVariant | null)[], any, Context>;
-        createPromotion?: CreatePromotionResolver<Promotion, any, Context>;
-        updatePromotion?: UpdatePromotionResolver<Promotion, any, Context>;
-        deletePromotion?: DeletePromotionResolver<DeletionResponse, any, Context>;
-        createRole?: CreateRoleResolver<Role, any, Context>;
-        updateRole?: UpdateRoleResolver<Role, any, Context>;
-        reindex?: ReindexResolver<SearchReindexResponse, any, Context>;
-        createShippingMethod?: CreateShippingMethodResolver<ShippingMethod, any, Context>;
-        updateShippingMethod?: UpdateShippingMethodResolver<ShippingMethod, any, Context>;
-        createTaxCategory?: CreateTaxCategoryResolver<TaxCategory, any, Context>;
-        updateTaxCategory?: UpdateTaxCategoryResolver<TaxCategory, any, Context>;
-        createTaxRate?: CreateTaxRateResolver<TaxRate, any, Context>;
-        updateTaxRate?: UpdateTaxRateResolver<TaxRate, any, Context>;
-        createZone?: CreateZoneResolver<Zone, any, Context>;
-        updateZone?: UpdateZoneResolver<Zone, any, Context>;
-        deleteZone?: DeleteZoneResolver<DeletionResponse, any, Context>;
-        addMembersToZone?: AddMembersToZoneResolver<Zone, any, Context>;
-        removeMembersFromZone?: RemoveMembersFromZoneResolver<Zone, any, Context>;
-        requestStarted?: RequestStartedResolver<number, any, Context>;
-        requestCompleted?: RequestCompletedResolver<number, any, Context>;
-        setAsLoggedIn?: SetAsLoggedInResolver<UserStatus, any, Context>;
-        setAsLoggedOut?: SetAsLoggedOutResolver<UserStatus, any, Context>;
-        setUiLanguage?: SetUiLanguageResolver<LanguageCode | null, any, Context>;
-    }
-
-    export type CreateAdministratorResolver<R = Administrator, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        CreateAdministratorArgs
-    >;
-    export interface CreateAdministratorArgs {
-        input: CreateAdministratorInput;
-    }
-
-    export type UpdateAdministratorResolver<R = Administrator, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        UpdateAdministratorArgs
-    >;
-    export interface UpdateAdministratorArgs {
-        input: UpdateAdministratorInput;
-    }
-
-    export type AssignRoleToAdministratorResolver<R = Administrator, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        AssignRoleToAdministratorArgs
-    >;
-    export interface AssignRoleToAdministratorArgs {
-        administratorId: string;
-        roleId: string;
-    }
-
-    export type CreateAssetsResolver<R = Asset[], Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        CreateAssetsArgs
-    >;
-    export interface CreateAssetsArgs {
-        input: CreateAssetInput[];
-    }
-
-    export type LoginResolver<R = LoginResult, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        LoginArgs
-    >;
-    export interface LoginArgs {
-        username: string;
-        password: string;
-        rememberMe?: boolean | null;
-    }
-
-    export type LogoutResolver<R = boolean, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type RegisterCustomerAccountResolver<R = boolean, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        RegisterCustomerAccountArgs
-    >;
-    export interface RegisterCustomerAccountArgs {
-        input: RegisterCustomerInput;
-    }
-
-    export type VerifyCustomerAccountResolver<R = LoginResult, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        VerifyCustomerAccountArgs
-    >;
-    export interface VerifyCustomerAccountArgs {
-        token: string;
-        password: string;
-    }
-
-    export type RefreshCustomerVerificationResolver<R = boolean, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        RefreshCustomerVerificationArgs
-    >;
-    export interface RefreshCustomerVerificationArgs {
-        emailAddress: string;
-    }
-
-    export type CreateChannelResolver<R = Channel, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        CreateChannelArgs
-    >;
-    export interface CreateChannelArgs {
-        input: CreateChannelInput;
-    }
-
-    export type UpdateChannelResolver<R = Channel, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        UpdateChannelArgs
-    >;
-    export interface UpdateChannelArgs {
-        input: UpdateChannelInput;
-    }
-
-    export type CreateCountryResolver<R = Country, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        CreateCountryArgs
-    >;
-    export interface CreateCountryArgs {
-        input: CreateCountryInput;
-    }
-
-    export type UpdateCountryResolver<R = Country, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        UpdateCountryArgs
-    >;
-    export interface UpdateCountryArgs {
-        input: UpdateCountryInput;
-    }
-
-    export type DeleteCountryResolver<R = DeletionResponse, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        DeleteCountryArgs
-    >;
-    export interface DeleteCountryArgs {
-        id: string;
-    }
-
-    export type CreateCustomerGroupResolver<R = CustomerGroup, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        CreateCustomerGroupArgs
-    >;
-    export interface CreateCustomerGroupArgs {
-        input: CreateCustomerGroupInput;
-    }
-
-    export type UpdateCustomerGroupResolver<R = CustomerGroup, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        UpdateCustomerGroupArgs
-    >;
-    export interface UpdateCustomerGroupArgs {
-        input: UpdateCustomerGroupInput;
-    }
-
-    export type AddCustomersToGroupResolver<R = CustomerGroup, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        AddCustomersToGroupArgs
-    >;
-    export interface AddCustomersToGroupArgs {
-        customerGroupId: string;
-        customerIds: string[];
-    }
-
-    export type RemoveCustomersFromGroupResolver<R = CustomerGroup, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        RemoveCustomersFromGroupArgs
-    >;
-    export interface RemoveCustomersFromGroupArgs {
-        customerGroupId: string;
-        customerIds: string[];
-    }
-
-    export type CreateCustomerResolver<R = Customer, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        CreateCustomerArgs
-    >;
-    export interface CreateCustomerArgs {
-        input: CreateCustomerInput;
-        password?: string | null;
-    }
-
-    export type UpdateCustomerResolver<R = Customer, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        UpdateCustomerArgs
-    >;
-    export interface UpdateCustomerArgs {
-        input: UpdateCustomerInput;
-    }
-
-    export type DeleteCustomerResolver<R = DeletionResponse, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        DeleteCustomerArgs
-    >;
-    export interface DeleteCustomerArgs {
-        id: string;
-    }
-
-    export type CreateCustomerAddressResolver<R = Address, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        CreateCustomerAddressArgs
-    >;
-    export interface CreateCustomerAddressArgs {
-        customerId: string;
-        input: CreateAddressInput;
-    }
-
-    export type UpdateCustomerAddressResolver<R = Address, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        UpdateCustomerAddressArgs
-    >;
-    export interface UpdateCustomerAddressArgs {
-        input: UpdateAddressInput;
-    }
-
-    export type CreateFacetResolver<R = Facet, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        CreateFacetArgs
-    >;
-    export interface CreateFacetArgs {
-        input: CreateFacetInput;
-    }
-
-    export type UpdateFacetResolver<R = Facet, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        UpdateFacetArgs
-    >;
-    export interface UpdateFacetArgs {
-        input: UpdateFacetInput;
-    }
-
-    export type DeleteFacetResolver<R = DeletionResponse, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        DeleteFacetArgs
-    >;
-    export interface DeleteFacetArgs {
-        id: string;
-        force?: boolean | null;
-    }
-
-    export type CreateFacetValuesResolver<R = FacetValue[], Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        CreateFacetValuesArgs
-    >;
-    export interface CreateFacetValuesArgs {
-        input: CreateFacetValueInput[];
-    }
-
-    export type UpdateFacetValuesResolver<R = FacetValue[], Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        UpdateFacetValuesArgs
-    >;
-    export interface UpdateFacetValuesArgs {
-        input: UpdateFacetValueInput[];
-    }
-
-    export type DeleteFacetValuesResolver<R = DeletionResponse[], Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        DeleteFacetValuesArgs
-    >;
-    export interface DeleteFacetValuesArgs {
-        ids: string[];
-        force?: boolean | null;
-    }
-
-    export type UpdateGlobalSettingsResolver<R = GlobalSettings, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        UpdateGlobalSettingsArgs
-    >;
-    export interface UpdateGlobalSettingsArgs {
-        input: UpdateGlobalSettingsInput;
-    }
-
-    export type ImportProductsResolver<R = ImportInfo | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        ImportProductsArgs
-    >;
-    export interface ImportProductsArgs {
-        csvFile: Upload;
-    }
-
-    export type AddItemToOrderResolver<R = Order | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        AddItemToOrderArgs
-    >;
-    export interface AddItemToOrderArgs {
-        productVariantId: string;
-        quantity: number;
-    }
-
-    export type RemoveItemFromOrderResolver<R = Order | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        RemoveItemFromOrderArgs
-    >;
-    export interface RemoveItemFromOrderArgs {
-        orderItemId: string;
-    }
-
-    export type AdjustItemQuantityResolver<R = Order | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        AdjustItemQuantityArgs
-    >;
-    export interface AdjustItemQuantityArgs {
-        orderItemId: string;
-        quantity: number;
-    }
-
-    export type TransitionOrderToStateResolver<R = Order | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        TransitionOrderToStateArgs
-    >;
-    export interface TransitionOrderToStateArgs {
-        state: string;
-    }
-
-    export type SetOrderShippingAddressResolver<R = Order | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        SetOrderShippingAddressArgs
-    >;
-    export interface SetOrderShippingAddressArgs {
-        input: CreateAddressInput;
-    }
-
-    export type SetOrderShippingMethodResolver<R = Order | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        SetOrderShippingMethodArgs
-    >;
-    export interface SetOrderShippingMethodArgs {
-        shippingMethodId: string;
-    }
-
-    export type AddPaymentToOrderResolver<R = Order | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        AddPaymentToOrderArgs
-    >;
-    export interface AddPaymentToOrderArgs {
-        input: PaymentInput;
-    }
-
-    export type SetCustomerForOrderResolver<R = Order | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        SetCustomerForOrderArgs
-    >;
-    export interface SetCustomerForOrderArgs {
-        input: CreateCustomerInput;
-    }
-
-    export type UpdatePaymentMethodResolver<R = PaymentMethod, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        UpdatePaymentMethodArgs
-    >;
-    export interface UpdatePaymentMethodArgs {
-        input: UpdatePaymentMethodInput;
-    }
-
-    export type CreateProductCategoryResolver<R = ProductCategory, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        CreateProductCategoryArgs
-    >;
-    export interface CreateProductCategoryArgs {
-        input: CreateProductCategoryInput;
-    }
-
-    export type UpdateProductCategoryResolver<R = ProductCategory, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        UpdateProductCategoryArgs
-    >;
-    export interface UpdateProductCategoryArgs {
-        input: UpdateProductCategoryInput;
-    }
-
-    export type MoveProductCategoryResolver<R = ProductCategory, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        MoveProductCategoryArgs
-    >;
-    export interface MoveProductCategoryArgs {
-        input: MoveProductCategoryInput;
-    }
-
-    export type CreateProductOptionGroupResolver<
-        R = ProductOptionGroup,
-        Parent = any,
-        Context = any
-    > = Resolver<R, Parent, Context, CreateProductOptionGroupArgs>;
-    export interface CreateProductOptionGroupArgs {
-        input: CreateProductOptionGroupInput;
-    }
-
-    export type UpdateProductOptionGroupResolver<
-        R = ProductOptionGroup,
-        Parent = any,
-        Context = any
-    > = Resolver<R, Parent, Context, UpdateProductOptionGroupArgs>;
-    export interface UpdateProductOptionGroupArgs {
-        input: UpdateProductOptionGroupInput;
-    }
-
-    export type CreateProductResolver<R = Product, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        CreateProductArgs
-    >;
-    export interface CreateProductArgs {
-        input: CreateProductInput;
-    }
-
-    export type UpdateProductResolver<R = Product, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        UpdateProductArgs
-    >;
-    export interface UpdateProductArgs {
-        input: UpdateProductInput;
-    }
-
-    export type DeleteProductResolver<R = DeletionResponse, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        DeleteProductArgs
-    >;
-    export interface DeleteProductArgs {
-        id: string;
-    }
-
-    export type AddOptionGroupToProductResolver<R = Product, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        AddOptionGroupToProductArgs
-    >;
-    export interface AddOptionGroupToProductArgs {
-        productId: string;
-        optionGroupId: string;
-    }
-
-    export type RemoveOptionGroupFromProductResolver<R = Product, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        RemoveOptionGroupFromProductArgs
-    >;
-    export interface RemoveOptionGroupFromProductArgs {
-        productId: string;
-        optionGroupId: string;
-    }
-
-    export type GenerateVariantsForProductResolver<R = Product, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        GenerateVariantsForProductArgs
-    >;
-    export interface GenerateVariantsForProductArgs {
-        productId: string;
-        defaultTaxCategoryId?: string | null;
-        defaultPrice?: number | null;
-        defaultSku?: string | null;
-    }
-
-    export type UpdateProductVariantsResolver<
-        R = (ProductVariant | null)[],
-        Parent = any,
-        Context = any
-    > = Resolver<R, Parent, Context, UpdateProductVariantsArgs>;
-    export interface UpdateProductVariantsArgs {
-        input: UpdateProductVariantInput[];
-    }
-
-    export type CreatePromotionResolver<R = Promotion, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        CreatePromotionArgs
-    >;
-    export interface CreatePromotionArgs {
-        input: CreatePromotionInput;
-    }
-
-    export type UpdatePromotionResolver<R = Promotion, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        UpdatePromotionArgs
-    >;
-    export interface UpdatePromotionArgs {
-        input: UpdatePromotionInput;
-    }
-
-    export type DeletePromotionResolver<R = DeletionResponse, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        DeletePromotionArgs
-    >;
-    export interface DeletePromotionArgs {
-        id: string;
-    }
-
-    export type CreateRoleResolver<R = Role, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        CreateRoleArgs
-    >;
-    export interface CreateRoleArgs {
-        input: CreateRoleInput;
-    }
-
-    export type UpdateRoleResolver<R = Role, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        UpdateRoleArgs
-    >;
-    export interface UpdateRoleArgs {
-        input: UpdateRoleInput;
-    }
-
-    export type ReindexResolver<R = SearchReindexResponse, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type CreateShippingMethodResolver<R = ShippingMethod, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        CreateShippingMethodArgs
-    >;
-    export interface CreateShippingMethodArgs {
-        input: CreateShippingMethodInput;
-    }
-
-    export type UpdateShippingMethodResolver<R = ShippingMethod, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        UpdateShippingMethodArgs
-    >;
-    export interface UpdateShippingMethodArgs {
-        input: UpdateShippingMethodInput;
-    }
-
-    export type CreateTaxCategoryResolver<R = TaxCategory, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        CreateTaxCategoryArgs
-    >;
-    export interface CreateTaxCategoryArgs {
-        input: CreateTaxCategoryInput;
-    }
-
-    export type UpdateTaxCategoryResolver<R = TaxCategory, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        UpdateTaxCategoryArgs
-    >;
-    export interface UpdateTaxCategoryArgs {
-        input: UpdateTaxCategoryInput;
-    }
-
-    export type CreateTaxRateResolver<R = TaxRate, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        CreateTaxRateArgs
-    >;
-    export interface CreateTaxRateArgs {
-        input: CreateTaxRateInput;
-    }
-
-    export type UpdateTaxRateResolver<R = TaxRate, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        UpdateTaxRateArgs
-    >;
-    export interface UpdateTaxRateArgs {
-        input: UpdateTaxRateInput;
-    }
-
-    export type CreateZoneResolver<R = Zone, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        CreateZoneArgs
-    >;
-    export interface CreateZoneArgs {
-        input: CreateZoneInput;
-    }
-
-    export type UpdateZoneResolver<R = Zone, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        UpdateZoneArgs
-    >;
-    export interface UpdateZoneArgs {
-        input: UpdateZoneInput;
-    }
-
-    export type DeleteZoneResolver<R = DeletionResponse, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        DeleteZoneArgs
-    >;
-    export interface DeleteZoneArgs {
-        id: string;
-    }
-
-    export type AddMembersToZoneResolver<R = Zone, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        AddMembersToZoneArgs
-    >;
-    export interface AddMembersToZoneArgs {
-        zoneId: string;
-        memberIds: string[];
-    }
-
-    export type RemoveMembersFromZoneResolver<R = Zone, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        RemoveMembersFromZoneArgs
-    >;
-    export interface RemoveMembersFromZoneArgs {
-        zoneId: string;
-        memberIds: string[];
-    }
-
-    export type RequestStartedResolver<R = number, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type RequestCompletedResolver<R = number, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type SetAsLoggedInResolver<R = UserStatus, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        SetAsLoggedInArgs
-    >;
-    export interface SetAsLoggedInArgs {
-        username: string;
-        loginTime: string;
-    }
-
-    export type SetAsLoggedOutResolver<R = UserStatus, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type SetUiLanguageResolver<R = LanguageCode | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context,
-        SetUiLanguageArgs
-    >;
-    export interface SetUiLanguageArgs {
-        languageCode?: LanguageCode | null;
-    }
-}
-
-export namespace LoginResultResolvers {
-    export interface Resolvers<Context = any> {
-        user?: UserResolver<CurrentUser, any, Context>;
-    }
-
-    export type UserResolver<R = CurrentUser, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-}
-
-export namespace DeletionResponseResolvers {
-    export interface Resolvers<Context = any> {
-        result?: ResultResolver<DeletionResult, any, Context>;
-        message?: MessageResolver<string | null, any, Context>;
-    }
-
-    export type ResultResolver<R = DeletionResult, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type MessageResolver<R = string | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-}
-
-export namespace ImportInfoResolvers {
-    export interface Resolvers<Context = any> {
-        errors?: ErrorsResolver<string[] | null, any, Context>;
-        processed?: ProcessedResolver<number, any, Context>;
-        imported?: ImportedResolver<number, any, Context>;
-    }
-
-    export type ErrorsResolver<R = string[] | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type ProcessedResolver<R = number, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type ImportedResolver<R = number, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-}
-
-export namespace SearchReindexResponseResolvers {
-    export interface Resolvers<Context = any> {
-        success?: SuccessResolver<boolean, any, Context>;
-        timeTaken?: TimeTakenResolver<number, any, Context>;
-        indexedItemCount?: IndexedItemCountResolver<number, any, Context>;
-    }
-
-    export type SuccessResolver<R = boolean, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type TimeTakenResolver<R = number, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type IndexedItemCountResolver<R = number, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
+
+export namespace GetPaymentMethodList {
+  export type Variables = {
+    options: PaymentMethodListOptions;
+  }
+
+  export type Query = {
+    __typename?: "Query";
+    
+    paymentMethods: PaymentMethods;
+  }
+
+  export type PaymentMethods = {
+    __typename?: "PaymentMethodList";
+    
+    items: Items[];
+    
+    totalItems: number;
+  } 
+
+  export type Items = PaymentMethod.Fragment
 }
 
-export namespace GetAdministrators {
-    export type Variables = {
-        options?: AdministratorListOptions | null;
-    };
+export namespace GetPaymentMethod {
+  export type Variables = {
+    id: string;
+  }
+
+  export type Query = {
+    __typename?: "Query";
+    
+    paymentMethod: Maybe<PaymentMethod>;
+  }
+
+  export type PaymentMethod = PaymentMethod.Fragment
+}
 
-    export type Query = {
-        __typename?: 'Query';
-        administrators: Administrators;
-    };
+export namespace UpdatePaymentMethod {
+  export type Variables = {
+    input: UpdatePaymentMethodInput;
+  }
 
-    export type Administrators = {
-        __typename?: 'AdministratorList';
-        items: Items[];
-        totalItems: number;
-    };
+  export type Mutation = {
+    __typename?: "Mutation";
+    
+    updatePaymentMethod: UpdatePaymentMethod;
+  }
 
-    export type Items = Administrator.Fragment;
+  export type UpdatePaymentMethod = PaymentMethod.Fragment
 }
 
-export namespace GetAdministrator {
-    export type Variables = {
-        id: string;
-    };
+export namespace GetGlobalSettings {
+  export type Variables = {
+  }
 
-    export type Query = {
-        __typename?: 'Query';
-        administrator?: Administrator | null;
-    };
+  export type Query = {
+    __typename?: "Query";
+    
+    globalSettings: GlobalSettings;
+  }
 
-    export type Administrator = Administrator.Fragment;
+  export type GlobalSettings = GlobalSettings.Fragment
 }
 
-export namespace CreateAdministrator {
-    export type Variables = {
-        input: CreateAdministratorInput;
-    };
+export namespace UpdateGlobalSettings {
+  export type Variables = {
+    input: UpdateGlobalSettingsInput;
+  }
 
-    export type Mutation = {
-        __typename?: 'Mutation';
-        createAdministrator: CreateAdministrator;
-    };
+  export type Mutation = {
+    __typename?: "Mutation";
+    
+    updateGlobalSettings: UpdateGlobalSettings;
+  }
 
-    export type CreateAdministrator = Administrator.Fragment;
+  export type UpdateGlobalSettings = GlobalSettings.Fragment
 }
 
-export namespace UpdateAdministrator {
-    export type Variables = {
-        input: UpdateAdministratorInput;
-    };
+export namespace GetServerConfig {
+  export type Variables = {
+  }
+
+  export type Query = {
+    __typename?: "Query";
+    
+    globalSettings: GlobalSettings;
+  }
 
-    export type Mutation = {
-        __typename?: 'Mutation';
-        updateAdministrator: UpdateAdministrator;
-    };
+  export type GlobalSettings = {
+    __typename?: "GlobalSettings";
+    
+    serverConfig: ServerConfig;
+  } 
 
-    export type UpdateAdministrator = Administrator.Fragment;
+  export type ServerConfig = {
+    __typename?: "ServerConfig";
+    
+    customFields: Maybe<Json>;
+  } 
 }
 
-export namespace GetRoles {
-    export type Variables = {
-        options?: RoleListOptions | null;
-    };
+export namespace GetShippingMethodList {
+  export type Variables = {
+    options?: Maybe<ShippingMethodListOptions>;
+  }
+
+  export type Query = {
+    __typename?: "Query";
+    
+    shippingMethods: ShippingMethods;
+  }
+
+  export type ShippingMethods = {
+    __typename?: "ShippingMethodList";
+    
+    items: Items[];
+    
+    totalItems: number;
+  } 
 
-    export type Query = {
-        __typename?: 'Query';
-        roles: Roles;
-    };
+  export type Items = ShippingMethod.Fragment
+}
+
+export namespace GetShippingMethod {
+  export type Variables = {
+    id: string;
+  }
 
-    export type Roles = {
-        __typename?: 'RoleList';
-        items: Items[];
-        totalItems: number;
-    };
+  export type Query = {
+    __typename?: "Query";
+    
+    shippingMethod: Maybe<ShippingMethod>;
+  }
 
-    export type Items = Role.Fragment;
+  export type ShippingMethod = ShippingMethod.Fragment
 }
 
-export namespace GetRole {
-    export type Variables = {
-        id: string;
-    };
+export namespace GetShippingMethodOperations {
+  export type Variables = {
+  }
+
+  export type Query = {
+    __typename?: "Query";
+    
+    shippingEligibilityCheckers: ShippingEligibilityCheckers[];
+    
+    shippingCalculators: ShippingCalculators[];
+  }
+
+  export type ShippingEligibilityCheckers = AdjustmentOperation.Fragment
+
+  export type ShippingCalculators = AdjustmentOperation.Fragment
+}
+
+export namespace CreateShippingMethod {
+  export type Variables = {
+    input: CreateShippingMethodInput;
+  }
+
+  export type Mutation = {
+    __typename?: "Mutation";
+    
+    createShippingMethod: CreateShippingMethod;
+  }
+
+  export type CreateShippingMethod = ShippingMethod.Fragment
+}
+
+export namespace UpdateShippingMethod {
+  export type Variables = {
+    input: UpdateShippingMethodInput;
+  }
+
+  export type Mutation = {
+    __typename?: "Mutation";
+    
+    updateShippingMethod: UpdateShippingMethod;
+  }
+
+  export type UpdateShippingMethod = ShippingMethod.Fragment
+}
+
+export namespace Administrator {
+  export type Fragment = {
+    __typename?: "Administrator";
+    
+    id: string;
+    
+    firstName: string;
+    
+    lastName: string;
+    
+    emailAddress: string;
+    
+    user: User;
+  }
+
+  export type User = {
+    __typename?: "User";
+    
+    id: string;
+    
+    identifier: string;
+    
+    lastLogin: Maybe<string>;
+    
+    roles: Roles[];
+  }
+
+  export type Roles = {
+    __typename?: "Role";
+    
+    id: string;
+    
+    code: string;
+    
+    description: string;
+    
+    permissions: Permission[];
+  }
+}
+
+export namespace Role {
+  export type Fragment = {
+    __typename?: "Role";
+    
+    id: string;
+    
+    code: string;
+    
+    description: string;
+    
+    permissions: Permission[];
+    
+    channels: Channels[];
+  }
+
+  export type Channels = {
+    __typename?: "Channel";
+    
+    id: string;
+    
+    code: string;
+    
+    token: string;
+  }
+}
+
+export namespace CurrentUser {
+  export type Fragment = {
+    __typename?: "CurrentUser";
+    
+    id: string;
+    
+    identifier: string;
+    
+    channelTokens: string[];
+  }
+}
+
+export namespace Address {
+  export type Fragment = {
+    __typename?: "Address";
+    
+    id: string;
+    
+    fullName: Maybe<string>;
+    
+    company: Maybe<string>;
+    
+    streetLine1: string;
+    
+    streetLine2: Maybe<string>;
+    
+    city: Maybe<string>;
+    
+    province: Maybe<string>;
+    
+    postalCode: Maybe<string>;
+    
+    country: Country;
+    
+    phoneNumber: Maybe<string>;
+    
+    defaultShippingAddress: Maybe<boolean>;
+    
+    defaultBillingAddress: Maybe<boolean>;
+  }
+
+  export type Country = {
+    __typename?: "Country";
+    
+    id: string;
+    
+    code: string;
+    
+    name: string;
+  }
+}
+
+export namespace Customer {
+  export type Fragment = {
+    __typename?: "Customer";
+    
+    id: string;
+    
+    title: Maybe<string>;
+    
+    firstName: string;
+    
+    lastName: string;
+    
+    phoneNumber: Maybe<string>;
+    
+    emailAddress: string;
+    
+    user: Maybe<User>;
+    
+    addresses: Maybe<Addresses[]>;
+  }
+
+  export type User = {
+    __typename?: "User";
+    
+    id: string;
+    
+    identifier: string;
+    
+    verified: boolean;
+    
+    lastLogin: Maybe<string>;
+  }
+
+  export type Addresses =Address.Fragment
+}
+
+export namespace FacetValue {
+  export type Fragment = {
+    __typename?: "FacetValue";
+    
+    id: string;
+    
+    languageCode: LanguageCode;
+    
+    code: string;
+    
+    name: string;
+    
+    translations: Translations[];
+    
+    facet: Facet;
+  }
+
+  export type Translations = {
+    __typename?: "FacetValueTranslation";
+    
+    id: string;
+    
+    languageCode: LanguageCode;
+    
+    name: string;
+  }
+
+  export type Facet = {
+    __typename?: "Facet";
+    
+    id: string;
+    
+    name: string;
+  }
+}
+
+export namespace FacetWithValues {
+  export type Fragment = {
+    __typename?: "Facet";
+    
+    id: string;
+    
+    languageCode: LanguageCode;
+    
+    code: string;
+    
+    name: string;
+    
+    translations: Translations[];
+    
+    values: Values[];
+  }
+
+  export type Translations = {
+    __typename?: "FacetTranslation";
+    
+    id: string;
+    
+    languageCode: LanguageCode;
+    
+    name: string;
+  }
+
+  export type Values =FacetValue.Fragment
+}
+
+export namespace Adjustment {
+  export type Fragment = {
+    __typename?: "Adjustment";
+    
+    adjustmentSource: string;
+    
+    amount: number;
+    
+    description: string;
+    
+    type: AdjustmentType;
+  }
+}
+
+export namespace ShippingAddress {
+  export type Fragment = {
+    __typename?: "ShippingAddress";
+    
+    fullName: Maybe<string>;
+    
+    company: Maybe<string>;
+    
+    streetLine1: Maybe<string>;
+    
+    streetLine2: Maybe<string>;
+    
+    city: Maybe<string>;
+    
+    province: Maybe<string>;
+    
+    postalCode: Maybe<string>;
+    
+    country: Maybe<string>;
+    
+    phoneNumber: Maybe<string>;
+  }
+}
+
+export namespace Order {
+  export type Fragment = {
+    __typename?: "Order";
+    
+    id: string;
+    
+    createdAt: DateTime;
+    
+    updatedAt: DateTime;
+    
+    code: string;
+    
+    state: string;
+    
+    total: number;
+    
+    currencyCode: CurrencyCode;
+    
+    customer: Maybe<Customer>;
+  }
+
+  export type Customer = {
+    __typename?: "Customer";
+    
+    id: string;
+    
+    firstName: string;
+    
+    lastName: string;
+  }
+}
+
+export namespace OrderWithLines {
+  export type Fragment = {
+    __typename?: "Order";
+    
+    id: string;
+    
+    createdAt: DateTime;
+    
+    updatedAt: DateTime;
+    
+    code: string;
+    
+    state: string;
+    
+    active: boolean;
+    
+    customer: Maybe<Customer>;
+    
+    lines: Lines[];
+    
+    adjustments: Adjustments[];
+    
+    subTotal: number;
+    
+    subTotalBeforeTax: number;
+    
+    totalBeforeTax: number;
+    
+    currencyCode: CurrencyCode;
+    
+    shipping: number;
+    
+    shippingMethod: Maybe<ShippingMethod>;
+    
+    shippingAddress: Maybe<ShippingAddress>;
+    
+    payments: Maybe<Payments[]>;
+    
+    total: number;
+  }
+
+  export type Customer = {
+    __typename?: "Customer";
+    
+    id: string;
+    
+    firstName: string;
+    
+    lastName: string;
+  }
+
+  export type Lines = {
+    __typename?: "OrderLine";
+    
+    id: string;
+    
+    featuredAsset: Maybe<FeaturedAsset>;
+    
+    productVariant: ProductVariant;
+    
+    unitPrice: number;
+    
+    unitPriceWithTax: number;
+    
+    quantity: number;
+    
+    items: Items[];
+    
+    totalPrice: number;
+  }
+
+  export type FeaturedAsset = {
+    __typename?: "Asset";
+    
+    preview: string;
+  }
+
+  export type ProductVariant = {
+    __typename?: "ProductVariant";
+    
+    id: string;
+    
+    name: string;
+    
+    sku: string;
+  }
+
+  export type Items = {
+    __typename?: "OrderItem";
+    
+    id: string;
+    
+    unitPrice: number;
+    
+    unitPriceIncludesTax: boolean;
+    
+    unitPriceWithTax: number;
+    
+    taxRate: number;
+  }
+
+  export type Adjustments =Adjustment.Fragment
+
+  export type ShippingMethod = {
+    __typename?: "ShippingMethod";
+    
+    id: string;
+    
+    code: string;
+    
+    description: string;
+  }
+
+  export type ShippingAddress =ShippingAddress.Fragment
+
+  export type Payments = {
+    __typename?: "Payment";
+    
+    id: string;
+    
+    transactionId: Maybe<string>;
+    
+    amount: number;
+    
+    method: string;
+    
+    state: string;
+    
+    metadata: Maybe<Json>;
+  }
+}
+
+export namespace Asset {
+  export type Fragment = {
+    __typename?: "Asset";
+    
+    id: string;
+    
+    name: string;
+    
+    fileSize: number;
+    
+    mimeType: string;
+    
+    type: AssetType;
+    
+    preview: string;
+    
+    source: string;
+  }
+}
+
+export namespace ProductVariant {
+  export type Fragment = {
+    __typename?: "ProductVariant";
+    
+    id: string;
+    
+    languageCode: LanguageCode;
+    
+    name: string;
+    
+    price: number;
+    
+    currencyCode: CurrencyCode;
+    
+    priceIncludesTax: boolean;
+    
+    priceWithTax: number;
+    
+    taxRateApplied: TaxRateApplied;
+    
+    taxCategory: TaxCategory;
+    
+    sku: string;
+    
+    options: Options[];
+    
+    facetValues: FacetValues[];
+    
+    featuredAsset: Maybe<FeaturedAsset>;
+    
+    assets: Assets[];
+    
+    translations: Translations[];
+  }
+
+  export type TaxRateApplied = {
+    __typename?: "TaxRate";
+    
+    id: string;
+    
+    name: string;
+    
+    value: number;
+  }
+
+  export type TaxCategory = {
+    __typename?: "TaxCategory";
+    
+    id: string;
+    
+    name: string;
+  }
+
+  export type Options = {
+    __typename?: "ProductOption";
+    
+    id: string;
+    
+    code: Maybe<string>;
+    
+    languageCode: Maybe<LanguageCode>;
+    
+    name: Maybe<string>;
+  }
+
+  export type FacetValues = {
+    __typename?: "FacetValue";
+    
+    id: string;
+    
+    code: string;
+    
+    name: string;
+    
+    facet: Facet;
+  }
+
+  export type Facet = {
+    __typename?: "Facet";
+    
+    id: string;
+    
+    name: string;
+  }
+
+  export type FeaturedAsset =Asset.Fragment
+
+  export type Assets =Asset.Fragment
+
+  export type Translations = {
+    __typename?: "ProductVariantTranslation";
+    
+    id: string;
+    
+    languageCode: LanguageCode;
+    
+    name: string;
+  }
+}
+
+export namespace ProductWithVariants {
+  export type Fragment = {
+    __typename?: "Product";
+    
+    id: string;
+    
+    languageCode: LanguageCode;
+    
+    name: string;
+    
+    slug: string;
+    
+    description: string;
+    
+    featuredAsset: Maybe<FeaturedAsset>;
+    
+    assets: Assets[];
+    
+    translations: Translations[];
+    
+    optionGroups: OptionGroups[];
+    
+    variants: Variants[];
+    
+    facetValues: FacetValues[];
+  }
+
+  export type FeaturedAsset =Asset.Fragment
+
+  export type Assets =Asset.Fragment
+
+  export type Translations = {
+    __typename?: "ProductTranslation";
+    
+    languageCode: LanguageCode;
+    
+    name: string;
+    
+    slug: string;
+    
+    description: string;
+  }
+
+  export type OptionGroups = {
+    __typename?: "ProductOptionGroup";
+    
+    id: string;
+    
+    languageCode: LanguageCode;
+    
+    code: string;
+    
+    name: string;
+  }
+
+  export type Variants =ProductVariant.Fragment
+
+  export type FacetValues = {
+    __typename?: "FacetValue";
+    
+    id: string;
+    
+    code: string;
+    
+    name: string;
+    
+    facet: Facet;
+  }
+
+  export type Facet = {
+    __typename?: "Facet";
+    
+    id: string;
+    
+    name: string;
+  }
+}
+
+export namespace ProductOptionGroup {
+  export type Fragment = {
+    __typename?: "ProductOptionGroup";
+    
+    id: string;
+    
+    languageCode: LanguageCode;
+    
+    code: string;
+    
+    name: string;
+    
+    translations: Translations[];
+    
+    options: Options[];
+  }
+
+  export type Translations = {
+    __typename?: "ProductOptionGroupTranslation";
+    
+    name: string;
+  }
+
+  export type Options = {
+    __typename?: "ProductOption";
+    
+    id: string;
+    
+    languageCode: Maybe<LanguageCode>;
+    
+    name: Maybe<string>;
+    
+    code: Maybe<string>;
+    
+    translations: _Translations[];
+  }
+
+  export type _Translations = {
+    __typename?: "ProductOptionTranslation";
+    
+    name: string;
+  }
+}
+
+export namespace ProductCategory {
+  export type Fragment = {
+    __typename?: "ProductCategory";
+    
+    id: string;
+    
+    name: string;
+    
+    description: string;
+    
+    languageCode: Maybe<LanguageCode>;
+    
+    featuredAsset: Maybe<FeaturedAsset>;
+    
+    assets: Assets[];
+    
+    facetValues: FacetValues[];
+    
+    translations: Translations[];
+    
+    parent: Parent;
+    
+    children: Maybe<Children[]>;
+  }
+
+  export type FeaturedAsset =Asset.Fragment
+
+  export type Assets =Asset.Fragment
+
+  export type FacetValues = {
+    __typename?: "FacetValue";
+    
+    id: string;
+    
+    name: string;
+    
+    code: string;
+  }
+
+  export type Translations = {
+    __typename?: "ProductCategoryTranslation";
+    
+    id: string;
+    
+    languageCode: LanguageCode;
+    
+    name: string;
+    
+    description: string;
+  }
+
+  export type Parent = {
+    __typename?: "ProductCategory";
+    
+    id: string;
+    
+    name: string;
+  }
+
+  export type Children = {
+    __typename?: "ProductCategory";
+    
+    id: string;
+    
+    name: string;
+  }
+}
+
+export namespace AdjustmentOperation {
+  export type Fragment = {
+    __typename?: "AdjustmentOperation";
+    
+    args: Args[];
+    
+    code: string;
+    
+    description: string;
+  }
+
+  export type Args = {
+    __typename?: "ConfigArg";
+    
+    name: string;
+    
+    type: string;
+    
+    value: Maybe<string>;
+  }
+}
+
+export namespace Promotion {
+  export type Fragment = {
+    __typename?: "Promotion";
+    
+    id: string;
+    
+    createdAt: DateTime;
+    
+    updatedAt: DateTime;
+    
+    name: string;
+    
+    enabled: boolean;
+    
+    conditions: Conditions[];
+    
+    actions: Actions[];
+  }
+
+  export type Conditions =AdjustmentOperation.Fragment
+
+  export type Actions =AdjustmentOperation.Fragment
+}
+
+export namespace Country {
+  export type Fragment = {
+    __typename?: "Country";
+    
+    id: string;
+    
+    code: string;
+    
+    name: string;
+    
+    enabled: boolean;
+    
+    translations: Translations[];
+  }
+
+  export type Translations = {
+    __typename?: "CountryTranslation";
+    
+    id: string;
+    
+    languageCode: LanguageCode;
+    
+    name: string;
+  }
+}
+
+export namespace Zone {
+  export type Fragment = {
+    __typename?: "Zone";
+    
+    id: string;
+    
+    name: string;
+    
+    members: Members[];
+  }
+
+  export type Members =Country.Fragment
+}
+
+export namespace TaxCategory {
+  export type Fragment = {
+    __typename?: "TaxCategory";
+    
+    id: string;
+    
+    name: string;
+  }
+}
+
+export namespace TaxRate {
+  export type Fragment = {
+    __typename?: "TaxRate";
+    
+    id: string;
+    
+    name: string;
+    
+    enabled: boolean;
+    
+    value: number;
+    
+    category: Category;
+    
+    zone: Zone;
+    
+    customerGroup: Maybe<CustomerGroup>;
+  }
+
+  export type Category = {
+    __typename?: "TaxCategory";
+    
+    id: string;
+    
+    name: string;
+  }
+
+  export type Zone = {
+    __typename?: "Zone";
+    
+    id: string;
+    
+    name: string;
+  }
+
+  export type CustomerGroup = {
+    __typename?: "CustomerGroup";
+    
+    id: string;
+    
+    name: string;
+  }
+}
+
+export namespace Channel {
+  export type Fragment = {
+    __typename?: "Channel";
+    
+    id: string;
+    
+    code: string;
+    
+    token: string;
+    
+    pricesIncludeTax: boolean;
+    
+    currencyCode: CurrencyCode;
+    
+    defaultLanguageCode: LanguageCode;
+    
+    defaultShippingZone: Maybe<DefaultShippingZone>;
+    
+    defaultTaxZone: Maybe<DefaultTaxZone>;
+  }
+
+  export type DefaultShippingZone = {
+    __typename?: "Zone";
+    
+    id: string;
+    
+    name: string;
+  }
+
+  export type DefaultTaxZone = {
+    __typename?: "Zone";
+    
+    id: string;
+    
+    name: string;
+  }
+}
+
+export namespace PaymentMethod {
+  export type Fragment = {
+    __typename?: "PaymentMethod";
+    
+    id: string;
+    
+    code: string;
+    
+    enabled: boolean;
+    
+    configArgs: ConfigArgs[];
+  }
+
+  export type ConfigArgs = {
+    __typename?: "ConfigArg";
+    
+    name: string;
+    
+    type: string;
+    
+    value: Maybe<string>;
+  }
+}
+
+export namespace GlobalSettings {
+  export type Fragment = {
+    __typename?: "GlobalSettings";
+    
+    availableLanguages: LanguageCode[];
+  }
+}
+
+export namespace ShippingMethod {
+  export type Fragment = {
+    __typename?: "ShippingMethod";
+    
+    id: string;
+    
+    createdAt: DateTime;
+    
+    updatedAt: DateTime;
+    
+    code: string;
+    
+    description: string;
+    
+    checker: Checker;
+    
+    calculator: Calculator;
+  }
+
+  export type Checker =AdjustmentOperation.Fragment
+
+  export type Calculator =AdjustmentOperation.Fragment
+}
+
+
+
+
+// ====================================================
+// Scalars
+// ====================================================
+
+
+
+
+
+// ====================================================
+// Interfaces
+// ====================================================
+
+
+
+export interface PaginatedList {
+  
+  items: Node[];
+  
+  totalItems: number;
+}
+
+
+export interface Node {
+  
+  id: string;
+}
+
+
+
+
+// ====================================================
+// Types
+// ====================================================
+
+
+
+export interface Query {
+  
+  administrators: AdministratorList;
+  
+  administrator?: Maybe<Administrator>;
+  
+  assets: AssetList;
+  
+  asset?: Maybe<Asset>;
+  
+  me?: Maybe<CurrentUser>;
+  
+  channels: Channel[];
+  
+  channel?: Maybe<Channel>;
+  
+  activeChannel: Channel;
+  
+  config: Config;
+  
+  countries: CountryList;
+  
+  country?: Maybe<Country>;
+  
+  availableCountries: Country[];
+  
+  customerGroups: CustomerGroup[];
+  
+  customerGroup?: Maybe<CustomerGroup>;
+  
+  customers: CustomerList;
+  
+  customer?: Maybe<Customer>;
+  
+  activeCustomer?: Maybe<Customer>;
+  
+  facets: FacetList;
+  
+  facet?: Maybe<Facet>;
+  
+  globalSettings: GlobalSettings;
+  
+  order?: Maybe<Order>;
+  
+  activeOrder?: Maybe<Order>;
+  
+  orderByCode?: Maybe<Order>;
+  
+  nextOrderStates: string[];
+  
+  orders: OrderList;
+  
+  eligibleShippingMethods: ShippingMethodQuote[];
+  
+  paymentMethods: PaymentMethodList;
+  
+  paymentMethod?: Maybe<PaymentMethod>;
+  
+  productCategories: ProductCategoryList;
+  
+  productCategory?: Maybe<ProductCategory>;
+  
+  productOptionGroups: ProductOptionGroup[];
+  
+  productOptionGroup?: Maybe<ProductOptionGroup>;
+  
+  products: ProductList;
+  
+  product?: Maybe<Product>;
+  
+  promotion?: Maybe<Promotion>;
+  
+  promotions: PromotionList;
+  
+  adjustmentOperations: AdjustmentOperations;
+  
+  roles: RoleList;
+  
+  role?: Maybe<Role>;
+  
+  search: SearchResponse;
+  
+  shippingMethods: ShippingMethodList;
+  
+  shippingMethod?: Maybe<ShippingMethod>;
+  
+  shippingEligibilityCheckers: AdjustmentOperation[];
+  
+  shippingCalculators: AdjustmentOperation[];
+  
+  taxCategories: TaxCategory[];
+  
+  taxCategory?: Maybe<TaxCategory>;
+  
+  taxRates: TaxRateList;
+  
+  taxRate?: Maybe<TaxRate>;
+  
+  zones: Zone[];
+  
+  zone?: Maybe<Zone>;
+  
+  temp__?: Maybe<boolean>;
+  
+  networkStatus: NetworkStatus;
+  
+  userStatus: UserStatus;
+  
+  uiState: UiState;
+}
+
+
+export interface AdministratorList extends PaginatedList {
+  
+  items: Administrator[];
+  
+  totalItems: number;
+}
+
+
+export interface Administrator extends Node {
+  
+  id: string;
+  
+  createdAt: DateTime;
+  
+  updatedAt: DateTime;
+  
+  firstName: string;
+  
+  lastName: string;
+  
+  emailAddress: string;
+  
+  user: User;
+}
+
+
+export interface User extends Node {
+  
+  id: string;
+  
+  createdAt: DateTime;
+  
+  updatedAt: DateTime;
+  
+  identifier: string;
+  
+  passwordHash: string;
+  
+  verified: boolean;
+  
+  roles: Role[];
+  
+  lastLogin?: Maybe<string>;
+  
+  customFields?: Maybe<Json>;
+}
+
+
+export interface Role extends Node {
+  
+  id: string;
+  
+  createdAt: DateTime;
+  
+  updatedAt: DateTime;
+  
+  code: string;
+  
+  description: string;
+  
+  permissions: Permission[];
+  
+  channels: Channel[];
+}
+
+
+export interface Channel extends Node {
+  
+  id: string;
+  
+  createdAt: DateTime;
+  
+  updatedAt: DateTime;
+  
+  code: string;
+  
+  token: string;
+  
+  defaultTaxZone?: Maybe<Zone>;
+  
+  defaultShippingZone?: Maybe<Zone>;
+  
+  defaultLanguageCode: LanguageCode;
+  
+  currencyCode: CurrencyCode;
+  
+  pricesIncludeTax: boolean;
+}
+
+
+export interface Zone extends Node {
+  
+  id: string;
+  
+  createdAt: DateTime;
+  
+  updatedAt: DateTime;
+  
+  name: string;
+  
+  members: Country[];
+}
+
+
+export interface Country extends Node {
+  
+  id: string;
+  
+  languageCode: LanguageCode;
+  
+  code: string;
+  
+  name: string;
+  
+  enabled: boolean;
+  
+  translations: CountryTranslation[];
+}
+
+
+export interface CountryTranslation {
+  
+  id: string;
+  
+  createdAt: DateTime;
+  
+  updatedAt: DateTime;
+  
+  languageCode: LanguageCode;
+  
+  name: string;
+}
+
+
+export interface AssetList extends PaginatedList {
+  
+  items: Asset[];
+  
+  totalItems: number;
+}
 
-    export type Query = {
-        __typename?: 'Query';
-        role?: Role | null;
-    };
 
-    export type Role = Role.Fragment;
+export interface Asset extends Node {
+  
+  id: string;
+  
+  name: string;
+  
+  type: AssetType;
+  
+  fileSize: number;
+  
+  mimeType: string;
+  
+  source: string;
+  
+  preview: string;
 }
 
-export namespace CreateRole {
-    export type Variables = {
-        input: CreateRoleInput;
-    };
-
-    export type Mutation = {
-        __typename?: 'Mutation';
-        createRole: CreateRole;
-    };
 
-    export type CreateRole = Role.Fragment;
+export interface CurrentUser {
+  
+  id: string;
+  
+  identifier: string;
+  
+  channelTokens: string[];
 }
 
-export namespace UpdateRole {
-    export type Variables = {
-        input: UpdateRoleInput;
-    };
-
-    export type Mutation = {
-        __typename?: 'Mutation';
-        updateRole: UpdateRole;
-    };
 
-    export type UpdateRole = Role.Fragment;
+export interface Config {
+  
+  customFields?: Maybe<Json>;
 }
 
-export namespace AssignRoleToAdministrator {
-    export type Variables = {
-        administratorId: string;
-        roleId: string;
-    };
-
-    export type Mutation = {
-        __typename?: 'Mutation';
-        assignRoleToAdministrator: AssignRoleToAdministrator;
-    };
 
-    export type AssignRoleToAdministrator = Administrator.Fragment;
+export interface CountryList extends PaginatedList {
+  
+  items: Country[];
+  
+  totalItems: number;
 }
 
-export namespace AttemptLogin {
-    export type Variables = {
-        username: string;
-        password: string;
-        rememberMe: boolean;
-    };
 
-    export type Mutation = {
-        __typename?: 'Mutation';
-        login: Login;
-    };
+export interface CustomerGroup extends Node {
+  
+  id: string;
+  
+  createdAt: DateTime;
+  
+  updatedAt: DateTime;
+  
+  name: string;
+}
 
-    export type Login = {
-        __typename?: 'LoginResult';
-        user: User;
-    };
 
-    export type User = CurrentUser.Fragment;
+export interface CustomerList extends PaginatedList {
+  
+  items: Customer[];
+  
+  totalItems: number;
 }
 
-export namespace LogOut {
-    export type Variables = {};
 
-    export type Mutation = {
-        __typename?: 'Mutation';
-        logout: boolean;
-    };
+export interface Customer extends Node {
+  
+  id: string;
+  
+  createdAt: DateTime;
+  
+  updatedAt: DateTime;
+  
+  title?: Maybe<string>;
+  
+  firstName: string;
+  
+  lastName: string;
+  
+  phoneNumber?: Maybe<string>;
+  
+  emailAddress: string;
+  
+  addresses?: Maybe<Address[]>;
+  
+  orders: OrderList;
+  
+  user?: Maybe<User>;
+  
+  customFields?: Maybe<Json>;
 }
 
-export namespace GetCurrentUser {
-    export type Variables = {};
-
-    export type Query = {
-        __typename?: 'Query';
-        me?: Me | null;
-    };
 
-    export type Me = CurrentUser.Fragment;
+export interface Address extends Node {
+  
+  id: string;
+  
+  createdAt: DateTime;
+  
+  updatedAt: DateTime;
+  
+  fullName?: Maybe<string>;
+  
+  company?: Maybe<string>;
+  
+  streetLine1: string;
+  
+  streetLine2?: Maybe<string>;
+  
+  city?: Maybe<string>;
+  
+  province?: Maybe<string>;
+  
+  postalCode?: Maybe<string>;
+  
+  country: Country;
+  
+  phoneNumber?: Maybe<string>;
+  
+  defaultShippingAddress?: Maybe<boolean>;
+  
+  defaultBillingAddress?: Maybe<boolean>;
+  
+  customFields?: Maybe<Json>;
 }
 
-export namespace RequestStarted {
-    export type Variables = {};
 
-    export type Mutation = {
-        __typename?: 'Mutation';
-        requestStarted: number;
-    };
+export interface OrderList extends PaginatedList {
+  
+  items: Order[];
+  
+  totalItems: number;
 }
 
-export namespace RequestCompleted {
-    export type Variables = {};
 
-    export type Mutation = {
-        __typename?: 'Mutation';
-        requestCompleted: number;
-    };
+export interface Order extends Node {
+  
+  id: string;
+  
+  createdAt: DateTime;
+  
+  updatedAt: DateTime;
+  
+  code: string;
+  
+  state: string;
+  
+  active: boolean;
+  
+  customer?: Maybe<Customer>;
+  
+  shippingAddress?: Maybe<ShippingAddress>;
+  
+  billingAddress?: Maybe<BillingAddress>;
+  
+  lines: OrderLine[];
+  
+  adjustments: Adjustment[];
+  
+  payments?: Maybe<Payment[]>;
+  
+  subTotalBeforeTax: number;
+  
+  subTotal: number;
+  
+  currencyCode: CurrencyCode;
+  
+  shipping: number;
+  
+  shippingMethod?: Maybe<ShippingMethod>;
+  
+  totalBeforeTax: number;
+  
+  total: number;
 }
 
-export namespace SetAsLoggedIn {
-    export type Variables = {
-        username: string;
-        loginTime: string;
-    };
-
-    export type Mutation = {
-        __typename?: 'Mutation';
-        setAsLoggedIn: SetAsLoggedIn;
-    };
 
-    export type SetAsLoggedIn = {
-        __typename?: 'UserStatus';
-        username: string;
-        isLoggedIn: boolean;
-        loginTime: string;
-    };
+export interface ShippingAddress {
+  
+  fullName?: Maybe<string>;
+  
+  company?: Maybe<string>;
+  
+  streetLine1?: Maybe<string>;
+  
+  streetLine2?: Maybe<string>;
+  
+  city?: Maybe<string>;
+  
+  province?: Maybe<string>;
+  
+  postalCode?: Maybe<string>;
+  
+  country?: Maybe<string>;
+  
+  countryCode?: Maybe<string>;
+  
+  phoneNumber?: Maybe<string>;
 }
 
-export namespace SetAsLoggedOut {
-    export type Variables = {};
-
-    export type Mutation = {
-        __typename?: 'Mutation';
-        setAsLoggedOut: SetAsLoggedOut;
-    };
 
-    export type SetAsLoggedOut = {
-        __typename?: 'UserStatus';
-        username: string;
-        isLoggedIn: boolean;
-        loginTime: string;
-    };
+export interface BillingAddress {
+  
+  fullName?: Maybe<string>;
+  
+  company?: Maybe<string>;
+  
+  streetLine1?: Maybe<string>;
+  
+  streetLine2?: Maybe<string>;
+  
+  city?: Maybe<string>;
+  
+  province?: Maybe<string>;
+  
+  postalCode?: Maybe<string>;
+  
+  country?: Maybe<string>;
+  
+  countryCode?: Maybe<string>;
+  
+  phoneNumber?: Maybe<string>;
 }
 
-export namespace SetUiLanguage {
-    export type Variables = {
-        languageCode: LanguageCode;
-    };
 
-    export type Mutation = {
-        __typename?: 'Mutation';
-        setUiLanguage?: LanguageCode | null;
-    };
+export interface OrderLine extends Node {
+  
+  id: string;
+  
+  createdAt: DateTime;
+  
+  updatedAt: DateTime;
+  
+  productVariant: ProductVariant;
+  
+  featuredAsset?: Maybe<Asset>;
+  
+  unitPrice: number;
+  
+  unitPriceWithTax: number;
+  
+  quantity: number;
+  
+  items: OrderItem[];
+  
+  totalPrice: number;
+  
+  adjustments: Adjustment[];
+  
+  order: Order;
 }
 
-export namespace GetNetworkStatus {
-    export type Variables = {};
-
-    export type Query = {
-        __typename?: 'Query';
-        networkStatus: NetworkStatus;
-    };
 
-    export type NetworkStatus = {
-        __typename?: 'NetworkStatus';
-        inFlightRequests: number;
-    };
+export interface ProductVariant extends Node {
+  
+  id: string;
+  
+  createdAt: DateTime;
+  
+  updatedAt: DateTime;
+  
+  languageCode: LanguageCode;
+  
+  sku: string;
+  
+  name: string;
+  
+  featuredAsset?: Maybe<Asset>;
+  
+  assets: Asset[];
+  
+  price: number;
+  
+  currencyCode: CurrencyCode;
+  
+  priceIncludesTax: boolean;
+  
+  priceWithTax: number;
+  
+  taxRateApplied: TaxRate;
+  
+  taxCategory: TaxCategory;
+  
+  options: ProductOption[];
+  
+  facetValues: FacetValue[];
+  
+  translations: ProductVariantTranslation[];
+  
+  customFields?: Maybe<Json>;
 }
 
-export namespace GetUserStatus {
-    export type Variables = {};
-
-    export type Query = {
-        __typename?: 'Query';
-        userStatus: UserStatus;
-    };
 
-    export type UserStatus = {
-        __typename?: 'UserStatus';
-        username: string;
-        isLoggedIn: boolean;
-        loginTime: string;
-    };
+export interface TaxRate extends Node {
+  
+  id: string;
+  
+  createdAt: DateTime;
+  
+  updatedAt: DateTime;
+  
+  name: string;
+  
+  enabled: boolean;
+  
+  value: number;
+  
+  category: TaxCategory;
+  
+  zone: Zone;
+  
+  customerGroup?: Maybe<CustomerGroup>;
 }
 
-export namespace GetUiState {
-    export type Variables = {};
-
-    export type Query = {
-        __typename?: 'Query';
-        uiState: UiState;
-    };
 
-    export type UiState = {
-        __typename?: 'UiState';
-        language: LanguageCode;
-    };
+export interface TaxCategory extends Node {
+  
+  id: string;
+  
+  createdAt: DateTime;
+  
+  updatedAt: DateTime;
+  
+  name: string;
 }
 
-export namespace GetCustomerList {
-    export type Variables = {
-        options?: CustomerListOptions | null;
-    };
-
-    export type Query = {
-        __typename?: 'Query';
-        customers: Customers;
-    };
-
-    export type Customers = {
-        __typename?: 'CustomerList';
-        items: Items[];
-        totalItems: number;
-    };
-
-    export type Items = {
-        __typename?: 'Customer';
-        id: string;
-        title?: string | null;
-        firstName: string;
-        lastName: string;
-        emailAddress: string;
-        user?: User | null;
-    };
-
-    export type User = {
-        __typename?: 'User';
-        id: string;
-        verified: boolean;
-    };
-}
 
-export namespace GetCustomer {
-    export type Variables = {
-        id: string;
-        orderListOptions?: OrderListOptions | null;
-    };
-
-    export type Query = {
-        __typename?: 'Query';
-        customer?: Customer | null;
-    };
-
-    export type Customer = {
-        __typename?: 'Customer';
-        orders: Orders;
-    } & Customer.Fragment;
-
-    export type Orders = {
-        __typename?: 'OrderList';
-        items: Items[];
-        totalItems: number;
-    };
-
-    export type Items = {
-        __typename?: 'Order';
-        id: string;
-        code: string;
-        state: string;
-        total: number;
-        currencyCode: CurrencyCode;
-        updatedAt: DateTime;
-    };
+export interface ProductOption extends Node {
+  
+  id: string;
+  
+  createdAt: DateTime;
+  
+  updatedAt: DateTime;
+  
+  languageCode?: Maybe<LanguageCode>;
+  
+  code?: Maybe<string>;
+  
+  name?: Maybe<string>;
+  
+  translations: ProductOptionTranslation[];
+  
+  customFields?: Maybe<Json>;
 }
 
-export namespace CreateCustomer {
-    export type Variables = {
-        input: CreateCustomerInput;
-        password?: string | null;
-    };
-
-    export type Mutation = {
-        __typename?: 'Mutation';
-        createCustomer: CreateCustomer;
-    };
 
-    export type CreateCustomer = Customer.Fragment;
+export interface ProductOptionTranslation {
+  
+  id: string;
+  
+  createdAt: DateTime;
+  
+  updatedAt: DateTime;
+  
+  languageCode: LanguageCode;
+  
+  name: string;
 }
 
-export namespace UpdateCustomer {
-    export type Variables = {
-        input: UpdateCustomerInput;
-    };
-
-    export type Mutation = {
-        __typename?: 'Mutation';
-        updateCustomer: UpdateCustomer;
-    };
 
-    export type UpdateCustomer = Customer.Fragment;
+export interface FacetValue extends Node {
+  
+  id: string;
+  
+  createdAt: DateTime;
+  
+  updatedAt: DateTime;
+  
+  languageCode: LanguageCode;
+  
+  facet: Facet;
+  
+  name: string;
+  
+  code: string;
+  
+  translations: FacetValueTranslation[];
+  
+  customFields?: Maybe<Json>;
 }
 
-export namespace CreateCustomerAddress {
-    export type Variables = {
-        customerId: string;
-        input: CreateAddressInput;
-    };
-
-    export type Mutation = {
-        __typename?: 'Mutation';
-        createCustomerAddress: CreateCustomerAddress;
-    };
 
-    export type CreateCustomerAddress = Address.Fragment;
+export interface Facet extends Node {
+  
+  id: string;
+  
+  createdAt: DateTime;
+  
+  updatedAt: DateTime;
+  
+  languageCode: LanguageCode;
+  
+  name: string;
+  
+  code: string;
+  
+  values: FacetValue[];
+  
+  translations: FacetTranslation[];
+  
+  customFields?: Maybe<Json>;
 }
 
-export namespace UpdateCustomerAddress {
-    export type Variables = {
-        input: UpdateAddressInput;
-    };
-
-    export type Mutation = {
-        __typename?: 'Mutation';
-        updateCustomerAddress: UpdateCustomerAddress;
-    };
 
-    export type UpdateCustomerAddress = Address.Fragment;
+export interface FacetTranslation {
+  
+  id: string;
+  
+  createdAt: DateTime;
+  
+  updatedAt: DateTime;
+  
+  languageCode: LanguageCode;
+  
+  name: string;
 }
 
-export namespace CreateFacet {
-    export type Variables = {
-        input: CreateFacetInput;
-    };
-
-    export type Mutation = {
-        __typename?: 'Mutation';
-        createFacet: CreateFacet;
-    };
 
-    export type CreateFacet = FacetWithValues.Fragment;
+export interface FacetValueTranslation {
+  
+  id: string;
+  
+  createdAt: DateTime;
+  
+  updatedAt: DateTime;
+  
+  languageCode: LanguageCode;
+  
+  name: string;
 }
 
-export namespace UpdateFacet {
-    export type Variables = {
-        input: UpdateFacetInput;
-    };
-
-    export type Mutation = {
-        __typename?: 'Mutation';
-        updateFacet: UpdateFacet;
-    };
 
-    export type UpdateFacet = FacetWithValues.Fragment;
+export interface ProductVariantTranslation {
+  
+  id: string;
+  
+  createdAt: DateTime;
+  
+  updatedAt: DateTime;
+  
+  languageCode: LanguageCode;
+  
+  name: string;
 }
 
-export namespace DeleteFacet {
-    export type Variables = {
-        id: string;
-        force?: boolean | null;
-    };
-
-    export type Mutation = {
-        __typename?: 'Mutation';
-        deleteFacet: DeleteFacet;
-    };
 
-    export type DeleteFacet = {
-        __typename?: 'DeletionResponse';
-        result: DeletionResult;
-        message?: string | null;
-    };
+export interface OrderItem extends Node {
+  
+  id: string;
+  
+  createdAt: DateTime;
+  
+  updatedAt: DateTime;
+  
+  unitPrice: number;
+  
+  unitPriceWithTax: number;
+  
+  unitPriceIncludesTax: boolean;
+  
+  taxRate: number;
+  
+  adjustments: Adjustment[];
 }
 
-export namespace CreateFacetValues {
-    export type Variables = {
-        input: CreateFacetValueInput[];
-    };
-
-    export type Mutation = {
-        __typename?: 'Mutation';
-        createFacetValues: CreateFacetValues[];
-    };
 
-    export type CreateFacetValues = FacetValue.Fragment;
+export interface Adjustment {
+  
+  adjustmentSource: string;
+  
+  type: AdjustmentType;
+  
+  description: string;
+  
+  amount: number;
 }
 
-export namespace UpdateFacetValues {
-    export type Variables = {
-        input: UpdateFacetValueInput[];
-    };
-
-    export type Mutation = {
-        __typename?: 'Mutation';
-        updateFacetValues: UpdateFacetValues[];
-    };
 
-    export type UpdateFacetValues = FacetValue.Fragment;
+export interface Payment extends Node {
+  
+  id: string;
+  
+  createdAt: DateTime;
+  
+  updatedAt: DateTime;
+  
+  method: string;
+  
+  amount: number;
+  
+  state: string;
+  
+  transactionId?: Maybe<string>;
+  
+  metadata?: Maybe<Json>;
 }
 
-export namespace DeleteFacetValues {
-    export type Variables = {
-        ids: string[];
-        force?: boolean | null;
-    };
-
-    export type Mutation = {
-        __typename?: 'Mutation';
-        deleteFacetValues: DeleteFacetValues[];
-    };
 
-    export type DeleteFacetValues = {
-        __typename?: 'DeletionResponse';
-        result: DeletionResult;
-        message?: string | null;
-    };
+export interface ShippingMethod extends Node {
+  
+  id: string;
+  
+  createdAt: DateTime;
+  
+  updatedAt: DateTime;
+  
+  code: string;
+  
+  description: string;
+  
+  checker: AdjustmentOperation;
+  
+  calculator: AdjustmentOperation;
 }
 
-export namespace GetFacetList {
-    export type Variables = {
-        options?: FacetListOptions | null;
-        languageCode?: LanguageCode | null;
-    };
 
-    export type Query = {
-        __typename?: 'Query';
-        facets: Facets;
-    };
+export interface AdjustmentOperation {
+  
+  code: string;
+  
+  args: ConfigArg[];
+  
+  description: string;
+}
 
-    export type Facets = {
-        __typename?: 'FacetList';
-        items: Items[];
-        totalItems: number;
-    };
 
-    export type Items = FacetWithValues.Fragment;
+export interface ConfigArg {
+  
+  name: string;
+  
+  type: string;
+  
+  value?: Maybe<string>;
 }
 
-export namespace GetFacetWithValues {
-    export type Variables = {
-        id: string;
-        languageCode?: LanguageCode | null;
-    };
-
-    export type Query = {
-        __typename?: 'Query';
-        facet?: Facet | null;
-    };
 
-    export type Facet = FacetWithValues.Fragment;
+export interface FacetList extends PaginatedList {
+  
+  items: Facet[];
+  
+  totalItems: number;
 }
 
-export namespace GetOrderList {
-    export type Variables = {
-        options?: OrderListOptions | null;
-    };
 
-    export type Query = {
-        __typename?: 'Query';
-        orders: Orders;
-    };
+export interface GlobalSettings {
+  
+  id: string;
+  
+  createdAt: DateTime;
+  
+  updatedAt: DateTime;
+  
+  availableLanguages: LanguageCode[];
+  
+  serverConfig: ServerConfig;
+  
+  customFields?: Maybe<GlobalSettingsCustomFields>;
+}
 
-    export type Orders = {
-        __typename?: 'OrderList';
-        items: Items[];
-        totalItems: number;
-    };
 
-    export type Items = Order.Fragment;
+export interface ServerConfig {
+  
+  customFields?: Maybe<Json>;
 }
 
-export namespace GetOrder {
-    export type Variables = {
-        id: string;
-    };
-
-    export type Query = {
-        __typename?: 'Query';
-        order?: Order | null;
-    };
 
-    export type Order = OrderWithLines.Fragment;
+export interface GlobalSettingsCustomFields {
+  
+  royalMailId?: Maybe<string>;
 }
 
-export namespace UpdateProduct {
-    export type Variables = {
-        input: UpdateProductInput;
-    };
-
-    export type Mutation = {
-        __typename?: 'Mutation';
-        updateProduct: UpdateProduct;
-    };
 
-    export type UpdateProduct = ProductWithVariants.Fragment;
+export interface ShippingMethodQuote {
+  
+  id: string;
+  
+  price: number;
+  
+  description: string;
 }
 
-export namespace CreateProduct {
-    export type Variables = {
-        input: CreateProductInput;
-    };
-
-    export type Mutation = {
-        __typename?: 'Mutation';
-        createProduct: CreateProduct;
-    };
 
-    export type CreateProduct = ProductWithVariants.Fragment;
+export interface PaymentMethodList extends PaginatedList {
+  
+  items: PaymentMethod[];
+  
+  totalItems: number;
 }
 
-export namespace DeleteProduct {
-    export type Variables = {
-        id: string;
-    };
-
-    export type Mutation = {
-        __typename?: 'Mutation';
-        deleteProduct: DeleteProduct;
-    };
 
-    export type DeleteProduct = {
-        __typename?: 'DeletionResponse';
-        result: DeletionResult;
-        message?: string | null;
-    };
+export interface PaymentMethod extends Node {
+  
+  id: string;
+  
+  createdAt: DateTime;
+  
+  updatedAt: DateTime;
+  
+  code: string;
+  
+  enabled: boolean;
+  
+  configArgs: ConfigArg[];
 }
 
-export namespace GenerateProductVariants {
-    export type Variables = {
-        productId: string;
-        defaultTaxCategoryId?: string | null;
-        defaultPrice?: number | null;
-        defaultSku?: string | null;
-    };
-
-    export type Mutation = {
-        __typename?: 'Mutation';
-        generateVariantsForProduct: GenerateVariantsForProduct;
-    };
 
-    export type GenerateVariantsForProduct = ProductWithVariants.Fragment;
+export interface ProductCategoryList extends PaginatedList {
+  
+  items: ProductCategory[];
+  
+  totalItems: number;
 }
 
-export namespace UpdateProductVariants {
-    export type Variables = {
-        input: UpdateProductVariantInput[];
-    };
-
-    export type Mutation = {
-        __typename?: 'Mutation';
-        updateProductVariants: (UpdateProductVariants | null)[];
-    };
 
-    export type UpdateProductVariants = ProductVariant.Fragment;
+export interface ProductCategory extends Node {
+  
+  id: string;
+  
+  createdAt: DateTime;
+  
+  updatedAt: DateTime;
+  
+  languageCode?: Maybe<LanguageCode>;
+  
+  name: string;
+  
+  position: number;
+  
+  description: string;
+  
+  featuredAsset?: Maybe<Asset>;
+  
+  assets: Asset[];
+  
+  parent: ProductCategory;
+  
+  children?: Maybe<ProductCategory[]>;
+  
+  facetValues: FacetValue[];
+  
+  descendantFacetValues: FacetValue[];
+  
+  translations: ProductCategoryTranslation[];
+  
+  customFields?: Maybe<Json>;
 }
 
-export namespace CreateProductOptionGroup {
-    export type Variables = {
-        input: CreateProductOptionGroupInput;
-    };
-
-    export type Mutation = {
-        __typename?: 'Mutation';
-        createProductOptionGroup: CreateProductOptionGroup;
-    };
 
-    export type CreateProductOptionGroup = ProductOptionGroup.Fragment;
+export interface ProductCategoryTranslation {
+  
+  id: string;
+  
+  createdAt: DateTime;
+  
+  updatedAt: DateTime;
+  
+  languageCode: LanguageCode;
+  
+  name: string;
+  
+  description: string;
 }
 
-export namespace AddOptionGroupToProduct {
-    export type Variables = {
-        productId: string;
-        optionGroupId: string;
-    };
-
-    export type Mutation = {
-        __typename?: 'Mutation';
-        addOptionGroupToProduct: AddOptionGroupToProduct;
-    };
-
-    export type AddOptionGroupToProduct = {
-        __typename?: 'Product';
-        id: string;
-        optionGroups: OptionGroups[];
-    };
-
-    export type OptionGroups = {
-        __typename?: 'ProductOptionGroup';
-        id: string;
-        code: string;
-        options: Options[];
-    };
-
-    export type Options = {
-        __typename?: 'ProductOption';
-        id: string;
-        code?: string | null;
-    };
-}
 
-export namespace RemoveOptionGroupFromProduct {
-    export type Variables = {
-        productId: string;
-        optionGroupId: string;
-    };
-
-    export type Mutation = {
-        __typename?: 'Mutation';
-        removeOptionGroupFromProduct: RemoveOptionGroupFromProduct;
-    };
-
-    export type RemoveOptionGroupFromProduct = {
-        __typename?: 'Product';
-        id: string;
-        optionGroups: OptionGroups[];
-    };
-
-    export type OptionGroups = {
-        __typename?: 'ProductOptionGroup';
-        id: string;
-        code: string;
-        options: Options[];
-    };
-
-    export type Options = {
-        __typename?: 'ProductOption';
-        id: string;
-        code?: string | null;
-    };
+export interface ProductOptionGroup extends Node {
+  
+  id: string;
+  
+  createdAt: DateTime;
+  
+  updatedAt: DateTime;
+  
+  languageCode: LanguageCode;
+  
+  code: string;
+  
+  name: string;
+  
+  options: ProductOption[];
+  
+  translations: ProductOptionGroupTranslation[];
+  
+  customFields?: Maybe<Json>;
 }
 
-export namespace GetProductWithVariants {
-    export type Variables = {
-        id: string;
-        languageCode?: LanguageCode | null;
-    };
-
-    export type Query = {
-        __typename?: 'Query';
-        product?: Product | null;
-    };
 
-    export type Product = ProductWithVariants.Fragment;
+export interface ProductOptionGroupTranslation {
+  
+  id: string;
+  
+  createdAt: DateTime;
+  
+  updatedAt: DateTime;
+  
+  languageCode: LanguageCode;
+  
+  name: string;
 }
 
-export namespace GetProductList {
-    export type Variables = {
-        options?: ProductListOptions | null;
-        languageCode?: LanguageCode | null;
-    };
-
-    export type Query = {
-        __typename?: 'Query';
-        products: Products;
-    };
-
-    export type Products = {
-        __typename?: 'ProductList';
-        items: Items[];
-        totalItems: number;
-    };
-
-    export type Items = {
-        __typename?: 'Product';
-        id: string;
-        languageCode: LanguageCode;
-        name: string;
-        slug: string;
-        featuredAsset?: FeaturedAsset | null;
-    };
-
-    export type FeaturedAsset = {
-        __typename?: 'Asset';
-        id: string;
-        preview: string;
-    };
-}
 
-export namespace GetProductOptionGroups {
-    export type Variables = {
-        filterTerm?: string | null;
-        languageCode?: LanguageCode | null;
-    };
-
-    export type Query = {
-        __typename?: 'Query';
-        productOptionGroups: ProductOptionGroups[];
-    };
-
-    export type ProductOptionGroups = {
-        __typename?: 'ProductOptionGroup';
-        id: string;
-        languageCode: LanguageCode;
-        code: string;
-        name: string;
-        options: Options[];
-    };
-
-    export type Options = {
-        __typename?: 'ProductOption';
-        id: string;
-        languageCode?: LanguageCode | null;
-        code?: string | null;
-        name?: string | null;
-    };
+export interface ProductList extends PaginatedList {
+  
+  items: Product[];
+  
+  totalItems: number;
 }
 
-export namespace GetAssetList {
-    export type Variables = {
-        options?: AssetListOptions | null;
-    };
 
-    export type Query = {
-        __typename?: 'Query';
-        assets: Assets;
-    };
+export interface Product extends Node {
+  
+  id: string;
+  
+  createdAt: DateTime;
+  
+  updatedAt: DateTime;
+  
+  languageCode: LanguageCode;
+  
+  name: string;
+  
+  slug: string;
+  
+  description: string;
+  
+  featuredAsset?: Maybe<Asset>;
+  
+  assets: Asset[];
+  
+  variants: ProductVariant[];
+  
+  optionGroups: ProductOptionGroup[];
+  
+  facetValues: FacetValue[];
+  
+  translations: ProductTranslation[];
+  
+  customFields?: Maybe<Json>;
+}
 
-    export type Assets = {
-        __typename?: 'AssetList';
-        items: Items[];
-        totalItems: number;
-    };
 
-    export type Items = Asset.Fragment;
+export interface ProductTranslation {
+  
+  id: string;
+  
+  createdAt: DateTime;
+  
+  updatedAt: DateTime;
+  
+  languageCode: LanguageCode;
+  
+  name: string;
+  
+  slug: string;
+  
+  description: string;
 }
 
-export namespace CreateAssets {
-    export type Variables = {
-        input: CreateAssetInput[];
-    };
-
-    export type Mutation = {
-        __typename?: 'Mutation';
-        createAssets: CreateAssets[];
-    };
 
-    export type CreateAssets = Asset.Fragment;
+export interface Promotion extends Node {
+  
+  id: string;
+  
+  createdAt: DateTime;
+  
+  updatedAt: DateTime;
+  
+  name: string;
+  
+  enabled: boolean;
+  
+  conditions: AdjustmentOperation[];
+  
+  actions: AdjustmentOperation[];
 }
 
-export namespace GetProductCategoryList {
-    export type Variables = {
-        options?: ProductCategoryListOptions | null;
-        languageCode?: LanguageCode | null;
-    };
-
-    export type Query = {
-        __typename?: 'Query';
-        productCategories: ProductCategories;
-    };
-
-    export type ProductCategories = {
-        __typename?: 'ProductCategoryList';
-        items: Items[];
-        totalItems: number;
-    };
-
-    export type Items = {
-        __typename?: 'ProductCategory';
-        id: string;
-        name: string;
-        description: string;
-        featuredAsset?: FeaturedAsset | null;
-        facetValues: FacetValues[];
-        parent: Parent;
-    };
-
-    export type FeaturedAsset = Asset.Fragment;
-
-    export type FacetValues = {
-        __typename?: 'FacetValue';
-        id: string;
-        code: string;
-        name: string;
-        facet: Facet;
-    };
-
-    export type Facet = {
-        __typename?: 'Facet';
-        id: string;
-        name: string;
-    };
-
-    export type Parent = {
-        __typename?: 'ProductCategory';
-        id: string;
-    };
-}
 
-export namespace GetProductCategory {
-    export type Variables = {
-        id: string;
-        languageCode?: LanguageCode | null;
-    };
+export interface PromotionList extends PaginatedList {
+  
+  items: Promotion[];
+  
+  totalItems: number;
+}
 
-    export type Query = {
-        __typename?: 'Query';
-        productCategory?: ProductCategory | null;
-    };
 
-    export type ProductCategory = ProductCategory.Fragment;
+export interface AdjustmentOperations {
+  
+  conditions: AdjustmentOperation[];
+  
+  actions: AdjustmentOperation[];
 }
 
-export namespace CreateProductCategory {
-    export type Variables = {
-        input: CreateProductCategoryInput;
-    };
-
-    export type Mutation = {
-        __typename?: 'Mutation';
-        createProductCategory: CreateProductCategory;
-    };
 
-    export type CreateProductCategory = ProductCategory.Fragment;
+export interface RoleList extends PaginatedList {
+  
+  items: Role[];
+  
+  totalItems: number;
 }
 
-export namespace UpdateProductCategory {
-    export type Variables = {
-        input: UpdateProductCategoryInput;
-    };
-
-    export type Mutation = {
-        __typename?: 'Mutation';
-        updateProductCategory: UpdateProductCategory;
-    };
 
-    export type UpdateProductCategory = ProductCategory.Fragment;
+export interface SearchResponse {
+  
+  items: SearchResult[];
+  
+  totalItems: number;
+  
+  facetValues: FacetValue[];
 }
 
-export namespace MoveProductCategory {
-    export type Variables = {
-        input: MoveProductCategoryInput;
-    };
-
-    export type Mutation = {
-        __typename?: 'Mutation';
-        moveProductCategory: MoveProductCategory;
-    };
 
-    export type MoveProductCategory = ProductCategory.Fragment;
+export interface SearchResult {
+  
+  sku: string;
+  
+  productId: string;
+  
+  productName: string;
+  
+  productPreview: string;
+  
+  productVariantId: string;
+  
+  productVariantName: string;
+  
+  productVariantPreview: string;
+  
+  description: string;
+  
+  facetIds: string[];
+  
+  facetValueIds: string[];
+  
+  score: number;
 }
 
-export namespace SearchProducts {
-    export type Variables = {
-        input: SearchInput;
-    };
-
-    export type Query = {
-        __typename?: 'Query';
-        search: Search;
-    };
-
-    export type Search = {
-        __typename?: 'SearchResponse';
-        totalItems: number;
-        items: Items[];
-    };
-
-    export type Items = {
-        __typename?: 'SearchResult';
-        productId: string;
-        productName: string;
-        productPreview: string;
-        productVariantId: string;
-        productVariantName: string;
-        productVariantPreview: string;
-        sku: string;
-    };
+
+export interface ShippingMethodList extends PaginatedList {
+  
+  items: ShippingMethod[];
+  
+  totalItems: number;
 }
 
-export namespace GetPromotionList {
-    export type Variables = {
-        options?: PromotionListOptions | null;
-    };
 
-    export type Query = {
-        __typename?: 'Query';
-        promotions: Promotions;
-    };
+export interface TaxRateList extends PaginatedList {
+  
+  items: TaxRate[];
+  
+  totalItems: number;
+}
 
-    export type Promotions = {
-        __typename?: 'PromotionList';
-        items: Items[];
-        totalItems: number;
-    };
 
-    export type Items = Promotion.Fragment;
+export interface NetworkStatus {
+  
+  inFlightRequests: number;
 }
 
-export namespace GetPromotion {
-    export type Variables = {
-        id: string;
-    };
-
-    export type Query = {
-        __typename?: 'Query';
-        promotion?: Promotion | null;
-    };
 
-    export type Promotion = Promotion.Fragment;
+export interface UserStatus {
+  
+  username: string;
+  
+  isLoggedIn: boolean;
+  
+  loginTime: string;
 }
 
-export namespace GetAdjustmentOperations {
-    export type Variables = {};
-
-    export type Query = {
-        __typename?: 'Query';
-        adjustmentOperations: AdjustmentOperations;
-    };
 
-    export type AdjustmentOperations = {
-        __typename?: 'AdjustmentOperations';
-        actions: Actions[];
-        conditions: Conditions[];
-    };
+export interface UiState {
+  
+  language: LanguageCode;
+}
 
-    export type Actions = AdjustmentOperation.Fragment;
 
-    export type Conditions = AdjustmentOperation.Fragment;
+export interface Mutation {
+  /** Create a new Administrator */
+  createAdministrator: Administrator;
+  /** Update an existing Administrator */
+  updateAdministrator: Administrator;
+  /** Assign a Role to an Administrator */
+  assignRoleToAdministrator: Administrator;
+  /** Create a new Asset */
+  createAssets: Asset[];
+  
+  login: LoginResult;
+  
+  logout: boolean;
+  /** Register a Customer account with the given credentials */
+  registerCustomerAccount: boolean;
+  /** Verify a Customer email address with the token sent to that address */
+  verifyCustomerAccount: LoginResult;
+  /** Regenerate and send a verification token for a new Customer registration */
+  refreshCustomerVerification: boolean;
+  /** Create a new Channel */
+  createChannel: Channel;
+  /** Update an existing Channel */
+  updateChannel: Channel;
+  /** Create a new Country */
+  createCountry: Country;
+  /** Update an existing Country */
+  updateCountry: Country;
+  /** Delete a Country */
+  deleteCountry: DeletionResponse;
+  /** Create a new CustomerGroup */
+  createCustomerGroup: CustomerGroup;
+  /** Update an existing CustomerGroup */
+  updateCustomerGroup: CustomerGroup;
+  /** Add Customers to a CustomerGroup */
+  addCustomersToGroup: CustomerGroup;
+  /** Remove Customers from a CustomerGroup */
+  removeCustomersFromGroup: CustomerGroup;
+  /** Create a new Customer. If a password is provided, a new User will also be created an linked to the Customer. */
+  createCustomer: Customer;
+  /** Update an existing Customer */
+  updateCustomer: Customer;
+  /** Delete a Customer */
+  deleteCustomer: DeletionResponse;
+  /** Create a new Address and associate it with the Customer specified by customerId */
+  createCustomerAddress: Address;
+  /** Update an existing Address */
+  updateCustomerAddress: Address;
+  /** Create a new Facet */
+  createFacet: Facet;
+  /** Update an existing Facet */
+  updateFacet: Facet;
+  /** Delete an existing Facet */
+  deleteFacet: DeletionResponse;
+  /** Create one or more FacetValues */
+  createFacetValues: FacetValue[];
+  /** Update one or more FacetValues */
+  updateFacetValues: FacetValue[];
+  /** Delete one or more FacetValues */
+  deleteFacetValues: DeletionResponse[];
+  
+  updateGlobalSettings: GlobalSettings;
+  
+  importProducts?: Maybe<ImportInfo>;
+  
+  addItemToOrder?: Maybe<Order>;
+  
+  removeItemFromOrder?: Maybe<Order>;
+  
+  adjustItemQuantity?: Maybe<Order>;
+  
+  transitionOrderToState?: Maybe<Order>;
+  
+  setOrderShippingAddress?: Maybe<Order>;
+  
+  setOrderShippingMethod?: Maybe<Order>;
+  
+  addPaymentToOrder?: Maybe<Order>;
+  
+  setCustomerForOrder?: Maybe<Order>;
+  /** Update an existing PaymentMethod */
+  updatePaymentMethod: PaymentMethod;
+  /** Create a new ProductCategory */
+  createProductCategory: ProductCategory;
+  /** Update an existing ProductCategory */
+  updateProductCategory: ProductCategory;
+  /** Move a ProductCategory to a different parent or index */
+  moveProductCategory: ProductCategory;
+  /** Create a new ProductOptionGroup */
+  createProductOptionGroup: ProductOptionGroup;
+  /** Update an existing ProductOptionGroup */
+  updateProductOptionGroup: ProductOptionGroup;
+  /** Create a new Product */
+  createProduct: Product;
+  /** Update an existing Product */
+  updateProduct: Product;
+  /** Delete a Product */
+  deleteProduct: DeletionResponse;
+  /** Add an OptionGroup to a Product */
+  addOptionGroupToProduct: Product;
+  /** Remove an OptionGroup from a Product */
+  removeOptionGroupFromProduct: Product;
+  /** Create a set of ProductVariants based on the OptionGroups assigned to the given Product */
+  generateVariantsForProduct: Product;
+  /** Update existing ProductVariants */
+  updateProductVariants: (Maybe<ProductVariant>)[];
+  
+  createPromotion: Promotion;
+  
+  updatePromotion: Promotion;
+  
+  deletePromotion: DeletionResponse;
+  /** Create a new Role */
+  createRole: Role;
+  /** Update an existing Role */
+  updateRole: Role;
+  
+  reindex: SearchReindexResponse;
+  /** Create a new ShippingMethod */
+  createShippingMethod: ShippingMethod;
+  /** Update an existing ShippingMethod */
+  updateShippingMethod: ShippingMethod;
+  /** Create a new TaxCategory */
+  createTaxCategory: TaxCategory;
+  /** Update an existing TaxCategory */
+  updateTaxCategory: TaxCategory;
+  /** Create a new TaxRate */
+  createTaxRate: TaxRate;
+  /** Update an existing TaxRate */
+  updateTaxRate: TaxRate;
+  /** Create a new Zone */
+  createZone: Zone;
+  /** Update an existing Zone */
+  updateZone: Zone;
+  /** Delete a Zone */
+  deleteZone: DeletionResponse;
+  /** Add members to a Zone */
+  addMembersToZone: Zone;
+  /** Remove members from a Zone */
+  removeMembersFromZone: Zone;
+  
+  requestStarted: number;
+  
+  requestCompleted: number;
+  
+  setAsLoggedIn: UserStatus;
+  
+  setAsLoggedOut: UserStatus;
+  
+  setUiLanguage?: Maybe<LanguageCode>;
 }
 
-export namespace CreatePromotion {
-    export type Variables = {
-        input: CreatePromotionInput;
-    };
-
-    export type Mutation = {
-        __typename?: 'Mutation';
-        createPromotion: CreatePromotion;
-    };
 
-    export type CreatePromotion = Promotion.Fragment;
+export interface LoginResult {
+  
+  user: CurrentUser;
 }
 
-export namespace UpdatePromotion {
-    export type Variables = {
-        input: UpdatePromotionInput;
-    };
-
-    export type Mutation = {
-        __typename?: 'Mutation';
-        updatePromotion: UpdatePromotion;
-    };
 
-    export type UpdatePromotion = Promotion.Fragment;
+export interface DeletionResponse {
+  
+  result: DeletionResult;
+  
+  message?: Maybe<string>;
 }
 
-export namespace GetCountryList {
-    export type Variables = {
-        options?: CountryListOptions | null;
-    };
-
-    export type Query = {
-        __typename?: 'Query';
-        countries: Countries;
-    };
-
-    export type Countries = {
-        __typename?: 'CountryList';
-        items: Items[];
-        totalItems: number;
-    };
-
-    export type Items = {
-        __typename?: 'Country';
-        id: string;
-        code: string;
-        name: string;
-        enabled: boolean;
-    };
-}
 
-export namespace GetAvailableCountries {
-    export type Variables = {};
+export interface ImportInfo {
+  
+  errors?: Maybe<string[]>;
+  
+  processed: number;
+  
+  imported: number;
+}
 
-    export type Query = {
-        __typename?: 'Query';
-        availableCountries: AvailableCountries[];
-    };
 
-    export type AvailableCountries = {
-        __typename?: 'Country';
-        id: string;
-        code: string;
-        name: string;
-        enabled: boolean;
-    };
+export interface SearchReindexResponse {
+  
+  success: boolean;
+  
+  timeTaken: number;
+  
+  indexedItemCount: number;
 }
 
-export namespace GetCountry {
-    export type Variables = {
-        id: string;
-    };
 
-    export type Query = {
-        __typename?: 'Query';
-        country?: Country | null;
-    };
 
-    export type Country = Country.Fragment;
+// ====================================================
+// Arguments
+// ====================================================
+
+export interface AdministratorsQueryArgs {
+  
+  options?: Maybe<AdministratorListOptions>;
+}
+export interface AdministratorQueryArgs {
+  
+  id: string;
+}
+export interface AssetsQueryArgs {
+  
+  options?: Maybe<AssetListOptions>;
+}
+export interface AssetQueryArgs {
+  
+  id: string;
+}
+export interface ChannelQueryArgs {
+  
+  id: string;
+}
+export interface CountriesQueryArgs {
+  
+  options?: Maybe<CountryListOptions>;
+}
+export interface CountryQueryArgs {
+  
+  id: string;
+}
+export interface CustomerGroupQueryArgs {
+  
+  id: string;
+}
+export interface CustomersQueryArgs {
+  
+  options?: Maybe<CustomerListOptions>;
+}
+export interface CustomerQueryArgs {
+  
+  id: string;
+}
+export interface FacetsQueryArgs {
+  
+  languageCode?: Maybe<LanguageCode>;
+  
+  options?: Maybe<FacetListOptions>;
+}
+export interface FacetQueryArgs {
+  
+  id: string;
+  
+  languageCode?: Maybe<LanguageCode>;
+}
+export interface OrderQueryArgs {
+  
+  id: string;
+}
+export interface OrderByCodeQueryArgs {
+  
+  code: string;
+}
+export interface OrdersQueryArgs {
+  
+  options?: Maybe<OrderListOptions>;
+}
+export interface PaymentMethodsQueryArgs {
+  
+  options?: Maybe<PaymentMethodListOptions>;
+}
+export interface PaymentMethodQueryArgs {
+  
+  id: string;
+}
+export interface ProductCategoriesQueryArgs {
+  
+  languageCode?: Maybe<LanguageCode>;
+  
+  options?: Maybe<ProductCategoryListOptions>;
+}
+export interface ProductCategoryQueryArgs {
+  
+  id: string;
+  
+  languageCode?: Maybe<LanguageCode>;
+}
+export interface ProductOptionGroupsQueryArgs {
+  
+  languageCode?: Maybe<LanguageCode>;
+  
+  filterTerm?: Maybe<string>;
+}
+export interface ProductOptionGroupQueryArgs {
+  
+  id: string;
+  
+  languageCode?: Maybe<LanguageCode>;
+}
+export interface ProductsQueryArgs {
+  
+  languageCode?: Maybe<LanguageCode>;
+  
+  options?: Maybe<ProductListOptions>;
+}
+export interface ProductQueryArgs {
+  
+  id: string;
+  
+  languageCode?: Maybe<LanguageCode>;
+}
+export interface PromotionQueryArgs {
+  
+  id: string;
+}
+export interface PromotionsQueryArgs {
+  
+  options?: Maybe<PromotionListOptions>;
+}
+export interface RolesQueryArgs {
+  
+  options?: Maybe<RoleListOptions>;
+}
+export interface RoleQueryArgs {
+  
+  id: string;
+}
+export interface SearchQueryArgs {
+  
+  input: SearchInput;
+}
+export interface ShippingMethodsQueryArgs {
+  
+  options?: Maybe<ShippingMethodListOptions>;
+}
+export interface ShippingMethodQueryArgs {
+  
+  id: string;
+}
+export interface TaxCategoryQueryArgs {
+  
+  id: string;
+}
+export interface TaxRatesQueryArgs {
+  
+  options?: Maybe<TaxRateListOptions>;
+}
+export interface TaxRateQueryArgs {
+  
+  id: string;
+}
+export interface ZoneQueryArgs {
+  
+  id: string;
+}
+export interface OrdersCustomerArgs {
+  
+  options?: Maybe<OrderListOptions>;
+}
+export interface CreateAdministratorMutationArgs {
+  
+  input: CreateAdministratorInput;
+}
+export interface UpdateAdministratorMutationArgs {
+  
+  input: UpdateAdministratorInput;
+}
+export interface AssignRoleToAdministratorMutationArgs {
+  
+  administratorId: string;
+  
+  roleId: string;
+}
+export interface CreateAssetsMutationArgs {
+  
+  input: CreateAssetInput[];
+}
+export interface LoginMutationArgs {
+  
+  username: string;
+  
+  password: string;
+  
+  rememberMe?: Maybe<boolean>;
+}
+export interface RegisterCustomerAccountMutationArgs {
+  
+  input: RegisterCustomerInput;
+}
+export interface VerifyCustomerAccountMutationArgs {
+  
+  token: string;
+  
+  password: string;
+}
+export interface RefreshCustomerVerificationMutationArgs {
+  
+  emailAddress: string;
+}
+export interface CreateChannelMutationArgs {
+  
+  input: CreateChannelInput;
+}
+export interface UpdateChannelMutationArgs {
+  
+  input: UpdateChannelInput;
 }
-
-export namespace CreateCountry {
-    export type Variables = {
-        input: CreateCountryInput;
-    };
-
-    export type Mutation = {
-        __typename?: 'Mutation';
-        createCountry: CreateCountry;
-    };
-
-    export type CreateCountry = Country.Fragment;
+export interface CreateCountryMutationArgs {
+  
+  input: CreateCountryInput;
 }
-
-export namespace UpdateCountry {
-    export type Variables = {
-        input: UpdateCountryInput;
-    };
-
-    export type Mutation = {
-        __typename?: 'Mutation';
-        updateCountry: UpdateCountry;
-    };
-
-    export type UpdateCountry = Country.Fragment;
+export interface UpdateCountryMutationArgs {
+  
+  input: UpdateCountryInput;
 }
-
-export namespace DeleteCountry {
-    export type Variables = {
-        id: string;
-    };
-
-    export type Mutation = {
-        __typename?: 'Mutation';
-        deleteCountry: DeleteCountry;
-    };
-
-    export type DeleteCountry = {
-        __typename?: 'DeletionResponse';
-        result: DeletionResult;
-        message?: string | null;
-    };
+export interface DeleteCountryMutationArgs {
+  
+  id: string;
 }
-
-export namespace GetZones {
-    export type Variables = {};
-
-    export type Query = {
-        __typename?: 'Query';
-        zones: Zones[];
-    };
-
-    export type Zones = {
-        __typename?: 'Zone';
-        id: string;
-        name: string;
-        members: Members[];
-    };
-
-    export type Members = {
-        __typename?: 'Country';
-        id: string;
-        name: string;
-        code: string;
-    };
+export interface CreateCustomerGroupMutationArgs {
+  
+  input: CreateCustomerGroupInput;
 }
-
-export namespace GetZone {
-    export type Variables = {
-        id: string;
-    };
-
-    export type Query = {
-        __typename?: 'Query';
-        zone?: Zone | null;
-    };
-
-    export type Zone = Zone.Fragment;
+export interface UpdateCustomerGroupMutationArgs {
+  
+  input: UpdateCustomerGroupInput;
 }
-
-export namespace CreateZone {
-    export type Variables = {
-        input: CreateZoneInput;
-    };
-
-    export type Mutation = {
-        __typename?: 'Mutation';
-        createZone: CreateZone;
-    };
-
-    export type CreateZone = Zone.Fragment;
+export interface AddCustomersToGroupMutationArgs {
+  
+  customerGroupId: string;
+  
+  customerIds: string[];
 }
-
-export namespace UpdateZone {
-    export type Variables = {
-        input: UpdateZoneInput;
-    };
-
-    export type Mutation = {
-        __typename?: 'Mutation';
-        updateZone: UpdateZone;
-    };
-
-    export type UpdateZone = Zone.Fragment;
+export interface RemoveCustomersFromGroupMutationArgs {
+  
+  customerGroupId: string;
+  
+  customerIds: string[];
 }
-
-export namespace AddMembersToZone {
-    export type Variables = {
-        zoneId: string;
-        memberIds: string[];
-    };
-
-    export type Mutation = {
-        __typename?: 'Mutation';
-        addMembersToZone: AddMembersToZone;
-    };
-
-    export type AddMembersToZone = Zone.Fragment;
+export interface CreateCustomerMutationArgs {
+  
+  input: CreateCustomerInput;
+  
+  password?: Maybe<string>;
 }
-
-export namespace RemoveMembersFromZone {
-    export type Variables = {
-        zoneId: string;
-        memberIds: string[];
-    };
-
-    export type Mutation = {
-        __typename?: 'Mutation';
-        removeMembersFromZone: RemoveMembersFromZone;
-    };
-
-    export type RemoveMembersFromZone = Zone.Fragment;
+export interface UpdateCustomerMutationArgs {
+  
+  input: UpdateCustomerInput;
 }
-
-export namespace GetTaxCategories {
-    export type Variables = {};
-
-    export type Query = {
-        __typename?: 'Query';
-        taxCategories: TaxCategories[];
-    };
-
-    export type TaxCategories = TaxCategory.Fragment;
+export interface DeleteCustomerMutationArgs {
+  
+  id: string;
 }
-
-export namespace GetTaxCategory {
-    export type Variables = {
-        id: string;
-    };
-
-    export type Query = {
-        __typename?: 'Query';
-        taxCategory?: TaxCategory | null;
-    };
-
-    export type TaxCategory = TaxCategory.Fragment;
+export interface CreateCustomerAddressMutationArgs {
+  
+  customerId: string;
+  
+  input: CreateAddressInput;
 }
-
-export namespace CreateTaxCategory {
-    export type Variables = {
-        input: CreateTaxCategoryInput;
-    };
-
-    export type Mutation = {
-        __typename?: 'Mutation';
-        createTaxCategory: CreateTaxCategory;
-    };
-
-    export type CreateTaxCategory = TaxCategory.Fragment;
+export interface UpdateCustomerAddressMutationArgs {
+  
+  input: UpdateAddressInput;
 }
-
-export namespace UpdateTaxCategory {
-    export type Variables = {
-        input: UpdateTaxCategoryInput;
-    };
-
-    export type Mutation = {
-        __typename?: 'Mutation';
-        updateTaxCategory: UpdateTaxCategory;
-    };
-
-    export type UpdateTaxCategory = TaxCategory.Fragment;
+export interface CreateFacetMutationArgs {
+  
+  input: CreateFacetInput;
 }
-
-export namespace GetTaxRateList {
-    export type Variables = {
-        options?: TaxRateListOptions | null;
-    };
-
-    export type Query = {
-        __typename?: 'Query';
-        taxRates: TaxRates;
-    };
-
-    export type TaxRates = {
-        __typename?: 'TaxRateList';
-        items: Items[];
-        totalItems: number;
-    };
-
-    export type Items = TaxRate.Fragment;
+export interface UpdateFacetMutationArgs {
+  
+  input: UpdateFacetInput;
 }
-
-export namespace GetTaxRate {
-    export type Variables = {
-        id: string;
-    };
-
-    export type Query = {
-        __typename?: 'Query';
-        taxRate?: TaxRate | null;
-    };
-
-    export type TaxRate = TaxRate.Fragment;
+export interface DeleteFacetMutationArgs {
+  
+  id: string;
+  
+  force?: Maybe<boolean>;
 }
-
-export namespace CreateTaxRate {
-    export type Variables = {
-        input: CreateTaxRateInput;
-    };
-
-    export type Mutation = {
-        __typename?: 'Mutation';
-        createTaxRate: CreateTaxRate;
-    };
-
-    export type CreateTaxRate = TaxRate.Fragment;
+export interface CreateFacetValuesMutationArgs {
+  
+  input: CreateFacetValueInput[];
 }
-
-export namespace UpdateTaxRate {
-    export type Variables = {
-        input: UpdateTaxRateInput;
-    };
-
-    export type Mutation = {
-        __typename?: 'Mutation';
-        updateTaxRate: UpdateTaxRate;
-    };
-
-    export type UpdateTaxRate = TaxRate.Fragment;
+export interface UpdateFacetValuesMutationArgs {
+  
+  input: UpdateFacetValueInput[];
 }
-
-export namespace GetChannels {
-    export type Variables = {};
-
-    export type Query = {
-        __typename?: 'Query';
-        channels: Channels[];
-    };
-
-    export type Channels = Channel.Fragment;
+export interface DeleteFacetValuesMutationArgs {
+  
+  ids: string[];
+  
+  force?: Maybe<boolean>;
 }
-
-export namespace GetChannel {
-    export type Variables = {
-        id: string;
-    };
-
-    export type Query = {
-        __typename?: 'Query';
-        channel?: Channel | null;
-    };
-
-    export type Channel = Channel.Fragment;
+export interface UpdateGlobalSettingsMutationArgs {
+  
+  input: UpdateGlobalSettingsInput;
 }
-
-export namespace GetActiveChannel {
-    export type Variables = {};
-
-    export type Query = {
-        __typename?: 'Query';
-        activeChannel: ActiveChannel;
-    };
-
-    export type ActiveChannel = Channel.Fragment;
+export interface ImportProductsMutationArgs {
+  
+  csvFile: Upload;
 }
-
-export namespace CreateChannel {
-    export type Variables = {
-        input: CreateChannelInput;
-    };
-
-    export type Mutation = {
-        __typename?: 'Mutation';
-        createChannel: CreateChannel;
-    };
-
-    export type CreateChannel = Channel.Fragment;
+export interface AddItemToOrderMutationArgs {
+  
+  productVariantId: string;
+  
+  quantity: number;
 }
-
-export namespace UpdateChannel {
-    export type Variables = {
-        input: UpdateChannelInput;
-    };
-
-    export type Mutation = {
-        __typename?: 'Mutation';
-        updateChannel: UpdateChannel;
-    };
-
-    export type UpdateChannel = Channel.Fragment;
+export interface RemoveItemFromOrderMutationArgs {
+  
+  orderItemId: string;
 }
-
-export namespace GetPaymentMethodList {
-    export type Variables = {
-        options: PaymentMethodListOptions;
-    };
-
-    export type Query = {
-        __typename?: 'Query';
-        paymentMethods: PaymentMethods;
-    };
-
-    export type PaymentMethods = {
-        __typename?: 'PaymentMethodList';
-        items: Items[];
-        totalItems: number;
-    };
-
-    export type Items = PaymentMethod.Fragment;
+export interface AdjustItemQuantityMutationArgs {
+  
+  orderItemId: string;
+  
+  quantity: number;
 }
-
-export namespace GetPaymentMethod {
-    export type Variables = {
-        id: string;
-    };
-
-    export type Query = {
-        __typename?: 'Query';
-        paymentMethod?: PaymentMethod | null;
-    };
-
-    export type PaymentMethod = PaymentMethod.Fragment;
+export interface TransitionOrderToStateMutationArgs {
+  
+  state: string;
 }
-
-export namespace UpdatePaymentMethod {
-    export type Variables = {
-        input: UpdatePaymentMethodInput;
-    };
-
-    export type Mutation = {
-        __typename?: 'Mutation';
-        updatePaymentMethod: UpdatePaymentMethod;
-    };
-
-    export type UpdatePaymentMethod = PaymentMethod.Fragment;
+export interface SetOrderShippingAddressMutationArgs {
+  
+  input: CreateAddressInput;
 }
-
-export namespace GetGlobalSettings {
-    export type Variables = {};
-
-    export type Query = {
-        __typename?: 'Query';
-        globalSettings: GlobalSettings;
-    };
-
-    export type GlobalSettings = GlobalSettings.Fragment;
+export interface SetOrderShippingMethodMutationArgs {
+  
+  shippingMethodId: string;
 }
-
-export namespace UpdateGlobalSettings {
-    export type Variables = {
-        input: UpdateGlobalSettingsInput;
-    };
-
-    export type Mutation = {
-        __typename?: 'Mutation';
-        updateGlobalSettings: UpdateGlobalSettings;
-    };
-
-    export type UpdateGlobalSettings = GlobalSettings.Fragment;
+export interface AddPaymentToOrderMutationArgs {
+  
+  input: PaymentInput;
 }
-
-export namespace GetServerConfig {
-    export type Variables = {};
-
-    export type Query = {
-        __typename?: 'Query';
-        globalSettings: GlobalSettings;
-    };
-
-    export type GlobalSettings = {
-        __typename?: 'GlobalSettings';
-        serverConfig: ServerConfig;
-    };
-
-    export type ServerConfig = {
-        __typename?: 'ServerConfig';
-        customFields?: Json | null;
-    };
+export interface SetCustomerForOrderMutationArgs {
+  
+  input: CreateCustomerInput;
 }
-
-export namespace GetShippingMethodList {
-    export type Variables = {
-        options?: ShippingMethodListOptions | null;
-    };
-
-    export type Query = {
-        __typename?: 'Query';
-        shippingMethods: ShippingMethods;
-    };
-
-    export type ShippingMethods = {
-        __typename?: 'ShippingMethodList';
-        items: Items[];
-        totalItems: number;
-    };
-
-    export type Items = ShippingMethod.Fragment;
+export interface UpdatePaymentMethodMutationArgs {
+  
+  input: UpdatePaymentMethodInput;
 }
-
-export namespace GetShippingMethod {
-    export type Variables = {
-        id: string;
-    };
-
-    export type Query = {
-        __typename?: 'Query';
-        shippingMethod?: ShippingMethod | null;
-    };
-
-    export type ShippingMethod = ShippingMethod.Fragment;
+export interface CreateProductCategoryMutationArgs {
+  
+  input: CreateProductCategoryInput;
 }
-
-export namespace GetShippingMethodOperations {
-    export type Variables = {};
-
-    export type Query = {
-        __typename?: 'Query';
-        shippingEligibilityCheckers: ShippingEligibilityCheckers[];
-        shippingCalculators: ShippingCalculators[];
-    };
-
-    export type ShippingEligibilityCheckers = AdjustmentOperation.Fragment;
-
-    export type ShippingCalculators = AdjustmentOperation.Fragment;
+export interface UpdateProductCategoryMutationArgs {
+  
+  input: UpdateProductCategoryInput;
 }
-
-export namespace CreateShippingMethod {
-    export type Variables = {
-        input: CreateShippingMethodInput;
-    };
-
-    export type Mutation = {
-        __typename?: 'Mutation';
-        createShippingMethod: CreateShippingMethod;
-    };
-
-    export type CreateShippingMethod = ShippingMethod.Fragment;
+export interface MoveProductCategoryMutationArgs {
+  
+  input: MoveProductCategoryInput;
 }
-
-export namespace UpdateShippingMethod {
-    export type Variables = {
-        input: UpdateShippingMethodInput;
-    };
-
-    export type Mutation = {
-        __typename?: 'Mutation';
-        updateShippingMethod: UpdateShippingMethod;
-    };
-
-    export type UpdateShippingMethod = ShippingMethod.Fragment;
+export interface CreateProductOptionGroupMutationArgs {
+  
+  input: CreateProductOptionGroupInput;
 }
-
-export namespace Administrator {
-    export type Fragment = {
-        __typename?: 'Administrator';
-        id: string;
-        firstName: string;
-        lastName: string;
-        emailAddress: string;
-        user: User;
-    };
-
-    export type User = {
-        __typename?: 'User';
-        id: string;
-        identifier: string;
-        lastLogin?: string | null;
-        roles: Roles[];
-    };
-
-    export type Roles = {
-        __typename?: 'Role';
-        id: string;
-        code: string;
-        description: string;
-        permissions: Permission[];
-    };
+export interface UpdateProductOptionGroupMutationArgs {
+  
+  input: UpdateProductOptionGroupInput;
 }
-
-export namespace Role {
-    export type Fragment = {
-        __typename?: 'Role';
-        id: string;
-        code: string;
-        description: string;
-        permissions: Permission[];
-        channels: Channels[];
-    };
-
-    export type Channels = {
-        __typename?: 'Channel';
-        id: string;
-        code: string;
-        token: string;
-    };
+export interface CreateProductMutationArgs {
+  
+  input: CreateProductInput;
 }
-
-export namespace CurrentUser {
-    export type Fragment = {
-        __typename?: 'CurrentUser';
-        id: string;
-        identifier: string;
-        channelTokens: string[];
-    };
+export interface UpdateProductMutationArgs {
+  
+  input: UpdateProductInput;
 }
-
-export namespace Address {
-    export type Fragment = {
-        __typename?: 'Address';
-        id: string;
-        fullName?: string | null;
-        company?: string | null;
-        streetLine1: string;
-        streetLine2?: string | null;
-        city?: string | null;
-        province?: string | null;
-        postalCode?: string | null;
-        country: Country;
-        phoneNumber?: string | null;
-        defaultShippingAddress?: boolean | null;
-        defaultBillingAddress?: boolean | null;
-    };
-
-    export type Country = {
-        __typename?: 'Country';
-        id: string;
-        code: string;
-        name: string;
-    };
+export interface DeleteProductMutationArgs {
+  
+  id: string;
 }
-
-export namespace Customer {
-    export type Fragment = {
-        __typename?: 'Customer';
-        id: string;
-        title?: string | null;
-        firstName: string;
-        lastName: string;
-        phoneNumber?: string | null;
-        emailAddress: string;
-        user?: User | null;
-        addresses?: Addresses[] | null;
-    };
-
-    export type User = {
-        __typename?: 'User';
-        id: string;
-        identifier: string;
-        verified: boolean;
-        lastLogin?: string | null;
-    };
-
-    export type Addresses = Address.Fragment;
+export interface AddOptionGroupToProductMutationArgs {
+  
+  productId: string;
+  
+  optionGroupId: string;
 }
-
-export namespace FacetValue {
-    export type Fragment = {
-        __typename?: 'FacetValue';
-        id: string;
-        languageCode: LanguageCode;
-        code: string;
-        name: string;
-        translations: Translations[];
-        facet: Facet;
-    };
-
-    export type Translations = {
-        __typename?: 'FacetValueTranslation';
-        id: string;
-        languageCode: LanguageCode;
-        name: string;
-    };
-
-    export type Facet = {
-        __typename?: 'Facet';
-        id: string;
-        name: string;
-    };
+export interface RemoveOptionGroupFromProductMutationArgs {
+  
+  productId: string;
+  
+  optionGroupId: string;
 }
-
-export namespace FacetWithValues {
-    export type Fragment = {
-        __typename?: 'Facet';
-        id: string;
-        languageCode: LanguageCode;
-        code: string;
-        name: string;
-        translations: Translations[];
-        values: Values[];
-    };
-
-    export type Translations = {
-        __typename?: 'FacetTranslation';
-        id: string;
-        languageCode: LanguageCode;
-        name: string;
-    };
-
-    export type Values = FacetValue.Fragment;
+export interface GenerateVariantsForProductMutationArgs {
+  
+  productId: string;
+  
+  defaultTaxCategoryId?: Maybe<string>;
+  
+  defaultPrice?: Maybe<number>;
+  
+  defaultSku?: Maybe<string>;
 }
-
-export namespace Adjustment {
-    export type Fragment = {
-        __typename?: 'Adjustment';
-        adjustmentSource: string;
-        amount: number;
-        description: string;
-        type: AdjustmentType;
-    };
+export interface UpdateProductVariantsMutationArgs {
+  
+  input: UpdateProductVariantInput[];
 }
-
-export namespace ShippingAddress {
-    export type Fragment = {
-        __typename?: 'ShippingAddress';
-        fullName?: string | null;
-        company?: string | null;
-        streetLine1?: string | null;
-        streetLine2?: string | null;
-        city?: string | null;
-        province?: string | null;
-        postalCode?: string | null;
-        country?: string | null;
-        phoneNumber?: string | null;
-    };
+export interface CreatePromotionMutationArgs {
+  
+  input: CreatePromotionInput;
 }
-
-export namespace Order {
-    export type Fragment = {
-        __typename?: 'Order';
-        id: string;
-        createdAt: DateTime;
-        updatedAt: DateTime;
-        code: string;
-        state: string;
-        total: number;
-        currencyCode: CurrencyCode;
-        customer?: Customer | null;
-    };
-
-    export type Customer = {
-        __typename?: 'Customer';
-        id: string;
-        firstName: string;
-        lastName: string;
-    };
+export interface UpdatePromotionMutationArgs {
+  
+  input: UpdatePromotionInput;
 }
-
-export namespace OrderWithLines {
-    export type Fragment = {
-        __typename?: 'Order';
-        id: string;
-        createdAt: DateTime;
-        updatedAt: DateTime;
-        code: string;
-        state: string;
-        active: boolean;
-        customer?: Customer | null;
-        lines: Lines[];
-        adjustments: Adjustments[];
-        subTotal: number;
-        subTotalBeforeTax: number;
-        totalBeforeTax: number;
-        currencyCode: CurrencyCode;
-        shipping: number;
-        shippingMethod?: ShippingMethod | null;
-        shippingAddress?: ShippingAddress | null;
-        payments?: Payments[] | null;
-        total: number;
-    };
-
-    export type Customer = {
-        __typename?: 'Customer';
-        id: string;
-        firstName: string;
-        lastName: string;
-    };
-
-    export type Lines = {
-        __typename?: 'OrderLine';
-        id: string;
-        featuredAsset?: FeaturedAsset | null;
-        productVariant: ProductVariant;
-        unitPrice: number;
-        unitPriceWithTax: number;
-        quantity: number;
-        items: Items[];
-        totalPrice: number;
-    };
-
-    export type FeaturedAsset = {
-        __typename?: 'Asset';
-        preview: string;
-    };
-
-    export type ProductVariant = {
-        __typename?: 'ProductVariant';
-        id: string;
-        name: string;
-        sku: string;
-    };
-
-    export type Items = {
-        __typename?: 'OrderItem';
-        id: string;
-        unitPrice: number;
-        unitPriceIncludesTax: boolean;
-        unitPriceWithTax: number;
-        taxRate: number;
-    };
-
-    export type Adjustments = Adjustment.Fragment;
-
-    export type ShippingMethod = {
-        __typename?: 'ShippingMethod';
-        id: string;
-        code: string;
-        description: string;
-    };
-
-    export type ShippingAddress = ShippingAddress.Fragment;
-
-    export type Payments = {
-        __typename?: 'Payment';
-        id: string;
-        transactionId?: string | null;
-        amount: number;
-        method: string;
-        state: string;
-        metadata?: Json | null;
-    };
+export interface DeletePromotionMutationArgs {
+  
+  id: string;
 }
-
-export namespace Asset {
-    export type Fragment = {
-        __typename?: 'Asset';
-        id: string;
-        name: string;
-        fileSize: number;
-        mimeType: string;
-        type: AssetType;
-        preview: string;
-        source: string;
-    };
+export interface CreateRoleMutationArgs {
+  
+  input: CreateRoleInput;
 }
-
-export namespace ProductVariant {
-    export type Fragment = {
-        __typename?: 'ProductVariant';
-        id: string;
-        languageCode: LanguageCode;
-        name: string;
-        price: number;
-        currencyCode: CurrencyCode;
-        priceIncludesTax: boolean;
-        priceWithTax: number;
-        taxRateApplied: TaxRateApplied;
-        taxCategory: TaxCategory;
-        sku: string;
-        options: Options[];
-        facetValues: FacetValues[];
-        featuredAsset?: FeaturedAsset | null;
-        assets: Assets[];
-        translations: Translations[];
-    };
-
-    export type TaxRateApplied = {
-        __typename?: 'TaxRate';
-        id: string;
-        name: string;
-        value: number;
-    };
-
-    export type TaxCategory = {
-        __typename?: 'TaxCategory';
-        id: string;
-        name: string;
-    };
-
-    export type Options = {
-        __typename?: 'ProductOption';
-        id: string;
-        code?: string | null;
-        languageCode?: LanguageCode | null;
-        name?: string | null;
-    };
-
-    export type FacetValues = {
-        __typename?: 'FacetValue';
-        id: string;
-        code: string;
-        name: string;
-        facet: Facet;
-    };
-
-    export type Facet = {
-        __typename?: 'Facet';
-        id: string;
-        name: string;
-    };
-
-    export type FeaturedAsset = Asset.Fragment;
-
-    export type Assets = Asset.Fragment;
-
-    export type Translations = {
-        __typename?: 'ProductVariantTranslation';
-        id: string;
-        languageCode: LanguageCode;
-        name: string;
-    };
+export interface UpdateRoleMutationArgs {
+  
+  input: UpdateRoleInput;
 }
-
-export namespace ProductWithVariants {
-    export type Fragment = {
-        __typename?: 'Product';
-        id: string;
-        languageCode: LanguageCode;
-        name: string;
-        slug: string;
-        description: string;
-        featuredAsset?: FeaturedAsset | null;
-        assets: Assets[];
-        translations: Translations[];
-        optionGroups: OptionGroups[];
-        variants: Variants[];
-        facetValues: FacetValues[];
-    };
-
-    export type FeaturedAsset = Asset.Fragment;
-
-    export type Assets = Asset.Fragment;
-
-    export type Translations = {
-        __typename?: 'ProductTranslation';
-        languageCode: LanguageCode;
-        name: string;
-        slug: string;
-        description: string;
-    };
-
-    export type OptionGroups = {
-        __typename?: 'ProductOptionGroup';
-        id: string;
-        languageCode: LanguageCode;
-        code: string;
-        name: string;
-    };
-
-    export type Variants = ProductVariant.Fragment;
-
-    export type FacetValues = {
-        __typename?: 'FacetValue';
-        id: string;
-        code: string;
-        name: string;
-        facet: Facet;
-    };
-
-    export type Facet = {
-        __typename?: 'Facet';
-        id: string;
-        name: string;
-    };
+export interface CreateShippingMethodMutationArgs {
+  
+  input: CreateShippingMethodInput;
 }
-
-export namespace ProductOptionGroup {
-    export type Fragment = {
-        __typename?: 'ProductOptionGroup';
-        id: string;
-        languageCode: LanguageCode;
-        code: string;
-        name: string;
-        translations: Translations[];
-        options: Options[];
-    };
-
-    export type Translations = {
-        __typename?: 'ProductOptionGroupTranslation';
-        name: string;
-    };
-
-    export type Options = {
-        __typename?: 'ProductOption';
-        id: string;
-        languageCode?: LanguageCode | null;
-        name?: string | null;
-        code?: string | null;
-        translations: _Translations[];
-    };
-
-    export type _Translations = {
-        __typename?: 'ProductOptionTranslation';
-        name: string;
-    };
+export interface UpdateShippingMethodMutationArgs {
+  
+  input: UpdateShippingMethodInput;
 }
-
-export namespace ProductCategory {
-    export type Fragment = {
-        __typename?: 'ProductCategory';
-        id: string;
-        name: string;
-        description: string;
-        languageCode?: LanguageCode | null;
-        featuredAsset?: FeaturedAsset | null;
-        assets: Assets[];
-        facetValues: FacetValues[];
-        translations: Translations[];
-        parent: Parent;
-        children?: Children[] | null;
-    };
-
-    export type FeaturedAsset = Asset.Fragment;
-
-    export type Assets = Asset.Fragment;
-
-    export type FacetValues = {
-        __typename?: 'FacetValue';
-        id: string;
-        name: string;
-        code: string;
-    };
-
-    export type Translations = {
-        __typename?: 'ProductCategoryTranslation';
-        id: string;
-        languageCode: LanguageCode;
-        name: string;
-        description: string;
-    };
-
-    export type Parent = {
-        __typename?: 'ProductCategory';
-        id: string;
-        name: string;
-    };
-
-    export type Children = {
-        __typename?: 'ProductCategory';
-        id: string;
-        name: string;
-    };
+export interface CreateTaxCategoryMutationArgs {
+  
+  input: CreateTaxCategoryInput;
 }
-
-export namespace AdjustmentOperation {
-    export type Fragment = {
-        __typename?: 'AdjustmentOperation';
-        args: Args[];
-        code: string;
-        description: string;
-    };
-
-    export type Args = {
-        __typename?: 'ConfigArg';
-        name: string;
-        type: string;
-        value?: string | null;
-    };
+export interface UpdateTaxCategoryMutationArgs {
+  
+  input: UpdateTaxCategoryInput;
 }
-
-export namespace Promotion {
-    export type Fragment = {
-        __typename?: 'Promotion';
-        id: string;
-        createdAt: DateTime;
-        updatedAt: DateTime;
-        name: string;
-        enabled: boolean;
-        conditions: Conditions[];
-        actions: Actions[];
-    };
-
-    export type Conditions = AdjustmentOperation.Fragment;
-
-    export type Actions = AdjustmentOperation.Fragment;
+export interface CreateTaxRateMutationArgs {
+  
+  input: CreateTaxRateInput;
 }
-
-export namespace Country {
-    export type Fragment = {
-        __typename?: 'Country';
-        id: string;
-        code: string;
-        name: string;
-        enabled: boolean;
-        translations: Translations[];
-    };
-
-    export type Translations = {
-        __typename?: 'CountryTranslation';
-        id: string;
-        languageCode: LanguageCode;
-        name: string;
-    };
+export interface UpdateTaxRateMutationArgs {
+  
+  input: UpdateTaxRateInput;
 }
-
-export namespace Zone {
-    export type Fragment = {
-        __typename?: 'Zone';
-        id: string;
-        name: string;
-        members: Members[];
-    };
-
-    export type Members = Country.Fragment;
+export interface CreateZoneMutationArgs {
+  
+  input: CreateZoneInput;
 }
-
-export namespace TaxCategory {
-    export type Fragment = {
-        __typename?: 'TaxCategory';
-        id: string;
-        name: string;
-    };
+export interface UpdateZoneMutationArgs {
+  
+  input: UpdateZoneInput;
 }
-
-export namespace TaxRate {
-    export type Fragment = {
-        __typename?: 'TaxRate';
-        id: string;
-        name: string;
-        enabled: boolean;
-        value: number;
-        category: Category;
-        zone: Zone;
-        customerGroup?: CustomerGroup | null;
-    };
-
-    export type Category = {
-        __typename?: 'TaxCategory';
-        id: string;
-        name: string;
-    };
-
-    export type Zone = {
-        __typename?: 'Zone';
-        id: string;
-        name: string;
-    };
-
-    export type CustomerGroup = {
-        __typename?: 'CustomerGroup';
-        id: string;
-        name: string;
-    };
+export interface DeleteZoneMutationArgs {
+  
+  id: string;
 }
-
-export namespace Channel {
-    export type Fragment = {
-        __typename?: 'Channel';
-        id: string;
-        code: string;
-        token: string;
-        pricesIncludeTax: boolean;
-        currencyCode: CurrencyCode;
-        defaultLanguageCode: LanguageCode;
-        defaultShippingZone?: DefaultShippingZone | null;
-        defaultTaxZone?: DefaultTaxZone | null;
-    };
-
-    export type DefaultShippingZone = {
-        __typename?: 'Zone';
-        id: string;
-        name: string;
-    };
-
-    export type DefaultTaxZone = {
-        __typename?: 'Zone';
-        id: string;
-        name: string;
-    };
+export interface AddMembersToZoneMutationArgs {
+  
+  zoneId: string;
+  
+  memberIds: string[];
 }
-
-export namespace PaymentMethod {
-    export type Fragment = {
-        __typename?: 'PaymentMethod';
-        id: string;
-        code: string;
-        enabled: boolean;
-        configArgs: ConfigArgs[];
-    };
-
-    export type ConfigArgs = {
-        __typename?: 'ConfigArg';
-        name: string;
-        type: string;
-        value?: string | null;
-    };
+export interface RemoveMembersFromZoneMutationArgs {
+  
+  zoneId: string;
+  
+  memberIds: string[];
 }
-
-export namespace GlobalSettings {
-    export type Fragment = {
-        __typename?: 'GlobalSettings';
-        availableLanguages: LanguageCode[];
-    };
+export interface SetAsLoggedInMutationArgs {
+  
+  username: string;
+  
+  loginTime: string;
+}
+export interface SetUiLanguageMutationArgs {
+  
+  languageCode?: Maybe<LanguageCode>;
 }
 
-export namespace ShippingMethod {
-    export type Fragment = {
-        __typename?: 'ShippingMethod';
-        id: string;
-        createdAt: DateTime;
-        updatedAt: DateTime;
-        code: string;
-        description: string;
-        checker: Checker;
-        calculator: Calculator;
-    };
-
-    export type Checker = AdjustmentOperation.Fragment;
 
-    export type Calculator = AdjustmentOperation.Fragment;
-}