Merge branch 'server-schema-codegen'

Closes #28

README.md

@@ -16,6 +16,16 @@ the server is located in the `server` directory.
 We will ship with an administration UI which is a stand-alone web application which can be used to perform tasks such
 as inventory, order and customer management. The code for this is located in the `admin-ui` directory.
 
+```
+vendure/
+├── admin-ui/       # Source of the admin ui app (an Angular CLI project)
+├── codegen/        # Scripts used to generate TypeScript types from the GraphQL schemas & documents
+├── docs/           # Documentation source (not much there yet)
+├── server/         # Source for the Vendure server
+├── shared/         # Types and utils shared by the server & admin ui
+
+```
+
 ## Development
 
 ### Server
@@ -39,8 +49,8 @@ Vendure uses [TypeORM](http://typeorm.io), so it compatible will any database wh
 
 ### Code Generation
 
-[apollo-cli](https://github.com/apollographql/apollo-cli) is used to automatically create TypeScript interfaces
-for all GraphQL queries used in the admin ui. These generated interfaces are used in both the admin ui and the server.
+[graphql-code-generator](https://github.com/dotansimha/graphql-code-generator) is used to automatically create TypeScript interfaces
+for all GraphQL server operations and admin ui queries. These generated interfaces are used in both the admin ui and the server.
 
 Run `yarn generate-gql-types` to generate TypeScript interfaces based on these queries. The generated
 types are located at [`./shared/generated-types.ts`](./shared/generated-types.ts).

admin-ui/src/app/administrator/components/admin-detail/admin-detail.component.ts

@@ -26,8 +26,8 @@ import { ServerConfigService } from '../../../data/server-config';
 })
 export class AdminDetailComponent extends BaseDetailComponent<Administrator> implements OnInit, OnDestroy {
     administrator$: Observable<Administrator>;
-    allRoles$: Observable<Role[]>;
-    selectedRoles: Role[] = [];
+    allRoles$: Observable<Role.Fragment[]>;
+    selectedRoles: Role.Fragment[] = [];
     administratorForm: FormGroup;
     selectedRolePermissions: { [K in Permission]: boolean } = {} as any;
 

admin-ui/src/app/administrator/components/administrator-list/administrator-list.component.ts

@@ -1,6 +1,6 @@
 import { Component } from '@angular/core';
 import { ActivatedRoute, Router } from '@angular/router';
-import { GetAdministrators, GetAdministrators_administrators_items } from 'shared/generated-types';
+import { GetAdministrators } from 'shared/generated-types';
 
 import { BaseListComponent } from '../../../common/base-list.component';
 import { DataService } from '../../../data/providers/data.service';
@@ -11,8 +11,8 @@ import { DataService } from '../../../data/providers/data.service';
     styleUrls: ['./administrator-list.component.scss'],
 })
 export class AdministratorListComponent extends BaseListComponent<
-    GetAdministrators,
-    GetAdministrators_administrators_items
+    GetAdministrators.Query,
+    GetAdministrators.Items
 > {
     constructor(private dataService: DataService, router: Router, route: ActivatedRoute) {
         super(router, route);

admin-ui/src/app/administrator/components/role-list/role-list.component.ts

@@ -1,6 +1,6 @@
 import { ChangeDetectionStrategy, Component } from '@angular/core';
 import { ActivatedRoute, Router } from '@angular/router';
-import { GetRoles, GetRoles_roles_items, Role } from 'shared/generated-types';
+import { GetRoles, Role } from 'shared/generated-types';
 import { CUSTOMER_ROLE_CODE, SUPER_ADMIN_ROLE_CODE } from 'shared/shared-constants';
 
 import { BaseListComponent } from '../../../common/base-list.component';
@@ -12,7 +12,7 @@ import { DataService } from '../../../data/providers/data.service';
     styleUrls: ['./role-list.component.scss'],
     changeDetection: ChangeDetectionStrategy.OnPush,
 })
-export class RoleListComponent extends BaseListComponent<GetRoles, GetRoles_roles_items> {
+export class RoleListComponent extends BaseListComponent<GetRoles.Query, GetRoles.Items> {
     constructor(private dataService: DataService, router: Router, route: ActivatedRoute) {
         super(router, route);
         super.setQueryFn(

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

@@ -5,7 +5,7 @@ import { BaseEntityResolver } from '../../../common/base-entity-resolver';
 import { DataService } from '../../../data/providers/data.service';
 
 @Injectable()
-export class AdministratorResolver extends BaseEntityResolver<Administrator> {
+export class AdministratorResolver extends BaseEntityResolver<Administrator.Fragment> {
     constructor(private dataService: DataService) {
         super(
             {

admin-ui/src/app/administrator/providers/routing/role-resolver.ts

@@ -5,7 +5,7 @@ import { BaseEntityResolver } from '../../../common/base-entity-resolver';
 import { DataService } from '../../../data/providers/data.service';
 
 @Injectable()
-export class RoleResolver extends BaseEntityResolver<Role> {
+export class RoleResolver extends BaseEntityResolver<Role.Fragment> {
     constructor(private dataService: DataService) {
         super(
             {

admin-ui/src/app/catalog/catalog.routes.ts

@@ -1,5 +1,5 @@
 import { Route } from '@angular/router';
-import { ProductWithVariants } from 'shared/generated-types';
+import { FacetWithValues, ProductWithVariants } from 'shared/generated-types';
 
 import { createResolveData } from '../common/base-entity-resolver';
 import { detailBreadcrumb } from '../common/detail-breadcrumb';
@@ -54,7 +54,7 @@ export const catalogRoutes: Route[] = [
 ];
 
 export function productBreadcrumb(data: any, params: any) {
-    return detailBreadcrumb<ProductWithVariants>({
+    return detailBreadcrumb<ProductWithVariants.Fragment>({
         entity: data.entity,
         id: params.id,
         breadcrumbKey: 'breadcrumb.products',
@@ -64,7 +64,7 @@ export function productBreadcrumb(data: any, params: any) {
 }
 
 export function facetBreadcrumb(data: any, params: any) {
-    return detailBreadcrumb<ProductWithVariants>({
+    return detailBreadcrumb<FacetWithValues.Fragment>({
         entity: data.entity,
         id: params.id,
         breadcrumbKey: 'breadcrumb.facets',

admin-ui/src/app/catalog/components/asset-list/asset-list.component.ts

@@ -3,7 +3,7 @@ import { ActivatedRoute, Router } from '@angular/router';
 import { PaginationInstance } from 'ngx-pagination';
 import { combineLatest, Observable } from 'rxjs';
 import { map } from 'rxjs/operators';
-import { GetAssetList, GetAssetList_assets_items } from 'shared/generated-types';
+import { GetAssetList } from 'shared/generated-types';
 
 import { BaseListComponent } from '../../../common/base-list.component';
 import { _ } from '../../../core/providers/i18n/mark-for-extraction';
@@ -15,7 +15,7 @@ import { DataService } from '../../../data/providers/data.service';
     templateUrl: './asset-list.component.html',
     styleUrls: ['./asset-list.component.scss'],
 })
-export class AssetListComponent extends BaseListComponent<GetAssetList, GetAssetList_assets_items>
+export class AssetListComponent extends BaseListComponent<GetAssetList.Query, GetAssetList.Items>
     implements OnInit {
     paginationConfig$: Observable<PaginationInstance>;
 

admin-ui/src/app/catalog/components/asset-picker-dialog/asset-picker-dialog.component.ts

@@ -2,7 +2,7 @@ import { ChangeDetectionStrategy, Component, OnInit } from '@angular/core';
 import { PaginationInstance } from 'ngx-pagination';
 import { Observable } from 'rxjs';
 import { map, tap } from 'rxjs/operators';
-import { Asset, GetAssetList, GetAssetListVariables } from 'shared/generated-types';
+import { Asset, GetAssetList } from 'shared/generated-types';
 
 import { _ } from '../../../core/providers/i18n/mark-for-extraction';
 import { NotificationService } from '../../../core/providers/notification/notification.service';
@@ -29,7 +29,7 @@ export class AssetPickerDialogComponent implements OnInit, Dialog<Asset[]> {
 
     resolveWith: (result?: Asset[]) => void;
     selection: Asset[] = [];
-    private listQuery: QueryResult<GetAssetList, GetAssetListVariables>;
+    private listQuery: QueryResult<GetAssetList.Query, GetAssetList.Variables>;
 
     constructor(private dataService: DataService, private notificationService: NotificationService) {}
 

admin-ui/src/app/catalog/components/create-option-group-dialog/create-option-group-dialog.component.ts

@@ -10,11 +10,11 @@ import { CreateOptionGroupFormComponent } from '../create-option-group-form/crea
     styleUrls: ['./create-option-group-dialog.component.scss'],
     changeDetection: ChangeDetectionStrategy.OnPush,
 })
-export class CreateOptionGroupDialogComponent implements Dialog<CreateProductOptionGroup> {
+export class CreateOptionGroupDialogComponent implements Dialog<CreateProductOptionGroup.Mutation> {
     productId: string;
     productName: string;
     @ViewChild('createOptionGroupForm') createOptionGroupForm: CreateOptionGroupFormComponent;
-    resolveWith: (result?: CreateProductOptionGroup) => void;
+    resolveWith: (result?: CreateProductOptionGroup.Mutation) => void;
 
     createOptionGroup() {
         this.createOptionGroupForm.createOptionGroup().subscribe(data => this.resolveWith(data));

admin-ui/src/app/catalog/components/create-option-group-form/create-option-group-form.component.ts

@@ -43,7 +43,7 @@ export class CreateOptionGroupFormComponent implements OnInit {
         }
     }
 
-    createOptionGroup(): Observable<CreateProductOptionGroup> {
+    createOptionGroup(): Observable<CreateProductOptionGroup.Mutation> {
         return this.dataService.product.createProductOptionGroups(this.createGroupFromForm());
     }
 

admin-ui/src/app/catalog/components/facet-detail/facet-detail.component.ts

@@ -6,7 +6,6 @@ import { map, mergeMap, take } from 'rxjs/operators';
 import {
     CreateFacetValueInput,
     FacetWithValues,
-    FacetWithValues_values,
     LanguageCode,
     UpdateFacetValueInput,
 } from 'shared/generated-types';
@@ -27,9 +26,10 @@ import { ServerConfigService } from '../../../data/server-config';
     styleUrls: ['./facet-detail.component.scss'],
     changeDetection: ChangeDetectionStrategy.OnPush,
 })
-export class FacetDetailComponent extends BaseDetailComponent<FacetWithValues> implements OnInit, OnDestroy {
-    facet$: Observable<FacetWithValues>;
-    values$: Observable<FacetWithValues_values[]>;
+export class FacetDetailComponent extends BaseDetailComponent<FacetWithValues.Fragment>
+    implements OnInit, OnDestroy {
+    facet$: Observable<FacetWithValues.Fragment>;
+    values$: Observable<FacetWithValues.Values[]>;
     customFields: CustomFieldConfig[];
     customValueFields: CustomFieldConfig[];
     facetForm: FormGroup;
@@ -189,7 +189,7 @@ export class FacetDetailComponent extends BaseDetailComponent<FacetWithValues> i
     /**
      * Sets the values of the form on changes to the facet or current language.
      */
-    protected setFormValues(facet: FacetWithValues, languageCode: LanguageCode) {
+    protected setFormValues(facet: FacetWithValues.Fragment, languageCode: LanguageCode) {
         const currentTranslation = facet.translations.find(t => t.languageCode === languageCode);
         if (currentTranslation) {
             this.facetForm.patchValue({
@@ -268,7 +268,7 @@ export class FacetDetailComponent extends BaseDetailComponent<FacetWithValues> i
      * can then be persisted to the API.
      */
     private getUpdatedFacet(
-        facet: FacetWithValues,
+        facet: FacetWithValues.Fragment,
         facetFormGroup: FormGroup,
         languageCode: LanguageCode,
     ): any {
@@ -283,7 +283,7 @@ export class FacetDetailComponent extends BaseDetailComponent<FacetWithValues> i
      * which can be persisted to the API.
      */
     private getUpdatedFacetValues(
-        facet: FacetWithValues,
+        facet: FacetWithValues.Fragment,
         valuesFormArray: FormArray,
         languageCode: LanguageCode,
     ): UpdateFacetValueInput[] {

admin-ui/src/app/catalog/components/facet-list/facet-list.component.ts

@@ -1,6 +1,6 @@
 import { Component } from '@angular/core';
 import { ActivatedRoute, Router } from '@angular/router';
-import { GetFacetList, GetFacetList_facets_items } from 'shared/generated-types';
+import { GetFacetList } from 'shared/generated-types';
 
 import { BaseListComponent } from '../../../common/base-list.component';
 import { DataService } from '../../../data/providers/data.service';
@@ -10,7 +10,7 @@ import { DataService } from '../../../data/providers/data.service';
     templateUrl: './facet-list.component.html',
     styleUrls: ['./facet-list.component.scss'],
 })
-export class FacetListComponent extends BaseListComponent<GetFacetList, GetFacetList_facets_items> {
+export class FacetListComponent extends BaseListComponent<GetFacetList.Query, GetFacetList.Items> {
     constructor(private dataService: DataService, router: Router, route: ActivatedRoute) {
         super(router, route);
         super.setQueryFn((...args: any[]) => this.dataService.facet.getFacets(...args), data => data.facets);

admin-ui/src/app/catalog/components/facet-value-selector/facet-value-selector.component.ts

@@ -4,7 +4,12 @@ import { FacetValue } from 'shared/generated-types';
 
 import { DataService } from '../../../data/providers/data.service';
 
-export type FacetValueSeletorItem = { name: string; facetName: string; id: string; value: FacetValue };
+export type FacetValueSeletorItem = {
+    name: string;
+    facetName: string;
+    id: string;
+    value: FacetValue.Fragment;
+};
 
 @Component({
     selector: 'vdr-facet-value-selector',
@@ -13,7 +18,7 @@ export type FacetValueSeletorItem = { name: string; facetName: string; id: strin
     changeDetection: ChangeDetectionStrategy.OnPush,
 })
 export class FacetValueSelectorComponent implements OnInit {
-    @Output() selectedValuesChange = new EventEmitter<FacetValue[]>();
+    @Output() selectedValuesChange = new EventEmitter<FacetValue.Fragment[]>();
 
     facetValues$: Observable<FacetValueSeletorItem[]>;
     constructor(private dataService: DataService) {}

admin-ui/src/app/catalog/components/generate-product-variants/generate-product-variants.component.ts

@@ -10,7 +10,7 @@ import { ProductVariantsWizardComponent } from '../product-variants-wizard/produ
     styleUrls: ['./generate-product-variants.component.scss'],
 })
 export class GenerateProductVariantsComponent {
-    @Input() product: ProductWithVariants;
+    @Input() product: ProductWithVariants.Fragment;
     @ViewChild('productVariantsWizard') productVariantsWizard: ProductVariantsWizardComponent;
     constructor(private dataService: DataService) {}
 

admin-ui/src/app/catalog/components/product-detail/product-detail.component.ts

@@ -7,7 +7,6 @@ import {
     CreateProductInput,
     LanguageCode,
     ProductWithVariants,
-    ProductWithVariants_variants,
     UpdateProductInput,
     UpdateProductVariantInput,
 } from 'shared/generated-types';
@@ -30,10 +29,10 @@ import { ApplyFacetDialogComponent } from '../apply-facet-dialog/apply-facet-dia
     styleUrls: ['./product-detail.component.scss'],
     changeDetection: ChangeDetectionStrategy.OnPush,
 })
-export class ProductDetailComponent extends BaseDetailComponent<ProductWithVariants>
+export class ProductDetailComponent extends BaseDetailComponent<ProductWithVariants.Fragment>
     implements OnInit, OnDestroy {
-    product$: Observable<ProductWithVariants>;
-    variants$: Observable<ProductWithVariants_variants[]>;
+    product$: Observable<ProductWithVariants.Fragment>;
+    variants$: Observable<ProductWithVariants.Variants[]>;
     customFields: CustomFieldConfig[];
     customVariantFields: CustomFieldConfig[];
     productForm: FormGroup;
@@ -206,7 +205,7 @@ export class ProductDetailComponent extends BaseDetailComponent<ProductWithVaria
     /**
      * Sets the values of the form on changes to the product or current language.
      */
-    protected setFormValues(product: ProductWithVariants, languageCode: LanguageCode) {
+    protected setFormValues(product: ProductWithVariants.Fragment, languageCode: LanguageCode) {
         const currentTranslation = product.translations.find(t => t.languageCode === languageCode);
         if (currentTranslation) {
             this.productForm.patchValue({
@@ -258,7 +257,7 @@ export class ProductDetailComponent extends BaseDetailComponent<ProductWithVaria
      * can then be persisted to the API.
      */
     private getUpdatedProduct(
-        product: ProductWithVariants,
+        product: ProductWithVariants.Fragment,
         productFormGroup: FormGroup,
         languageCode: LanguageCode,
     ): UpdateProductInput | CreateProductInput {
@@ -282,7 +281,7 @@ export class ProductDetailComponent extends BaseDetailComponent<ProductWithVaria
      * which can be persisted to the API.
      */
     private getUpdatedProductVariants(
-        product: ProductWithVariants,
+        product: ProductWithVariants.Fragment,
         variantsFormArray: FormArray,
         languageCode: LanguageCode,
     ): UpdateProductVariantInput[] {

admin-ui/src/app/catalog/components/product-list/product-list.component.ts

@@ -1,7 +1,7 @@
 import { Component } from '@angular/core';
 import { ActivatedRoute, Router } from '@angular/router';
 import { Observable } from 'rxjs';
-import { GetProductList, GetProductList_products_items } from 'shared/generated-types';
+import { GetProductList } from 'shared/generated-types';
 
 import { BaseListComponent } from '../../../common/base-list.component';
 import { DataService } from '../../../data/providers/data.service';
@@ -11,7 +11,7 @@ import { DataService } from '../../../data/providers/data.service';
     templateUrl: './product-list.component.html',
     styleUrls: ['./product-list.component.scss'],
 })
-export class ProductListComponent extends BaseListComponent<GetProductList, GetProductList_products_items> {
+export class ProductListComponent extends BaseListComponent<GetProductList.Query, GetProductList.Items> {
     constructor(private dataService: DataService, router: Router, route: ActivatedRoute) {
         super(router, route);
         super.setQueryFn(

admin-ui/src/app/catalog/components/product-variants-list/product-variants-list.component.ts

@@ -1,7 +1,6 @@
 import { ChangeDetectionStrategy, Component, Input } from '@angular/core';
 import { FormArray } from '@angular/forms';
-
-import { ProductWithVariants_variants } from 'shared/generated-types';
+import { ProductWithVariants } from 'shared/generated-types';
 
 @Component({
     selector: 'vdr-product-variants-list',
@@ -11,7 +10,7 @@ import { ProductWithVariants_variants } from 'shared/generated-types';
 })
 export class ProductVariantsListComponent {
     @Input('productVariantsFormArray') formArray: FormArray;
-    @Input() variants: ProductWithVariants_variants[];
+    @Input() variants: ProductWithVariants.Variants[];
     selectedVariantIds: string[] = [];
 
     areAllSelected(): boolean {

admin-ui/src/app/catalog/components/product-variants-wizard/product-variants-wizard.component.ts

@@ -17,11 +17,11 @@ import { SelectOptionGroupComponent } from '../select-option-group/select-option
     styleUrls: ['./product-variants-wizard.component.scss'],
 })
 export class ProductVariantsWizardComponent implements OnChanges {
-    @Input() product: ProductWithVariants;
+    @Input() product: ProductWithVariants.Fragment;
     @ViewChild('wizard') wizard: ClrWizard;
     @ViewChild('createOptionGroupForm') createOptionGroupForm: CreateOptionGroupFormComponent;
     @ViewChild('selectOptionGroup') selectOptionGroup: SelectOptionGroupComponent;
-    selectedOptionGroups: Array<Partial<ProductOptionGroup>> = [];
+    selectedOptionGroups: Array<Partial<ProductOptionGroup.Fragment>> = [];
     productVariantPreviewList: string[] = [];
     defaultPrice = 0;
     defaultSku = '';
@@ -72,7 +72,7 @@ export class ProductVariantsWizardComponent implements OnChanges {
         });
     }
 
-    toggleSelectedGroup(optionGroup: ProductOptionGroup) {
+    toggleSelectedGroup(optionGroup: ProductOptionGroup.Fragment) {
         const selected = !!this.selectedOptionGroups.find(og => og.id === optionGroup.id);
         if (selected) {
             this.selectedOptionGroups = this.selectedOptionGroups.filter(og => og.id !== optionGroup.id);

admin-ui/src/app/catalog/components/select-option-group-dialog/select-option-group-dialog.component.ts

@@ -1,5 +1,5 @@
 import { ChangeDetectionStrategy, Component } from '@angular/core';
-import { GetProductOptionGroups_productOptionGroups, ProductOptionGroup } from 'shared/generated-types';
+import { ProductOptionGroup } from 'shared/generated-types';
 
 import { Dialog } from '../../../shared/providers/modal/modal.service';
 
@@ -9,11 +9,11 @@ import { Dialog } from '../../../shared/providers/modal/modal.service';
     styleUrls: ['./select-option-group-dialog.component.scss'],
     changeDetection: ChangeDetectionStrategy.OnPush,
 })
-export class SelectOptionGroupDialogComponent implements Dialog<ProductOptionGroup> {
-    existingOptionGroups: Array<Partial<ProductOptionGroup>>;
-    resolveWith: (result?: ProductOptionGroup) => void;
+export class SelectOptionGroupDialogComponent implements Dialog<ProductOptionGroup.Fragment> {
+    existingOptionGroups: Array<Partial<ProductOptionGroup.Fragment>>;
+    resolveWith: (result?: ProductOptionGroup.Fragment) => void;
 
-    selectGroup(group: ProductOptionGroup) {
+    selectGroup(group: ProductOptionGroup.Fragment) {
         this.resolveWith(group);
     }
 

admin-ui/src/app/catalog/components/select-option-group/select-option-group.component.ts

@@ -11,11 +11,7 @@ import {
 import { FormControl } from '@angular/forms';
 import { Observable, Subject } from 'rxjs';
 import { debounceTime, map, takeUntil } from 'rxjs/operators';
-import {
-    GetProductOptionGroups,
-    GetProductOptionGroupsVariables,
-    ProductOptionGroup,
-} from 'shared/generated-types';
+import { GetProductOptionGroups, ProductOptionGroup } from 'shared/generated-types';
 import { DeepPartial } from 'shared/shared-types';
 
 import { DataService } from '../../../data/providers/data.service';
@@ -32,7 +28,7 @@ export class SelectOptionGroupComponent implements OnInit, OnChanges, OnDestroy
     @Output() selectGroup = new EventEmitter<ProductOptionGroup>();
     optionGroups$: Observable<Array<DeepPartial<ProductOptionGroup>>>;
     filterInput = new FormControl();
-    optionGroupsQuery: QueryResult<GetProductOptionGroups, GetProductOptionGroupsVariables>;
+    optionGroupsQuery: QueryResult<GetProductOptionGroups.Query, GetProductOptionGroups.Variables>;
     truncateOptionsTo = 4;
     private inputChange$ = new Subject<ProductOptionGroup[]>();
     private destroy$ = new Subject<void>();

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

@@ -9,7 +9,7 @@ import { DataService } from '../../../data/providers/data.service';
  * Resolves the id from the path into a Customer entity.
  */
 @Injectable()
-export class FacetResolver extends BaseEntityResolver<FacetWithValues> {
+export class FacetResolver extends BaseEntityResolver<FacetWithValues.Fragment> {
     constructor(private dataService: DataService) {
         super(
             {

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

@@ -10,7 +10,7 @@ import { DataService } from '../../../data/providers/data.service';
  */
 
 @Injectable()
-export class ProductResolver extends BaseEntityResolver<ProductWithVariants> {
+export class ProductResolver extends BaseEntityResolver<ProductWithVariants.Fragment> {
     constructor(private dataService: DataService) {
         super(
             {

admin-ui/src/app/common/base-entity-resolver.ts

@@ -23,7 +23,7 @@ export function createResolveData<T extends BaseEntityResolver<R>, R>(
 export class BaseEntityResolver<T> implements Resolve<Observable<T>> {
     constructor(
         private readonly emptyEntity: T,
-        private entityStream: (id: string) => Observable<T | null>,
+        private entityStream: (id: string) => Observable<T | null | undefined>,
     ) {}
 
     resolve(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): Observable<Observable<T>> {

admin-ui/src/app/common/utilities/create-updated-translatable.spec.ts

@@ -18,7 +18,7 @@ describe('createUpdatedTranslatable()', () => {
                 { languageCode: LanguageCode.en, name: 'Old Name EN' },
                 { languageCode: LanguageCode.de, name: 'Old Name DE' },
             ],
-        } as DeepPartial<ProductWithVariants>;
+        } as DeepPartial<ProductWithVariants.Fragment>;
     });
 
     it('returns a clone', () => {

admin-ui/src/app/core/providers/auth/auth.service.ts

@@ -17,7 +17,7 @@ export class AuthService {
      * Attempts to log in via the REST login endpoint and updates the app
      * state on success.
      */
-    logIn(username: string, password: string, rememberMe: boolean): Observable<SetAsLoggedIn> {
+    logIn(username: string, password: string, rememberMe: boolean): Observable<SetAsLoggedIn.Mutation> {
         return this.dataService.auth.attemptLogin(username, password, rememberMe).pipe(
             switchMap(response => {
                 this.setChannelToken(response.login.user.channelTokens[0]);

admin-ui/src/app/data/client-state/client-defaults.ts

@@ -1,20 +1,20 @@
-import { GetNetworkStatus, GetUiState, GetUserStatus, LanguageCode } from 'shared/generated-types';
+import { GetNetworkStatus, GetUiState, GetUserStatus } from 'shared/generated-types';
 
 import { getDefaultLanguage } from '../../common/utilities/get-default-language';
 
-export const clientDefaults: GetNetworkStatus & GetUserStatus & GetUiState = {
+export const clientDefaults = {
     networkStatus: {
         inFlightRequests: 0,
         __typename: 'NetworkStatus',
-    },
+    } as GetNetworkStatus.NetworkStatus,
     userStatus: {
         username: '',
         isLoggedIn: false,
         loginTime: '',
         __typename: 'UserStatus',
-    },
+    } as GetUserStatus.UserStatus,
     uiState: {
         language: getDefaultLanguage(),
         __typename: 'UiState',
-    },
+    } as GetUiState.UiState,
 };

admin-ui/src/app/data/client-state/client-resolvers.ts

@@ -4,10 +4,9 @@ import {
     GetNetworkStatus,
     GetUiState,
     GetUserStatus,
-    GetUserStatus_userStatus,
     LanguageCode,
-    SetAsLoggedInVariables,
-    SetUiLanguageVariables,
+    SetAsLoggedIn,
+    SetUiLanguage,
 } from 'shared/generated-types';
 
 import { GET_NEWTORK_STATUS } from '../definitions/local-definitions';
@@ -32,9 +31,9 @@ export const clientResolvers: ResolverDefinition = {
         requestCompleted: (_, args, { cache }): number => {
             return updateRequestsInFlight(cache, -1);
         },
-        setAsLoggedIn: (_, args: SetAsLoggedInVariables, { cache }): GetUserStatus_userStatus => {
+        setAsLoggedIn: (_, args: SetAsLoggedIn.Variables, { cache }): GetUserStatus.UserStatus => {
             const { username, loginTime } = args;
-            const data: GetUserStatus = {
+            const data: GetUserStatus.Query = {
                 userStatus: {
                     __typename: 'UserStatus',
                     username,
@@ -45,8 +44,8 @@ export const clientResolvers: ResolverDefinition = {
             cache.writeData({ data });
             return data.userStatus;
         },
-        setAsLoggedOut: (_, args, { cache }): GetUserStatus_userStatus => {
-            const data: GetUserStatus = {
+        setAsLoggedOut: (_, args, { cache }): GetUserStatus.UserStatus => {
+            const data: GetUserStatus.Query = {
                 userStatus: {
                     __typename: 'UserStatus',
                     username: '',
@@ -57,8 +56,8 @@ export const clientResolvers: ResolverDefinition = {
             cache.writeData({ data });
             return data.userStatus;
         },
-        setUiLanguage: (_, args: SetUiLanguageVariables, { cache }): LanguageCode => {
-            const data: GetUiState = {
+        setUiLanguage: (_, args: SetUiLanguage.Variables, { cache }): LanguageCode => {
+            const data: GetUiState.Query = {
                 uiState: {
                     __typename: 'UiState',
                     language: args.languageCode,
@@ -71,9 +70,9 @@ export const clientResolvers: ResolverDefinition = {
 };
 
 function updateRequestsInFlight(cache: InMemoryCache, increment: 1 | -1): number {
-    const previous = cache.readQuery<GetNetworkStatus>({ query: GET_NEWTORK_STATUS });
+    const previous = cache.readQuery<GetNetworkStatus.Query>({ query: GET_NEWTORK_STATUS });
     const inFlightRequests = previous.networkStatus.inFlightRequests + increment;
-    const data: GetNetworkStatus = {
+    const data: GetNetworkStatus.Query = {
         networkStatus: {
             __typename: 'NetworkStatus',
             inFlightRequests,

admin-ui/src/app/data/client-state/client-types.graphql

@@ -1,10 +1,10 @@
-extend type Query {
+type Query {
     networkStatus: NetworkStatus!
     userStatus: UserStatus!
     uiState: UiState!
 }
 
-extend type Mutation {
+type Mutation {
     requestStarted: Int!
     requestCompleted: Int!
     setAsLoggedIn(username: String!, loginTime: String!): UserStatus!

admin-ui/src/app/data/definitions/product-definitions.ts

@@ -7,7 +7,6 @@ export const ASSET_FRAGMENT = gql`
         fileSize
         mimeType
         type
-        name
         preview
         source
     }

admin-ui/src/app/data/providers/administrator-data.service.ts

@@ -1,25 +1,16 @@
-import { Observable } from 'rxjs';
 import {
     CreateAdministrator,
     CreateAdministratorInput,
-    CreateAdministratorVariables,
     CreateRole,
     CreateRoleInput,
-    CreateRoleVariables,
     GetAdministrator,
     GetAdministrators,
-    GetAdministratorsVariables,
-    GetAdministratorVariables,
     GetRole,
     GetRoles,
-    GetRolesVariables,
-    GetRoleVariables,
     UpdateAdministrator,
     UpdateAdministratorInput,
-    UpdateAdministratorVariables,
     UpdateRole,
     UpdateRoleInput,
-    UpdateRoleVariables,
 } from 'shared/generated-types';
 
 import {
@@ -32,47 +23,49 @@ import {
     UPDATE_ADMINISTRATOR,
     UPDATE_ROLE,
 } from '../definitions/administrator-definitions';
-import { QueryResult } from '../query-result';
 
 import { BaseDataService } from './base-data.service';
 
 export class AdministratorDataService {
     constructor(private baseDataService: BaseDataService) {}
 
-    getAdministrators(
-        take: number = 10,
-        skip: number = 0,
-    ): QueryResult<GetAdministrators, GetAdministratorsVariables> {
-        return this.baseDataService.query<GetAdministrators, GetAdministratorsVariables>(GET_ADMINISTRATORS, {
-            options: {
-                take,
-                skip,
+    getAdministrators(take: number = 10, skip: number = 0) {
+        return this.baseDataService.query<GetAdministrators.Query, GetAdministrators.Variables>(
+            GET_ADMINISTRATORS,
+            {
+                options: {
+                    take,
+                    skip,
+                },
             },
-        });
+        );
     }
 
-    getAdministrator(id: string): QueryResult<GetAdministrator, GetAdministratorVariables> {
-        return this.baseDataService.query<GetAdministrator, GetAdministratorVariables>(GET_ADMINISTRATOR, {
-            id,
-        });
+    getAdministrator(id: string) {
+        return this.baseDataService.query<GetAdministrator.Query, GetAdministrator.Variables>(
+            GET_ADMINISTRATOR,
+            {
+                id,
+            },
+        );
     }
 
-    createAdministrator(input: CreateAdministratorInput): Observable<CreateAdministrator> {
-        return this.baseDataService.mutate<CreateAdministrator, CreateAdministratorVariables>(
+    createAdministrator(input: CreateAdministratorInput) {
+        return this.baseDataService.mutate<CreateAdministrator.Mutation, CreateAdministrator.Variables>(
             CREATE_ADMINISTRATOR,
             { input },
         );
     }
 
-    updateAdministrator(input: UpdateAdministratorInput): Observable<UpdateAdministrator> {
-        return this.baseDataService.mutate<UpdateAdministrator, UpdateAdministratorVariables>(
+    updateAdministrator(input: UpdateAdministratorInput) {
+        return this.baseDataService.mutate<UpdateAdministrator.Mutation, UpdateAdministrator.Variables>(
             UPDATE_ADMINISTRATOR,
             { input },
         );
     }
 
-    getRoles(take: number = 10, skip: number = 0): QueryResult<GetRoles, GetRolesVariables> {
-        return this.baseDataService.query<GetRoles, GetRolesVariables>(GET_ROLES, {
+    getRoles(take: number = 10, skip: number = 0) {
+        return this.baseDataService.query<GetRoles.Query, GetRoles.Variables>(GET_ROLES, {
             options: {
                 take,
                 skip,
@@ -80,15 +73,15 @@ export class AdministratorDataService {
         });
     }
 
-    getRole(id: string): QueryResult<GetRole, GetRoleVariables> {
-        return this.baseDataService.query<GetRole, GetRoleVariables>(GET_ROLE, { id });
+    getRole(id: string) {
+        return this.baseDataService.query<GetRole.Query, GetRole.Variables>(GET_ROLE, { id });
     }
 
-    createRole(input: CreateRoleInput): Observable<CreateRole> {
-        return this.baseDataService.mutate<CreateRole, CreateRoleVariables>(CREATE_ROLE, { input });
+    createRole(input: CreateRoleInput) {
+        return this.baseDataService.mutate<CreateRole.Mutation, CreateRole.Variables>(CREATE_ROLE, { input });
     }
 
-    updateRole(input: UpdateRoleInput): Observable<UpdateRole> {
-        return this.baseDataService.mutate<UpdateRole, UpdateRoleVariables>(UPDATE_ROLE, { input });
+    updateRole(input: UpdateRoleInput) {
+        return this.baseDataService.mutate<UpdateRole.Mutation, UpdateRole.Variables>(UPDATE_ROLE, { input });
     }
 }

admin-ui/src/app/data/providers/auth-data.service.ts

@@ -1,27 +1,25 @@
-import { Observable } from 'rxjs';
-import { AttemptLogin, AttemptLoginVariables, GetCurrentUser, LogOut } from 'shared/generated-types';
+import { AttemptLogin, GetCurrentUser, LogOut } from 'shared/generated-types';
 
 import { ATTEMPT_LOGIN, GET_CURRENT_USER, LOG_OUT } from '../definitions/auth-definitions';
-import { QueryResult } from '../query-result';
 
 import { BaseDataService } from './base-data.service';
 
 export class AuthDataService {
     constructor(private baseDataService: BaseDataService) {}
 
-    checkLoggedIn(): QueryResult<GetCurrentUser> {
-        return this.baseDataService.query<GetCurrentUser>(GET_CURRENT_USER);
+    checkLoggedIn() {
+        return this.baseDataService.query<GetCurrentUser.Query>(GET_CURRENT_USER);
     }
 
-    attemptLogin(username: string, password: string, rememberMe: boolean): Observable<AttemptLogin> {
-        return this.baseDataService.mutate<AttemptLogin, AttemptLoginVariables>(ATTEMPT_LOGIN, {
+    attemptLogin(username: string, password: string, rememberMe: boolean) {
+        return this.baseDataService.mutate<AttemptLogin.Mutation, AttemptLogin.Variables>(ATTEMPT_LOGIN, {
             username,
             password,
             rememberMe,
         });
     }
 
-    logOut(): Observable<LogOut> {
-        return this.baseDataService.mutate<LogOut>(LOG_OUT);
+    logOut() {
+        return this.baseDataService.mutate<LogOut.Mutation>(LOG_OUT);
     }
 }

admin-ui/src/app/data/providers/client-data.service.ts

@@ -1,4 +1,3 @@
-import { Observable } from 'rxjs';
 import {
     GetNetworkStatus,
     GetUiState,
@@ -7,10 +6,7 @@ import {
     RequestCompleted,
     RequestStarted,
     SetAsLoggedIn,
-    SetAsLoggedInVariables,
-    SetAsLoggedOut,
     SetUiLanguage,
-    SetUiLanguageVariables,
 } from 'shared/generated-types';
 
 import {
@@ -23,7 +19,6 @@ import {
     SET_AS_LOGGED_OUT,
     SET_UI_LANGUAGE,
 } from '../definitions/local-definitions';
-import { QueryResult } from '../query-result';
 
 import { BaseDataService } from './base-data.service';
 
@@ -34,39 +29,42 @@ import { BaseDataService } from './base-data.service';
 export class ClientDataService {
     constructor(private baseDataService: BaseDataService) {}
 
-    startRequest(): Observable<RequestStarted> {
-        return this.baseDataService.mutate<RequestStarted>(REQUEST_STARTED);
+    startRequest() {
+        return this.baseDataService.mutate<RequestStarted.Mutation>(REQUEST_STARTED);
     }
 
-    completeRequest(): Observable<RequestCompleted> {
-        return this.baseDataService.mutate<RequestCompleted>(REQUEST_COMPLETED);
+    completeRequest() {
+        return this.baseDataService.mutate<RequestCompleted.Mutation>(REQUEST_COMPLETED);
     }
 
-    getNetworkStatus(): QueryResult<GetNetworkStatus> {
-        return this.baseDataService.query<GetNetworkStatus>(GET_NEWTORK_STATUS, {}, 'cache-first');
+    getNetworkStatus() {
+        return this.baseDataService.query<GetNetworkStatus.Query>(GET_NEWTORK_STATUS, {}, 'cache-first');
     }
 
-    loginSuccess(username: string): Observable<SetAsLoggedIn> {
-        return this.baseDataService.mutate<SetAsLoggedIn, SetAsLoggedInVariables>(SET_AS_LOGGED_IN, {
-            username,
-            loginTime: Date.now().toString(),
-        });
+    loginSuccess(username: string) {
+        return this.baseDataService.mutate<SetAsLoggedIn.Mutation, SetAsLoggedIn.Variables>(
+            SET_AS_LOGGED_IN,
+            {
+                username,
+                loginTime: Date.now().toString(),
+            },
+        );
     }
 
-    logOut(): Observable<SetAsLoggedOut> {
+    logOut() {
         return this.baseDataService.mutate(SET_AS_LOGGED_OUT);
     }
 
-    userStatus(): QueryResult<GetUserStatus> {
-        return this.baseDataService.query<GetUserStatus>(GET_USER_STATUS, {}, 'cache-first');
+    userStatus() {
+        return this.baseDataService.query<GetUserStatus.Query>(GET_USER_STATUS, {}, 'cache-first');
     }
 
-    uiState(): QueryResult<GetUiState> {
-        return this.baseDataService.query<GetUiState>(GET_UI_STATE, {}, 'cache-first');
+    uiState() {
+        return this.baseDataService.query<GetUiState.Query>(GET_UI_STATE, {}, 'cache-first');
     }
 
-    setUiLanguage(languageCode: LanguageCode): Observable<SetUiLanguage> {
-        return this.baseDataService.mutate<SetUiLanguage, SetUiLanguageVariables>(SET_UI_LANGUAGE, {
+    setUiLanguage(languageCode: LanguageCode) {
+        return this.baseDataService.mutate<SetUiLanguage.Mutation, SetUiLanguage.Variables>(SET_UI_LANGUAGE, {
             languageCode,
         });
     }

admin-ui/src/app/data/providers/facet-data.service.ts

@@ -1,26 +1,18 @@
-import { Observable } from 'rxjs';
 import {
     CreateFacet,
     CreateFacetInput,
     CreateFacetValueInput,
     CreateFacetValues,
-    CreateFacetValuesVariables,
-    CreateFacetVariables,
     GetFacetList,
-    GetFacetListVariables,
     GetFacetWithValues,
-    GetFacetWithValuesVariables,
     UpdateFacet,
     UpdateFacetInput,
     UpdateFacetValueInput,
     UpdateFacetValues,
-    UpdateFacetValuesVariables,
-    UpdateFacetVariables,
 } from 'shared/generated-types';
 import { pick } from 'shared/pick';
 
 import { getDefaultLanguage } from '../../common/utilities/get-default-language';
-import { addCustomFields } from '../add-custom-fields';
 import {
     CREATE_FACET,
     CREATE_FACET_VALUES,
@@ -29,15 +21,14 @@ import {
     UPDATE_FACET,
     UPDATE_FACET_VALUES,
 } from '../definitions/facet-definitions';
-import { QueryResult } from '../query-result';
 
 import { BaseDataService } from './base-data.service';
 
 export class FacetDataService {
     constructor(private baseDataService: BaseDataService) {}
 
-    getFacets(take: number = 10, skip: number = 0): QueryResult<GetFacetList, GetFacetListVariables> {
-        return this.baseDataService.query<GetFacetList, GetFacetListVariables>(GET_FACET_LIST, {
+    getFacets(take: number = 10, skip: number = 0) {
+        return this.baseDataService.query<GetFacetList.Query, GetFacetList.Variables>(GET_FACET_LIST, {
             options: {
                 take,
                 skip,
@@ -46,8 +37,8 @@ export class FacetDataService {
         });
     }
 
-    getFacet(id: string): QueryResult<GetFacetWithValues, GetFacetWithValuesVariables> {
-        return this.baseDataService.query<GetFacetWithValues, GetFacetWithValuesVariables>(
+    getFacet(id: string) {
+        return this.baseDataService.query<GetFacetWithValues.Query, GetFacetWithValues.Variables>(
             GET_FACET_WITH_VALUES,
             {
                 id,
@@ -56,35 +47,35 @@ export class FacetDataService {
         );
     }
 
-    createFacet(facet: CreateFacetInput): Observable<CreateFacet> {
-        const input: CreateFacetVariables = {
+    createFacet(facet: CreateFacetInput) {
+        const input: CreateFacet.Variables = {
             input: pick(facet, ['code', 'translations', 'values', 'customFields']),
         };
-        return this.baseDataService.mutate<CreateFacet, CreateFacetVariables>(CREATE_FACET, input);
+        return this.baseDataService.mutate<CreateFacet.Mutation, CreateFacet.Variables>(CREATE_FACET, input);
     }
 
-    updateFacet(facet: UpdateFacetInput): Observable<UpdateFacet> {
-        const input: UpdateFacetVariables = {
+    updateFacet(facet: UpdateFacetInput) {
+        const input: UpdateFacet.Variables = {
             input: pick(facet, ['id', 'code', 'translations', 'customFields']),
         };
-        return this.baseDataService.mutate<UpdateFacet, UpdateFacetVariables>(UPDATE_FACET, input);
+        return this.baseDataService.mutate<UpdateFacet.Mutation, UpdateFacet.Variables>(UPDATE_FACET, input);
     }
 
-    createFacetValues(facetValues: CreateFacetValueInput[]): Observable<CreateFacetValues> {
-        const input: CreateFacetValuesVariables = {
+    createFacetValues(facetValues: CreateFacetValueInput[]) {
+        const input: CreateFacetValues.Variables = {
             input: facetValues.map(pick(['facetId', 'code', 'translations', 'customFields'])),
         };
-        return this.baseDataService.mutate<CreateFacetValues, CreateFacetValuesVariables>(
+        return this.baseDataService.mutate<CreateFacetValues.Mutation, CreateFacetValues.Variables>(
             CREATE_FACET_VALUES,
             input,
         );
     }
 
-    updateFacetValues(facetValues: UpdateFacetValueInput[]): Observable<UpdateFacetValues> {
-        const input: UpdateFacetValuesVariables = {
+    updateFacetValues(facetValues: UpdateFacetValueInput[]) {
+        const input: UpdateFacetValues.Variables = {
             input: facetValues.map(pick(['id', 'code', 'translations', 'customFields'])),
         };
-        return this.baseDataService.mutate<UpdateFacetValues, UpdateFacetValuesVariables>(
+        return this.baseDataService.mutate<UpdateFacetValues.Mutation, UpdateFacetValues.Variables>(
             UPDATE_FACET_VALUES,
             input,
         );

admin-ui/src/app/data/providers/product-data.service.ts

@@ -1,40 +1,25 @@
-import { Observable } from 'rxjs';
 import {
     AddOptionGroupToProduct,
-    AddOptionGroupToProductVariables,
     ApplyFacetValuesToProductVariants,
-    ApplyFacetValuesToProductVariantsVariables,
     CreateAssets,
-    CreateAssetsVariables,
     CreateProduct,
     CreateProductInput,
     CreateProductOptionGroup,
     CreateProductOptionGroupInput,
-    CreateProductOptionGroupVariables,
-    CreateProductVariables,
     GenerateProductVariants,
-    GenerateProductVariantsVariables,
     GetAssetList,
-    GetAssetListVariables,
     GetProductList,
-    GetProductListVariables,
     GetProductOptionGroups,
-    GetProductOptionGroupsVariables,
     GetProductWithVariants,
-    GetProductWithVariantsVariables,
     RemoveOptionGroupFromProduct,
-    RemoveOptionGroupFromProductVariables,
     UpdateProduct,
     UpdateProductInput,
-    UpdateProductVariables,
     UpdateProductVariantInput,
     UpdateProductVariants,
-    UpdateProductVariantsVariables,
 } from 'shared/generated-types';
 import { pick } from 'shared/pick';
 
 import { getDefaultLanguage } from '../../common/utilities/get-default-language';
-import { addCustomFields } from '../add-custom-fields';
 import {
     ADD_OPTION_GROUP_TO_PRODUCT,
     APPLY_FACET_VALUE_TO_PRODUCT_VARIANTS,
@@ -50,15 +35,14 @@ import {
     UPDATE_PRODUCT,
     UPDATE_PRODUCT_VARIANTS,
 } from '../definitions/product-definitions';
-import { QueryResult } from '../query-result';
 
 import { BaseDataService } from './base-data.service';
 
 export class ProductDataService {
     constructor(private baseDataService: BaseDataService) {}
 
-    getProducts(take: number = 10, skip: number = 0): QueryResult<GetProductList, GetProductListVariables> {
-        return this.baseDataService.query<GetProductList, GetProductListVariables>(GET_PRODUCT_LIST, {
+    getProducts(take: number = 10, skip: number = 0) {
+        return this.baseDataService.query<GetProductList.Query, GetProductList.Variables>(GET_PRODUCT_LIST, {
             options: {
                 take,
                 skip,
@@ -67,8 +51,8 @@ export class ProductDataService {
         });
     }
 
-    getProduct(id: string): QueryResult<GetProductWithVariants, GetProductWithVariantsVariables> {
-        return this.baseDataService.query<GetProductWithVariants, GetProductWithVariantsVariables>(
+    getProduct(id: string) {
+        return this.baseDataService.query<GetProductWithVariants.Query, GetProductWithVariants.Variables>(
             GET_PRODUCT_WITH_VARIANTS,
             {
                 id,
@@ -77,75 +61,69 @@ export class ProductDataService {
         );
     }
 
-    createProduct(product: CreateProductInput): Observable<CreateProduct> {
-        const input: CreateProductVariables = {
+    createProduct(product: CreateProductInput) {
+        const input: CreateProduct.Variables = {
             input: pick(product, ['translations', 'customFields', 'assetIds', 'featuredAssetId']),
         };
-        return this.baseDataService.mutate<CreateProduct, CreateProductVariables>(CREATE_PRODUCT, input);
+        return this.baseDataService.mutate<CreateProduct.Mutation, CreateProduct.Variables>(
+            CREATE_PRODUCT,
+            input,
+        );
     }
 
-    updateProduct(product: UpdateProductInput): Observable<UpdateProduct> {
-        const input: UpdateProductVariables = {
+    updateProduct(product: UpdateProductInput) {
+        const input: UpdateProduct.Variables = {
             input: pick(product, ['id', 'translations', 'customFields', 'assetIds', 'featuredAssetId']),
         };
-        return this.baseDataService.mutate<UpdateProduct, UpdateProductVariables>(UPDATE_PRODUCT, input);
+        return this.baseDataService.mutate<UpdateProduct.Mutation, UpdateProduct.Variables>(
+            UPDATE_PRODUCT,
+            input,
+        );
     }
 
-    generateProductVariants(
-        productId: string,
-        defaultPrice?: number,
-        defaultSku?: string,
-    ): Observable<GenerateProductVariants> {
-        return this.baseDataService.mutate<GenerateProductVariants, GenerateProductVariantsVariables>(
-            GENERATE_PRODUCT_VARIANTS,
-            { productId, defaultPrice, defaultSku },
-        );
+    generateProductVariants(productId: string, defaultPrice?: number, defaultSku?: string) {
+        return this.baseDataService.mutate<
+            GenerateProductVariants.Mutation,
+            GenerateProductVariants.Variables
+        >(GENERATE_PRODUCT_VARIANTS, { productId, defaultPrice, defaultSku });
     }
 
-    updateProductVariants(variants: UpdateProductVariantInput[]): Observable<UpdateProductVariants> {
-        const input: UpdateProductVariantsVariables = {
+    updateProductVariants(variants: UpdateProductVariantInput[]) {
+        const input: UpdateProductVariants.Variables = {
             input: variants.map(pick(['id', 'translations', 'sku', 'price'])),
         };
-        return this.baseDataService.mutate<UpdateProductVariants, UpdateProductVariantsVariables>(
+        return this.baseDataService.mutate<UpdateProductVariants.Mutation, UpdateProductVariants.Variables>(
             UPDATE_PRODUCT_VARIANTS,
             input,
         );
     }
 
-    createProductOptionGroups(
-        productOptionGroup: CreateProductOptionGroupInput,
-    ): Observable<CreateProductOptionGroup> {
-        const input: CreateProductOptionGroupVariables = {
+    createProductOptionGroups(productOptionGroup: CreateProductOptionGroupInput) {
+        const input: CreateProductOptionGroup.Variables = {
             input: productOptionGroup,
         };
-        return this.baseDataService.mutate<CreateProductOptionGroup, CreateProductOptionGroupVariables>(
-            CREATE_PRODUCT_OPTION_GROUP,
-            input,
-        );
+        return this.baseDataService.mutate<
+            CreateProductOptionGroup.Mutation,
+            CreateProductOptionGroup.Variables
+        >(CREATE_PRODUCT_OPTION_GROUP, input);
     }
 
-    addOptionGroupToProduct(
-        variables: AddOptionGroupToProductVariables,
-    ): Observable<AddOptionGroupToProduct> {
-        return this.baseDataService.mutate<AddOptionGroupToProduct, AddOptionGroupToProductVariables>(
-            ADD_OPTION_GROUP_TO_PRODUCT,
-            variables,
-        );
+    addOptionGroupToProduct(variables: AddOptionGroupToProduct.Variables) {
+        return this.baseDataService.mutate<
+            AddOptionGroupToProduct.Mutation,
+            AddOptionGroupToProduct.Variables
+        >(ADD_OPTION_GROUP_TO_PRODUCT, variables);
     }
 
-    removeOptionGroupFromProduct(
-        variables: RemoveOptionGroupFromProductVariables,
-    ): Observable<RemoveOptionGroupFromProduct> {
+    removeOptionGroupFromProduct(variables: RemoveOptionGroupFromProduct.Variables) {
         return this.baseDataService.mutate<
-            RemoveOptionGroupFromProduct,
-            RemoveOptionGroupFromProductVariables
+            RemoveOptionGroupFromProduct.Mutation,
+            RemoveOptionGroupFromProduct.Variables
         >(REMOVE_OPTION_GROUP_FROM_PRODUCT, variables);
     }
 
-    getProductOptionGroups(
-        filterTerm?: string,
-    ): QueryResult<GetProductOptionGroups, GetProductOptionGroupsVariables> {
-        return this.baseDataService.query<GetProductOptionGroups, GetProductOptionGroupsVariables>(
+    getProductOptionGroups(filterTerm?: string) {
+        return this.baseDataService.query<GetProductOptionGroups.Query, GetProductOptionGroups.Variables>(
             GET_PRODUCT_OPTION_GROUPS,
             {
                 filterTerm,
@@ -154,21 +132,18 @@ export class ProductDataService {
         );
     }
 
-    applyFacetValuesToProductVariants(
-        facetValueIds: string[],
-        productVariantIds: string[],
-    ): Observable<ApplyFacetValuesToProductVariants> {
+    applyFacetValuesToProductVariants(facetValueIds: string[], productVariantIds: string[]) {
         return this.baseDataService.mutate<
-            ApplyFacetValuesToProductVariants,
-            ApplyFacetValuesToProductVariantsVariables
+            ApplyFacetValuesToProductVariants.Mutation,
+            ApplyFacetValuesToProductVariants.Variables
         >(APPLY_FACET_VALUE_TO_PRODUCT_VARIANTS, {
             facetValueIds,
             productVariantIds,
         });
     }
 
-    getAssetList(take: number = 10, skip: number = 0): QueryResult<GetAssetList, GetAssetListVariables> {
-        return this.baseDataService.query<GetAssetList, GetAssetListVariables>(GET_ASSET_LIST, {
+    getAssetList(take: number = 10, skip: number = 0) {
+        return this.baseDataService.query<GetAssetList.Query, GetAssetList.Variables>(GET_ASSET_LIST, {
             options: {
                 skip,
                 take,
@@ -176,8 +151,8 @@ export class ProductDataService {
         });
     }
 
-    createAssets(files: File[]): Observable<CreateAssets> {
-        return this.baseDataService.mutate<CreateAssets, CreateAssetsVariables>(CREATE_ASSETS, {
+    createAssets(files: File[]) {
+        return this.baseDataService.mutate<CreateAssets.Mutation, CreateAssets.Variables>(CREATE_ASSETS, {
             input: files.map(file => ({ file })),
         });
     }

admin-ui/src/app/data/server-config.ts

@@ -1,10 +1,10 @@
 import { Injectable, Injector } from '@angular/core';
-import { GetServerConfig, GetServerConfig_config } from 'shared/generated-types';
+import { GetServerConfig } from 'shared/generated-types';
 
 import { GET_SERVER_CONFIG } from './definitions/config-definitions';
 import { BaseDataService } from './providers/base-data.service';
 
-export type ServerConfig = GetServerConfig_config;
+export type ServerConfig = GetServerConfig.Config;
 
 export function initializeServerConfigService(serverConfigService: ServerConfigService): () => Promise<any> {
     return serverConfigService.init();
@@ -28,7 +28,7 @@ export class ServerConfigService {
         const baseDataService = this.injector.get<BaseDataService>(BaseDataService);
         return () =>
             baseDataService
-                .query<GetServerConfig>(GET_SERVER_CONFIG)
+                .query<GetServerConfig.Query>(GET_SERVER_CONFIG)
                 .single$.toPromise()
                 .then(
                     result => {

codegen/client-schema.ts

@@ -0,0 +1,30 @@
+import * as fs from 'fs';
+import { makeExecutableSchema } from 'graphql-tools';
+import * as path from 'path';
+
+const CLIENT_SCHEMA_FILE = '../admin-ui/src/app/data/client-state/client-types.graphql';
+const LANGUAGE_CODE_FILE = '../server/src/common/types/language-code.graphql';
+
+function loadGraphQL(file: string): string {
+  const filePath = path.join(__dirname, file);
+  return fs.readFileSync(filePath, 'utf8');
+}
+
+/**
+ * Augments the client schema (used by apollo-link-state) with missing
+ * definitions, to allow the codegen step to work correctly.
+ * See: https://github.com/dotansimha/graphql-code-generator/issues/583
+ */
+function getClientSchema() {
+    const clientDirective = `
+        directive @client on FIELD
+    `;
+    const clientSchemaString = loadGraphQL(CLIENT_SCHEMA_FILE);
+    const languageCodeString = loadGraphQL(LANGUAGE_CODE_FILE);
+    const schema = makeExecutableSchema({
+        typeDefs: [clientSchemaString, clientDirective, languageCodeString],
+    });
+    return schema;
+}
+
+export default getClientSchema();

codegen/download-introspection-schema.ts

@@ -0,0 +1,45 @@
+import * as fs from 'fs';
+import { introspectionQuery } from 'graphql';
+import * as http from 'http';
+import * as path from 'path';
+
+import { API_PATH, API_PORT } from '../shared/shared-constants';
+
+// tslint:disable:no-console
+
+/**
+ * Makes an introspection query to the Vendure server and writes the result to a
+ * schema.json file.
+ *
+ * If there is an error connecting to the server, the promise resolves to false.
+ */
+export function downloadIntrospectionSchema(outputFilePath: string): Promise<boolean> {
+    const body = JSON.stringify({ query: introspectionQuery });
+
+    return new Promise((resolve, reject) => {
+        const request = http.request({
+            method: 'post',
+            host: 'localhost',
+            port: API_PORT,
+            path: '/' + API_PATH,
+            headers: {
+                'Content-Type': 'application/json',
+                'Content-Length': Buffer.byteLength(body),
+            },
+        }, response => {
+            const outputFile = fs.createWriteStream(outputFilePath);
+            response.pipe(outputFile);
+            response.on('end', () => resolve(true));
+            response.on('error', reject);
+        });
+        request.write(body);
+        request.end();
+        request.on('error', (err: any) => {
+            if (err.code === 'ECONNREFUSED') {
+                console.error(`ERROR: Could not connect to the Vendure server at http://localhost:${API_PORT}/${API_PATH}`);
+                resolve(false);
+            }
+            reject(err);
+        });
+    });
+}

codegen/generate-graphql-types.ts

@@ -0,0 +1,33 @@
+import { generate } from 'graphql-code-generator';
+import * as 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 SCHEMA_OUTPUT_FILE = path.join(__dirname, '../schema.json');
+
+// tslint:disable:no-console
+
+downloadIntrospectionSchema(SCHEMA_OUTPUT_FILE)
+    .then((downloaded) => {
+        if (!downloaded) {
+            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'),
+            overwrite: true,
+            args: [CLIENT_QUERY_FILES],
+        });
+    })
+    .then(result => {
+            process.exit(0);
+        },
+        err => {
+            console.error(err);
+            process.exit(1);
+        });

generate-graphql-types.ts

@@ -1,106 +0,0 @@
-import { spawn } from 'child_process';
-import * as fs from 'fs';
-
-import { API_PATH, API_PORT } from './shared/shared-constants';
-
-// tslint:disable:no-console
-const API_URL = `http://localhost:${API_PORT}/${API_PATH}`;
-const SCHEMA_JSON_FILE = './schema.json';
-const CLIENT_SCHEMA_FILES = './admin-ui/src/app/data/client-state/client-types.graphql';
-const CLIENT_QUERY_FILES = '"./admin-ui/src/app/data/definitions/*.ts"';
-const TYPESCRIPT_DEFINITIONS_FILE = './shared/generated-types.ts';
-
-main().catch(e => {
-    console.log('Could not generate types!', e);
-    process.exitCode = 1;
-});
-
-/**
- * This script uses apollo-codegen to generate TypeScript interfaces for all
- * GraphQL queries defined in the admin-ui app. Run it via the package.json
- * script "generate-gql-types".
- */
-async function main(): Promise<void> {
-    try {
-        await downloadSchemaFromApi(API_URL, SCHEMA_JSON_FILE);
-    } catch {
-        console.log('Could not connect to Vendure server. Attempting to build typed from existing schema.json');
-    }
-    await generateTypeScriptTypesFromSchema(
-        SCHEMA_JSON_FILE,
-        CLIENT_SCHEMA_FILES,
-        CLIENT_QUERY_FILES,
-        TYPESCRIPT_DEFINITIONS_FILE,
-    );
-}
-
-/**
- * Downloads the schema from the provided GraphQL endpoint using the `apollo schema:download`
- * cli command and returns the result as an IntrospectionQuery object.
- */
-async function downloadSchemaFromApi(apiEndpoint: string, outputFile: string): Promise<void> {
-    console.log(`Downloading schema from ${API_URL}`);
-    const TEMP_API_SCHEMA = '../schema.temp.json';
-    await runCommand('yarn', ['apollo', 'schema:download', TEMP_API_SCHEMA, `--endpoint=${API_URL}`]);
-
-    console.log(`Downloaded schema from ${API_URL}`);
-
-    const schemaFromApi = fs.readFileSync(TEMP_API_SCHEMA, { encoding: 'utf8' });
-    fs.unlinkSync(TEMP_API_SCHEMA);
-    const introspectionSchema = JSON.parse(schemaFromApi);
-    fs.writeFileSync(
-        SCHEMA_JSON_FILE,
-        JSON.stringify({
-            __schema: introspectionSchema,
-        }),
-    );
-}
-
-/**
- * Generates TypeScript definitions from the provided schema json file sing the `apollo codegen:generate` cli command.
- */
-async function generateTypeScriptTypesFromSchema(
-    schemaFile: string,
-    clientSchemaFiles: string,
-    queryFiles: string,
-    outputFile: string,
-): Promise<number> {
-    return runCommand('yarn', [
-        'apollo',
-        'codegen:generate',
-        outputFile,
-        '--addTypename',
-        '--outputFlat',
-        '--target=typescript',
-        `--clientSchema=${clientSchemaFiles}`,
-        `--queries=${queryFiles}`,
-        `--schema=${schemaFile}`,
-    ]);
-}
-
-/**
- * Runs a command-line command and resolves when completed.
- */
-function runCommand(command: string, args: string[]): Promise<number> {
-    return new Promise((resolve, reject) => {
-        const cp = spawn(command, args, { shell: true });
-
-        cp.on('error', reject);
-        cp.stdout.on('data', data => {
-            if (4 < data.length) {
-                console.log(`${data}`);
-            }
-        });
-        cp.stderr.on('data', data => {
-            if (4 < data.length) {
-                console.log(`${data}`);
-            }
-        });
-        cp.on('close', code => {
-            if (code !== 0) {
-                reject(code);
-            }
-            resolve(code);
-        });
-    });
-}

package.json

@@ -3,7 +3,7 @@
   "version": "0.1.0",
   "scripts": {
     "apollo": "apollo",
-    "generate-gql-types": "ts-node generate-graphql-types.ts",
+    "generate-gql-types": "ts-node ./codegen/generate-graphql-types.ts",
     "postinstall": "cd admin-ui && yarn && cd ../server && yarn",
     "test": "cd admin-ui && yarn test --watch=false --browsers=ChromeHeadlessCI --progress=false && cd ../server && yarn test && yarn test:e2e",
     "format": "prettier --write",
@@ -14,7 +14,10 @@
     "prepush": "yarn test && cd admin-ui && yarn build --prod"
   },
   "devDependencies": {
-    "apollo": "^1.7.1",
+    "graphql": "^14.0.2",
+    "graphql-code-generator": "^0.12.6",
+    "graphql-codegen-typescript-template": "^0.12.6",
+    "graphql-tools": "^4.0.0",
     "husky": "^0.14.3",
     "lint-staged": "^7.2.0",
     "prettier": "^1.13.7",

server/e2e/administrator.e2e-spec.ts

@@ -1,13 +1,9 @@
 import {
     Administrator,
     CreateAdministrator,
-    CreateAdministratorVariables,
     GetAdministrator,
     GetAdministrators,
-    GetAdministratorsVariables,
-    GetAdministratorVariables,
     UpdateAdministrator,
-    UpdateAdministratorVariables,
 } from 'shared/generated-types';
 
 import {
@@ -23,7 +19,7 @@ import { TestServer } from './test-server';
 describe('Administrator resolver', () => {
     const client = new TestClient();
     const server = new TestServer();
-    let createdAdmin: Administrator;
+    let createdAdmin: Administrator.Fragment;
 
     beforeAll(async () => {
         const token = await server.init({
@@ -38,13 +34,15 @@ describe('Administrator resolver', () => {
     });
 
     it('administrators', async () => {
-        const result = await client.query<GetAdministrators, GetAdministratorsVariables>(GET_ADMINISTRATORS);
+        const result = await client.query<GetAdministrators.Query, GetAdministrators.Variables>(
+            GET_ADMINISTRATORS,
+        );
         expect(result.administrators.items.length).toBe(1);
         expect(result.administrators.totalItems).toBe(1);
     });
 
     it('createAdministrator', async () => {
-        const result = await client.query<CreateAdministrator, CreateAdministratorVariables>(
+        const result = await client.query<CreateAdministrator.Mutation, CreateAdministrator.Variables>(
             CREATE_ADMINISTRATOR,
             {
                 input: {
@@ -62,14 +60,17 @@ describe('Administrator resolver', () => {
     });
 
     it('administrator', async () => {
-        const result = await client.query<GetAdministrator, GetAdministratorVariables>(GET_ADMINISTRATOR, {
-            id: createdAdmin.id,
-        });
+        const result = await client.query<GetAdministrator.Query, GetAdministrator.Variables>(
+            GET_ADMINISTRATOR,
+            {
+                id: createdAdmin.id,
+            },
+        );
         expect(result.administrator).toEqual(createdAdmin);
     });
 
     it('updateAdministrator', async () => {
-        const result = await client.query<UpdateAdministrator, UpdateAdministratorVariables>(
+        const result = await client.query<UpdateAdministrator.Mutation, UpdateAdministrator.Variables>(
             UPDATE_ADMINISTRATOR,
             {
                 input: {
@@ -86,7 +87,7 @@ describe('Administrator resolver', () => {
     });
 
     it('updateAdministrator works with partial input', async () => {
-        const result = await client.query<UpdateAdministrator, UpdateAdministratorVariables>(
+        const result = await client.query<UpdateAdministrator.Mutation, UpdateAdministrator.Variables>(
             UPDATE_ADMINISTRATOR,
             {
                 input: {
@@ -102,7 +103,7 @@ describe('Administrator resolver', () => {
 
     it('updateAdministrator throws with invalid roleId', async () => {
         try {
-            const result = await client.query<UpdateAdministrator, UpdateAdministratorVariables>(
+            const result = await client.query<UpdateAdministrator.Mutation, UpdateAdministrator.Variables>(
                 UPDATE_ADMINISTRATOR,
                 {
                     input: {

server/e2e/auth.e2e-spec.ts

@@ -1,21 +1,16 @@
 import { DocumentNode } from 'graphql';
 import gql from 'graphql-tag';
 import {
-    AssignRoleToAdministrator,
-    AssignRoleToAdministratorVariables,
-    AttemptLoginVariables,
     CreateAdministrator,
-    CreateAdministratorVariables,
-    CreateProductVariables,
+    CreateProductMutationArgs,
     CreateRole,
-    CreateRoleVariables,
+    LoginMutationArgs,
     Permission,
-    UpdateProductVariables,
+    UpdateProductMutationArgs,
 } from 'shared/generated-types';
 import { SUPER_ADMIN_USER_IDENTIFIER, SUPER_ADMIN_USER_PASSWORD } from 'shared/shared-constants';
 
 import {
-    ASSIGN_ROLE_TO_ADMINISTRATOR,
     CREATE_ADMINISTRATOR,
     CREATE_ROLE,
 } from '../../admin-ui/src/app/data/definitions/administrator-definitions';
@@ -46,12 +41,12 @@ describe('Authorization & permissions', () => {
     });
 
     describe('Anonymous user', () => {
-        beforeAll(() => {
-            client.asAnonymousUser();
+        beforeAll(async () => {
+            await client.asAnonymousUser();
         });
 
         it('can attempt login', async () => {
-            await assertRequestAllowed<AttemptLoginVariables>(ATTEMPT_LOGIN, {
+            await assertRequestAllowed<LoginMutationArgs>(ATTEMPT_LOGIN, {
                 username: SUPER_ADMIN_USER_IDENTIFIER,
                 password: SUPER_ADMIN_USER_PASSWORD,
                 rememberMe: false,
@@ -73,7 +68,7 @@ describe('Authorization & permissions', () => {
         });
 
         it('cannot uppdate', async () => {
-            await assertRequestForbidden<UpdateProductVariables>(UPDATE_PRODUCT, {
+            await assertRequestForbidden<UpdateProductMutationArgs>(UPDATE_PRODUCT, {
                 input: {
                     id: '1',
                     translations: [],
@@ -82,7 +77,7 @@ describe('Authorization & permissions', () => {
         });
 
         it('cannot create', async () => {
-            await assertRequestForbidden<CreateProductVariables>(CREATE_PRODUCT, {
+            await assertRequestForbidden<CreateProductMutationArgs>(CREATE_PRODUCT, {
                 input: {
                     translations: [],
                 },
@@ -157,7 +152,7 @@ describe('Authorization & permissions', () => {
         code: string,
         permissions: Permission[],
     ): Promise<{ identifier: string; password: string }> {
-        const roleResult = await client.query<CreateRole, CreateRoleVariables>(CREATE_ROLE, {
+        const roleResult = await client.query<CreateRole.Mutation, CreateRole.Variables>(CREATE_ROLE, {
             input: {
                 code,
                 description: '',
@@ -172,7 +167,7 @@ describe('Authorization & permissions', () => {
             .substr(2, 8)}`;
         const password = `test`;
 
-        const adminResult = await client.query<CreateAdministrator, CreateAdministratorVariables>(
+        const adminResult = await client.query<CreateAdministrator.Mutation, CreateAdministrator.Variables>(
             CREATE_ADMINISTRATOR,
             {
                 input: {

server/e2e/product.e2e-spec.ts

@@ -1,28 +1,17 @@
 import {
     AddOptionGroupToProduct,
-    AddOptionGroupToProductVariables,
     ApplyFacetValuesToProductVariants,
-    ApplyFacetValuesToProductVariantsVariables,
     CreateProduct,
-    CreateProduct_createProduct,
-    CreateProductVariables,
     GenerateProductVariants,
-    GenerateProductVariants_generateVariantsForProduct_variants,
-    GenerateProductVariantsVariables,
     GetAssetList,
-    GetAssetListVariables,
     GetProductList,
-    GetProductListVariables,
     GetProductWithVariants,
-    GetProductWithVariantsVariables,
     LanguageCode,
+    ProductWithVariants,
     RemoveOptionGroupFromProduct,
-    RemoveOptionGroupFromProductVariables,
     SortOrder,
     UpdateProduct,
-    UpdateProductVariables,
     UpdateProductVariants,
-    UpdateProductVariantsVariables,
 } from 'shared/generated-types';
 import { omit } from 'shared/omit';
 
@@ -62,52 +51,64 @@ describe('Product resolver', () => {
 
     describe('products list query', () => {
         it('returns all products when no options passed', async () => {
-            const result = await client.query<GetProductList, GetProductListVariables>(GET_PRODUCT_LIST, {
-                languageCode: LanguageCode.en,
-            });
+            const result = await client.query<GetProductList.Query, GetProductList.Variables>(
+                GET_PRODUCT_LIST,
+                {
+                    languageCode: LanguageCode.en,
+                },
+            );
 
             expect(result.products.items.length).toBe(20);
             expect(result.products.totalItems).toBe(20);
         });
 
         it('limits result set with skip & take', async () => {
-            const result = await client.query<GetProductList, GetProductListVariables>(GET_PRODUCT_LIST, {
-                languageCode: LanguageCode.en,
-                options: {
-                    skip: 0,
-                    take: 3,
+            const result = await client.query<GetProductList.Query, GetProductList.Variables>(
+                GET_PRODUCT_LIST,
+                {
+                    languageCode: LanguageCode.en,
+                    options: {
+                        skip: 0,
+                        take: 3,
+                    },
                 },
-            });
+            );
 
             expect(result.products.items.length).toBe(3);
             expect(result.products.totalItems).toBe(20);
         });
 
         it('filters by name', async () => {
-            const result = await client.query<GetProductList, GetProductListVariables>(GET_PRODUCT_LIST, {
-                languageCode: LanguageCode.en,
-                options: {
-                    filter: {
-                        name: {
-                            contains: 'fish',
+            const result = await client.query<GetProductList.Query, GetProductList.Variables>(
+                GET_PRODUCT_LIST,
+                {
+                    languageCode: LanguageCode.en,
+                    options: {
+                        filter: {
+                            name: {
+                                contains: 'fish',
+                            },
                         },
                     },
                 },
-            });
+            );
 
             expect(result.products.items.length).toBe(1);
             expect(result.products.items[0].name).toBe('en Practical Frozen Fish');
         });
 
         it('sorts by name', async () => {
-            const result = await client.query<GetProductList, GetProductListVariables>(GET_PRODUCT_LIST, {
-                languageCode: LanguageCode.en,
-                options: {
-                    sort: {
-                        name: SortOrder.ASC,
+            const result = await client.query<GetProductList.Query, GetProductList.Variables>(
+                GET_PRODUCT_LIST,
+                {
+                    languageCode: LanguageCode.en,
+                    options: {
+                        sort: {
+                            name: SortOrder.ASC,
+                        },
                     },
                 },
-            });
+            );
 
             expect(result.products.items.map(p => p.name)).toMatchSnapshot();
         });
@@ -115,7 +116,7 @@ describe('Product resolver', () => {
 
     describe('product query', () => {
         it('returns expected properties', async () => {
-            const result = await client.query<GetProductWithVariants, GetProductWithVariantsVariables>(
+            const result = await client.query<GetProductWithVariants.Query, GetProductWithVariants.Variables>(
                 GET_PRODUCT_WITH_VARIANTS,
                 {
                     languageCode: LanguageCode.en,
@@ -132,7 +133,7 @@ describe('Product resolver', () => {
         });
 
         it('returns null when id not found', async () => {
-            const result = await client.query<GetProductWithVariants, GetProductWithVariantsVariables>(
+            const result = await client.query<GetProductWithVariants.Query, GetProductWithVariants.Variables>(
                 GET_PRODUCT_WITH_VARIANTS,
                 {
                     languageCode: LanguageCode.en,
@@ -145,89 +146,103 @@ describe('Product resolver', () => {
     });
 
     describe('product mutation', () => {
-        let newProduct: CreateProduct_createProduct;
+        let newProduct: ProductWithVariants.Fragment;
 
         it('createProduct creates a new Product', async () => {
-            const result = await client.query<CreateProduct, CreateProductVariables>(CREATE_PRODUCT, {
-                input: {
-                    translations: [
-                        {
-                            languageCode: LanguageCode.en,
-                            name: 'en Baked Potato',
-                            slug: 'en-baked-potato',
-                            description: 'A baked potato',
-                        },
-                        {
-                            languageCode: LanguageCode.de,
-                            name: 'de Baked Potato',
-                            slug: 'de-baked-potato',
-                            description: 'Eine baked Erdapfel',
-                        },
-                    ],
+            const result = await client.query<CreateProduct.Mutation, CreateProduct.Variables>(
+                CREATE_PRODUCT,
+                {
+                    input: {
+                        translations: [
+                            {
+                                languageCode: LanguageCode.en,
+                                name: 'en Baked Potato',
+                                slug: 'en-baked-potato',
+                                description: 'A baked potato',
+                            },
+                            {
+                                languageCode: LanguageCode.de,
+                                name: 'de Baked Potato',
+                                slug: 'de-baked-potato',
+                                description: 'Eine baked Erdapfel',
+                            },
+                        ],
+                    },
                 },
-            });
+            );
             newProduct = result.createProduct;
             expect(newProduct).toMatchSnapshot();
         });
 
         it('createProduct creates a new Product with assets', async () => {
-            const assetsResult = await client.query<GetAssetList, GetAssetListVariables>(GET_ASSET_LIST);
+            const assetsResult = await client.query<GetAssetList.Query, GetAssetList.Variables>(
+                GET_ASSET_LIST,
+            );
             const assetIds = assetsResult.assets.items.slice(0, 2).map(a => a.id);
             const featuredAssetId = assetsResult.assets.items[0].id;
 
-            const result = await client.query<CreateProduct, CreateProductVariables>(CREATE_PRODUCT, {
-                input: {
-                    assetIds,
-                    featuredAssetId,
-                    translations: [
-                        {
-                            languageCode: LanguageCode.en,
-                            name: 'en Has Assets',
-                            slug: 'en-has-assets',
-                            description: 'A product with assets',
-                        },
-                    ],
+            const result = await client.query<CreateProduct.Mutation, CreateProduct.Variables>(
+                CREATE_PRODUCT,
+                {
+                    input: {
+                        assetIds,
+                        featuredAssetId,
+                        translations: [
+                            {
+                                languageCode: LanguageCode.en,
+                                name: 'en Has Assets',
+                                slug: 'en-has-assets',
+                                description: 'A product with assets',
+                            },
+                        ],
+                    },
                 },
-            });
+            );
             expect(result.createProduct.assets.map(a => a.id)).toEqual(assetIds);
             expect(result.createProduct.featuredAsset!.id).toBe(featuredAssetId);
         });
 
         it('updateProduct updates a Product', async () => {
-            const result = await client.query<UpdateProduct, UpdateProductVariables>(UPDATE_PRODUCT, {
-                input: {
-                    id: newProduct.id,
-                    translations: [
-                        {
-                            languageCode: LanguageCode.en,
-                            name: 'en Mashed Potato',
-                            slug: 'en-mashed-potato',
-                            description: 'A blob of mashed potato',
-                        },
-                        {
-                            languageCode: LanguageCode.de,
-                            name: 'de Mashed Potato',
-                            slug: 'de-mashed-potato',
-                            description: 'Eine blob von gemashed Erdapfel',
-                        },
-                    ],
+            const result = await client.query<UpdateProduct.Mutation, UpdateProduct.Variables>(
+                UPDATE_PRODUCT,
+                {
+                    input: {
+                        id: newProduct.id,
+                        translations: [
+                            {
+                                languageCode: LanguageCode.en,
+                                name: 'en Mashed Potato',
+                                slug: 'en-mashed-potato',
+                                description: 'A blob of mashed potato',
+                            },
+                            {
+                                languageCode: LanguageCode.de,
+                                name: 'de Mashed Potato',
+                                slug: 'de-mashed-potato',
+                                description: 'Eine blob von gemashed Erdapfel',
+                            },
+                        ],
+                    },
                 },
-            });
+            );
             expect(result.updateProduct).toMatchSnapshot();
         });
 
         it('updateProduct accepts partial input', async () => {
-            const result = await client.query<UpdateProduct, UpdateProductVariables>(UPDATE_PRODUCT, {
-                input: {
-                    id: newProduct.id,
-                    translations: [
-                        {
-                            languageCode: LanguageCode.en,
-                            name: 'en Very Mashed Potato',
-                        },
-                    ],
+            const result = await client.query<UpdateProduct.Mutation, UpdateProduct.Variables>(
+                UPDATE_PRODUCT,
+                {
+                    input: {
+                        id: newProduct.id,
+                        translations: [
+                            {
+                                languageCode: LanguageCode.en,
+                                name: 'en Very Mashed Potato',
+                            },
+                        ],
+                    },
                 },
-            });
+            );
             expect(result.updateProduct.translations.length).toBe(2);
             expect(result.updateProduct.translations[0].name).toBe('en Very Mashed Potato');
             expect(result.updateProduct.translations[0].description).toBe('A blob of mashed potato');
@@ -235,43 +250,51 @@ describe('Product resolver', () => {
         });
 
         it('updateProduct adds Assets to a product and sets featured asset', async () => {
-            const assetsResult = await client.query<GetAssetList, GetAssetListVariables>(GET_ASSET_LIST);
+            const assetsResult = await client.query<GetAssetList.Query, GetAssetList.Variables>(
+                GET_ASSET_LIST,
+            );
             const assetIds = assetsResult.assets.items.map(a => a.id);
             const featuredAssetId = assetsResult.assets.items[2].id;
 
-            const result = await client.query<UpdateProduct, UpdateProductVariables>(UPDATE_PRODUCT, {
-                input: {
-                    id: newProduct.id,
-                    assetIds,
-                    featuredAssetId,
+            const result = await client.query<UpdateProduct.Mutation, UpdateProduct.Variables>(
+                UPDATE_PRODUCT,
+                {
+                    input: {
+                        id: newProduct.id,
+                        assetIds,
+                        featuredAssetId,
+                    },
                 },
-            });
+            );
             expect(result.updateProduct.assets.map(a => a.id)).toEqual(assetIds);
             expect(result.updateProduct.featuredAsset!.id).toBe(featuredAssetId);
         });
 
         it('updateProduct sets a featured asset', async () => {
-            const productResult = await client.query<GetProductWithVariants, GetProductWithVariantsVariables>(
-                GET_PRODUCT_WITH_VARIANTS,
-                {
-                    id: newProduct.id,
-                    languageCode: LanguageCode.en,
-                },
-            );
+            const productResult = await client.query<
+                GetProductWithVariants.Query,
+                GetProductWithVariants.Variables
+            >(GET_PRODUCT_WITH_VARIANTS, {
+                id: newProduct.id,
+                languageCode: LanguageCode.en,
+            });
             const assets = productResult.product!.assets;
 
-            const result = await client.query<UpdateProduct, UpdateProductVariables>(UPDATE_PRODUCT, {
-                input: {
-                    id: newProduct.id,
-                    featuredAssetId: assets[0].id,
+            const result = await client.query<UpdateProduct.Mutation, UpdateProduct.Variables>(
+                UPDATE_PRODUCT,
+                {
+                    input: {
+                        id: newProduct.id,
+                        featuredAssetId: assets[0].id,
+                    },
                 },
-            });
+            );
             expect(result.updateProduct.featuredAsset!.id).toBe(assets[0].id);
         });
 
         it('updateProduct errors with an invalid productId', async () => {
             try {
-                await client.query<UpdateProduct, UpdateProductVariables>(UPDATE_PRODUCT, {
+                await client.query<UpdateProduct.Mutation, UpdateProduct.Variables>(UPDATE_PRODUCT, {
                     input: {
                         id: '999',
                         translations: [
@@ -299,20 +322,20 @@ describe('Product resolver', () => {
         });
 
         it('addOptionGroupToProduct adds an option group', async () => {
-            const result = await client.query<AddOptionGroupToProduct, AddOptionGroupToProductVariables>(
-                ADD_OPTION_GROUP_TO_PRODUCT,
-                {
-                    optionGroupId: 'T_1',
-                    productId: newProduct.id,
-                },
-            );
+            const result = await client.query<
+                AddOptionGroupToProduct.Mutation,
+                AddOptionGroupToProduct.Variables
+            >(ADD_OPTION_GROUP_TO_PRODUCT, {
+                optionGroupId: 'T_1',
+                productId: newProduct.id,
+            });
             expect(result.addOptionGroupToProduct.optionGroups.length).toBe(1);
             expect(result.addOptionGroupToProduct.optionGroups[0].id).toBe('T_1');
         });
 
         it('addOptionGroupToProduct errors with an invalid productId', async () => {
             try {
-                await client.query<AddOptionGroupToProduct, AddOptionGroupToProductVariables>(
+                await client.query<AddOptionGroupToProduct.Mutation, AddOptionGroupToProduct.Variables>(
                     ADD_OPTION_GROUP_TO_PRODUCT,
                     {
                         optionGroupId: 'T_1',
@@ -329,7 +352,7 @@ describe('Product resolver', () => {
 
         it('addOptionGroupToProduct errors with an invalid optionGroupId', async () => {
             try {
-                await client.query<AddOptionGroupToProduct, AddOptionGroupToProductVariables>(
+                await client.query<AddOptionGroupToProduct.Mutation, AddOptionGroupToProduct.Variables>(
                     ADD_OPTION_GROUP_TO_PRODUCT,
                     {
                         optionGroupId: '999',
@@ -346,8 +369,8 @@ describe('Product resolver', () => {
 
         it('removeOptionGroupFromProduct removes an option group', async () => {
             const result = await client.query<
-                RemoveOptionGroupFromProduct,
-                RemoveOptionGroupFromProductVariables
+                RemoveOptionGroupFromProduct.Mutation,
+                RemoveOptionGroupFromProduct.Variables
             >(REMOVE_OPTION_GROUP_FROM_PRODUCT, {
                 optionGroupId: '1',
                 productId: '1',
@@ -357,13 +380,13 @@ describe('Product resolver', () => {
 
         it('removeOptionGroupFromProduct errors with an invalid productId', async () => {
             try {
-                await client.query<RemoveOptionGroupFromProduct, RemoveOptionGroupFromProductVariables>(
-                    REMOVE_OPTION_GROUP_FROM_PRODUCT,
-                    {
-                        optionGroupId: '1',
-                        productId: '999',
-                    },
-                );
+                await client.query<
+                    RemoveOptionGroupFromProduct.Mutation,
+                    RemoveOptionGroupFromProduct.Variables
+                >(REMOVE_OPTION_GROUP_FROM_PRODUCT, {
+                    optionGroupId: '1',
+                    productId: '999',
+                });
                 fail('Should have thrown');
             } catch (err) {
                 expect(err.message).toEqual(
@@ -373,17 +396,17 @@ describe('Product resolver', () => {
         });
 
         describe('variants', () => {
-            let variants: GenerateProductVariants_generateVariantsForProduct_variants[];
+            let variants: ProductWithVariants.Variants[];
 
             it('generateVariantsForProduct generates variants', async () => {
-                const result = await client.query<GenerateProductVariants, GenerateProductVariantsVariables>(
-                    GENERATE_PRODUCT_VARIANTS,
-                    {
-                        productId: newProduct.id,
-                        defaultPrice: 123,
-                        defaultSku: 'ABC',
-                    },
-                );
+                const result = await client.query<
+                    GenerateProductVariants.Mutation,
+                    GenerateProductVariants.Variables
+                >(GENERATE_PRODUCT_VARIANTS, {
+                    productId: newProduct.id,
+                    defaultPrice: 123,
+                    defaultSku: 'ABC',
+                });
                 variants = result.generateVariantsForProduct.variants;
                 expect(variants.length).toBe(2);
                 expect(variants[0].options.length).toBe(1);
@@ -392,7 +415,7 @@ describe('Product resolver', () => {
 
             it('generateVariantsForProduct throws with an invalid productId', async () => {
                 try {
-                    await client.query<GenerateProductVariants, GenerateProductVariantsVariables>(
+                    await client.query<GenerateProductVariants.Mutation, GenerateProductVariants.Variables>(
                         GENERATE_PRODUCT_VARIANTS,
                         {
                             productId: '999',
@@ -408,19 +431,19 @@ describe('Product resolver', () => {
 
             it('updateProductVariants updates variants', async () => {
                 const firstVariant = variants[0];
-                const result = await client.query<UpdateProductVariants, UpdateProductVariantsVariables>(
-                    UPDATE_PRODUCT_VARIANTS,
-                    {
-                        input: [
-                            {
-                                id: firstVariant.id,
-                                translations: firstVariant.translations,
-                                sku: 'ABC',
-                                price: 432,
-                            },
-                        ],
-                    },
-                );
+                const result = await client.query<
+                    UpdateProductVariants.Mutation,
+                    UpdateProductVariants.Variables
+                >(UPDATE_PRODUCT_VARIANTS, {
+                    input: [
+                        {
+                            id: firstVariant.id,
+                            translations: firstVariant.translations,
+                            sku: 'ABC',
+                            price: 432,
+                        },
+                    ],
+                });
                 const updatedVariant = result.updateProductVariants[0];
                 if (!updatedVariant) {
                     fail('no updated variant returned.');
@@ -432,7 +455,7 @@ describe('Product resolver', () => {
 
             it('updateProductVariants throws with an invalid variant id', async () => {
                 try {
-                    await client.query<UpdateProductVariants, UpdateProductVariantsVariables>(
+                    await client.query<UpdateProductVariants.Mutation, UpdateProductVariants.Variables>(
                         UPDATE_PRODUCT_VARIANTS,
                         {
                             input: [
@@ -455,8 +478,8 @@ describe('Product resolver', () => {
 
             it('applyFacetValuesToProductVariants adds facets to variants', async () => {
                 const result = await client.query<
-                    ApplyFacetValuesToProductVariants,
-                    ApplyFacetValuesToProductVariantsVariables
+                    ApplyFacetValuesToProductVariants.Mutation,
+                    ApplyFacetValuesToProductVariants.Variables
                 >(APPLY_FACET_VALUE_TO_PRODUCT_VARIANTS, {
                     facetValueIds: ['1', '3', '5'],
                     productVariantIds: variants.map(v => v.id),
@@ -470,8 +493,8 @@ describe('Product resolver', () => {
             it('applyFacetValuesToProductVariants errors with invalid facet value id', async () => {
                 try {
                     await client.query<
-                        ApplyFacetValuesToProductVariants,
-                        ApplyFacetValuesToProductVariantsVariables
+                        ApplyFacetValuesToProductVariants.Mutation,
+                        ApplyFacetValuesToProductVariants.Variables
                     >(APPLY_FACET_VALUE_TO_PRODUCT_VARIANTS, {
                         facetValueIds: ['999', '888'],
                         productVariantIds: variants.map(v => v.id),
@@ -487,8 +510,8 @@ describe('Product resolver', () => {
             it('applyFacetValuesToProductVariants errors with invalid variant id', async () => {
                 try {
                     await client.query<
-                        ApplyFacetValuesToProductVariants,
-                        ApplyFacetValuesToProductVariantsVariables
+                        ApplyFacetValuesToProductVariants.Mutation,
+                        ApplyFacetValuesToProductVariants.Variables
                     >(APPLY_FACET_VALUE_TO_PRODUCT_VARIANTS, {
                         facetValueIds: ['1', '3', '5'],
                         productVariantIds: ['999'],

server/e2e/role.e2e-spec.ts

@@ -1,15 +1,4 @@
-import {
-    CreateRole,
-    CreateRoleVariables,
-    GetRole,
-    GetRoles,
-    GetRolesVariables,
-    GetRoleVariables,
-    Permission,
-    Role,
-    UpdateRole,
-    UpdateRoleVariables,
-} from 'shared/generated-types';
+import { CreateRole, GetRole, GetRoles, Permission, Role, UpdateRole } from 'shared/generated-types';
 import { omit } from 'shared/omit';
 import { CUSTOMER_ROLE_CODE, SUPER_ADMIN_ROLE_CODE } from 'shared/shared-constants';
 
@@ -26,8 +15,8 @@ import { TestServer } from './test-server';
 describe('Role resolver', () => {
     const client = new TestClient();
     const server = new TestServer();
-    let createdRole: Role;
-    let defaultRoles: Role[];
+    let createdRole: Role.Fragment;
+    let defaultRoles: Role.Fragment[];
 
     beforeAll(async () => {
         const token = await server.init({
@@ -42,7 +31,7 @@ describe('Role resolver', () => {
     });
 
     it('roles', async () => {
-        const result = await client.query<GetRoles, GetRolesVariables>(GET_ROLES);
+        const result = await client.query<GetRoles.Query, GetRoles.Variables>(GET_ROLES);
 
         defaultRoles = result.roles.items;
         expect(result.roles.items.length).toBe(2);
@@ -50,7 +39,7 @@ describe('Role resolver', () => {
     });
 
     it('createRole', async () => {
-        const result = await client.query<CreateRole, CreateRoleVariables>(CREATE_ROLE, {
+        const result = await client.query<CreateRole.Mutation, CreateRole.Variables>(CREATE_ROLE, {
             input: {
                 code: 'test',
                 description: 'test role',
@@ -63,12 +52,12 @@ describe('Role resolver', () => {
     });
 
     it('role', async () => {
-        const result = await client.query<GetRole, GetRoleVariables>(GET_ROLE, { id: createdRole.id });
+        const result = await client.query<GetRole.Query, GetRole.Variables>(GET_ROLE, { id: createdRole.id });
         expect(result.role).toEqual(createdRole);
     });
 
     it('updateRole', async () => {
-        const result = await client.query<UpdateRole, UpdateRoleVariables>(UPDATE_ROLE, {
+        const result = await client.query<UpdateRole.Mutation, UpdateRole.Variables>(UPDATE_ROLE, {
             input: {
                 id: createdRole.id,
                 code: 'test-modified',
@@ -81,7 +70,7 @@ describe('Role resolver', () => {
     });
 
     it('updateRole works with partial input', async () => {
-        const result = await client.query<UpdateRole, UpdateRoleVariables>(UPDATE_ROLE, {
+        const result = await client.query<UpdateRole.Mutation, UpdateRole.Variables>(UPDATE_ROLE, {
             input: {
                 id: createdRole.id,
                 code: 'test-modified-again',
@@ -104,7 +93,7 @@ describe('Role resolver', () => {
             return;
         }
         try {
-            const result = await client.query<UpdateRole, UpdateRoleVariables>(UPDATE_ROLE, {
+            const result = await client.query<UpdateRole.Mutation, UpdateRole.Variables>(UPDATE_ROLE, {
                 input: {
                     id: superAdminRole.id,
                     code: 'superadmin-modified',
@@ -127,7 +116,7 @@ describe('Role resolver', () => {
             return;
         }
         try {
-            const result = await client.query<UpdateRole, UpdateRoleVariables>(UPDATE_ROLE, {
+            const result = await client.query<UpdateRole.Mutation, UpdateRole.Variables>(UPDATE_ROLE, {
                 input: {
                     id: customerRole.id,
                     code: 'customer-modified',

server/mock-data/mock-data.service.ts

@@ -4,21 +4,17 @@ import gql from 'graphql-tag';
 import * as path from 'path';
 import {
     AddOptionGroupToProduct,
-    AddOptionGroupToProductVariables,
     Asset,
+    CreateAddressInput,
+    CreateCustomerInput,
     CreateFacet,
     CreateFacetValueWithFacetInput,
-    CreateFacetVariables,
     CreateProduct,
     CreateProductOptionGroup,
-    CreateProductOptionGroupVariables,
-    CreateProductVariables,
     GenerateProductVariants,
-    GenerateProductVariantsVariables,
     LanguageCode,
     ProductTranslationInput,
     UpdateProductVariants,
-    UpdateProductVariantsVariables,
 } from 'shared/generated-types';
 
 import { CREATE_FACET } from '../../admin-ui/src/app/data/definitions/facet-definitions';
@@ -29,9 +25,7 @@ import {
     GENERATE_PRODUCT_VARIANTS,
     UPDATE_PRODUCT_VARIANTS,
 } from '../../admin-ui/src/app/data/definitions/product-definitions';
-import { CreateAddressDto } from '../src/entity/address/address.dto';
 import { Channel } from '../src/entity/channel/channel.entity';
-import { CreateCustomerDto } from '../src/entity/customer/customer.dto';
 import { Customer } from '../src/entity/customer/customer.entity';
 
 import { SimpleGraphQLClient } from './simple-graphql-client';
@@ -68,31 +62,34 @@ export class MockDataService {
 
     async populateOptions(): Promise<string> {
         return this.client
-            .query<CreateProductOptionGroup, CreateProductOptionGroupVariables>(CREATE_PRODUCT_OPTION_GROUP, {
-                input: {
-                    code: 'size',
-                    translations: [
-                        { languageCode: LanguageCode.en, name: 'Size' },
-                        { languageCode: LanguageCode.de, name: 'Größe' },
-                    ],
-                    options: [
-                        {
-                            code: 'small',
-                            translations: [
-                                { languageCode: LanguageCode.en, name: 'Small' },
-                                { languageCode: LanguageCode.de, name: 'Klein' },
-                            ],
-                        },
-                        {
-                            code: 'large',
-                            translations: [
-                                { languageCode: LanguageCode.en, name: 'Large' },
-                                { languageCode: LanguageCode.de, name: 'Groß' },
-                            ],
-                        },
-                    ],
+            .query<CreateProductOptionGroup.Mutation, CreateProductOptionGroup.Variables>(
+                CREATE_PRODUCT_OPTION_GROUP,
+                {
+                    input: {
+                        code: 'size',
+                        translations: [
+                            { languageCode: LanguageCode.en, name: 'Size' },
+                            { languageCode: LanguageCode.de, name: 'Größe' },
+                        ],
+                        options: [
+                            {
+                                code: 'small',
+                                translations: [
+                                    { languageCode: LanguageCode.en, name: 'Small' },
+                                    { languageCode: LanguageCode.de, name: 'Klein' },
+                                ],
+                            },
+                            {
+                                code: 'large',
+                                translations: [
+                                    { languageCode: LanguageCode.en, name: 'Large' },
+                                    { languageCode: LanguageCode.de, name: 'Groß' },
+                                ],
+                            },
+                        ],
+                    },
                 },
-            })
+            )
             .then(data => {
                 this.log('Created option group:', data.createProductOptionGroup.name);
                 return data.createProductOptionGroup.id;
@@ -119,7 +116,7 @@ export class MockDataService {
                     lastName,
                     emailAddress: faker.internet.email(firstName, lastName),
                     phoneNumber: faker.phone.phoneNumber(),
-                } as CreateCustomerDto,
+                } as CreateCustomerInput,
                 password: 'test',
             };
 
@@ -129,7 +126,7 @@ export class MockDataService {
 
             if (customer) {
                 const query2 = gql`
-                    mutation($customerId: ID!, $input: CreateAddressInput) {
+                    mutation($customerId: ID!, $input: CreateAddressInput!) {
                         createCustomerAddress(customerId: $customerId, input: $input) {
                             id
                             streetLine1
@@ -145,7 +142,7 @@ export class MockDataService {
                         province: faker.address.county(),
                         postalCode: faker.address.zipCode(),
                         country: faker.address.country(),
-                    } as CreateAddressDto,
+                    } as CreateAddressInput,
                     customerId: customer.id,
                 };
 
@@ -181,7 +178,7 @@ export class MockDataService {
             // get 2 (pseudo) random asset ids
             const randomAssets = this.shuffleArray(assets).slice(0, 2);
 
-            const variables: CreateProductVariables = {
+            const variables: CreateProduct.Variables = {
                 input: {
                     translations: languageCodes.map(code =>
                         this.makeProductTranslation(code, name, slug, description),
@@ -192,7 +189,7 @@ export class MockDataService {
             };
 
             const product = await this.client
-                .query<CreateProduct, CreateProductVariables>(query, variables)
+                .query<CreateProduct.Mutation, CreateProduct.Variables>(query, variables)
                 .then(
                     data => {
                         this.log(`Created Product ${i + 1}:`, data.createProduct.name);
@@ -202,7 +199,7 @@ export class MockDataService {
                 );
 
             if (product) {
-                await this.client.query<AddOptionGroupToProduct, AddOptionGroupToProductVariables>(
+                await this.client.query<AddOptionGroupToProduct.Mutation, AddOptionGroupToProduct.Variables>(
                     ADD_OPTION_GROUP_TO_PRODUCT,
                     {
                         productId: product.createProduct.id,
@@ -219,7 +216,7 @@ export class MockDataService {
                     delete variantDE.id;
                     variant.translations.push(variantDE);
                 }
-                await this.client.query<UpdateProductVariants, UpdateProductVariantsVariables>(
+                await this.client.query<UpdateProductVariants.Mutation, UpdateProductVariants.Variables>(
                     UPDATE_PRODUCT_VARIANTS,
                     {
                         input: variants.map(({ id, translations, sku, price }) => ({
@@ -235,7 +232,7 @@ export class MockDataService {
     }
 
     async populateFacets() {
-        await this.client.query<CreateFacet, CreateFacetVariables>(CREATE_FACET, {
+        await this.client.query<CreateFacet.Mutation, CreateFacet.Variables>(CREATE_FACET, {
             input: {
                 code: 'brand',
                 translations: [
@@ -287,9 +284,9 @@ export class MockDataService {
         };
     }
 
-    private async makeProductVariant(productId: string): Promise<GenerateProductVariants> {
+    private async makeProductVariant(productId: string): Promise<GenerateProductVariants.Mutation> {
         const query = GENERATE_PRODUCT_VARIANTS;
-        return this.client.query<GenerateProductVariants, GenerateProductVariantsVariables>(query, {
+        return this.client.query<GenerateProductVariants.Mutation, GenerateProductVariants.Variables>(query, {
             productId,
             defaultSku: faker.random.alphaNumeric(5),
             defaultPrice: faker.random.number({

server/mock-data/simple-graphql-client.ts

@@ -63,7 +63,7 @@ export class SimpleGraphQLClient {
      * Upload spec: https://github.com/jaydenseric/graphql-multipart-request-spec
      * Discussion of issue: https://github.com/jaydenseric/apollo-upload-client/issues/32
      */
-    uploadAssets(filePaths: string[]): Promise<CreateAssets> {
+    uploadAssets(filePaths: string[]): Promise<CreateAssets.Mutation> {
         return new Promise((resolve, reject) => {
             const curl = new Curl();
 
@@ -132,7 +132,6 @@ export class SimpleGraphQLClient {
                             identifier
                             channelTokens
                         }
-                        token
                     }
                 }
             `,

server/src/api/resolvers/administrator.resolver.ts

@@ -1,11 +1,12 @@
 import { Args, Mutation, Query, Resolver } from '@nestjs/graphql';
 import {
-    AssignRoleToAdministratorVariables,
-    CreateAdministratorVariables,
-    GetAdministratorsVariables,
-    GetAdministratorVariables,
+    AdministratorList,
+    AdministratorQueryArgs,
+    AdministratorsQueryArgs,
+    AssignRoleToAdministratorMutationArgs,
+    CreateAdministratorMutationArgs,
     Permission,
-    UpdateAdministratorVariables,
+    UpdateAdministratorMutationArgs,
 } from 'shared/generated-types';
 import { PaginatedList } from 'shared/shared-types';
 
@@ -20,27 +21,27 @@ export class AdministratorResolver {
 
     @Query()
     @Allow(Permission.ReadAdministrator)
-    administrators(@Args() args: GetAdministratorsVariables): Promise<PaginatedList<Administrator>> {
+    administrators(@Args() args: AdministratorsQueryArgs): Promise<PaginatedList<Administrator>> {
         return this.administratorService.findAll(args.options || undefined);
     }
 
     @Query()
     @Allow(Permission.ReadAdministrator)
-    administrator(@Args() args: GetAdministratorVariables): Promise<Administrator | undefined> {
+    administrator(@Args() args: AdministratorQueryArgs): Promise<Administrator | undefined> {
         return this.administratorService.findOne(args.id);
     }
 
     @Mutation()
     @Allow(Permission.CreateAdministrator)
     @Decode('roleIds')
-    createAdministrator(@Args() args: CreateAdministratorVariables): Promise<Administrator> {
+    createAdministrator(@Args() args: CreateAdministratorMutationArgs): Promise<Administrator> {
         const { input } = args;
         return this.administratorService.create(input);
     }
 
     @Mutation()
     @Allow(Permission.CreateAdministrator)
-    updateAdministrator(@Args() args: UpdateAdministratorVariables): Promise<Administrator> {
+    updateAdministrator(@Args() args: UpdateAdministratorMutationArgs): Promise<Administrator> {
         const { input } = args;
         return this.administratorService.update(input);
     }
@@ -48,7 +49,7 @@ export class AdministratorResolver {
     @Mutation()
     @Allow(Permission.UpdateAdministrator)
     @Decode('administratorId', 'roleId')
-    assignRoleToAdministrator(@Args() args: AssignRoleToAdministratorVariables): Promise<Administrator> {
+    assignRoleToAdministrator(@Args() args: AssignRoleToAdministratorMutationArgs): Promise<Administrator> {
         return this.administratorService.assignRole(args.administratorId, args.roleId);
     }
 }

server/src/api/resolvers/asset.resolver.ts

@@ -1,5 +1,10 @@
-import { Args, Context, Mutation, Query, Resolver } from '@nestjs/graphql';
-import { CreateAssetsVariables, Permission } from 'shared/generated-types';
+import { Args, Mutation, Query, Resolver } from '@nestjs/graphql';
+import {
+    AssetQueryArgs,
+    AssetsQueryArgs,
+    CreateAssetsMutationArgs,
+    Permission,
+} from 'shared/generated-types';
 import { PaginatedList } from 'shared/shared-types';
 
 import { Asset } from '../../entity/asset/asset.entity';
@@ -15,7 +20,7 @@ export class AssetResolver {
      */
     @Query()
     @Allow(Permission.ReadCatalog)
-    async asset(@Args() args: any): Promise<Asset | undefined> {
+    async asset(@Args() args: AssetQueryArgs): Promise<Asset | undefined> {
         return this.assetService.findOne(args.id);
     }
 
@@ -24,8 +29,8 @@ export class AssetResolver {
      */
     @Query()
     @Allow(Permission.ReadCatalog)
-    async assets(@Args() args: any): Promise<PaginatedList<Asset>> {
-        return this.assetService.findAll(args.options);
+    async assets(@Args() args: AssetsQueryArgs): Promise<PaginatedList<Asset>> {
+        return this.assetService.findAll(args.options || undefined);
     }
 
     /**
@@ -33,7 +38,7 @@ export class AssetResolver {
      */
     @Mutation()
     @Allow(Permission.CreateCatalog)
-    async createAssets(@Args() args: CreateAssetsVariables): Promise<Asset[]> {
+    async createAssets(@Args() args: CreateAssetsMutationArgs): Promise<Asset[]> {
         return Promise.all(args.input.map(asset => this.assetService.create(asset)));
     }
 }

server/src/api/resolvers/auth.resolver.ts

@@ -1,6 +1,6 @@
 import { Args, Context, Mutation, Query, Resolver } from '@nestjs/graphql';
 import { Request, Response } from 'express';
-import { AttemptLoginVariables, Permission } from 'shared/generated-types';
+import { LoginMutationArgs, LoginResult, MutationResolvers, Permission } from 'shared/generated-types';
 
 import { ConfigService } from '../../config/config.service';
 import { User } from '../../entity/user/user.entity';
@@ -24,28 +24,25 @@ export class AuthResolver {
      */
     @Mutation()
     async login(
-        @Args() args: AttemptLoginVariables,
+        @Args() args: LoginMutationArgs,
         @Context('req') req: Request,
         @Context('res') res: Response,
-    ) {
+    ): Promise<LoginResult> {
         const session = await this.authService.authenticate(args.username, args.password);
-
-        if (session) {
-            setAuthToken({
-                req,
-                res,
-                authOptions: this.configService.authOptions,
-                rememberMe: args.rememberMe,
-                authToken: session.token,
-            });
-            return {
-                user: this.publiclyAccessibleUser(session.user),
-            };
-        }
+        setAuthToken({
+            req,
+            res,
+            authOptions: this.configService.authOptions,
+            rememberMe: args.rememberMe || false,
+            authToken: session.token,
+        });
+        return {
+            user: this.publiclyAccessibleUser(session.user),
+        };
     }
 
     @Mutation()
-    async logout(@Context('req') req: Request, @Context('res') res: Response) {
+    async logout(@Context('req') req: Request, @Context('res') res: Response): Promise<boolean> {
         const token = extractAuthToken(req, this.configService.authOptions.tokenMethod);
         if (!token) {
             return false;

server/src/api/resolvers/channel.resolver.ts

@@ -1,5 +1,5 @@
 import { Args, Mutation, Resolver } from '@nestjs/graphql';
-import { Permission } from 'shared/generated-types';
+import { CreateChannelMutationArgs, Permission } from 'shared/generated-types';
 
 import { Channel } from '../../entity/channel/channel.entity';
 import { ChannelService } from '../../service/providers/channel.service';
@@ -11,7 +11,7 @@ export class ChannelResolver {
 
     @Mutation()
     @Allow(Permission.SuperAdmin)
-    createChannel(@Args() args): Promise<Channel> {
+    createChannel(@Args() args: CreateChannelMutationArgs): Promise<Channel> {
         return this.channelService.create(args.code);
     }
 }

server/src/api/resolvers/customer.resolver.ts

@@ -1,5 +1,11 @@
 import { Args, Mutation, Query, ResolveProperty, Resolver } from '@nestjs/graphql';
-import { Permission } from 'shared/generated-types';
+import {
+    CreateCustomerAddressMutationArgs,
+    CreateCustomerMutationArgs,
+    CustomerQueryArgs,
+    CustomersQueryArgs,
+    Permission,
+} from 'shared/generated-types';
 import { PaginatedList } from 'shared/shared-types';
 
 import { Address } from '../../entity/address/address.entity';
@@ -14,13 +20,13 @@ export class CustomerResolver {
 
     @Query()
     @Allow(Permission.ReadCustomer)
-    async customers(@Args() args): Promise<PaginatedList<Customer>> {
-        return this.customerService.findAll(args.options);
+    async customers(@Args() args: CustomersQueryArgs): Promise<PaginatedList<Customer>> {
+        return this.customerService.findAll(args.options || undefined);
     }
 
     @Query()
     @Allow(Permission.ReadCustomer)
-    async customer(@Args() args): Promise<Customer | undefined> {
+    async customer(@Args() args: CustomerQueryArgs): Promise<Customer | undefined> {
         return this.customerService.findOne(args.id);
     }
 
@@ -32,15 +38,15 @@ export class CustomerResolver {
 
     @Mutation()
     @Allow(Permission.CreateCustomer)
-    async createCustomer(@Args() args): Promise<Customer> {
+    async createCustomer(@Args() args: CreateCustomerMutationArgs): Promise<Customer> {
         const { input, password } = args;
-        return this.customerService.create(input, password);
+        return this.customerService.create(input, password || undefined);
     }
 
     @Mutation()
     @Allow(Permission.CreateCustomer)
     @Decode('customerId')
-    async createCustomerAddress(@Args() args): Promise<Address> {
+    async createCustomerAddress(@Args() args: CreateCustomerAddressMutationArgs): Promise<Address> {
         const { customerId, input } = args;
         return this.customerService.createAddress(customerId, input);
     }

server/src/api/resolvers/facet.resolver.ts

@@ -1,10 +1,12 @@
 import { Args, Mutation, Query, Resolver } from '@nestjs/graphql';
 import {
-    CreateFacetValuesVariables,
-    CreateFacetVariables,
+    CreateFacetMutationArgs,
+    CreateFacetValuesMutationArgs,
+    FacetQueryArgs,
+    FacetsQueryArgs,
     Permission,
-    UpdateFacetValuesVariables,
-    UpdateFacetVariables,
+    UpdateFacetMutationArgs,
+    UpdateFacetValuesMutationArgs,
 } from 'shared/generated-types';
 import { PaginatedList } from 'shared/shared-types';
 
@@ -16,6 +18,8 @@ import { I18nError } from '../../i18n/i18n-error';
 import { FacetValueService } from '../../service/providers/facet-value.service';
 import { FacetService } from '../../service/providers/facet.service';
 import { Allow } from '../common/auth-guard';
+import { RequestContext } from '../common/request-context';
+import { Ctx } from '../common/request-context.decorator';
 
 @Resolver('Facet')
 export class FacetResolver {
@@ -23,19 +27,25 @@ export class FacetResolver {
 
     @Query()
     @Allow(Permission.ReadCatalog)
-    facets(@Args() args): Promise<PaginatedList<Translated<Facet>>> {
-        return this.facetService.findAll(args.languageCode, args.options);
+    facets(
+        @Ctx() ctx: RequestContext,
+        @Args() args: FacetsQueryArgs,
+    ): Promise<PaginatedList<Translated<Facet>>> {
+        return this.facetService.findAll(ctx.languageCode, args.options || undefined);
     }
 
     @Query()
     @Allow(Permission.ReadCatalog)
-    async facet(@Args() args): Promise<Translated<Facet> | undefined> {
-        return this.facetService.findOne(args.id, args.languageCode);
+    async facet(
+        @Ctx() ctx: RequestContext,
+        @Args() args: FacetQueryArgs,
+    ): Promise<Translated<Facet> | undefined> {
+        return this.facetService.findOne(args.id, ctx.languageCode);
     }
 
     @Mutation()
     @Allow(Permission.CreateCatalog)
-    async createFacet(@Args() args: CreateFacetVariables): Promise<Translated<Facet>> {
+    async createFacet(@Args() args: CreateFacetMutationArgs): Promise<Translated<Facet>> {
         const { input } = args;
         const facet = await this.facetService.create(args.input);
 
@@ -50,7 +60,7 @@ export class FacetResolver {
 
     @Mutation()
     @Allow(Permission.UpdateCatalog)
-    async updateFacet(@Args() args: UpdateFacetVariables): Promise<Translated<Facet>> {
+    async updateFacet(@Args() args: UpdateFacetMutationArgs): Promise<Translated<Facet>> {
         const { input } = args;
         return this.facetService.update(args.input);
     }
@@ -58,7 +68,7 @@ export class FacetResolver {
     @Mutation()
     @Allow(Permission.CreateCatalog)
     async createFacetValues(
-        @Args() args: CreateFacetValuesVariables,
+        @Args() args: CreateFacetValuesMutationArgs,
     ): Promise<Array<Translated<FacetValue>>> {
         const { input } = args;
         const facetId = input[0].facetId;
@@ -72,7 +82,7 @@ export class FacetResolver {
     @Mutation()
     @Allow(Permission.UpdateCatalog)
     async updateFacetValues(
-        @Args() args: UpdateFacetValuesVariables,
+        @Args() args: UpdateFacetValuesMutationArgs,
     ): Promise<Array<Translated<FacetValue>>> {
         const { input } = args;
         return Promise.all(input.map(facetValue => this.facetValueService.update(facetValue)));

server/src/api/resolvers/order.resolver.ts

@@ -1,5 +1,12 @@
 import { Args, Mutation, Query, Resolver } from '@nestjs/graphql';
-import { Permission } from 'shared/generated-types';
+import {
+    AddItemToOrderMutationArgs,
+    AdjustItemQuantityMutationArgs,
+    OrderQueryArgs,
+    OrdersQueryArgs,
+    Permission,
+    RemoveItemFromOrderMutationArgs,
+} from 'shared/generated-types';
 import { PaginatedList } from 'shared/shared-types';
 
 import { Order } from '../../entity/order/order.entity';
@@ -17,13 +24,13 @@ export class OrderResolver {
 
     @Query()
     @Allow(Permission.ReadOrder)
-    orders(@Args() args): Promise<PaginatedList<Order>> {
+    orders(@Args() args: OrdersQueryArgs): Promise<PaginatedList<Order>> {
         return {} as any;
     }
 
     @Query()
     @Allow(Permission.ReadOrder, Permission.Owner)
-    async order(@Ctx() ctx: RequestContext, @Args() args): Promise<Order | undefined> {
+    async order(@Ctx() ctx: RequestContext, @Args() args: OrderQueryArgs): Promise<Order | undefined> {
         const order = await this.orderService.findOne(ctx, args.id);
         if (order && ctx.authorizedAsOwnerOnly) {
             if (ctx.session && ctx.session.activeOrder && ctx.session.activeOrder.id === order.id) {
@@ -38,7 +45,10 @@ export class OrderResolver {
     @Mutation()
     @Allow(Permission.UpdateOrder, Permission.Owner)
     @Decode('productVariantId')
-    async addItemToOrder(@Ctx() ctx: RequestContext, @Args() args): Promise<Order> {
+    async addItemToOrder(
+        @Ctx() ctx: RequestContext,
+        @Args() args: AddItemToOrderMutationArgs,
+    ): Promise<Order> {
         const order = await this.getOrderFromContext(ctx);
         return this.orderService.addItemToOrder(ctx, order.id, args.productVariantId, args.quantity);
     }
@@ -46,7 +56,10 @@ export class OrderResolver {
     @Mutation()
     @Allow(Permission.UpdateOrder, Permission.Owner)
     @Decode('orderItemId')
-    async adjustItemQuantity(@Ctx() ctx: RequestContext, @Args() args): Promise<Order> {
+    async adjustItemQuantity(
+        @Ctx() ctx: RequestContext,
+        @Args() args: AdjustItemQuantityMutationArgs,
+    ): Promise<Order> {
         const order = await this.getOrderFromContext(ctx);
         return this.orderService.adjustItemQuantity(ctx, order.id, args.orderItemId, args.quantity);
     }
@@ -54,7 +67,10 @@ export class OrderResolver {
     @Mutation()
     @Allow(Permission.UpdateOrder, Permission.Owner)
     @Decode('orderItemId')
-    async removeItemFromOrder(@Ctx() ctx: RequestContext, @Args() args): Promise<Order> {
+    async removeItemFromOrder(
+        @Ctx() ctx: RequestContext,
+        @Args() args: RemoveItemFromOrderMutationArgs,
+    ): Promise<Order> {
         const order = await this.getOrderFromContext(ctx);
         return this.orderService.removeItemFromOrder(ctx, order.id, args.orderItemId);
     }

server/src/api/resolvers/product-option.resolver.ts

@@ -1,5 +1,11 @@
 import { Args, Mutation, Query, ResolveProperty, Resolver } from '@nestjs/graphql';
-import { CreateProductOptionGroupVariables, Permission } from 'shared/generated-types';
+import {
+    CreateProductOptionGroupMutationArgs,
+    Permission,
+    ProductOptionGroupQueryArgs,
+    ProductOptionGroupsQueryArgs,
+    UpdateProductOptionGroupMutationArgs,
+} from 'shared/generated-types';
 
 import { Translated } from '../../common/types/locale-types';
 import { ProductOptionGroup } from '../../entity/product-option-group/product-option-group.entity';
@@ -7,6 +13,8 @@ import { ProductOption } from '../../entity/product-option/product-option.entity
 import { ProductOptionGroupService } from '../../service/providers/product-option-group.service';
 import { ProductOptionService } from '../../service/providers/product-option.service';
 import { Allow } from '../common/auth-guard';
+import { RequestContext } from '../common/request-context';
+import { Ctx } from '../common/request-context.decorator';
 
 @Resolver('ProductOptionGroup')
 export class ProductOptionResolver {
@@ -17,14 +25,20 @@ export class ProductOptionResolver {
 
     @Query()
     @Allow(Permission.ReadCatalog)
-    productOptionGroups(@Args() args): Promise<Array<Translated<ProductOptionGroup>>> {
-        return this.productOptionGroupService.findAll(args.languageCode, args.filterTerm);
+    productOptionGroups(
+        @Ctx() ctx: RequestContext,
+        @Args() args: ProductOptionGroupsQueryArgs,
+    ): Promise<Array<Translated<ProductOptionGroup>>> {
+        return this.productOptionGroupService.findAll(ctx.languageCode, args.filterTerm || undefined);
     }
 
     @Query()
     @Allow(Permission.ReadCatalog)
-    productOptionGroup(@Args() args): Promise<Translated<ProductOptionGroup> | undefined> {
-        return this.productOptionGroupService.findOne(args.id, args.languageCode);
+    productOptionGroup(
+        @Ctx() ctx: RequestContext,
+        @Args() args: ProductOptionGroupQueryArgs,
+    ): Promise<Translated<ProductOptionGroup> | undefined> {
+        return this.productOptionGroupService.findOne(args.id, ctx.languageCode);
     }
 
     @ResolveProperty()
@@ -40,7 +54,7 @@ export class ProductOptionResolver {
     @Mutation()
     @Allow(Permission.CreateCatalog)
     async createProductOptionGroup(
-        @Args() args: CreateProductOptionGroupVariables,
+        @Args() args: CreateProductOptionGroupMutationArgs,
     ): Promise<Translated<ProductOptionGroup>> {
         const { input } = args;
         const group = await this.productOptionGroupService.create(args.input);
@@ -56,7 +70,9 @@ export class ProductOptionResolver {
 
     @Mutation()
     @Allow(Permission.UpdateCatalog)
-    async updateProductOptionGroup(@Args() args): Promise<Translated<ProductOptionGroup>> {
+    async updateProductOptionGroup(
+        @Args() args: UpdateProductOptionGroupMutationArgs,
+    ): Promise<Translated<ProductOptionGroup>> {
         const { input } = args;
         return this.productOptionGroupService.update(args.input);
     }

server/src/api/resolvers/product.resolver.ts

@@ -1,15 +1,15 @@
 import { Args, Mutation, Query, Resolver } from '@nestjs/graphql';
 import {
-    AddOptionGroupToProductVariables,
-    ApplyFacetValuesToProductVariantsVariables,
-    CreateProductVariables,
-    GenerateProductVariantsVariables,
-    GetProductListVariables,
-    GetProductWithVariantsVariables,
+    AddOptionGroupToProductMutationArgs,
+    ApplyFacetValuesToProductVariantsMutationArgs,
+    CreateProductMutationArgs,
+    GenerateVariantsForProductMutationArgs,
     Permission,
-    RemoveOptionGroupFromProductVariables,
-    UpdateProductVariables,
-    UpdateProductVariantsVariables,
+    ProductQueryArgs,
+    ProductsQueryArgs,
+    RemoveOptionGroupFromProductMutationArgs,
+    UpdateProductMutationArgs,
+    UpdateProductVariantsMutationArgs,
 } from 'shared/generated-types';
 import { ID, PaginatedList } from 'shared/shared-types';
 
@@ -39,7 +39,7 @@ export class ProductResolver {
     @Allow(Permission.ReadCatalog)
     async products(
         @Ctx() ctx: RequestContext,
-        @Args() args: GetProductListVariables,
+        @Args() args: ProductsQueryArgs,
     ): Promise<PaginatedList<Translated<Product>>> {
         return this.productService.findAll(ctx, args.options || undefined);
     }
@@ -48,7 +48,7 @@ export class ProductResolver {
     @Allow(Permission.ReadCatalog)
     async product(
         @Ctx() ctx: RequestContext,
-        @Args() args: GetProductWithVariantsVariables,
+        @Args() args: ProductQueryArgs,
     ): Promise<Translated<Product> | undefined> {
         return this.productService.findOne(ctx, args.id);
     }
@@ -58,7 +58,7 @@ export class ProductResolver {
     @Decode('assetIds', 'featuredAssetId')
     async createProduct(
         @Ctx() ctx: RequestContext,
-        @Args() args: CreateProductVariables,
+        @Args() args: CreateProductMutationArgs,
     ): Promise<Translated<Product>> {
         const { input } = args;
         return this.productService.create(ctx, input);
@@ -69,7 +69,7 @@ export class ProductResolver {
     @Decode('assetIds', 'featuredAssetId')
     async updateProduct(
         @Ctx() ctx: RequestContext,
-        @Args() args: UpdateProductVariables,
+        @Args() args: UpdateProductMutationArgs,
     ): Promise<Translated<Product>> {
         const { input } = args;
         return this.productService.update(ctx, input);
@@ -80,7 +80,7 @@ export class ProductResolver {
     @Decode('productId', 'optionGroupId')
     async addOptionGroupToProduct(
         @Ctx() ctx: RequestContext,
-        @Args() args: AddOptionGroupToProductVariables,
+        @Args() args: AddOptionGroupToProductMutationArgs,
     ): Promise<Translated<Product>> {
         const { productId, optionGroupId } = args;
         return this.productService.addOptionGroupToProduct(ctx, productId, optionGroupId);
@@ -91,7 +91,7 @@ export class ProductResolver {
     @Decode('productId', 'optionGroupId')
     async removeOptionGroupFromProduct(
         @Ctx() ctx: RequestContext,
-        @Args() args: RemoveOptionGroupFromProductVariables,
+        @Args() args: RemoveOptionGroupFromProductMutationArgs,
     ): Promise<Translated<Product>> {
         const { productId, optionGroupId } = args;
         return this.productService.removeOptionGroupFromProduct(ctx, productId, optionGroupId);
@@ -102,7 +102,7 @@ export class ProductResolver {
     @Decode('productId')
     async generateVariantsForProduct(
         @Ctx() ctx: RequestContext,
-        @Args() args: GenerateProductVariantsVariables,
+        @Args() args: GenerateVariantsForProductMutationArgs,
     ): Promise<Translated<Product>> {
         const { productId, defaultPrice, defaultSku } = args;
         await this.productVariantService.generateVariantsForProduct(ctx, productId, defaultPrice, defaultSku);
@@ -113,7 +113,7 @@ export class ProductResolver {
     @Allow(Permission.UpdateCatalog)
     async updateProductVariants(
         @Ctx() ctx: RequestContext,
-        @Args() args: UpdateProductVariantsVariables,
+        @Args() args: UpdateProductVariantsMutationArgs,
     ): Promise<Array<Translated<ProductVariant>>> {
         const { input } = args;
         return Promise.all(input.map(variant => this.productVariantService.update(variant)));
@@ -124,7 +124,7 @@ export class ProductResolver {
     @Decode('facetValueIds', 'productVariantIds')
     async applyFacetValuesToProductVariants(
         @Ctx() ctx: RequestContext,
-        @Args() args: ApplyFacetValuesToProductVariantsVariables,
+        @Args() args: ApplyFacetValuesToProductVariantsMutationArgs,
     ): Promise<Array<Translated<ProductVariant>>> {
         const { facetValueIds, productVariantIds } = args;
         const facetValues = await Promise.all(

server/src/api/resolvers/role.resolver.ts

@@ -1,10 +1,10 @@
 import { Args, Mutation, Query, Resolver } from '@nestjs/graphql';
 import {
-    CreateRoleVariables,
-    GetRolesVariables,
-    GetRoleVariables,
+    CreateRoleMutationArgs,
     Permission,
-    UpdateRoleVariables,
+    RoleQueryArgs,
+    RolesQueryArgs,
+    UpdateRoleMutationArgs,
 } from 'shared/generated-types';
 import { PaginatedList } from 'shared/shared-types';
 
@@ -18,26 +18,26 @@ export class RoleResolver {
 
     @Query()
     @Allow(Permission.ReadAdministrator)
-    roles(@Args() args: GetRolesVariables): Promise<PaginatedList<Role>> {
+    roles(@Args() args: RolesQueryArgs): Promise<PaginatedList<Role>> {
         return this.roleService.findAll(args.options || undefined);
     }
 
     @Query()
     @Allow(Permission.ReadAdministrator)
-    role(@Args() args: GetRoleVariables): Promise<Role | undefined> {
+    role(@Args() args: RoleQueryArgs): Promise<Role | undefined> {
         return this.roleService.findOne(args.id);
     }
 
     @Mutation()
     @Allow(Permission.CreateAdministrator)
-    createRole(@Args() args: CreateRoleVariables): Promise<Role> {
+    createRole(@Args() args: CreateRoleMutationArgs): Promise<Role> {
         const { input } = args;
         return this.roleService.create(input);
     }
 
     @Mutation()
     @Allow(Permission.UpdateAdministrator)
-    updateRole(@Args() args: UpdateRoleVariables): Promise<Role> {
+    updateRole(@Args() args: UpdateRoleMutationArgs): Promise<Role> {
         const { input } = args;
         return this.roleService.update(input);
     }

server/src/api/types/auth.api.graphql

@@ -9,8 +9,6 @@ type Mutation {
 
 type LoginResult {
     user: CurrentUser!
-    "The token will only be returned when using the `bearer` tokenMethod"
-    token: String
 }
 
 type CurrentUser {

server/src/api/types/customer.api.graphql

@@ -7,7 +7,7 @@ type Mutation {
   "Create a new Customer. If a password is provided, a new User will also be created an linked to the Customer."
   createCustomer(input: CreateCustomerInput!, password: String): Customer!
   "Create a new Address and associate it with the Customer specified by customerId"
-  createCustomerAddress(customerId: ID, input: CreateAddressInput): Address!
+  createCustomerAddress(customerId: ID!, input: CreateAddressInput!): Address!
 }
 
 type CustomerList implements PaginatedList {

server/src/api/types/facet.api.graphql

@@ -5,9 +5,9 @@ type Query {
 
 type Mutation {
     "Create a new Facet"
-    createFacet(input: CreateFacetInput): Facet!
+    createFacet(input: CreateFacetInput!): Facet!
     "Update an existing Facet"
-    updateFacet(input: UpdateFacetInput): Facet!
+    updateFacet(input: UpdateFacetInput!): Facet!
     "Create one or more FacetValues"
     createFacetValues(input: [CreateFacetValueInput!]!): [FacetValue!]!
     "Update one or more FacetValues"

server/src/api/types/product-option.api.graphql

@@ -5,7 +5,7 @@ type Query {
 
 type Mutation {
     "Create a new ProductOptionGroup"
-    createProductOptionGroup(input: CreateProductOptionGroupInput): ProductOptionGroup!
+    createProductOptionGroup(input: CreateProductOptionGroupInput!): ProductOptionGroup!
     "Update an existing ProductOptionGroup"
-    updateProductOptionGroup(input: UpdateProductOptionGroupInput): ProductOptionGroup!
+    updateProductOptionGroup(input: UpdateProductOptionGroupInput!): ProductOptionGroup!
 }

server/src/api/types/product.api.graphql

@@ -5,17 +5,23 @@ type Query {
 
 type Mutation {
     "Create a new Product"
-    createProduct(input: CreateProductInput): Product!
+    createProduct(input: CreateProductInput!): Product!
+
     "Update an existing Product"
-    updateProduct(input: UpdateProductInput): Product!
+    updateProduct(input: UpdateProductInput!): Product!
+
     "Add an OptionGroup to a Product"
     addOptionGroupToProduct(productId: ID!, optionGroupId: ID!): Product!
+
     "Remove an OptionGroup from a Product"
     removeOptionGroupFromProduct(productId: ID!, optionGroupId: ID!): Product!
+
     "Create a set of ProductVariants based on the OptionGroups assigned to the given Product"
     generateVariantsForProduct(productId: ID!, defaultPrice: Int, defaultSku: String): Product!
+
     "Update existing ProductVariants"
     updateProductVariants(input: [UpdateProductVariantInput!]!): [ProductVariant]!
+
     "Applies a FacetValue to the given ProductVariants"
     applyFacetValuesToProductVariants(facetValueIds: [ID!]!, productVariantIds: [ID!]!): [ProductVariant!]!
 }

server/src/entity/address/address.dto.ts

@@ -1,13 +0,0 @@
-export interface CreateAddressDto {
-    fullName: string;
-    company: string;
-    streetLine1: string;
-    streetLine2: string;
-    city: string;
-    province: string;
-    postalCode: string;
-    country: string;
-    phoneNumber: string;
-    defaultShippingAddress: boolean;
-    defaultBillingAddress: boolean;
-}

server/src/entity/customer/customer.dto.ts

@@ -1,6 +0,0 @@
-export interface CreateCustomerDto {
-    firstName?: string;
-    lastName?: string;
-    phoneNumber?: string;
-    emailAddress: string;
-}

server/src/entity/product-option-group/product-option-group.dto.ts

@@ -1,8 +0,0 @@
-import { TranslatedInput } from '../../common/types/locale-types';
-
-import { ProductOptionGroup } from './product-option-group.entity';
-
-export interface UpdateProductOptionGroupDto extends TranslatedInput<ProductOptionGroup> {
-    id: string;
-    code?: string;
-}

server/src/entity/product-variant/create-product-variant.dto.ts

@@ -1,11 +0,0 @@
-import { ID } from 'shared/shared-types';
-
-import { TranslatedInput } from '../../common/types/locale-types';
-
-import { ProductVariant } from './product-variant.entity';
-
-export interface CreateProductVariantDto extends TranslatedInput<ProductVariant> {
-    sku: string;
-    price: number;
-    optionCodes?: string[];
-}

server/src/service/helpers/create-translatable.ts

@@ -14,15 +14,15 @@ export function createTranslatable<T extends Translatable>(
 ) {
     return async function saveTranslatable(
         connection: Connection,
-        dto: TranslatedInput<T>,
+        input: TranslatedInput<T>,
         data?: any,
     ): Promise<T> {
-        const entity = new entityType(dto);
+        const entity = new entityType(input);
         const translations: Array<Translation<T>> = [];
 
-        if (dto.translations) {
-            for (const input of dto.translations) {
-                const translation = new translationType(input);
+        if (input.translations) {
+            for (const translationInput of input.translations) {
+                const translation = new translationType(translationInput);
                 translations.push(translation);
                 await connection.manager.save(translation);
             }

server/src/service/helpers/update-translatable.ts

@@ -18,21 +18,21 @@ export function updateTranslatable<T extends Translatable>(
 ) {
     return async function saveTranslatable(
         connection: Connection,
-        dto: TranslatedInput<T> & { id: ID },
+        input: TranslatedInput<T> & { id: ID },
     ): Promise<T> {
         const existingTranslations = await connection.getRepository(translationType).find({
-            where: { base: dto.id },
+            where: { base: input.id },
             relations: ['base'],
         });
 
         const translationUpdater = translationUpdaterService.create(translationType);
-        const diff = translationUpdater.diff(existingTranslations, dto.translations);
+        const diff = translationUpdater.diff(existingTranslations, input.translations);
 
         const entity = await translationUpdater.applyDiff(
-            new entityType({ ...dto, translations: existingTranslations }),
+            new entityType({ ...input, translations: existingTranslations }),
             diff,
         );
-        const updatedEntity = patchEntity(entity as any, omit(dto, ['translations']));
+        const updatedEntity = patchEntity(entity as any, omit(input, ['translations']));
         return connection.manager.save(entity);
     };
 }

server/src/service/providers/customer.service.ts

@@ -1,12 +1,11 @@
 import { Injectable } from '@nestjs/common';
 import { InjectConnection } from '@nestjs/typeorm';
+import { CreateAddressInput, CreateCustomerInput } from 'shared/generated-types';
 import { ID, PaginatedList } from 'shared/shared-types';
 import { Connection } from 'typeorm';
 
 import { ListQueryOptions } from '../../common/types/common-types';
-import { CreateAddressDto } from '../../entity/address/address.dto';
 import { Address } from '../../entity/address/address.entity';
-import { CreateCustomerDto } from '../../entity/customer/customer.dto';
 import { Customer } from '../../entity/customer/customer.entity';
 import { User } from '../../entity/user/user.entity';
 import { I18nError } from '../../i18n/i18n-error';
@@ -23,7 +22,7 @@ export class CustomerService {
         private roleService: RoleService,
     ) {}
 
-    findAll(options: ListQueryOptions<Customer>): Promise<PaginatedList<Customer>> {
+    findAll(options: ListQueryOptions<Customer> | undefined): Promise<PaginatedList<Customer>> {
         return buildListQuery(this.connection, Customer, options)
             .getManyAndCount()
             .then(([items, totalItems]) => ({ items, totalItems }));
@@ -41,13 +40,13 @@ export class CustomerService {
             .getMany();
     }
 
-    async create(createCustomerDto: CreateCustomerDto, password?: string): Promise<Customer> {
-        const customer = new Customer(createCustomerDto);
+    async create(input: CreateCustomerInput, password?: string): Promise<Customer> {
+        const customer = new Customer(input);
 
         if (password) {
             const user = new User();
             user.passwordHash = await this.passwordService.hash(password);
-            user.identifier = createCustomerDto.emailAddress;
+            user.identifier = input.emailAddress;
             user.roles = [await this.roleService.getCustomerRole()];
             const createdUser = await this.connection.manager.save(user);
             customer.user = createdUser;
@@ -56,7 +55,7 @@ export class CustomerService {
         return this.connection.getRepository(Customer).save(customer);
     }
 
-    async createAddress(customerId: string, createAddressDto: CreateAddressDto): Promise<Address> {
+    async createAddress(customerId: string, input: CreateAddressInput): Promise<Address> {
         const customer = await this.connection.manager.findOne(Customer, customerId, {
             relations: ['addresses'],
         });
@@ -65,7 +64,7 @@ export class CustomerService {
             throw new I18nError('error.entity-with-id-not-found', { entityName: 'Customer', id: customerId });
         }
 
-        const address = new Address(createAddressDto);
+        const address = new Address(input);
 
         const createdAddress = await this.connection.manager.getRepository(Address).save(address);
 

server/src/service/providers/facet-value.service.ts

@@ -47,16 +47,16 @@ export class FacetValueService {
 
     async create(
         facet: Facet,
-        createFacetValueDto: CreateFacetValueInput | CreateFacetValueWithFacetInput,
+        input: CreateFacetValueInput | CreateFacetValueWithFacetInput,
     ): Promise<Translated<FacetValue>> {
         const save = createTranslatable(FacetValue, FacetValueTranslation, fv => (fv.facet = facet));
-        const facetValue = await save(this.connection, createFacetValueDto);
+        const facetValue = await save(this.connection, input);
         return assertFound(this.findOne(facetValue.id, DEFAULT_LANGUAGE_CODE));
     }
 
-    async update(updateFacetValueDto: UpdateFacetValueInput): Promise<Translated<FacetValue>> {
+    async update(input: UpdateFacetValueInput): Promise<Translated<FacetValue>> {
         const save = updateTranslatable(FacetValue, FacetValueTranslation, this.translationUpdaterService);
-        const facetValue = await save(this.connection, updateFacetValueDto);
+        const facetValue = await save(this.connection, input);
         return assertFound(this.findOne(facetValue.id, DEFAULT_LANGUAGE_CODE));
     }
 }

server/src/service/providers/facet.service.ts

@@ -24,7 +24,10 @@ export class FacetService {
         private translationUpdaterService: TranslationUpdaterService,
     ) {}
 
-    findAll(lang: LanguageCode, options: ListQueryOptions<Facet>): Promise<PaginatedList<Translated<Facet>>> {
+    findAll(
+        lang: LanguageCode,
+        options?: ListQueryOptions<Facet>,
+    ): Promise<PaginatedList<Translated<Facet>>> {
         const relations = ['values'];
 
         return buildListQuery(this.connection, Facet, options, relations)
@@ -46,15 +49,15 @@ export class FacetService {
             .then(facet => facet && translateDeep(facet, lang, ['values']));
     }
 
-    async create(createFacetDto: CreateFacetInput): Promise<Translated<Facet>> {
+    async create(input: CreateFacetInput): Promise<Translated<Facet>> {
         const save = createTranslatable(Facet, FacetTranslation);
-        const facet = await save(this.connection, createFacetDto);
+        const facet = await save(this.connection, input);
         return assertFound(this.findOne(facet.id, DEFAULT_LANGUAGE_CODE));
     }
 
-    async update(updateFacetDto: UpdateFacetInput): Promise<Translated<Facet>> {
+    async update(input: UpdateFacetInput): Promise<Translated<Facet>> {
         const save = updateTranslatable(Facet, FacetTranslation, this.translationUpdaterService);
-        const facet = await save(this.connection, updateFacetDto);
+        const facet = await save(this.connection, input);
         return assertFound(this.findOne(facet.id, DEFAULT_LANGUAGE_CODE));
     }
 }

server/src/service/providers/product-option-group.service.ts

@@ -1,6 +1,10 @@
 import { Injectable } from '@nestjs/common';
 import { InjectConnection } from '@nestjs/typeorm';
-import { CreateProductOptionGroupInput, LanguageCode } from 'shared/generated-types';
+import {
+    CreateProductOptionGroupInput,
+    LanguageCode,
+    UpdateProductOptionGroupInput,
+} from 'shared/generated-types';
 import { ID } from 'shared/shared-types';
 import { Connection, FindManyOptions, Like } from 'typeorm';
 
@@ -8,7 +12,6 @@ import { DEFAULT_LANGUAGE_CODE } from '../../common/constants';
 import { Translated } from '../../common/types/locale-types';
 import { assertFound } from '../../common/utils';
 import { ProductOptionGroupTranslation } from '../../entity/product-option-group/product-option-group-translation.entity';
-import { UpdateProductOptionGroupDto } from '../../entity/product-option-group/product-option-group.dto';
 import { ProductOptionGroup } from '../../entity/product-option-group/product-option-group.entity';
 
 import { createTranslatable } from '../helpers/create-translatable';
@@ -45,23 +48,19 @@ export class ProductOptionGroupService {
             .then(group => group && translateDeep(group, lang, ['options']));
     }
 
-    async create(
-        createProductOptionGroupDto: CreateProductOptionGroupInput,
-    ): Promise<Translated<ProductOptionGroup>> {
+    async create(input: CreateProductOptionGroupInput): Promise<Translated<ProductOptionGroup>> {
         const save = createTranslatable(ProductOptionGroup, ProductOptionGroupTranslation);
-        const group = await save(this.connection, createProductOptionGroupDto);
+        const group = await save(this.connection, input);
         return assertFound(this.findOne(group.id, DEFAULT_LANGUAGE_CODE));
     }
 
-    async update(
-        updateProductOptionGroupDto: UpdateProductOptionGroupDto,
-    ): Promise<Translated<ProductOptionGroup>> {
+    async update(input: UpdateProductOptionGroupInput): Promise<Translated<ProductOptionGroup>> {
         const save = updateTranslatable(
             ProductOptionGroup,
             ProductOptionGroupTranslation,
             this.translationUpdaterService,
         );
-        const group = await save(this.connection, updateProductOptionGroupDto);
+        const group = await save(this.connection, input);
         return assertFound(this.findOne(group.id, DEFAULT_LANGUAGE_CODE));
     }
 }

server/src/service/providers/product-option.service.ts

@@ -36,10 +36,10 @@ export class ProductOptionService {
 
     async create(
         group: ProductOptionGroup,
-        createProductOptionDto: CreateProductOptionInput,
+        input: CreateProductOptionInput,
     ): Promise<Translated<ProductOption>> {
         const save = createTranslatable(ProductOption, ProductOptionTranslation, po => (po.group = group));
-        const option = await save(this.connection, createProductOptionDto);
+        const option = await save(this.connection, input);
         return assertFound(this.findOne(option.id, DEFAULT_LANGUAGE_CODE));
     }
 }

server/src/service/providers/product-variant.service.ts

@@ -1,6 +1,6 @@
 import { Injectable } from '@nestjs/common';
 import { InjectConnection } from '@nestjs/typeorm';
-import { UpdateProductVariantInput } from 'shared/generated-types';
+import { CreateProductVariantInput, UpdateProductVariantInput } from 'shared/generated-types';
 import { ID } from 'shared/shared-types';
 import { generateAllCombinations } from 'shared/shared-utils';
 import { Connection } from 'typeorm';
@@ -11,7 +11,6 @@ import { Translated } from '../../common/types/locale-types';
 import { assertFound, idsAreEqual } from '../../common/utils';
 import { FacetValue } from '../../entity/facet-value/facet-value.entity';
 import { ProductOption } from '../../entity/product-option/product-option.entity';
-import { CreateProductVariantDto } from '../../entity/product-variant/create-product-variant.dto';
 import { ProductVariantPrice } from '../../entity/product-variant/product-variant-price.entity';
 import { ProductVariantTranslation } from '../../entity/product-variant/product-variant-translation.entity';
 import { ProductVariant } from '../../entity/product-variant/product-variant.entity';
@@ -45,10 +44,10 @@ export class ProductVariantService {
     async create(
         ctx: RequestContext,
         product: Product,
-        createProductVariantDto: CreateProductVariantDto,
+        input: CreateProductVariantInput,
     ): Promise<ProductVariant> {
         const save = createTranslatable(ProductVariant, ProductVariantTranslation, async variant => {
-            const { optionCodes } = createProductVariantDto;
+            const { optionCodes } = input;
             if (optionCodes && optionCodes.length) {
                 const options = await this.connection.getRepository(ProductOption).find();
                 const selectedOptions = options.filter(og => optionCodes.includes(og.code));
@@ -57,18 +56,18 @@ export class ProductVariantService {
             variant.product = product;
             const variantPrice = new ProductVariantPrice();
         });
-        return await save(this.connection, createProductVariantDto, { channelId: ctx.channelId });
+        return await save(this.connection, input, { channelId: ctx.channelId });
     }
 
-    async update(updateProductVariantsDto: UpdateProductVariantInput): Promise<Translated<ProductVariant>> {
+    async update(input: UpdateProductVariantInput): Promise<Translated<ProductVariant>> {
         const save = updateTranslatable(
             ProductVariant,
             ProductVariantTranslation,
             this.translationUpdaterService,
         );
-        await save(this.connection, updateProductVariantsDto);
+        await save(this.connection, input);
         const variant = await assertFound(
-            this.connection.manager.getRepository(ProductVariant).findOne(updateProductVariantsDto.id, {
+            this.connection.manager.getRepository(ProductVariant).findOne(input.id, {
                 relations: ['options', 'facetValues'],
             }),
         );

server/tsconfig.json

@@ -6,7 +6,7 @@
     "removeComments": true,
     "noLib": false,
     "skipLibCheck": true,
-    "lib": ["es2017"],
+    "lib": ["es2017", "esnext.asynciterable"],
     "allowSyntheticDefaultImports": true,
     "emitDecoratorMetadata": true,
     "experimentalDecorators": true,

shared/generated-types.ts

@@ -1,2470 +1,3516 @@
 /* tslint:disable */
-// This file was automatically generated and should not be edited.
-
-// ====================================================
-// GraphQL query operation: GetAdministrators
-// ====================================================
-
-export interface GetAdministrators_administrators_items_user_roles {
-  __typename: "Role";
-  id: string;
-  code: string;
-  description: string;
-  permissions: Permission[];
-}
-
-export interface GetAdministrators_administrators_items_user {
-  __typename: "User";
-  id: string;
-  identifier: string;
-  lastLogin: string | null;
-  roles: GetAdministrators_administrators_items_user_roles[];
-}
-
-export interface GetAdministrators_administrators_items {
-  __typename: "Administrator";
-  id: string;
-  firstName: string;
-  lastName: string;
-  emailAddress: string;
-  user: GetAdministrators_administrators_items_user;
-}
-
-export interface GetAdministrators_administrators {
-  __typename: "AdministratorList";
-  items: GetAdministrators_administrators_items[];
-  totalItems: number;
-}
-
-export interface GetAdministrators {
-  administrators: GetAdministrators_administrators;
-}
-
-export interface GetAdministratorsVariables {
-  options?: AdministratorListOptions | null;
+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>;
+};
+
+export type DateTime = any;
+
+export type Json = any;
+
+export type Upload = any;
+
+export interface PaginatedList {
+    items: Node[];
+    totalItems: number;
+}
+
+export interface Node {
+    id: string;
+}
+
+export interface Query {
+    administrators: AdministratorList;
+    administrator?: Administrator | null;
+    assets: AssetList;
+    asset?: Asset | null;
+    me?: CurrentUser | null;
+    config: Config;
+    customers: CustomerList;
+    customer?: Customer | null;
+    facets: FacetList;
+    facet?: Facet | null;
+    order?: Order | null;
+    orders?: OrderList | null;
+    productOptionGroups: ProductOptionGroup[];
+    productOptionGroup?: ProductOptionGroup | null;
+    products: ProductList;
+    product?: Product | null;
+    roles: RoleList;
+    role?: Role | null;
+    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;
+    roles: Role[];
+    lastLogin?: string | null;
+    customFields?: Json | null;
+}
+
+export interface Role extends Node {
+    id: string;
+    code: string;
+    description: string;
+    permissions: Permission[];
+    channels: Channel[];
+}
+
+export interface Channel extends Node {
+    id: string;
+    createdAt: DateTime;
+    updatedAt: DateTime;
+    code: string;
+    token: string;
+}
+
+export interface AssetList extends PaginatedList {
+    items: Asset[];
+    totalItems: number;
+}
+
+export interface Asset extends Node {
+    id: string;
+    name: string;
+    type: AssetType;
+    fileSize: number;
+    mimeType: string;
+    source: string;
+    preview: string;
 }
 
-/* tslint:disable */
-// This file was automatically generated and should not be edited.
-
-// ====================================================
-// GraphQL query operation: GetAdministrator
-// ====================================================
-
-export interface GetAdministrator_administrator_user_roles {
-  __typename: "Role";
-  id: string;
-  code: string;
-  description: string;
-  permissions: Permission[];
-}
+export interface CurrentUser {
+    id: string;
+    identifier: string;
+    channelTokens: string[];
+}
+
+export interface Config {
+    customFields?: Json | null;
+}
+
+export interface CustomerList extends PaginatedList {
+    items: Customer[];
+    totalItems: number;
+}
+
+export interface Customer extends Node {
+    id: string;
+    createdAt: DateTime;
+    updatedAt: DateTime;
+    firstName: string;
+    lastName: string;
+    phoneNumber?: string | null;
+    emailAddress: string;
+    addresses?: Address[] | null;
+    user?: User | null;
+    customFields?: Json | null;
+}
+
+export interface Address extends Node {
+    id: string;
+    createdAt: DateTime;
+    updatedAt: DateTime;
+    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;
+    defaultShippingAddress?: boolean | null;
+    defaultBillingAddress?: boolean | null;
+    customFields?: Json | null;
+}
+
+export interface FacetList extends PaginatedList {
+    items: Facet[];
+    totalItems: number;
+}
+
+export interface Facet extends Node {
+    id: string;
+    createdAt: DateTime;
+    updatedAt: DateTime;
+    languageCode: LanguageCode;
+    name: string;
+    code: string;
+    values: FacetValue[];
+    translations: FacetTranslation[];
+    customFields?: FacetCustomFields | null;
+}
+
+export interface FacetValue extends Node {
+    id: string;
+    createdAt: DateTime;
+    updatedAt: DateTime;
+    languageCode?: LanguageCode | null;
+    name: string;
+    code: string;
+    translations: FacetValueTranslation[];
+    customFields?: FacetValueCustomFields | null;
+}
+
+export interface FacetValueTranslation {
+    id: string;
+    createdAt: DateTime;
+    updatedAt: DateTime;
+    languageCode: LanguageCode;
+    name: string;
+}
+
+export interface FacetValueCustomFields {
+    link?: string | null;
+    available?: boolean | null;
+}
+
+export interface FacetTranslation {
+    id: string;
+    createdAt: DateTime;
+    updatedAt: DateTime;
+    languageCode: LanguageCode;
+    name: string;
+}
+
+export interface FacetCustomFields {
+    searchable?: boolean | null;
+}
+
+export interface Order extends Node {
+    id: string;
+    createdAt: DateTime;
+    updatedAt: DateTime;
+    code: string;
+    customer: Customer;
+    items: OrderItem[];
+    adjustments: Adjustment[];
+}
+
+export interface OrderItem extends Node {
+    id: string;
+    createdAt: DateTime;
+    updatedAt: DateTime;
+    productVariant: ProductVariant;
+    unitPrice: number;
+    quantity: number;
+    adjustments: Adjustment[];
+    order: Order;
+}
+
+export interface ProductVariant extends Node {
+    id: string;
+    createdAt: DateTime;
+    updatedAt: DateTime;
+    languageCode: LanguageCode;
+    sku: string;
+    name: string;
+    price: number;
+    options: ProductOption[];
+    facetValues: FacetValue[];
+    translations: ProductVariantTranslation[];
+    customFields?: Json | null;
+}
+
+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 ProductOptionTranslation {
+    id: string;
+    createdAt: DateTime;
+    updatedAt: DateTime;
+    languageCode: LanguageCode;
+    name: string;
+}
+
+export interface ProductVariantTranslation {
+    id: string;
+    createdAt: DateTime;
+    updatedAt: DateTime;
+    languageCode: LanguageCode;
+    name: string;
+}
 
-export interface GetAdministrator_administrator_user {
-  __typename: "User";
-  id: string;
-  identifier: string;
-  lastLogin: string | null;
-  roles: GetAdministrator_administrator_user_roles[];
+export interface Adjustment extends Node {
+    id: string;
+    createdAt: DateTime;
+    updatedAt: DateTime;
+    type: string;
+    amount: number;
+    target: AdjustmentTarget;
+    source: AdjustmentSource;
 }
 
-export interface GetAdministrator_administrator {
-  __typename: "Administrator";
-  id: string;
-  firstName: string;
-  lastName: string;
-  emailAddress: string;
-  user: GetAdministrator_administrator_user;
+export interface AdjustmentSource extends Node {
+    id: string;
+    createdAt: DateTime;
+    updatedAt: DateTime;
+    name: string;
+    type: string;
+}
+
+export interface OrderList extends PaginatedList {
+    items: Order[];
+    totalItems: number;
+}
+
+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 ProductOptionGroupTranslation {
+    id: string;
+    createdAt: DateTime;
+    updatedAt: DateTime;
+    languageCode: LanguageCode;
+    name: string;
+}
+
+export interface ProductList extends PaginatedList {
+    items: Product[];
+    totalItems: number;
+}
+
+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[];
+    translations: ProductTranslation[];
+    customFields?: ProductCustomFields | null;
+}
+
+export interface ProductTranslation {
+    id: string;
+    createdAt: DateTime;
+    updatedAt: DateTime;
+    languageCode: LanguageCode;
+    name: string;
+    slug: string;
+    description: string;
+    customFields?: ProductTranslationCustomFields | null;
+}
+
+export interface ProductTranslationCustomFields {
+    nickname?: string | null;
+}
+
+export interface ProductCustomFields {
+    infoUrl?: string | null;
+    downloadable?: boolean | null;
+    nickname?: string | null;
+}
+
+export interface RoleList extends PaginatedList {
+    items: Role[];
+    totalItems: number;
+}
+
+export interface NetworkStatus {
+    inFlightRequests: number;
+}
+
+export interface UserStatus {
+    username: string;
+    isLoggedIn: boolean;
+    loginTime: string;
+}
+
+export interface UiState {
+    language: LanguageCode;
+}
+
+export interface Mutation {
+    createAdministrator: Administrator;
+    updateAdministrator: Administrator;
+    assignRoleToAdministrator: Administrator;
+    createAssets: Asset[];
+    login: LoginResult;
+    logout: boolean;
+    createChannel: Channel;
+    createCustomer: Customer;
+    createCustomerAddress: Address;
+    createFacet: Facet;
+    updateFacet: Facet;
+    createFacetValues: FacetValue[];
+    updateFacetValues: FacetValue[];
+    addItemToOrder?: Order | null;
+    removeItemFromOrder?: Order | null;
+    adjustItemQuantity?: Order | null;
+    createProductOptionGroup: ProductOptionGroup;
+    updateProductOptionGroup: ProductOptionGroup;
+    createProduct: Product;
+    updateProduct: Product;
+    addOptionGroupToProduct: Product;
+    removeOptionGroupFromProduct: Product;
+    generateVariantsForProduct: Product;
+    updateProductVariants: (ProductVariant | null)[];
+    applyFacetValuesToProductVariants: ProductVariant[];
+    createRole: Role;
+    updateRole: Role;
+    requestStarted: number;
+    requestCompleted: number;
+    setAsLoggedIn: UserStatus;
+    setAsLoggedOut: UserStatus;
+    setUiLanguage?: LanguageCode | null;
+}
+
+export interface LoginResult {
+    user: CurrentUser;
 }
 
-export interface GetAdministrator {
-  administrator: GetAdministrator_administrator | null;
+export interface AdministratorListOptions {
+    take?: number | null;
+    skip?: number | null;
+    sort?: AdministratorSortParameter | null;
+    filter?: AdministratorFilterParameter | null;
 }
 
-export interface GetAdministratorVariables {
-  id: string;
+export interface AdministratorSortParameter {
+    id?: SortOrder | null;
+    createdAt?: SortOrder | null;
+    updatedAt?: SortOrder | null;
+    firstName?: SortOrder | null;
+    lastName?: SortOrder | null;
+    emailAddress?: SortOrder | null;
 }
 
-/* tslint:disable */
-// This file was automatically generated and should not be edited.
-
-// ====================================================
-// GraphQL mutation operation: CreateAdministrator
-// ====================================================
-
-export interface CreateAdministrator_createAdministrator_user_roles {
-  __typename: "Role";
-  id: string;
-  code: string;
-  description: string;
-  permissions: Permission[];
+export interface AdministratorFilterParameter {
+    firstName?: StringOperators | null;
+    lastName?: StringOperators | null;
+    emailAddress?: StringOperators | null;
+    createdAt?: DateOperators | null;
+    updatedAt?: DateOperators | null;
 }
 
-export interface CreateAdministrator_createAdministrator_user {
-  __typename: "User";
-  id: string;
-  identifier: string;
-  lastLogin: string | null;
-  roles: CreateAdministrator_createAdministrator_user_roles[];
+export interface StringOperators {
+    eq?: string | null;
+    contains?: string | null;
 }
 
-export interface CreateAdministrator_createAdministrator {
-  __typename: "Administrator";
-  id: string;
-  firstName: string;
-  lastName: string;
-  emailAddress: string;
-  user: CreateAdministrator_createAdministrator_user;
+export interface DateOperators {
+    eq?: DateTime | null;
+    before?: DateTime | null;
+    after?: DateTime | null;
+    between?: DateRange | null;
 }
 
-export interface CreateAdministrator {
-  /**
-   * Create a new Administrator
-   */
-  createAdministrator: CreateAdministrator_createAdministrator;
+export interface DateRange {
+    start: DateTime;
+    end: DateTime;
 }
 
-export interface CreateAdministratorVariables {
-  input: CreateAdministratorInput;
+export interface AssetListOptions {
+    take?: number | null;
+    skip?: number | null;
+    sort?: AssetSortParameter | null;
+    filter?: AssetFilterParameter | null;
 }
 
-/* tslint:disable */
-// This file was automatically generated and should not be edited.
-
-// ====================================================
-// GraphQL mutation operation: UpdateAdministrator
-// ====================================================
-
-export interface UpdateAdministrator_updateAdministrator_user_roles {
-  __typename: "Role";
-  id: string;
-  code: string;
-  description: string;
-  permissions: Permission[];
+export interface AssetSortParameter {
+    id?: SortOrder | null;
+    createdAt?: SortOrder | null;
+    updatedAt?: SortOrder | null;
+    name?: SortOrder | null;
+    description?: SortOrder | null;
 }
 
-export interface UpdateAdministrator_updateAdministrator_user {
-  __typename: "User";
-  id: string;
-  identifier: string;
-  lastLogin: string | null;
-  roles: UpdateAdministrator_updateAdministrator_user_roles[];
+export interface AssetFilterParameter {
+    name?: StringOperators | null;
+    description?: StringOperators | null;
+    type?: StringOperators | null;
+    createdAt?: DateOperators | null;
+    updatedAt?: DateOperators | null;
 }
 
-export interface UpdateAdministrator_updateAdministrator {
-  __typename: "Administrator";
-  id: string;
-  firstName: string;
-  lastName: string;
-  emailAddress: string;
-  user: UpdateAdministrator_updateAdministrator_user;
+export interface CustomerListOptions {
+    take?: number | null;
+    skip?: number | null;
+    sort?: CustomerSortParameter | null;
+    filter?: CustomerFilterParameter | null;
 }
 
-export interface UpdateAdministrator {
-  /**
-   * Update an existing Administrator
-   */
-  updateAdministrator: UpdateAdministrator_updateAdministrator;
+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 UpdateAdministratorVariables {
-  input: UpdateAdministratorInput;
+export interface CustomerFilterParameter {
+    firstName?: StringOperators | null;
+    lastName?: StringOperators | null;
+    phoneNumber?: StringOperators | null;
+    emailAddress?: StringOperators | null;
+    createdAt?: DateOperators | null;
+    updatedAt?: DateOperators | null;
 }
 
-/* tslint:disable */
-// This file was automatically generated and should not be edited.
-
-// ====================================================
-// GraphQL query operation: GetRoles
-// ====================================================
-
-export interface GetRoles_roles_items_channels {
-  __typename: "Channel";
-  id: string;
-  code: string;
-  token: string;
+export interface FacetListOptions {
+    take?: number | null;
+    skip?: number | null;
+    sort?: FacetSortParameter | null;
+    filter?: FacetFilterParameter | null;
 }
 
-export interface GetRoles_roles_items {
-  __typename: "Role";
-  id: string;
-  code: string;
-  description: string;
-  permissions: Permission[];
-  channels: GetRoles_roles_items_channels[];
+export interface FacetSortParameter {
+    id?: SortOrder | null;
+    createdAt?: SortOrder | null;
+    updatedAt?: SortOrder | null;
+    name?: SortOrder | null;
+    code?: SortOrder | null;
+    searchable?: SortOrder | null;
 }
 
-export interface GetRoles_roles {
-  __typename: "RoleList";
-  items: GetRoles_roles_items[];
-  totalItems: number;
+export interface FacetFilterParameter {
+    name?: StringOperators | null;
+    code?: StringOperators | null;
+    createdAt?: DateOperators | null;
+    updatedAt?: DateOperators | null;
+    searchable?: BooleanOperators | null;
 }
 
-export interface GetRoles {
-  roles: GetRoles_roles;
+export interface BooleanOperators {
+    eq?: boolean | null;
 }
 
-export interface GetRolesVariables {
-  options?: RoleListOptions | null;
+export interface OrderListOptions {
+    take?: number | null;
+    skip?: number | null;
+    sort?: OrderSortParameter | null;
+    filter?: OrderFilterParameter | null;
 }
 
-/* tslint:disable */
-// This file was automatically generated and should not be edited.
-
-// ====================================================
-// GraphQL query operation: GetRole
-// ====================================================
-
-export interface GetRole_role_channels {
-  __typename: "Channel";
-  id: string;
-  code: string;
-  token: string;
+export interface OrderSortParameter {
+    id?: SortOrder | null;
+    createdAt?: SortOrder | null;
+    updatedAt?: SortOrder | null;
+    code?: SortOrder | null;
 }
 
-export interface GetRole_role {
-  __typename: "Role";
-  id: string;
-  code: string;
-  description: string;
-  permissions: Permission[];
-  channels: GetRole_role_channels[];
+export interface OrderFilterParameter {
+    code?: StringOperators | null;
+    createdAt?: DateOperators | null;
+    updatedAt?: DateOperators | null;
 }
 
-export interface GetRole {
-  role: GetRole_role | null;
+export interface ProductListOptions {
+    take?: number | null;
+    skip?: number | null;
+    sort?: ProductSortParameter | null;
+    filter?: ProductFilterParameter | null;
 }
 
-export interface GetRoleVariables {
-  id: string;
+export interface ProductSortParameter {
+    id?: SortOrder | null;
+    createdAt?: SortOrder | null;
+    updatedAt?: SortOrder | null;
+    name?: SortOrder | null;
+    slug?: SortOrder | null;
+    description?: SortOrder | null;
+    image?: SortOrder | null;
+    infoUrl?: SortOrder | null;
+    downloadable?: SortOrder | null;
+    nickname?: SortOrder | null;
 }
 
-/* tslint:disable */
-// This file was automatically generated and should not be edited.
-
-// ====================================================
-// GraphQL mutation operation: CreateRole
-// ====================================================
-
-export interface CreateRole_createRole_channels {
-  __typename: "Channel";
-  id: string;
-  code: string;
-  token: string;
+export interface ProductFilterParameter {
+    name?: StringOperators | null;
+    slug?: StringOperators | null;
+    description?: StringOperators | null;
+    createdAt?: DateOperators | null;
+    updatedAt?: DateOperators | null;
+    infoUrl?: StringOperators | null;
+    downloadable?: BooleanOperators | null;
+    nickname?: StringOperators | null;
 }
 
-export interface CreateRole_createRole {
-  __typename: "Role";
-  id: string;
-  code: string;
-  description: string;
-  permissions: Permission[];
-  channels: CreateRole_createRole_channels[];
+export interface RoleListOptions {
+    take?: number | null;
+    skip?: number | null;
+    sort?: RoleSortParameter | null;
+    filter?: RoleFilterParameter | null;
 }
 
-export interface CreateRole {
-  /**
-   * Create a new Role
-   */
-  createRole: CreateRole_createRole;
+export interface RoleSortParameter {
+    id?: SortOrder | null;
+    createdAt?: SortOrder | null;
+    updatedAt?: SortOrder | null;
+    code?: SortOrder | null;
+    description?: SortOrder | null;
 }
 
-export interface CreateRoleVariables {
-  input: CreateRoleInput;
+export interface RoleFilterParameter {
+    code?: StringOperators | null;
+    description?: StringOperators | null;
+    createdAt?: DateOperators | null;
+    updatedAt?: DateOperators | null;
 }
 
-/* tslint:disable */
-// This file was automatically generated and should not be edited.
-
-// ====================================================
-// GraphQL mutation operation: UpdateRole
-// ====================================================
-
-export interface UpdateRole_updateRole_channels {
-  __typename: "Channel";
-  id: string;
-  code: string;
-  token: string;
+export interface CreateAdministratorInput {
+    firstName: string;
+    lastName: string;
+    emailAddress: string;
+    password: string;
+    roleIds: string[];
 }
 
-export interface UpdateRole_updateRole {
-  __typename: "Role";
-  id: string;
-  code: string;
-  description: string;
-  permissions: Permission[];
-  channels: UpdateRole_updateRole_channels[];
+export interface UpdateAdministratorInput {
+    id: string;
+    firstName?: string | null;
+    lastName?: string | null;
+    emailAddress?: string | null;
+    password?: string | null;
+    roleIds?: string[] | null;
 }
 
-export interface UpdateRole {
-  /**
-   * Update an existing new Role
-   */
-  updateRole: UpdateRole_updateRole;
+export interface CreateAssetInput {
+    file: Upload;
 }
 
-export interface UpdateRoleVariables {
-  input: UpdateRoleInput;
+export interface CreateCustomerInput {
+    firstName: string;
+    lastName: string;
+    phoneNumber?: string | null;
+    emailAddress: string;
+    customFields?: Json | null;
 }
 
-/* tslint:disable */
-// This file was automatically generated and should not be edited.
-
-// ====================================================
-// GraphQL mutation operation: AssignRoleToAdministrator
-// ====================================================
-
-export interface AssignRoleToAdministrator_assignRoleToAdministrator_user_roles {
-  __typename: "Role";
-  id: string;
-  code: string;
-  description: string;
-  permissions: Permission[];
+export interface CreateAddressInput {
+    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;
+    defaultShippingAddress?: boolean | null;
+    defaultBillingAddress?: boolean | null;
+    customFields?: Json | null;
 }
 
-export interface AssignRoleToAdministrator_assignRoleToAdministrator_user {
-  __typename: "User";
-  id: string;
-  identifier: string;
-  lastLogin: string | null;
-  roles: AssignRoleToAdministrator_assignRoleToAdministrator_user_roles[];
+export interface CreateFacetInput {
+    code: string;
+    translations: FacetTranslationInput[];
+    values?: CreateFacetValueWithFacetInput[] | null;
+    customFields?: CreateFacetCustomFieldsInput | null;
 }
 
-export interface AssignRoleToAdministrator_assignRoleToAdministrator {
-  __typename: "Administrator";
-  id: string;
-  firstName: string;
-  lastName: string;
-  emailAddress: string;
-  user: AssignRoleToAdministrator_assignRoleToAdministrator_user;
+export interface FacetTranslationInput {
+    id?: string | null;
+    languageCode: LanguageCode;
+    name?: string | null;
+    customFields?: Json | null;
 }
 
-export interface AssignRoleToAdministrator {
-  /**
-   * Assign a Role to an Administrator
-   */
-  assignRoleToAdministrator: AssignRoleToAdministrator_assignRoleToAdministrator;
+export interface CreateFacetValueWithFacetInput {
+    code: string;
+    translations: FacetValueTranslationInput[];
 }
 
-export interface AssignRoleToAdministratorVariables {
-  administratorId: string;
-  roleId: string;
+export interface FacetValueTranslationInput {
+    id?: string | null;
+    languageCode: LanguageCode;
+    name?: string | null;
+    customFields?: Json | null;
 }
 
-/* tslint:disable */
-// This file was automatically generated and should not be edited.
-
-// ====================================================
-// GraphQL mutation operation: AttemptLogin
-// ====================================================
-
-export interface AttemptLogin_login_user {
-  __typename: "CurrentUser";
-  id: string;
-  identifier: string;
-  channelTokens: string[];
+export interface CreateFacetCustomFieldsInput {
+    searchable?: boolean | null;
 }
 
-export interface AttemptLogin_login {
-  __typename: "LoginResult";
-  user: AttemptLogin_login_user;
+export interface UpdateFacetInput {
+    id: string;
+    code?: string | null;
+    translations?: FacetTranslationInput[] | null;
+    customFields?: UpdateFacetCustomFieldsInput | null;
 }
 
-export interface AttemptLogin {
-  login: AttemptLogin_login;
+export interface UpdateFacetCustomFieldsInput {
+    searchable?: boolean | null;
 }
 
-export interface AttemptLoginVariables {
-  username: string;
-  password: string;
-  rememberMe: boolean;
+export interface CreateFacetValueInput {
+    facetId: string;
+    code: string;
+    translations: FacetValueTranslationInput[];
+    customFields?: CreateFacetValueCustomFieldsInput | null;
 }
 
-/* tslint:disable */
-// This file was automatically generated and should not be edited.
-
-// ====================================================
-// GraphQL mutation operation: LogOut
-// ====================================================
-
-export interface LogOut {
-  logout: boolean;
+export interface CreateFacetValueCustomFieldsInput {
+    link?: string | null;
+    available?: boolean | null;
 }
 
-/* tslint:disable */
-// This file was automatically generated and should not be edited.
-
-// ====================================================
-// GraphQL query operation: GetCurrentUser
-// ====================================================
-
-export interface GetCurrentUser_me {
-  __typename: "CurrentUser";
-  id: string;
-  identifier: string;
-  channelTokens: string[];
+export interface UpdateFacetValueInput {
+    id: string;
+    code?: string | null;
+    translations?: FacetValueTranslationInput[] | null;
+    customFields?: UpdateFacetValueCustomFieldsInput | null;
 }
 
-export interface GetCurrentUser {
-  me: GetCurrentUser_me | null;
+export interface UpdateFacetValueCustomFieldsInput {
+    link?: string | null;
+    available?: boolean | null;
 }
 
-/* tslint:disable */
-// This file was automatically generated and should not be edited.
-
-// ====================================================
-// GraphQL query operation: GetServerConfig
-// ====================================================
-
-export interface GetServerConfig_config {
-  __typename: "Config";
-  customFields: any | null;
+export interface CreateProductOptionGroupInput {
+    code: string;
+    translations: ProductOptionGroupTranslationInput[];
+    options: CreateProductOptionInput[];
+    customFields?: Json | null;
 }
 
-export interface GetServerConfig {
-  config: GetServerConfig_config;
+export interface ProductOptionGroupTranslationInput {
+    id?: string | null;
+    languageCode: LanguageCode;
+    name?: string | null;
+    customFields?: Json | null;
 }
 
-/* tslint:disable */
-// This file was automatically generated and should not be edited.
-
-// ====================================================
-// GraphQL mutation operation: CreateFacet
-// ====================================================
-
-export interface CreateFacet_createFacet_translations {
-  __typename: "FacetTranslation";
-  id: string;
-  languageCode: LanguageCode;
-  name: string;
+export interface CreateProductOptionInput {
+    code: string;
+    translations: ProductOptionGroupTranslationInput[];
+    customFields?: Json | null;
 }
 
-export interface CreateFacet_createFacet_values_translations {
-  __typename: "FacetValueTranslation";
-  id: string;
-  languageCode: LanguageCode;
-  name: string;
+export interface UpdateProductOptionGroupInput {
+    id: string;
+    code?: string | null;
+    translations?: ProductOptionGroupTranslationInput[] | null;
+    customFields?: Json | null;
 }
 
-export interface CreateFacet_createFacet_values {
-  __typename: "FacetValue";
-  id: string;
-  languageCode: LanguageCode | null;
-  code: string;
-  name: string;
-  translations: CreateFacet_createFacet_values_translations[];
+export interface CreateProductInput {
+    featuredAssetId?: string | null;
+    assetIds?: string[] | null;
+    translations: ProductTranslationInput[];
+    customFields?: CreateProductCustomFieldsInput | null;
 }
 
-export interface CreateFacet_createFacet {
-  __typename: "Facet";
-  id: string;
-  languageCode: LanguageCode;
-  code: string;
-  name: string;
-  translations: CreateFacet_createFacet_translations[];
-  values: CreateFacet_createFacet_values[];
+export interface ProductTranslationInput {
+    id?: string | null;
+    languageCode: LanguageCode;
+    name?: string | null;
+    slug?: string | null;
+    description?: string | null;
+    customFields?: ProductTranslationCustomFieldsInput | null;
 }
 
-export interface CreateFacet {
-  /**
-   * Create a new Facet
-   */
-  createFacet: CreateFacet_createFacet;
+export interface ProductTranslationCustomFieldsInput {
+    nickname?: string | null;
 }
 
-export interface CreateFacetVariables {
-  input: CreateFacetInput;
+export interface CreateProductCustomFieldsInput {
+    infoUrl?: string | null;
+    downloadable?: boolean | null;
 }
 
-/* tslint:disable */
-// This file was automatically generated and should not be edited.
-
-// ====================================================
-// GraphQL mutation operation: UpdateFacet
-// ====================================================
-
-export interface UpdateFacet_updateFacet_translations {
-  __typename: "FacetTranslation";
-  id: string;
-  languageCode: LanguageCode;
-  name: string;
+export interface UpdateProductInput {
+    id: string;
+    featuredAssetId?: string | null;
+    assetIds?: string[] | null;
+    translations?: ProductTranslationInput[] | null;
+    customFields?: UpdateProductCustomFieldsInput | null;
 }
 
-export interface UpdateFacet_updateFacet_values_translations {
-  __typename: "FacetValueTranslation";
-  id: string;
-  languageCode: LanguageCode;
-  name: string;
+export interface UpdateProductCustomFieldsInput {
+    infoUrl?: string | null;
+    downloadable?: boolean | null;
 }
 
-export interface UpdateFacet_updateFacet_values {
-  __typename: "FacetValue";
-  id: string;
-  languageCode: LanguageCode | null;
-  code: string;
-  name: string;
-  translations: UpdateFacet_updateFacet_values_translations[];
+export interface UpdateProductVariantInput {
+    id: string;
+    translations?: ProductVariantTranslationInput[] | null;
+    sku?: string | null;
+    price?: number | null;
+    customFields?: Json | null;
 }
 
-export interface UpdateFacet_updateFacet {
-  __typename: "Facet";
-  id: string;
-  languageCode: LanguageCode;
-  code: string;
-  name: string;
-  translations: UpdateFacet_updateFacet_translations[];
-  values: UpdateFacet_updateFacet_values[];
+export interface ProductVariantTranslationInput {
+    id?: string | null;
+    languageCode: LanguageCode;
+    name?: string | null;
+    customFields?: Json | null;
 }
 
-export interface UpdateFacet {
-  /**
-   * Update an existing Facet
-   */
-  updateFacet: UpdateFacet_updateFacet;
+export interface CreateRoleInput {
+    code: string;
+    description: string;
+    permissions: Permission[];
 }
 
-export interface UpdateFacetVariables {
-  input: UpdateFacetInput;
+export interface UpdateRoleInput {
+    id: string;
+    code?: string | null;
+    description?: string | null;
+    permissions?: Permission[] | null;
 }
 
-/* tslint:disable */
-// This file was automatically generated and should not be edited.
-
-// ====================================================
-// GraphQL mutation operation: CreateFacetValues
-// ====================================================
-
-export interface CreateFacetValues_createFacetValues_translations {
-  __typename: "FacetValueTranslation";
-  id: string;
-  languageCode: LanguageCode;
-  name: string;
+export interface CreateProductVariantInput {
+    translations: ProductVariantTranslationInput[];
+    sku: string;
+    price: number;
+    optionCodes?: string[] | null;
+    customFields?: Json | null;
 }
 
-export interface CreateFacetValues_createFacetValues {
-  __typename: "FacetValue";
-  id: string;
-  languageCode: LanguageCode | null;
-  code: string;
-  name: string;
-  translations: CreateFacetValues_createFacetValues_translations[];
+export interface NumberOperators {
+    eq?: number | null;
+    lt?: number | null;
+    lte?: number | null;
+    gt?: number | null;
+    gte?: number | null;
+    between?: NumberRange | null;
 }
 
-export interface CreateFacetValues {
-  /**
-   * Create one or more FacetValues
-   */
-  createFacetValues: CreateFacetValues_createFacetValues[];
+export interface NumberRange {
+    start: number;
+    end: number;
 }
 
-export interface CreateFacetValuesVariables {
-  input: CreateFacetValueInput[];
+export interface ProductOptionTranslationInput {
+    id?: string | null;
+    languageCode: LanguageCode;
+    name?: string | null;
+    customFields?: Json | null;
 }
-
-/* tslint:disable */
-// This file was automatically generated and should not be edited.
-
-// ====================================================
-// GraphQL mutation operation: UpdateFacetValues
-// ====================================================
-
-export interface UpdateFacetValues_updateFacetValues_translations {
-  __typename: "FacetValueTranslation";
-  id: string;
-  languageCode: LanguageCode;
-  name: string;
+export interface AdministratorsQueryArgs {
+    options?: AdministratorListOptions | null;
 }
-
-export interface UpdateFacetValues_updateFacetValues {
-  __typename: "FacetValue";
-  id: string;
-  languageCode: LanguageCode | null;
-  code: string;
-  name: string;
-  translations: UpdateFacetValues_updateFacetValues_translations[];
+export interface AdministratorQueryArgs {
+    id: string;
 }
-
-export interface UpdateFacetValues {
-  /**
-   * Update one or more FacetValues
-   */
-  updateFacetValues: UpdateFacetValues_updateFacetValues[];
+export interface AssetsQueryArgs {
+    options?: AssetListOptions | null;
 }
-
-export interface UpdateFacetValuesVariables {
-  input: UpdateFacetValueInput[];
+export interface AssetQueryArgs {
+    id: string;
 }
-
-/* tslint:disable */
-// This file was automatically generated and should not be edited.
-
-// ====================================================
-// GraphQL query operation: GetFacetList
-// ====================================================
-
-export interface GetFacetList_facets_items_translations {
-  __typename: "FacetTranslation";
-  id: string;
-  languageCode: LanguageCode;
-  name: string;
+export interface CustomersQueryArgs {
+    options?: CustomerListOptions | null;
 }
-
-export interface GetFacetList_facets_items_values_translations {
-  __typename: "FacetValueTranslation";
-  id: string;
-  languageCode: LanguageCode;
-  name: string;
+export interface CustomerQueryArgs {
+    id: string;
 }
-
-export interface GetFacetList_facets_items_values {
-  __typename: "FacetValue";
-  id: string;
-  languageCode: LanguageCode | null;
-  code: string;
-  name: string;
-  translations: GetFacetList_facets_items_values_translations[];
+export interface FacetsQueryArgs {
+    languageCode?: LanguageCode | null;
+    options?: FacetListOptions | null;
 }
-
-export interface GetFacetList_facets_items {
-  __typename: "Facet";
-  id: string;
-  languageCode: LanguageCode;
-  code: string;
-  name: string;
-  translations: GetFacetList_facets_items_translations[];
-  values: GetFacetList_facets_items_values[];
+export interface FacetQueryArgs {
+    id: string;
+    languageCode?: LanguageCode | null;
 }
-
-export interface GetFacetList_facets {
-  __typename: "FacetList";
-  items: GetFacetList_facets_items[];
-  totalItems: number;
+export interface OrderQueryArgs {
+    id: string;
 }
-
-export interface GetFacetList {
-  facets: GetFacetList_facets;
+export interface OrdersQueryArgs {
+    options?: OrderListOptions | null;
 }
-
-export interface GetFacetListVariables {
-  options?: FacetListOptions | null;
-  languageCode?: LanguageCode | null;
+export interface ProductOptionGroupsQueryArgs {
+    languageCode?: LanguageCode | null;
+    filterTerm?: string | null;
 }
-
-/* tslint:disable */
-// This file was automatically generated and should not be edited.
-
-// ====================================================
-// GraphQL query operation: GetFacetWithValues
-// ====================================================
-
-export interface GetFacetWithValues_facet_translations {
-  __typename: "FacetTranslation";
-  id: string;
-  languageCode: LanguageCode;
-  name: string;
+export interface ProductOptionGroupQueryArgs {
+    id: string;
+    languageCode?: LanguageCode | null;
 }
-
-export interface GetFacetWithValues_facet_values_translations {
-  __typename: "FacetValueTranslation";
-  id: string;
-  languageCode: LanguageCode;
-  name: string;
+export interface ProductsQueryArgs {
+    languageCode?: LanguageCode | null;
+    options?: ProductListOptions | null;
 }
-
-export interface GetFacetWithValues_facet_values {
-  __typename: "FacetValue";
-  id: string;
-  languageCode: LanguageCode | null;
-  code: string;
-  name: string;
-  translations: GetFacetWithValues_facet_values_translations[];
+export interface ProductQueryArgs {
+    id: string;
+    languageCode?: LanguageCode | null;
 }
-
-export interface GetFacetWithValues_facet {
-  __typename: "Facet";
-  id: string;
-  languageCode: LanguageCode;
-  code: string;
-  name: string;
-  translations: GetFacetWithValues_facet_translations[];
-  values: GetFacetWithValues_facet_values[];
+export interface RolesQueryArgs {
+    options?: RoleListOptions | null;
 }
-
-export interface GetFacetWithValues {
-  facet: GetFacetWithValues_facet | null;
+export interface RoleQueryArgs {
+    id: string;
 }
-
-export interface GetFacetWithValuesVariables {
-  id: string;
-  languageCode?: LanguageCode | null;
+export interface CreateAdministratorMutationArgs {
+    input: CreateAdministratorInput;
 }
-
-/* tslint:disable */
-// This file was automatically generated and should not be edited.
-
-// ====================================================
-// GraphQL mutation operation: RequestStarted
-// ====================================================
-
-export interface RequestStarted {
-  requestStarted: number;
+export interface UpdateAdministratorMutationArgs {
+    input: UpdateAdministratorInput;
 }
-
-/* tslint:disable */
-// This file was automatically generated and should not be edited.
-
-// ====================================================
-// GraphQL mutation operation: RequestCompleted
-// ====================================================
-
-export interface RequestCompleted {
-  requestCompleted: number;
+export interface AssignRoleToAdministratorMutationArgs {
+    administratorId: string;
+    roleId: string;
 }
-
-/* tslint:disable */
-// This file was automatically generated and should not be edited.
-
-// ====================================================
-// GraphQL mutation operation: SetAsLoggedIn
-// ====================================================
-
-export interface SetAsLoggedIn_setAsLoggedIn {
-  __typename: "UserStatus";
-  username: string;
-  isLoggedIn: boolean;
-  loginTime: string;
+export interface CreateAssetsMutationArgs {
+    input: CreateAssetInput[];
 }
-
-export interface SetAsLoggedIn {
-  setAsLoggedIn: SetAsLoggedIn_setAsLoggedIn;
+export interface LoginMutationArgs {
+    username: string;
+    password: string;
+    rememberMe?: boolean | null;
 }
-
-export interface SetAsLoggedInVariables {
-  username: string;
-  loginTime: string;
+export interface CreateChannelMutationArgs {
+    code: string;
 }
-
-/* tslint:disable */
-// This file was automatically generated and should not be edited.
-
-// ====================================================
-// GraphQL mutation operation: SetAsLoggedOut
-// ====================================================
-
-export interface SetAsLoggedOut_setAsLoggedOut {
-  __typename: "UserStatus";
-  username: string;
-  isLoggedIn: boolean;
-  loginTime: string;
+export interface CreateCustomerMutationArgs {
+    input: CreateCustomerInput;
+    password?: string | null;
 }
-
-export interface SetAsLoggedOut {
-  setAsLoggedOut: SetAsLoggedOut_setAsLoggedOut;
+export interface CreateCustomerAddressMutationArgs {
+    customerId: string;
+    input: CreateAddressInput;
 }
-
-/* tslint:disable */
-// This file was automatically generated and should not be edited.
-
-// ====================================================
-// GraphQL mutation operation: SetUiLanguage
-// ====================================================
-
-export interface SetUiLanguage {
-  setUiLanguage: LanguageCode | null;
+export interface CreateFacetMutationArgs {
+    input: CreateFacetInput;
 }
-
-export interface SetUiLanguageVariables {
-  languageCode: LanguageCode;
+export interface UpdateFacetMutationArgs {
+    input: UpdateFacetInput;
 }
-
-/* tslint:disable */
-// This file was automatically generated and should not be edited.
-
-// ====================================================
-// GraphQL query operation: GetNetworkStatus
-// ====================================================
-
-export interface GetNetworkStatus_networkStatus {
-  __typename: "NetworkStatus";
-  inFlightRequests: number;
+export interface CreateFacetValuesMutationArgs {
+    input: CreateFacetValueInput[];
 }
-
-export interface GetNetworkStatus {
-  networkStatus: GetNetworkStatus_networkStatus;
+export interface UpdateFacetValuesMutationArgs {
+    input: UpdateFacetValueInput[];
 }
-
-/* tslint:disable */
-// This file was automatically generated and should not be edited.
-
-// ====================================================
-// GraphQL query operation: GetUserStatus
-// ====================================================
-
-export interface GetUserStatus_userStatus {
-  __typename: "UserStatus";
-  username: string;
-  isLoggedIn: boolean;
-  loginTime: string;
+export interface AddItemToOrderMutationArgs {
+    productVariantId: string;
+    quantity: number;
 }
-
-export interface GetUserStatus {
-  userStatus: GetUserStatus_userStatus;
+export interface RemoveItemFromOrderMutationArgs {
+    orderItemId: string;
 }
-
-/* tslint:disable */
-// This file was automatically generated and should not be edited.
-
-// ====================================================
-// GraphQL query operation: GetUiState
-// ====================================================
-
-export interface GetUiState_uiState {
-  __typename: "UiState";
-  language: LanguageCode;
+export interface AdjustItemQuantityMutationArgs {
+    orderItemId: string;
+    quantity: number;
 }
-
-export interface GetUiState {
-  uiState: GetUiState_uiState;
+export interface CreateProductOptionGroupMutationArgs {
+    input: CreateProductOptionGroupInput;
 }
-
-/* tslint:disable */
-// This file was automatically generated and should not be edited.
-
-// ====================================================
-// GraphQL mutation operation: UpdateProduct
-// ====================================================
-
-export interface UpdateProduct_updateProduct_featuredAsset {
-  __typename: "Asset";
-  id: string;
-  name: string;
-  fileSize: number;
-  mimeType: string;
-  type: AssetType;
-  preview: string;
-  source: string;
-}
-
-export interface UpdateProduct_updateProduct_assets {
-  __typename: "Asset";
-  id: string;
-  name: string;
-  fileSize: number;
-  mimeType: string;
-  type: AssetType;
-  preview: string;
-  source: string;
-}
-
-export interface UpdateProduct_updateProduct_translations {
-  __typename: "ProductTranslation";
-  languageCode: LanguageCode;
-  name: string;
-  slug: string;
-  description: string;
-}
-
-export interface UpdateProduct_updateProduct_optionGroups {
-  __typename: "ProductOptionGroup";
-  id: string;
-  languageCode: LanguageCode;
-  code: string;
-  name: string;
-}
-
-export interface UpdateProduct_updateProduct_variants_options {
-  __typename: "ProductOption";
-  id: string;
-  code: string | null;
-  languageCode: LanguageCode | null;
-  name: string | null;
-}
-
-export interface UpdateProduct_updateProduct_variants_facetValues {
-  __typename: "FacetValue";
-  id: string;
-  code: string;
-  name: string;
-}
-
-export interface UpdateProduct_updateProduct_variants_translations {
-  __typename: "ProductVariantTranslation";
-  id: string;
-  languageCode: LanguageCode;
-  name: string;
-}
-
-export interface UpdateProduct_updateProduct_variants {
-  __typename: "ProductVariant";
-  id: string;
-  languageCode: LanguageCode;
-  name: string;
-  price: number;
-  sku: string;
-  options: UpdateProduct_updateProduct_variants_options[];
-  facetValues: UpdateProduct_updateProduct_variants_facetValues[];
-  translations: UpdateProduct_updateProduct_variants_translations[];
-}
-
-export interface UpdateProduct_updateProduct {
-  __typename: "Product";
-  id: string;
-  languageCode: LanguageCode;
-  name: string;
-  slug: string;
-  description: string;
-  featuredAsset: UpdateProduct_updateProduct_featuredAsset | null;
-  assets: UpdateProduct_updateProduct_assets[];
-  translations: UpdateProduct_updateProduct_translations[];
-  optionGroups: UpdateProduct_updateProduct_optionGroups[];
-  variants: UpdateProduct_updateProduct_variants[];
-}
-
-export interface UpdateProduct {
-  /**
-   * Update an existing Product
-   */
-  updateProduct: UpdateProduct_updateProduct;
-}
-
-export interface UpdateProductVariables {
-  input: UpdateProductInput;
+export interface UpdateProductOptionGroupMutationArgs {
+    input: UpdateProductOptionGroupInput;
 }
-
-/* tslint:disable */
-// This file was automatically generated and should not be edited.
-
-// ====================================================
-// GraphQL mutation operation: CreateProduct
-// ====================================================
-
-export interface CreateProduct_createProduct_featuredAsset {
-  __typename: "Asset";
-  id: string;
-  name: string;
-  fileSize: number;
-  mimeType: string;
-  type: AssetType;
-  preview: string;
-  source: string;
-}
-
-export interface CreateProduct_createProduct_assets {
-  __typename: "Asset";
-  id: string;
-  name: string;
-  fileSize: number;
-  mimeType: string;
-  type: AssetType;
-  preview: string;
-  source: string;
-}
-
-export interface CreateProduct_createProduct_translations {
-  __typename: "ProductTranslation";
-  languageCode: LanguageCode;
-  name: string;
-  slug: string;
-  description: string;
-}
-
-export interface CreateProduct_createProduct_optionGroups {
-  __typename: "ProductOptionGroup";
-  id: string;
-  languageCode: LanguageCode;
-  code: string;
-  name: string;
-}
-
-export interface CreateProduct_createProduct_variants_options {
-  __typename: "ProductOption";
-  id: string;
-  code: string | null;
-  languageCode: LanguageCode | null;
-  name: string | null;
-}
-
-export interface CreateProduct_createProduct_variants_facetValues {
-  __typename: "FacetValue";
-  id: string;
-  code: string;
-  name: string;
-}
-
-export interface CreateProduct_createProduct_variants_translations {
-  __typename: "ProductVariantTranslation";
-  id: string;
-  languageCode: LanguageCode;
-  name: string;
-}
-
-export interface CreateProduct_createProduct_variants {
-  __typename: "ProductVariant";
-  id: string;
-  languageCode: LanguageCode;
-  name: string;
-  price: number;
-  sku: string;
-  options: CreateProduct_createProduct_variants_options[];
-  facetValues: CreateProduct_createProduct_variants_facetValues[];
-  translations: CreateProduct_createProduct_variants_translations[];
-}
-
-export interface CreateProduct_createProduct {
-  __typename: "Product";
-  id: string;
-  languageCode: LanguageCode;
-  name: string;
-  slug: string;
-  description: string;
-  featuredAsset: CreateProduct_createProduct_featuredAsset | null;
-  assets: CreateProduct_createProduct_assets[];
-  translations: CreateProduct_createProduct_translations[];
-  optionGroups: CreateProduct_createProduct_optionGroups[];
-  variants: CreateProduct_createProduct_variants[];
-}
-
-export interface CreateProduct {
-  /**
-   * Create a new Product
-   */
-  createProduct: CreateProduct_createProduct;
-}
-
-export interface CreateProductVariables {
-  input: CreateProductInput;
+export interface CreateProductMutationArgs {
+    input: CreateProductInput;
 }
-
-/* tslint:disable */
-// This file was automatically generated and should not be edited.
-
-// ====================================================
-// GraphQL mutation operation: GenerateProductVariants
-// ====================================================
-
-export interface GenerateProductVariants_generateVariantsForProduct_featuredAsset {
-  __typename: "Asset";
-  id: string;
-  name: string;
-  fileSize: number;
-  mimeType: string;
-  type: AssetType;
-  preview: string;
-  source: string;
-}
-
-export interface GenerateProductVariants_generateVariantsForProduct_assets {
-  __typename: "Asset";
-  id: string;
-  name: string;
-  fileSize: number;
-  mimeType: string;
-  type: AssetType;
-  preview: string;
-  source: string;
-}
-
-export interface GenerateProductVariants_generateVariantsForProduct_translations {
-  __typename: "ProductTranslation";
-  languageCode: LanguageCode;
-  name: string;
-  slug: string;
-  description: string;
-}
-
-export interface GenerateProductVariants_generateVariantsForProduct_optionGroups {
-  __typename: "ProductOptionGroup";
-  id: string;
-  languageCode: LanguageCode;
-  code: string;
-  name: string;
-}
-
-export interface GenerateProductVariants_generateVariantsForProduct_variants_options {
-  __typename: "ProductOption";
-  id: string;
-  code: string | null;
-  languageCode: LanguageCode | null;
-  name: string | null;
-}
-
-export interface GenerateProductVariants_generateVariantsForProduct_variants_facetValues {
-  __typename: "FacetValue";
-  id: string;
-  code: string;
-  name: string;
-}
-
-export interface GenerateProductVariants_generateVariantsForProduct_variants_translations {
-  __typename: "ProductVariantTranslation";
-  id: string;
-  languageCode: LanguageCode;
-  name: string;
-}
-
-export interface GenerateProductVariants_generateVariantsForProduct_variants {
-  __typename: "ProductVariant";
-  id: string;
-  languageCode: LanguageCode;
-  name: string;
-  price: number;
-  sku: string;
-  options: GenerateProductVariants_generateVariantsForProduct_variants_options[];
-  facetValues: GenerateProductVariants_generateVariantsForProduct_variants_facetValues[];
-  translations: GenerateProductVariants_generateVariantsForProduct_variants_translations[];
-}
-
-export interface GenerateProductVariants_generateVariantsForProduct {
-  __typename: "Product";
-  id: string;
-  languageCode: LanguageCode;
-  name: string;
-  slug: string;
-  description: string;
-  featuredAsset: GenerateProductVariants_generateVariantsForProduct_featuredAsset | null;
-  assets: GenerateProductVariants_generateVariantsForProduct_assets[];
-  translations: GenerateProductVariants_generateVariantsForProduct_translations[];
-  optionGroups: GenerateProductVariants_generateVariantsForProduct_optionGroups[];
-  variants: GenerateProductVariants_generateVariantsForProduct_variants[];
-}
-
-export interface GenerateProductVariants {
-  /**
-   * Create a set of ProductVariants based on the OptionGroups assigned to the given Product
-   */
-  generateVariantsForProduct: GenerateProductVariants_generateVariantsForProduct;
-}
-
-export interface GenerateProductVariantsVariables {
-  productId: string;
-  defaultPrice?: number | null;
-  defaultSku?: string | null;
+export interface UpdateProductMutationArgs {
+    input: UpdateProductInput;
 }
-
-/* tslint:disable */
-// This file was automatically generated and should not be edited.
-
-// ====================================================
-// GraphQL mutation operation: UpdateProductVariants
-// ====================================================
-
-export interface UpdateProductVariants_updateProductVariants_options {
-  __typename: "ProductOption";
-  id: string;
-  code: string | null;
-  languageCode: LanguageCode | null;
-  name: string | null;
+export interface AddOptionGroupToProductMutationArgs {
+    productId: string;
+    optionGroupId: string;
 }
-
-export interface UpdateProductVariants_updateProductVariants_facetValues {
-  __typename: "FacetValue";
-  id: string;
-  code: string;
-  name: string;
+export interface RemoveOptionGroupFromProductMutationArgs {
+    productId: string;
+    optionGroupId: string;
 }
-
-export interface UpdateProductVariants_updateProductVariants_translations {
-  __typename: "ProductVariantTranslation";
-  id: string;
-  languageCode: LanguageCode;
-  name: string;
+export interface GenerateVariantsForProductMutationArgs {
+    productId: string;
+    defaultPrice?: number | null;
+    defaultSku?: string | null;
 }
-
-export interface UpdateProductVariants_updateProductVariants {
-  __typename: "ProductVariant";
-  id: string;
-  languageCode: LanguageCode;
-  name: string;
-  price: number;
-  sku: string;
-  options: UpdateProductVariants_updateProductVariants_options[];
-  facetValues: UpdateProductVariants_updateProductVariants_facetValues[];
-  translations: UpdateProductVariants_updateProductVariants_translations[];
+export interface UpdateProductVariantsMutationArgs {
+    input: UpdateProductVariantInput[];
 }
-
-export interface UpdateProductVariants {
-  /**
-   * Update existing ProductVariants
-   */
-  updateProductVariants: (UpdateProductVariants_updateProductVariants | null)[];
+export interface ApplyFacetValuesToProductVariantsMutationArgs {
+    facetValueIds: string[];
+    productVariantIds: string[];
 }
-
-export interface UpdateProductVariantsVariables {
-  input: UpdateProductVariantInput[];
+export interface CreateRoleMutationArgs {
+    input: CreateRoleInput;
 }
-
-/* tslint:disable */
-// This file was automatically generated and should not be edited.
-
-// ====================================================
-// GraphQL mutation operation: CreateProductOptionGroup
-// ====================================================
-
-export interface CreateProductOptionGroup_createProductOptionGroup_translations {
-  __typename: "ProductOptionGroupTranslation";
-  name: string;
+export interface UpdateRoleMutationArgs {
+    input: UpdateRoleInput;
 }
-
-export interface CreateProductOptionGroup_createProductOptionGroup_options_translations {
-  __typename: "ProductOptionTranslation";
-  name: string;
+export interface SetAsLoggedInMutationArgs {
+    username: string;
+    loginTime: string;
 }
-
-export interface CreateProductOptionGroup_createProductOptionGroup_options {
-  __typename: "ProductOption";
-  id: string;
-  languageCode: LanguageCode | null;
-  name: string | null;
-  code: string | null;
-  translations: CreateProductOptionGroup_createProductOptionGroup_options_translations[];
+export interface SetUiLanguageMutationArgs {
+    languageCode?: LanguageCode | null;
 }
 
-export interface CreateProductOptionGroup_createProductOptionGroup {
-  __typename: "ProductOptionGroup";
-  id: string;
-  languageCode: LanguageCode;
-  code: string;
-  name: string;
-  translations: CreateProductOptionGroup_createProductOptionGroup_translations[];
-  options: CreateProductOptionGroup_createProductOptionGroup_options[];
-}
-
-export interface CreateProductOptionGroup {
-  /**
-   * Create a new ProductOptionGroup
-   */
-  createProductOptionGroup: CreateProductOptionGroup_createProductOptionGroup;
-}
-
-export interface CreateProductOptionGroupVariables {
-  input: CreateProductOptionGroupInput;
+export enum SortOrder {
+    ASC = 'ASC',
+    DESC = 'DESC',
 }
 
-/* tslint:disable */
-// This file was automatically generated and should not be edited.
-
-// ====================================================
-// GraphQL mutation operation: AddOptionGroupToProduct
-// ====================================================
-
-export interface AddOptionGroupToProduct_addOptionGroupToProduct_optionGroups_options {
-  __typename: "ProductOption";
-  id: string;
-  code: string | null;
+export enum Permission {
+    Authenticated = 'Authenticated',
+    SuperAdmin = 'SuperAdmin',
+    Owner = 'Owner',
+    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',
 }
 
-export interface AddOptionGroupToProduct_addOptionGroupToProduct_optionGroups {
-  __typename: "ProductOptionGroup";
-  id: string;
-  code: string;
-  options: AddOptionGroupToProduct_addOptionGroupToProduct_optionGroups_options[];
+export enum AssetType {
+    IMAGE = 'IMAGE',
+    VIDEO = 'VIDEO',
+    BINARY = 'BINARY',
 }
 
-export interface AddOptionGroupToProduct_addOptionGroupToProduct {
-  __typename: "Product";
-  id: string;
-  optionGroups: AddOptionGroupToProduct_addOptionGroupToProduct_optionGroups[];
-}
+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 type AdjustmentTarget = Order | OrderItem;
+
+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>;
+        config?: ConfigResolver<Config, any, Context>;
+        customers?: CustomersResolver<CustomerList, any, Context>;
+        customer?: CustomerResolver<Customer | null, any, Context>;
+        facets?: FacetsResolver<FacetList, any, Context>;
+        facet?: FacetResolver<Facet | null, any, Context>;
+        order?: OrderResolver<Order | null, any, Context>;
+        orders?: OrdersResolver<OrderList | 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>;
+        roles?: RolesResolver<RoleList, any, Context>;
+        role?: RoleResolver<Role | 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 ConfigResolver<R = Config, Parent = any, Context = any> = Resolver<R, Parent, Context>;
+    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 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 OrderResolver<R = Order | null, Parent = any, Context = any> = Resolver<
+        R,
+        Parent,
+        Context,
+        OrderArgs
+    >;
+    export interface OrderArgs {
+        id: string;
+    }
+
+    export type OrdersResolver<R = OrderList | null, Parent = any, Context = any> = Resolver<
+        R,
+        Parent,
+        Context,
+        OrdersArgs
+    >;
+    export interface OrdersArgs {
+        options?: OrderListOptions | 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 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 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>;
+        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 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>;
+        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 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>;
+    }
+
+    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 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 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>;
+        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>;
+        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 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 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 | 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>;
+        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 | 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 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 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 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<FacetCustomFields | 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 = FacetCustomFields | null, 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 | null, any, Context>;
+        name?: NameResolver<string, any, Context>;
+        code?: CodeResolver<string, any, Context>;
+        translations?: TranslationsResolver<FacetValueTranslation[], any, Context>;
+        customFields?: CustomFieldsResolver<FacetValueCustomFields | 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 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 = FacetValueCustomFields | null,
+        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 FacetValueCustomFieldsResolvers {
+    export interface Resolvers<Context = any> {
+        link?: LinkResolver<string | null, any, Context>;
+        available?: AvailableResolver<boolean | null, any, Context>;
+    }
+
+    export type LinkResolver<R = string | null, Parent = any, Context = any> = Resolver<R, Parent, Context>;
+    export type AvailableResolver<R = boolean | 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 FacetCustomFieldsResolvers {
+    export interface Resolvers<Context = any> {
+        searchable?: SearchableResolver<boolean | null, any, Context>;
+    }
+
+    export type SearchableResolver<R = boolean | null, 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>;
+        customer?: CustomerResolver<Customer, any, Context>;
+        items?: ItemsResolver<OrderItem[], 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 CodeResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
+    export type CustomerResolver<R = Customer, Parent = any, Context = any> = Resolver<R, Parent, Context>;
+    export type ItemsResolver<R = OrderItem[], Parent = any, Context = any> = Resolver<R, Parent, Context>;
+    export type AdjustmentsResolver<R = Adjustment[], 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>;
+        productVariant?: ProductVariantResolver<ProductVariant, any, Context>;
+        unitPrice?: UnitPriceResolver<number, any, Context>;
+        quantity?: QuantityResolver<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 UnitPriceResolver<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 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>;
+        price?: PriceResolver<number, 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 PriceResolver<R = number, 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 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 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 AdjustmentResolvers {
+    export interface Resolvers<Context = any> {
+        id?: IdResolver<string, any, Context>;
+        createdAt?: CreatedAtResolver<DateTime, any, Context>;
+        updatedAt?: UpdatedAtResolver<DateTime, any, Context>;
+        type?: TypeResolver<string, any, Context>;
+        amount?: AmountResolver<number, any, Context>;
+        target?: TargetResolver<AdjustmentTarget, any, Context>;
+        source?: SourceResolver<AdjustmentSource, 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 TypeResolver<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 TargetResolver<R = AdjustmentTarget, Parent = any, Context = any> = Resolver<
+        R,
+        Parent,
+        Context
+    >;
+    export type SourceResolver<R = AdjustmentSource, Parent = any, Context = any> = Resolver<
+        R,
+        Parent,
+        Context
+    >;
+}
+
+export namespace AdjustmentSourceResolvers {
+    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>;
+        type?: TypeResolver<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 type TypeResolver<R = string, 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 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>;
+        translations?: TranslationsResolver<ProductTranslation[], any, Context>;
+        customFields?: CustomFieldsResolver<ProductCustomFields | 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 TranslationsResolver<R = ProductTranslation[], Parent = any, Context = any> = Resolver<
+        R,
+        Parent,
+        Context
+    >;
+    export type CustomFieldsResolver<R = ProductCustomFields | 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>;
+        customFields?: CustomFieldsResolver<ProductTranslationCustomFields | 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 CustomFieldsResolver<
+        R = ProductTranslationCustomFields | null,
+        Parent = any,
+        Context = any
+    > = Resolver<R, Parent, Context>;
+}
+
+export namespace ProductTranslationCustomFieldsResolvers {
+    export interface Resolvers<Context = any> {
+        nickname?: NicknameResolver<string | null, any, Context>;
+    }
+
+    export type NicknameResolver<R = string | null, Parent = any, Context = any> = Resolver<
+        R,
+        Parent,
+        Context
+    >;
+}
+
+export namespace ProductCustomFieldsResolvers {
+    export interface Resolvers<Context = any> {
+        infoUrl?: InfoUrlResolver<string | null, any, Context>;
+        downloadable?: DownloadableResolver<boolean | null, any, Context>;
+        nickname?: NicknameResolver<string | null, any, Context>;
+    }
+
+    export type InfoUrlResolver<R = string | null, Parent = any, Context = any> = Resolver<
+        R,
+        Parent,
+        Context
+    >;
+    export type DownloadableResolver<R = boolean | null, Parent = any, Context = any> = Resolver<
+        R,
+        Parent,
+        Context
+    >;
+    export type NicknameResolver<R = string | null, 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 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>;
+        createChannel?: CreateChannelResolver<Channel, any, Context>;
+        createCustomer?: CreateCustomerResolver<Customer, any, Context>;
+        createCustomerAddress?: CreateCustomerAddressResolver<Address, any, Context>;
+        createFacet?: CreateFacetResolver<Facet, any, Context>;
+        updateFacet?: UpdateFacetResolver<Facet, any, Context>;
+        createFacetValues?: CreateFacetValuesResolver<FacetValue[], any, Context>;
+        updateFacetValues?: UpdateFacetValuesResolver<FacetValue[], any, Context>;
+        addItemToOrder?: AddItemToOrderResolver<Order | null, any, Context>;
+        removeItemFromOrder?: RemoveItemFromOrderResolver<Order | null, any, Context>;
+        adjustItemQuantity?: AdjustItemQuantityResolver<Order | null, any, Context>;
+        createProductOptionGroup?: CreateProductOptionGroupResolver<ProductOptionGroup, any, Context>;
+        updateProductOptionGroup?: UpdateProductOptionGroupResolver<ProductOptionGroup, any, Context>;
+        createProduct?: CreateProductResolver<Product, any, Context>;
+        updateProduct?: UpdateProductResolver<Product, any, Context>;
+        addOptionGroupToProduct?: AddOptionGroupToProductResolver<Product, any, Context>;
+        removeOptionGroupFromProduct?: RemoveOptionGroupFromProductResolver<Product, any, Context>;
+        generateVariantsForProduct?: GenerateVariantsForProductResolver<Product, any, Context>;
+        updateProductVariants?: UpdateProductVariantsResolver<(ProductVariant | null)[], any, Context>;
+        applyFacetValuesToProductVariants?: ApplyFacetValuesToProductVariantsResolver<
+            ProductVariant[],
+            any,
+            Context
+        >;
+        createRole?: CreateRoleResolver<Role, any, Context>;
+        updateRole?: UpdateRoleResolver<Role, 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 CreateChannelResolver<R = Channel, Parent = any, Context = any> = Resolver<
+        R,
+        Parent,
+        Context,
+        CreateChannelArgs
+    >;
+    export interface CreateChannelArgs {
+        code: 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 CreateCustomerAddressResolver<R = Address, Parent = any, Context = any> = Resolver<
+        R,
+        Parent,
+        Context,
+        CreateCustomerAddressArgs
+    >;
+    export interface CreateCustomerAddressArgs {
+        customerId: string;
+        input: CreateAddressInput;
+    }
+
+    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 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 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 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 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;
+        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 ApplyFacetValuesToProductVariantsResolver<
+        R = ProductVariant[],
+        Parent = any,
+        Context = any
+    > = Resolver<R, Parent, Context, ApplyFacetValuesToProductVariantsArgs>;
+    export interface ApplyFacetValuesToProductVariantsArgs {
+        facetValueIds: string[];
+        productVariantIds: 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 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 GetAdministrators {
+    export type Variables = {
+        options?: AdministratorListOptions | null;
+    };
+
+    export type Query = {
+        __typename?: 'Query';
+        administrators: Administrators;
+    };
+
+    export type Administrators = {
+        __typename?: 'AdministratorList';
+        items: Items[];
+        totalItems: number;
+    };
+
+    export type Items = Administrator.Fragment;
+}
+
+export namespace GetAdministrator {
+    export type Variables = {
+        id: string;
+    };
+
+    export type Query = {
+        __typename?: 'Query';
+        administrator?: Administrator | null;
+    };
+
+    export type Administrator = Administrator.Fragment;
+}
+
+export namespace CreateAdministrator {
+    export type Variables = {
+        input: CreateAdministratorInput;
+    };
+
+    export type Mutation = {
+        __typename?: 'Mutation';
+        createAdministrator: CreateAdministrator;
+    };
+
+    export type CreateAdministrator = Administrator.Fragment;
+}
+
+export namespace UpdateAdministrator {
+    export type Variables = {
+        input: UpdateAdministratorInput;
+    };
 
-export interface AddOptionGroupToProduct {
-  /**
-   * Add an OptionGroup to a Product
-   */
-  addOptionGroupToProduct: AddOptionGroupToProduct_addOptionGroupToProduct;
-}
+    export type Mutation = {
+        __typename?: 'Mutation';
+        updateAdministrator: UpdateAdministrator;
+    };
 
-export interface AddOptionGroupToProductVariables {
-  productId: string;
-  optionGroupId: string;
+    export type UpdateAdministrator = Administrator.Fragment;
 }
 
-/* tslint:disable */
-// This file was automatically generated and should not be edited.
+export namespace GetRoles {
+    export type Variables = {
+        options?: RoleListOptions | null;
+    };
 
-// ====================================================
-// GraphQL mutation operation: RemoveOptionGroupFromProduct
-// ====================================================
+    export type Query = {
+        __typename?: 'Query';
+        roles: Roles;
+    };
 
-export interface RemoveOptionGroupFromProduct_removeOptionGroupFromProduct_optionGroups_options {
-  __typename: "ProductOption";
-  id: string;
-  code: string | null;
-}
+    export type Roles = {
+        __typename?: 'RoleList';
+        items: Items[];
+        totalItems: number;
+    };
 
-export interface RemoveOptionGroupFromProduct_removeOptionGroupFromProduct_optionGroups {
-  __typename: "ProductOptionGroup";
-  id: string;
-  code: string;
-  options: RemoveOptionGroupFromProduct_removeOptionGroupFromProduct_optionGroups_options[];
+    export type Items = Role.Fragment;
 }
 
-export interface RemoveOptionGroupFromProduct_removeOptionGroupFromProduct {
-  __typename: "Product";
-  id: string;
-  optionGroups: RemoveOptionGroupFromProduct_removeOptionGroupFromProduct_optionGroups[];
-}
+export namespace GetRole {
+    export type Variables = {
+        id: string;
+    };
 
-export interface RemoveOptionGroupFromProduct {
-  /**
-   * Remove an OptionGroup from a Product
-   */
-  removeOptionGroupFromProduct: RemoveOptionGroupFromProduct_removeOptionGroupFromProduct;
-}
+    export type Query = {
+        __typename?: 'Query';
+        role?: Role | null;
+    };
 
-export interface RemoveOptionGroupFromProductVariables {
-  productId: string;
-  optionGroupId: string;
+    export type Role = Role.Fragment;
 }
 
-/* tslint:disable */
-// This file was automatically generated and should not be edited.
+export namespace CreateRole {
+    export type Variables = {
+        input: CreateRoleInput;
+    };
 
-// ====================================================
-// GraphQL mutation operation: ApplyFacetValuesToProductVariants
-// ====================================================
+    export type Mutation = {
+        __typename?: 'Mutation';
+        createRole: CreateRole;
+    };
 
-export interface ApplyFacetValuesToProductVariants_applyFacetValuesToProductVariants_options {
-  __typename: "ProductOption";
-  id: string;
-  code: string | null;
-  languageCode: LanguageCode | null;
-  name: string | null;
+    export type CreateRole = Role.Fragment;
 }
 
-export interface ApplyFacetValuesToProductVariants_applyFacetValuesToProductVariants_facetValues {
-  __typename: "FacetValue";
-  id: string;
-  code: string;
-  name: string;
-}
+export namespace UpdateRole {
+    export type Variables = {
+        input: UpdateRoleInput;
+    };
 
-export interface ApplyFacetValuesToProductVariants_applyFacetValuesToProductVariants_translations {
-  __typename: "ProductVariantTranslation";
-  id: string;
-  languageCode: LanguageCode;
-  name: string;
-}
+    export type Mutation = {
+        __typename?: 'Mutation';
+        updateRole: UpdateRole;
+    };
 
-export interface ApplyFacetValuesToProductVariants_applyFacetValuesToProductVariants {
-  __typename: "ProductVariant";
-  id: string;
-  languageCode: LanguageCode;
-  name: string;
-  price: number;
-  sku: string;
-  options: ApplyFacetValuesToProductVariants_applyFacetValuesToProductVariants_options[];
-  facetValues: ApplyFacetValuesToProductVariants_applyFacetValuesToProductVariants_facetValues[];
-  translations: ApplyFacetValuesToProductVariants_applyFacetValuesToProductVariants_translations[];
+    export type UpdateRole = Role.Fragment;
 }
 
-export interface ApplyFacetValuesToProductVariants {
-  /**
-   * Applies a FacetValue to the given ProductVariants
-   */
-  applyFacetValuesToProductVariants: ApplyFacetValuesToProductVariants_applyFacetValuesToProductVariants[];
-}
+export namespace AssignRoleToAdministrator {
+    export type Variables = {
+        administratorId: string;
+        roleId: string;
+    };
 
-export interface ApplyFacetValuesToProductVariantsVariables {
-  facetValueIds: string[];
-  productVariantIds: string[];
-}
+    export type Mutation = {
+        __typename?: 'Mutation';
+        assignRoleToAdministrator: AssignRoleToAdministrator;
+    };
 
-/* tslint:disable */
-// This file was automatically generated and should not be edited.
-
-// ====================================================
-// GraphQL query operation: GetProductWithVariants
-// ====================================================
-
-export interface GetProductWithVariants_product_featuredAsset {
-  __typename: "Asset";
-  id: string;
-  name: string;
-  fileSize: number;
-  mimeType: string;
-  type: AssetType;
-  preview: string;
-  source: string;
-}
-
-export interface GetProductWithVariants_product_assets {
-  __typename: "Asset";
-  id: string;
-  name: string;
-  fileSize: number;
-  mimeType: string;
-  type: AssetType;
-  preview: string;
-  source: string;
-}
-
-export interface GetProductWithVariants_product_translations {
-  __typename: "ProductTranslation";
-  languageCode: LanguageCode;
-  name: string;
-  slug: string;
-  description: string;
-}
-
-export interface GetProductWithVariants_product_optionGroups {
-  __typename: "ProductOptionGroup";
-  id: string;
-  languageCode: LanguageCode;
-  code: string;
-  name: string;
-}
-
-export interface GetProductWithVariants_product_variants_options {
-  __typename: "ProductOption";
-  id: string;
-  code: string | null;
-  languageCode: LanguageCode | null;
-  name: string | null;
-}
-
-export interface GetProductWithVariants_product_variants_facetValues {
-  __typename: "FacetValue";
-  id: string;
-  code: string;
-  name: string;
-}
-
-export interface GetProductWithVariants_product_variants_translations {
-  __typename: "ProductVariantTranslation";
-  id: string;
-  languageCode: LanguageCode;
-  name: string;
-}
-
-export interface GetProductWithVariants_product_variants {
-  __typename: "ProductVariant";
-  id: string;
-  languageCode: LanguageCode;
-  name: string;
-  price: number;
-  sku: string;
-  options: GetProductWithVariants_product_variants_options[];
-  facetValues: GetProductWithVariants_product_variants_facetValues[];
-  translations: GetProductWithVariants_product_variants_translations[];
-}
-
-export interface GetProductWithVariants_product {
-  __typename: "Product";
-  id: string;
-  languageCode: LanguageCode;
-  name: string;
-  slug: string;
-  description: string;
-  featuredAsset: GetProductWithVariants_product_featuredAsset | null;
-  assets: GetProductWithVariants_product_assets[];
-  translations: GetProductWithVariants_product_translations[];
-  optionGroups: GetProductWithVariants_product_optionGroups[];
-  variants: GetProductWithVariants_product_variants[];
-}
-
-export interface GetProductWithVariants {
-  product: GetProductWithVariants_product | null;
-}
-
-export interface GetProductWithVariantsVariables {
-  id: string;
-  languageCode?: LanguageCode | null;
+    export type AssignRoleToAdministrator = Administrator.Fragment;
 }
 
-/* tslint:disable */
-// This file was automatically generated and should not be edited.
+export namespace AttemptLogin {
+    export type Variables = {
+        username: string;
+        password: string;
+        rememberMe: boolean;
+    };
 
-// ====================================================
-// GraphQL query operation: GetProductList
-// ====================================================
+    export type Mutation = {
+        __typename?: 'Mutation';
+        login: Login;
+    };
 
-export interface GetProductList_products_items {
-  __typename: "Product";
-  id: string;
-  languageCode: LanguageCode;
-  name: string;
-  slug: string;
-  description: string;
-}
+    export type Login = {
+        __typename?: 'LoginResult';
+        user: User;
+    };
 
-export interface GetProductList_products {
-  __typename: "ProductList";
-  items: GetProductList_products_items[];
-  totalItems: number;
+    export type User = CurrentUser.Fragment;
 }
 
-export interface GetProductList {
-  products: GetProductList_products;
-}
+export namespace LogOut {
+    export type Variables = {};
 
-export interface GetProductListVariables {
-  options?: ProductListOptions | null;
-  languageCode?: LanguageCode | null;
+    export type Mutation = {
+        __typename?: 'Mutation';
+        logout: boolean;
+    };
 }
 
-/* tslint:disable */
-// This file was automatically generated and should not be edited.
+export namespace GetCurrentUser {
+    export type Variables = {};
 
-// ====================================================
-// GraphQL query operation: GetProductOptionGroups
-// ====================================================
+    export type Query = {
+        __typename?: 'Query';
+        me?: Me | null;
+    };
 
-export interface GetProductOptionGroups_productOptionGroups_options {
-  __typename: "ProductOption";
-  id: string;
-  languageCode: LanguageCode | null;
-  code: string | null;
-  name: string | null;
+    export type Me = CurrentUser.Fragment;
 }
 
-export interface GetProductOptionGroups_productOptionGroups {
-  __typename: "ProductOptionGroup";
-  id: string;
-  languageCode: LanguageCode;
-  code: string;
-  name: string;
-  options: GetProductOptionGroups_productOptionGroups_options[];
-}
+export namespace GetServerConfig {
+    export type Variables = {};
 
-export interface GetProductOptionGroups {
-  productOptionGroups: GetProductOptionGroups_productOptionGroups[];
-}
+    export type Query = {
+        __typename?: 'Query';
+        config: Config;
+    };
 
-export interface GetProductOptionGroupsVariables {
-  filterTerm?: string | null;
-  languageCode?: LanguageCode | null;
+    export type Config = {
+        __typename?: 'Config';
+        customFields?: Json | null;
+    };
 }
 
-/* tslint:disable */
-// This file was automatically generated and should not be edited.
+export namespace CreateFacet {
+    export type Variables = {
+        input: CreateFacetInput;
+    };
 
-// ====================================================
-// GraphQL query operation: GetAssetList
-// ====================================================
+    export type Mutation = {
+        __typename?: 'Mutation';
+        createFacet: CreateFacet;
+    };
 
-export interface GetAssetList_assets_items {
-  __typename: "Asset";
-  id: string;
-  name: string;
-  fileSize: number;
-  mimeType: string;
-  type: AssetType;
-  preview: string;
-  source: string;
+    export type CreateFacet = FacetWithValues.Fragment;
 }
 
-export interface GetAssetList_assets {
-  __typename: "AssetList";
-  items: GetAssetList_assets_items[];
-  totalItems: number;
-}
+export namespace UpdateFacet {
+    export type Variables = {
+        input: UpdateFacetInput;
+    };
 
-export interface GetAssetList {
-  assets: GetAssetList_assets;
-}
+    export type Mutation = {
+        __typename?: 'Mutation';
+        updateFacet: UpdateFacet;
+    };
 
-export interface GetAssetListVariables {
-  options?: AssetListOptions | null;
+    export type UpdateFacet = FacetWithValues.Fragment;
 }
 
-/* tslint:disable */
-// This file was automatically generated and should not be edited.
-
-// ====================================================
-// GraphQL mutation operation: CreateAssets
-// ====================================================
+export namespace CreateFacetValues {
+    export type Variables = {
+        input: CreateFacetValueInput[];
+    };
 
-export interface CreateAssets_createAssets {
-  __typename: "Asset";
-  id: string;
-  name: string;
-  fileSize: number;
-  mimeType: string;
-  type: AssetType;
-  preview: string;
-  source: string;
-}
-
-export interface CreateAssets {
-  /**
-   * Create a new Asset
-   */
-  createAssets: CreateAssets_createAssets[];
-}
+    export type Mutation = {
+        __typename?: 'Mutation';
+        createFacetValues: CreateFacetValues[];
+    };
 
-export interface CreateAssetsVariables {
-  input: CreateAssetInput[];
+    export type CreateFacetValues = FacetValue.Fragment;
 }
 
-/* tslint:disable */
-// This file was automatically generated and should not be edited.
-
-// ====================================================
-// GraphQL fragment: Administrator
-// ====================================================
-
-export interface Administrator_user_roles {
-  __typename: "Role";
-  id: string;
-  code: string;
-  description: string;
-  permissions: Permission[];
-}
+export namespace UpdateFacetValues {
+    export type Variables = {
+        input: UpdateFacetValueInput[];
+    };
 
-export interface Administrator_user {
-  __typename: "User";
-  id: string;
-  identifier: string;
-  lastLogin: string | null;
-  roles: Administrator_user_roles[];
-}
+    export type Mutation = {
+        __typename?: 'Mutation';
+        updateFacetValues: UpdateFacetValues[];
+    };
 
-export interface Administrator {
-  __typename: "Administrator";
-  id: string;
-  firstName: string;
-  lastName: string;
-  emailAddress: string;
-  user: Administrator_user;
+    export type UpdateFacetValues = FacetValue.Fragment;
 }
 
-/* tslint:disable */
-// This file was automatically generated and should not be edited.
+export namespace GetFacetList {
+    export type Variables = {
+        options?: FacetListOptions | null;
+        languageCode?: LanguageCode | null;
+    };
 
-// ====================================================
-// GraphQL fragment: Role
-// ====================================================
+    export type Query = {
+        __typename?: 'Query';
+        facets: Facets;
+    };
 
-export interface Role_channels {
-  __typename: "Channel";
-  id: string;
-  code: string;
-  token: string;
-}
+    export type Facets = {
+        __typename?: 'FacetList';
+        items: Items[];
+        totalItems: number;
+    };
 
-export interface Role {
-  __typename: "Role";
-  id: string;
-  code: string;
-  description: string;
-  permissions: Permission[];
-  channels: Role_channels[];
+    export type Items = FacetWithValues.Fragment;
 }
 
-/* tslint:disable */
-// This file was automatically generated and should not be edited.
+export namespace GetFacetWithValues {
+    export type Variables = {
+        id: string;
+        languageCode?: LanguageCode | null;
+    };
 
-// ====================================================
-// GraphQL fragment: CurrentUser
-// ====================================================
+    export type Query = {
+        __typename?: 'Query';
+        facet?: Facet | null;
+    };
 
-export interface CurrentUser {
-  __typename: "CurrentUser";
-  id: string;
-  identifier: string;
-  channelTokens: string[];
+    export type Facet = FacetWithValues.Fragment;
 }
 
-/* tslint:disable */
-// This file was automatically generated and should not be edited.
-
-// ====================================================
-// GraphQL fragment: FacetValue
-// ====================================================
-
-export interface FacetValue_translations {
-  __typename: "FacetValueTranslation";
-  id: string;
-  languageCode: LanguageCode;
-  name: string;
-}
+export namespace RequestStarted {
+    export type Variables = {};
 
-export interface FacetValue {
-  __typename: "FacetValue";
-  id: string;
-  languageCode: LanguageCode | null;
-  code: string;
-  name: string;
-  translations: FacetValue_translations[];
+    export type Mutation = {
+        __typename?: 'Mutation';
+        requestStarted: number;
+    };
 }
 
-/* tslint:disable */
-// This file was automatically generated and should not be edited.
-
-// ====================================================
-// GraphQL fragment: FacetWithValues
-// ====================================================
+export namespace RequestCompleted {
+    export type Variables = {};
 
-export interface FacetWithValues_translations {
-  __typename: "FacetTranslation";
-  id: string;
-  languageCode: LanguageCode;
-  name: string;
+    export type Mutation = {
+        __typename?: 'Mutation';
+        requestCompleted: number;
+    };
 }
 
-export interface FacetWithValues_values_translations {
-  __typename: "FacetValueTranslation";
-  id: string;
-  languageCode: LanguageCode;
-  name: string;
-}
+export namespace SetAsLoggedIn {
+    export type Variables = {
+        username: string;
+        loginTime: string;
+    };
 
-export interface FacetWithValues_values {
-  __typename: "FacetValue";
-  id: string;
-  languageCode: LanguageCode | null;
-  code: string;
-  name: string;
-  translations: FacetWithValues_values_translations[];
-}
+    export type Mutation = {
+        __typename?: 'Mutation';
+        setAsLoggedIn: SetAsLoggedIn;
+    };
 
-export interface FacetWithValues {
-  __typename: "Facet";
-  id: string;
-  languageCode: LanguageCode;
-  code: string;
-  name: string;
-  translations: FacetWithValues_translations[];
-  values: FacetWithValues_values[];
+    export type SetAsLoggedIn = {
+        __typename?: 'UserStatus';
+        username: string;
+        isLoggedIn: boolean;
+        loginTime: string;
+    };
 }
 
-/* tslint:disable */
-// This file was automatically generated and should not be edited.
+export namespace SetAsLoggedOut {
+    export type Variables = {};
 
-// ====================================================
-// GraphQL fragment: Asset
-// ====================================================
+    export type Mutation = {
+        __typename?: 'Mutation';
+        setAsLoggedOut: SetAsLoggedOut;
+    };
 
-export interface Asset {
-  __typename: "Asset";
-  id: string;
-  name: string;
-  fileSize: number;
-  mimeType: string;
-  type: AssetType;
-  preview: string;
-  source: string;
+    export type SetAsLoggedOut = {
+        __typename?: 'UserStatus';
+        username: string;
+        isLoggedIn: boolean;
+        loginTime: string;
+    };
 }
 
-/* tslint:disable */
-// This file was automatically generated and should not be edited.
-
-// ====================================================
-// GraphQL fragment: ProductVariant
-// ====================================================
-
-export interface ProductVariant_options {
-  __typename: "ProductOption";
-  id: string;
-  code: string | null;
-  languageCode: LanguageCode | null;
-  name: string | null;
-}
+export namespace SetUiLanguage {
+    export type Variables = {
+        languageCode: LanguageCode;
+    };
 
-export interface ProductVariant_facetValues {
-  __typename: "FacetValue";
-  id: string;
-  code: string;
-  name: string;
+    export type Mutation = {
+        __typename?: 'Mutation';
+        setUiLanguage?: LanguageCode | null;
+    };
 }
 
-export interface ProductVariant_translations {
-  __typename: "ProductVariantTranslation";
-  id: string;
-  languageCode: LanguageCode;
-  name: string;
-}
+export namespace GetNetworkStatus {
+    export type Variables = {};
 
-export interface ProductVariant {
-  __typename: "ProductVariant";
-  id: string;
-  languageCode: LanguageCode;
-  name: string;
-  price: number;
-  sku: string;
-  options: ProductVariant_options[];
-  facetValues: ProductVariant_facetValues[];
-  translations: ProductVariant_translations[];
-}
+    export type Query = {
+        __typename?: 'Query';
+        networkStatus: NetworkStatus;
+    };
 
-/* tslint:disable */
-// This file was automatically generated and should not be edited.
-
-// ====================================================
-// GraphQL fragment: ProductWithVariants
-// ====================================================
-
-export interface ProductWithVariants_featuredAsset {
-  __typename: "Asset";
-  id: string;
-  name: string;
-  fileSize: number;
-  mimeType: string;
-  type: AssetType;
-  preview: string;
-  source: string;
-}
-
-export interface ProductWithVariants_assets {
-  __typename: "Asset";
-  id: string;
-  name: string;
-  fileSize: number;
-  mimeType: string;
-  type: AssetType;
-  preview: string;
-  source: string;
-}
-
-export interface ProductWithVariants_translations {
-  __typename: "ProductTranslation";
-  languageCode: LanguageCode;
-  name: string;
-  slug: string;
-  description: string;
-}
-
-export interface ProductWithVariants_optionGroups {
-  __typename: "ProductOptionGroup";
-  id: string;
-  languageCode: LanguageCode;
-  code: string;
-  name: string;
-}
-
-export interface ProductWithVariants_variants_options {
-  __typename: "ProductOption";
-  id: string;
-  code: string | null;
-  languageCode: LanguageCode | null;
-  name: string | null;
-}
-
-export interface ProductWithVariants_variants_facetValues {
-  __typename: "FacetValue";
-  id: string;
-  code: string;
-  name: string;
-}
-
-export interface ProductWithVariants_variants_translations {
-  __typename: "ProductVariantTranslation";
-  id: string;
-  languageCode: LanguageCode;
-  name: string;
-}
-
-export interface ProductWithVariants_variants {
-  __typename: "ProductVariant";
-  id: string;
-  languageCode: LanguageCode;
-  name: string;
-  price: number;
-  sku: string;
-  options: ProductWithVariants_variants_options[];
-  facetValues: ProductWithVariants_variants_facetValues[];
-  translations: ProductWithVariants_variants_translations[];
-}
-
-export interface ProductWithVariants {
-  __typename: "Product";
-  id: string;
-  languageCode: LanguageCode;
-  name: string;
-  slug: string;
-  description: string;
-  featuredAsset: ProductWithVariants_featuredAsset | null;
-  assets: ProductWithVariants_assets[];
-  translations: ProductWithVariants_translations[];
-  optionGroups: ProductWithVariants_optionGroups[];
-  variants: ProductWithVariants_variants[];
+    export type NetworkStatus = {
+        __typename?: 'NetworkStatus';
+        inFlightRequests: number;
+    };
 }
 
-/* tslint:disable */
-// This file was automatically generated and should not be edited.
+export namespace GetUserStatus {
+    export type Variables = {};
 
-// ====================================================
-// GraphQL fragment: ProductOptionGroup
-// ====================================================
+    export type Query = {
+        __typename?: 'Query';
+        userStatus: UserStatus;
+    };
 
-export interface ProductOptionGroup_translations {
-  __typename: "ProductOptionGroupTranslation";
-  name: string;
+    export type UserStatus = {
+        __typename?: 'UserStatus';
+        username: string;
+        isLoggedIn: boolean;
+        loginTime: string;
+    };
 }
 
-export interface ProductOptionGroup_options_translations {
-  __typename: "ProductOptionTranslation";
-  name: string;
-}
+export namespace GetUiState {
+    export type Variables = {};
 
-export interface ProductOptionGroup_options {
-  __typename: "ProductOption";
-  id: string;
-  languageCode: LanguageCode | null;
-  name: string | null;
-  code: string | null;
-  translations: ProductOptionGroup_options_translations[];
-}
+    export type Query = {
+        __typename?: 'Query';
+        uiState: UiState;
+    };
 
-export interface ProductOptionGroup {
-  __typename: "ProductOptionGroup";
-  id: string;
-  languageCode: LanguageCode;
-  code: string;
-  name: string;
-  translations: ProductOptionGroup_translations[];
-  options: ProductOptionGroup_options[];
+    export type UiState = {
+        __typename?: 'UiState';
+        language: LanguageCode;
+    };
 }
 
-/* tslint:disable */
-// This file was automatically generated and should not be edited.
+export namespace UpdateProduct {
+    export type Variables = {
+        input: UpdateProductInput;
+    };
 
-//==============================================================
-// START Enums and Input Objects
-//==============================================================
+    export type Mutation = {
+        __typename?: 'Mutation';
+        updateProduct: UpdateProduct;
+    };
 
-export enum AssetType {
-  BINARY = "BINARY",
-  IMAGE = "IMAGE",
-  VIDEO = "VIDEO",
+    export type UpdateProduct = ProductWithVariants.Fragment;
 }
 
-/**
- * ISO 639-1 language code
- */
-export enum LanguageCode {
-  aa = "aa",
-  ab = "ab",
-  ae = "ae",
-  af = "af",
-  ak = "ak",
-  am = "am",
-  an = "an",
-  ar = "ar",
-  as = "as",
-  av = "av",
-  ay = "ay",
-  az = "az",
-  ba = "ba",
-  be = "be",
-  bg = "bg",
-  bh = "bh",
-  bi = "bi",
-  bm = "bm",
-  bn = "bn",
-  bo = "bo",
-  br = "br",
-  bs = "bs",
-  ca = "ca",
-  ce = "ce",
-  ch = "ch",
-  co = "co",
-  cr = "cr",
-  cs = "cs",
-  cu = "cu",
-  cv = "cv",
-  cy = "cy",
-  da = "da",
-  de = "de",
-  dv = "dv",
-  dz = "dz",
-  ee = "ee",
-  el = "el",
-  en = "en",
-  eo = "eo",
-  es = "es",
-  et = "et",
-  eu = "eu",
-  fa = "fa",
-  ff = "ff",
-  fi = "fi",
-  fj = "fj",
-  fo = "fo",
-  fr = "fr",
-  fy = "fy",
-  ga = "ga",
-  gd = "gd",
-  gl = "gl",
-  gn = "gn",
-  gu = "gu",
-  gv = "gv",
-  ha = "ha",
-  he = "he",
-  hi = "hi",
-  ho = "ho",
-  hr = "hr",
-  ht = "ht",
-  hu = "hu",
-  hy = "hy",
-  hz = "hz",
-  ia = "ia",
-  id = "id",
-  ie = "ie",
-  ig = "ig",
-  ii = "ii",
-  ik = "ik",
-  io = "io",
-  is = "is",
-  it = "it",
-  iu = "iu",
-  ja = "ja",
-  jv = "jv",
-  ka = "ka",
-  kg = "kg",
-  ki = "ki",
-  kj = "kj",
-  kk = "kk",
-  kl = "kl",
-  km = "km",
-  kn = "kn",
-  ko = "ko",
-  kr = "kr",
-  ks = "ks",
-  ku = "ku",
-  kv = "kv",
-  kw = "kw",
-  ky = "ky",
-  la = "la",
-  lb = "lb",
-  lg = "lg",
-  li = "li",
-  ln = "ln",
-  lo = "lo",
-  lt = "lt",
-  lu = "lu",
-  lv = "lv",
-  mg = "mg",
-  mh = "mh",
-  mi = "mi",
-  mk = "mk",
-  ml = "ml",
-  mn = "mn",
-  mr = "mr",
-  ms = "ms",
-  mt = "mt",
-  my = "my",
-  na = "na",
-  nb = "nb",
-  nd = "nd",
-  ne = "ne",
-  ng = "ng",
-  nl = "nl",
-  nn = "nn",
-  no = "no",
-  nr = "nr",
-  nv = "nv",
-  ny = "ny",
-  oc = "oc",
-  oj = "oj",
-  om = "om",
-  or = "or",
-  os = "os",
-  pa = "pa",
-  pi = "pi",
-  pl = "pl",
-  ps = "ps",
-  pt = "pt",
-  qu = "qu",
-  rm = "rm",
-  rn = "rn",
-  ro = "ro",
-  ru = "ru",
-  rw = "rw",
-  sa = "sa",
-  sc = "sc",
-  sd = "sd",
-  se = "se",
-  sg = "sg",
-  si = "si",
-  sk = "sk",
-  sl = "sl",
-  sm = "sm",
-  sn = "sn",
-  so = "so",
-  sq = "sq",
-  sr = "sr",
-  ss = "ss",
-  st = "st",
-  su = "su",
-  sv = "sv",
-  sw = "sw",
-  ta = "ta",
-  te = "te",
-  tg = "tg",
-  th = "th",
-  ti = "ti",
-  tk = "tk",
-  tl = "tl",
-  tn = "tn",
-  to = "to",
-  tr = "tr",
-  ts = "ts",
-  tt = "tt",
-  tw = "tw",
-  ty = "ty",
-  ug = "ug",
-  uk = "uk",
-  ur = "ur",
-  uz = "uz",
-  ve = "ve",
-  vi = "vi",
-  vo = "vo",
-  wa = "wa",
-  wo = "wo",
-  xh = "xh",
-  yi = "yi",
-  yo = "yo",
-  za = "za",
-  zh = "zh",
-  zu = "zu",
-}
-
-/**
- *  Permissions for administrators and customers 
- */
-export enum Permission {
-  Authenticated = "Authenticated",
-  CreateAdministrator = "CreateAdministrator",
-  CreateCatalog = "CreateCatalog",
-  CreateCustomer = "CreateCustomer",
-  CreateOrder = "CreateOrder",
-  DeleteAdministrator = "DeleteAdministrator",
-  DeleteCatalog = "DeleteCatalog",
-  DeleteCustomer = "DeleteCustomer",
-  DeleteOrder = "DeleteOrder",
-  Owner = "Owner",
-  ReadAdministrator = "ReadAdministrator",
-  ReadCatalog = "ReadCatalog",
-  ReadCustomer = "ReadCustomer",
-  ReadOrder = "ReadOrder",
-  SuperAdmin = "SuperAdmin",
-  UpdateAdministrator = "UpdateAdministrator",
-  UpdateCatalog = "UpdateCatalog",
-  UpdateCustomer = "UpdateCustomer",
-  UpdateOrder = "UpdateOrder",
-}
+export namespace CreateProduct {
+    export type Variables = {
+        input: CreateProductInput;
+    };
 
-export enum SortOrder {
-  ASC = "ASC",
-  DESC = "DESC",
-}
+    export type Mutation = {
+        __typename?: 'Mutation';
+        createProduct: CreateProduct;
+    };
 
-export interface AdministratorFilterParameter {
-  firstName?: StringOperators | null;
-  lastName?: StringOperators | null;
-  emailAddress?: StringOperators | null;
-  createdAt?: DateOperators | null;
-  updatedAt?: DateOperators | null;
+    export type CreateProduct = ProductWithVariants.Fragment;
 }
 
-export interface AdministratorListOptions {
-  take?: number | null;
-  skip?: number | null;
-  sort?: AdministratorSortParameter | null;
-  filter?: AdministratorFilterParameter | null;
-}
+export namespace GenerateProductVariants {
+    export type Variables = {
+        productId: string;
+        defaultPrice?: number | null;
+        defaultSku?: string | null;
+    };
 
-export interface AdministratorSortParameter {
-  id?: SortOrder | null;
-  createdAt?: SortOrder | null;
-  updatedAt?: SortOrder | null;
-  firstName?: SortOrder | null;
-  lastName?: SortOrder | null;
-  emailAddress?: SortOrder | null;
-}
+    export type Mutation = {
+        __typename?: 'Mutation';
+        generateVariantsForProduct: GenerateVariantsForProduct;
+    };
 
-export interface AssetFilterParameter {
-  name?: StringOperators | null;
-  description?: StringOperators | null;
-  type?: StringOperators | null;
-  createdAt?: DateOperators | null;
-  updatedAt?: DateOperators | null;
+    export type GenerateVariantsForProduct = ProductWithVariants.Fragment;
 }
 
-export interface AssetListOptions {
-  take?: number | null;
-  skip?: number | null;
-  sort?: AssetSortParameter | null;
-  filter?: AssetFilterParameter | null;
-}
+export namespace UpdateProductVariants {
+    export type Variables = {
+        input: UpdateProductVariantInput[];
+    };
 
-export interface AssetSortParameter {
-  id?: SortOrder | null;
-  createdAt?: SortOrder | null;
-  updatedAt?: SortOrder | null;
-  name?: SortOrder | null;
-  description?: SortOrder | null;
-}
+    export type Mutation = {
+        __typename?: 'Mutation';
+        updateProductVariants: (UpdateProductVariants | null)[];
+    };
 
-export interface BooleanOperators {
-  eq?: boolean | null;
+    export type UpdateProductVariants = ProductVariant.Fragment;
 }
 
-export interface CreateAdministratorInput {
-  firstName: string;
-  lastName: string;
-  emailAddress: string;
-  password: string;
-  roleIds: string[];
-}
+export namespace CreateProductOptionGroup {
+    export type Variables = {
+        input: CreateProductOptionGroupInput;
+    };
 
-export interface CreateAssetInput {
-  file: any;
-}
+    export type Mutation = {
+        __typename?: 'Mutation';
+        createProductOptionGroup: CreateProductOptionGroup;
+    };
 
-export interface CreateFacetCustomFieldsInput {
-  searchable?: boolean | null;
+    export type CreateProductOptionGroup = ProductOptionGroup.Fragment;
 }
 
-export interface CreateFacetInput {
-  code: string;
-  translations: FacetTranslationInput[];
-  values?: CreateFacetValueWithFacetInput[] | null;
-  customFields?: CreateFacetCustomFieldsInput | null;
-}
+export namespace AddOptionGroupToProduct {
+    export type Variables = {
+        productId: string;
+        optionGroupId: string;
+    };
 
-export interface CreateFacetValueCustomFieldsInput {
-  link?: string | null;
-  available?: boolean | null;
-}
+    export type Mutation = {
+        __typename?: 'Mutation';
+        addOptionGroupToProduct: AddOptionGroupToProduct;
+    };
 
-export interface CreateFacetValueInput {
-  facetId: string;
-  code: string;
-  translations: FacetValueTranslationInput[];
-  customFields?: CreateFacetValueCustomFieldsInput | null;
-}
+    export type AddOptionGroupToProduct = {
+        __typename?: 'Product';
+        id: string;
+        optionGroups: OptionGroups[];
+    };
 
-export interface CreateFacetValueWithFacetInput {
-  code: string;
-  translations: FacetValueTranslationInput[];
+    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 namespace ApplyFacetValuesToProductVariants {
+    export type Variables = {
+        facetValueIds: string[];
+        productVariantIds: string[];
+    };
+
+    export type Mutation = {
+        __typename?: 'Mutation';
+        applyFacetValuesToProductVariants: ApplyFacetValuesToProductVariants[];
+    };
+
+    export type ApplyFacetValuesToProductVariants = ProductVariant.Fragment;
+}
+
+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 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;
+        description: 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 namespace GetAssetList {
+    export type Variables = {
+        options?: AssetListOptions | null;
+    };
+
+    export type Query = {
+        __typename?: 'Query';
+        assets: Assets;
+    };
+
+    export type Assets = {
+        __typename?: 'AssetList';
+        items: Items[];
+        totalItems: number;
+    };
+
+    export type Items = Asset.Fragment;
+}
+
+export namespace CreateAssets {
+    export type Variables = {
+        input: CreateAssetInput[];
+    };
+
+    export type Mutation = {
+        __typename?: 'Mutation';
+        createAssets: CreateAssets[];
+    };
+
+    export type CreateAssets = Asset.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?: string | null;
+        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 FacetValue {
+    export type Fragment = {
+        __typename?: 'FacetValue';
+        id: string;
+        languageCode?: LanguageCode | null;
+        code: string;
+        name: string;
+        translations: Translations[];
+    };
+
+    export type Translations = {
+        __typename?: 'FacetValueTranslation';
+        id: string;
+        languageCode: LanguageCode;
+        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 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;
+        sku: string;
+        options: Options[];
+        facetValues: FacetValues[];
+        translations: Translations[];
+    };
+
+    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;
+    };
+
+    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?: FeaturedAsset | null;
+        assets: Assets[];
+        translations: Translations[];
+        optionGroups: OptionGroups[];
+        variants: Variants[];
+    };
+
+    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 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 CreateProductCustomFieldsInput {
-  infoUrl?: string | null;
-  downloadable?: boolean | null;
-}
-
-export interface CreateProductInput {
-  featuredAssetId?: string | null;
-  assetIds?: string[] | null;
-  translations: ProductTranslationInput[];
-  customFields?: CreateProductCustomFieldsInput | null;
-}
-
-export interface CreateProductOptionGroupInput {
-  code: string;
-  translations: ProductOptionGroupTranslationInput[];
-  options: CreateProductOptionInput[];
-  customFields?: any | null;
-}
-
-export interface CreateProductOptionInput {
-  code: string;
-  translations: ProductOptionGroupTranslationInput[];
-  customFields?: any | null;
-}
-
-export interface CreateRoleInput {
-  code: string;
-  description: string;
-  permissions: Permission[];
-}
-
-export interface DateOperators {
-  eq?: any | null;
-  before?: any | null;
-  after?: any | null;
-  between?: DateRange | null;
-}
-
-export interface DateRange {
-  start: any;
-  end: any;
-}
-
-export interface FacetFilterParameter {
-  name?: StringOperators | null;
-  code?: StringOperators | null;
-  createdAt?: DateOperators | null;
-  updatedAt?: DateOperators | null;
-  searchable?: BooleanOperators | null;
-}
-
-export interface FacetListOptions {
-  take?: number | null;
-  skip?: number | null;
-  sort?: FacetSortParameter | null;
-  filter?: FacetFilterParameter | null;
-}
-
-export interface FacetSortParameter {
-  id?: SortOrder | null;
-  createdAt?: SortOrder | null;
-  updatedAt?: SortOrder | null;
-  name?: SortOrder | null;
-  code?: SortOrder | null;
-  searchable?: SortOrder | null;
-}
-
-export interface FacetTranslationInput {
-  id?: string | null;
-  languageCode: LanguageCode;
-  name?: string | null;
-  customFields?: any | null;
-}
-
-export interface FacetValueTranslationInput {
-  id?: string | null;
-  languageCode: LanguageCode;
-  name?: string | null;
-  customFields?: any | null;
-}
-
-export interface ProductFilterParameter {
-  name?: StringOperators | null;
-  slug?: StringOperators | null;
-  description?: StringOperators | null;
-  createdAt?: DateOperators | null;
-  updatedAt?: DateOperators | null;
-  infoUrl?: StringOperators | null;
-  downloadable?: BooleanOperators | null;
-  nickname?: StringOperators | null;
-}
-
-export interface ProductListOptions {
-  take?: number | null;
-  skip?: number | null;
-  sort?: ProductSortParameter | null;
-  filter?: ProductFilterParameter | null;
-}
-
-export interface ProductOptionGroupTranslationInput {
-  id?: string | null;
-  languageCode: LanguageCode;
-  name?: string | null;
-  customFields?: any | null;
-}
-
-export interface ProductSortParameter {
-  id?: SortOrder | null;
-  createdAt?: SortOrder | null;
-  updatedAt?: SortOrder | null;
-  name?: SortOrder | null;
-  slug?: SortOrder | null;
-  description?: SortOrder | null;
-  image?: SortOrder | null;
-  infoUrl?: SortOrder | null;
-  downloadable?: SortOrder | null;
-  nickname?: SortOrder | null;
-}
-
-export interface ProductTranslationCustomFieldsInput {
-  nickname?: string | null;
-}
-
-export interface ProductTranslationInput {
-  id?: string | null;
-  languageCode: LanguageCode;
-  name?: string | null;
-  slug?: string | null;
-  description?: string | null;
-  customFields?: ProductTranslationCustomFieldsInput | null;
-}
-
-export interface ProductVariantTranslationInput {
-  id?: string | null;
-  languageCode: LanguageCode;
-  name?: string | null;
-  customFields?: any | null;
-}
-
-export interface RoleFilterParameter {
-  code?: StringOperators | null;
-  description?: StringOperators | null;
-  createdAt?: DateOperators | null;
-  updatedAt?: DateOperators | null;
-}
-
-export interface RoleListOptions {
-  take?: number | null;
-  skip?: number | null;
-  sort?: RoleSortParameter | null;
-  filter?: RoleFilterParameter | null;
-}
-
-export interface RoleSortParameter {
-  id?: SortOrder | null;
-  createdAt?: SortOrder | null;
-  updatedAt?: SortOrder | null;
-  code?: SortOrder | null;
-  description?: SortOrder | null;
-}
-
-export interface StringOperators {
-  eq?: string | null;
-  contains?: string | null;
-}
-
-export interface UpdateAdministratorInput {
-  id: string;
-  firstName?: string | null;
-  lastName?: string | null;
-  emailAddress?: string | null;
-  password?: string | null;
-  roleIds?: string[] | null;
-}
-
-export interface UpdateFacetCustomFieldsInput {
-  searchable?: boolean | null;
-}
-
-export interface UpdateFacetInput {
-  id: string;
-  code?: string | null;
-  translations?: FacetTranslationInput[] | null;
-  customFields?: UpdateFacetCustomFieldsInput | null;
-}
-
-export interface UpdateFacetValueCustomFieldsInput {
-  link?: string | null;
-  available?: boolean | null;
-}
-
-export interface UpdateFacetValueInput {
-  id: string;
-  code?: string | null;
-  translations?: FacetValueTranslationInput[] | null;
-  customFields?: UpdateFacetValueCustomFieldsInput | null;
-}
-
-export interface UpdateProductCustomFieldsInput {
-  infoUrl?: string | null;
-  downloadable?: boolean | null;
-}
-
-export interface UpdateProductInput {
-  id: string;
-  featuredAssetId?: string | null;
-  assetIds?: string[] | null;
-  translations?: ProductTranslationInput[] | null;
-  customFields?: UpdateProductCustomFieldsInput | null;
-}
-
-export interface UpdateProductVariantInput {
-  id: string;
-  translations?: ProductVariantTranslationInput[] | null;
-  sku?: string | null;
-  price?: number | null;
-  customFields?: any | null;
-}
-
-export interface UpdateRoleInput {
-  id: string;
-  code?: string | null;
-  description?: string | null;
-  permissions?: Permission[] | null;
-}
-
-//==============================================================
-// END Enums and Input Objects
-//==============================================================

shared/shared-types.ts

@@ -4,11 +4,11 @@
  * Source: https://stackoverflow.com/a/49936686/772859
  */
 export type DeepPartial<T> = {
-  [P in keyof T]?: T[P] extends Array<infer U>
+  [P in keyof T]?: null | (T[P] extends Array<infer U>
     ? Array<DeepPartial<U>>
     : T[P] extends ReadonlyArray<infer U>
       ? ReadonlyArray<DeepPartial<U>>
-      : DeepPartial<T[P]>
+      : DeepPartial<T[P]>)
 };
 // tslint:enable:no-shadowed-variable