import { Binding as BaseBinding, BindingOptions } from 'graphql-binding'
import { GraphQLResolveInfo } from 'graphql'

export interface ResetByEmailInput {
  email?: String
  messageCampaignId?: String
}

export interface FacetsInput {
  key?: String
  value?: String[] | String
}

export interface GuestProfileAddressDetails {
  firstName: String
  lastName: String
  phone: String
  email: String
  type?: String
  postalCode: String
}

export interface DeleteCardInput {
  creditId?: String
  email?: String
}

export interface DeletePaymentId {
  id: String
}

export interface UpdateAddressesParams {
  id?: String
  type?: String
  firstName?: String
  lastName?: String
  phone?: String
  addressLine1?: String
  addressLine2?: String
  city?: String
  country?: String
  state?: String
  postalCode?: String
  customParams?: AddressCustomParams
}

export interface AddressToDelete {
  type?: String
  id?: String
}

export interface AddToBagInput {
  skuId: String
  itemid: String
  title?: String
  quantity?: Int
  itemType?: String
  customParams?: CategoryIdParam
  subProducts?: subProducts[] | subProducts
}

export interface DeletePaymentDetails {
  item?: DeletePaymentId
  items?: DeletePaymentId[] | DeletePaymentId
}

export interface UpdateShippingInput {
  address?: UpdateShippingParams
  customParams?: AddressInputParams
}

export interface PaymentCustomParams {
  addCardDetailToProfile?: String[] | String
  setAsDefaultCardInProfile?: String[] | String
  useDefaultCard?: String[] | String
}

export interface RemoveAddressInput {
  address?: removeAddressParams
}

export interface CreditCardInput {
  number: String
  type: String
  cvv: String
  expirationMonth: String
  expirationYear: String
  name: String
  id?: String
}

export interface AddressCustomParams {
  validated?: String[] | String
  override?: String[] | String
  default?: String[] | String
}

export interface Payment {
  type?: String
  amount: String
  creditCard?: CreditCardInput[] | CreditCardInput
  address?: PaymentAddress[] | PaymentAddress
  customParams?: PaymentCustomParams
}

export interface AddressParams {
  addresses?: AddressesParams[] | AddressesParams
}

export interface PaymentDetail {
  itemType?: String
  title?: String
  payment: Payment
}

export interface UpdatePasswordParams {
  oldPassword?: String
  newPassword?: String
}

export interface PaymentDetails {
  items?: PaymentDetail[] | PaymentDetail
  paymentMethods?: Payment[] | Payment
  shippingAddresses?: PaymentAddress[] | PaymentAddress
}

export interface EndpointInput {
  categoryId: String
  categoryName: String
  categoryAttribute: String
}

export interface UpdateSecurityInput {
  userName?: String
  challengeQuestion?: String
  challengeAnswer?: String
}

export interface ResetBySecurityQuestions {
  emailId?: String
  challengeQuestion1?: String
  challengeAnswer1?: String
  password?: String
}

export interface UserLoginInput {
  userName?: String
  password?: String
  authToken?: String
  provider?: String
}

export interface EstimateInfoInput {
  postalCode?: String
  state?: String
  country?: String
  city?: String
}

export interface RegisterUserInput {
  userName: String
  password: String
  telephone: String
  firstName: String
  lastName?: String
}

export interface UpdateShippingParams {
  addresses?: UpdateAddressesParams[] | UpdateAddressesParams
}

export interface ShippingCustomParams {
  addAddressToProfile?: String[] | String
  useDefaultAddress?: String[] | String
  setAsDefaultAddressInProfile?: String[] | String
  overrideAddressValidation?: String[] | String
}

export interface AddressInputParams {
  locale?: String
  messageCampaignId?: String
}

export interface PaymentAddress {
  addressLine1: String
  addressLine2?: String
  postalCode: String
  city: String
  state: String
  country: String
  phone: String
  email: String
  lastName: String
  firstName: String
  deliveryInstruction?: String
  customParams?: ShippingCustomParams
}

export interface AddAddressInput {
  address?: AddressParams
  customParams?: AddressInputParams
}

export interface DeleteFromBagInput {
  id: String
}

export interface UpdateProfileInput {
  firstName?: String
  lastName?: String
  userId?: String
}

export interface AddCardInput {
  cardType?: String
  cardNumber?: String
  expirationmonth?: String
  expirationyear?: String
  expiryDate?: String
  firstName?: String
  lastName?: String
  makeDefaultCard?: String
  securityCode?: String
}

export interface CategoryIdParam {
  categoryId?: String
}

export interface subProducts {
  skuId: String
  itemid: String
  customParams?: CustomParams
}

export interface CustomParams {
  mainProduct?: String
  mandatoryProduct?: String
  optionalProduct?: String
  quantity?: Int
}

export interface UpdateBagInput {
  quantity?: Int
  id?: String
}

export interface removeAddressParams {
  addresses?: AddressToDelete[] | AddressToDelete
}

export interface ValidateByEmailInput {
  password?: String
  resetParam?: String
  messageCampaignId?: String
}

export interface TabbedFeaturedProductListInput {
  endpoints?: EndpointInput[] | EndpointInput
}

export interface AddressesParams {
  type?: String
  firstName?: String
  lastName?: String
  phone?: String
  addressLine1?: String
  addressLine2?: String
  city?: String
  country?: String
  state?: String
  postalCode?: String
  customParams?: AddressCustomParams
}

export interface IBuyInfo {
  pricing?: Pricing
  inventorystatus?: String
  instock?: String
  preorder?: String
  preorderdate?: String
  deliverydate?: String
  availablequantity?: String
  availability?: Availability[]
  promomessages?: Label[]
}

export interface Loyalty {
  transaction?: TransactionList
  loyaltyPoints?: LoyaltyPoints
}

export interface PricedNormal {
  type?: String
  label?: String
  value?: String
}

export interface ReviewResponse {
  type?: String
  properties?: ReviewProperties
}

export interface SkuState {
  starttime?: String
}

export interface ReviewProperties {
  childreninfo?: ChildrenInfo
  reviewrating?: ProductReviewRating
  state?: PrdocutReviewState
}

export interface Specifications {
  label?: String
  value?: String
}

export interface ChildrenInfo {
  count?: String
}

export interface SkuOffers {
  name?: String
  properties?: SkuOfferProperties
}

export interface ProductReviewRating {
  reviewcount?: String
  reviews?: Reviews[]
}

export interface OfferItemInfo {
  description?: LabelValue[]
}

export interface Reviews {
  identifier?: String
  reviewcreated?: String
  negativereviewcount?: String
  rating?: String
  reviewupdated?: String
  label?: String
  positivereviewcount?: String
  userid?: String
  ratingrange?: String
  isfeatured?: String
  reviewcount?: String
  isratingsonly?: String
  location?: String
  value?: String
  username?: String
}

export interface HomePage {
  titleText?: HomePageTitleText
  background?: HomePageBackground
  videos?: HomePageVideo[]
}

export interface PrdocutReviewState {
  errormessage?: String
  offset?: String
  limit?: String
  locale?: String
  status?: String
}

export interface HomePageBackground {
  mainBG?: String
  bottomBG?: String
}

export interface HomePageVideo {
  index?: Int
  thumbnailImage?: String
  autoplay?: Boolean
  loop?: Boolean
  controls?: Boolean
  logo?: String
  title?: String
  slogan?: String
  shareTitle?: String
  videoLength?: Float
}

export interface UserResponseProperties {
  creditcardinfo?: UserCreditCardInfo
  state: UserState
  userinfo?: UserProfileInfo[]
}

export interface EstimateShippingMath {
  estTotalShippingPrice?: String
}

export interface RatingResponse {
  identifier?: String
  recommendedcount?: String
  ratings?: Ratings[]
  rating?: String
  count?: String
  ratingrange?: String
}

export interface Ratings {
  label?: String
  value?: String
}

export interface OrderDetail {
  packages?: OrderPackage[]
  paymentcardinfo?: PaymentCardDetail[]
  payments?: OrderPayment[]
  state?: OrderListState
}

export interface SkuBuyInfo extends IBuyInfo {
  pricing?: Pricing
  inventorystatus?: String
  instock?: String
  preorder?: String
  preorderdate?: String
  deliverydate?: String
  availablequantity?: String
  availability?: Availability[]
  promomessages?: Label[]
}

export interface OrderMath {
  subTotal?: String
  giftSale?: String
  tax?: String
  shippingCharge?: String
  shippingTax?: String
  discount?: String
  total?: String
  grandTotal?: String
  couponTotal?: String
}

export interface SkuProperties {
  buyinfo?: SkuBuyInfo
  iteminfo?: SkuItemInfo
  state?: SkuState
  skuinfo?: SkuInfo
}

export interface OrderProductProperties {
  buyinfo?: CartBuyInfo
  cartinfo?: OrderProductCartInfo
  iteminfo?: OrderProductItemInfo
  state?: OrderProductState
  math?: Math
  orderinfo?: OrderInfo
  userinfo?: PackageUserInfo
}

export interface Sku {
  identifier: ID_Output
  image?: String
  type: String
  name?: String
  properties?: SkuProperties
  additional?: LabelValue[]
  specifications?: Specifications[]
  children?: SkuChildren
}

export interface OrderProductCartInfo {
  totaltax?: String
  total?: String
  discountonlytotal?: String
  valueaddedtaxes?: LabelValue[]
  shippingmethods?: ShippingMethod[]
  surcharges?: TypeValue[]
  orderitemid?: String
  discounttotal?: String
}

export interface ProductChildren {
  skus?: Sku[]
  products?: Product[]
  relatedproducts?: Product[]
  recommentedproducts?: Product[]
}

export interface TypeValue {
  type?: String
  value?: String
}

export interface AddToBagResponse {
  type?: String
  properties?: PromoProperties
  children?: ChildrenProducts
}

export interface CartInfo {
  quantity?: String
  discounttotal?: String
  discountonlytotal?: String
  giftitem?: String
  iseligible?: String
  pretaxtotal?: String
  shippingcharge?: String
  shippingtax?: String
  subtotal?: String
  total?: String
  totaltax?: String
  discount?: LabelValue[]
  shippingmethods?: ShippingMethod[]
  valueaddedtaxes?: LabelValue[]
  valuesapplied?: CartInfoValues[]
}

export interface PromoProperties {
  state?: CartState
}

export interface Value {
  value?: String
}

export interface ChildrenProducts {
  products?: CartProduct[]
}

export interface Math {
  cost?: String
  currency?: String
  discountcost?: String
  discount?: String
  estTotalShippingDiscount?: String
  estTotalShippingPrice?: String
  estTotalShippingTax?: String
  estTotalTax?: String
  estunittax?: String
  esttax?: String
  estfulfilcost?: String
  estfulfilsale?: String
  estfulfiltax?: String
  fulfiltax?: String
  fulfilcost?: String
  fulfilsale?: String
  giftdiscount?: String
  giftcost?: String
  giftsale?: String
  estUnitTax?: String
  grandTotal?: String
  grandTotalAfterPayment?: String
  grandTotalTax?: String
  maxBagCount?: String
  quantity?: String
  sale?: String
  tax?: String
  totalBagCount?: String
  totalBagCountWithErrors?: String
  totalCost?: String
  totalDiscount?: String
  totalGiftWrapCost?: String
  totalGiftWrapDiscount?: String
  totalGiftWrapPrice?: String
  totalGiftWrapTax?: String
  totalSale?: String
  unittax?: String
  unitCost?: String
  unitSale?: String
}

export interface State {
  starttime?: String
  additionalinfo?: LabelValue[]
}

export interface PackageUserInfo {
  userid?: String
}

export interface UpdateBagResponse {
  type?: String
  properties?: CartProperties
  children?: ChildrenProducts
}

export interface ShippingDetail {
  price?: String
  shippingaddress?: ShippingAddress[]
  hasShipped?: Boolean
}

export interface CartProperties {
  buyinfo?: CartBuyInfo
  cartinfo?: CartInfo
  iteminfo?: CartItemInfo
  math?: Math
  state?: CartState
  userinfo?: CartUserInfo
}

export interface CardDetail {
  cardBrand?: String
  cardExpirationMonth?: String
  cardExpirationYear?: String
  cardNumber?: String
  cardType?: String
}

export interface Name {
  name?: String
}

export interface OrderPaymentProperties {
  creditcardinfo?: CreditCardInfo[]
  paymentcardinfo?: OrderPaymentCardDetail
}

export interface DeleteFromBagResponse {
  type?: String
  properties?: DeleteFromBagProperties
}

export interface CardInfo {
  identifier?: String
  amount?: String
  addressinfo?: CardAddressInfo
  credits?: String
  type?: String
  additionalinfo?: LabelValue[]
  points?: String
}

export interface DeleteFromBagProperties {
  state?: CartState
}

export interface PhoneDetail {
  phonenumber?: String
}

export interface ShippingMethodResponse {
  type?: String
  properties?: ShippingMethodProperties
}

export interface OrderListState {
  statuscode?: String
  offset?: String
  count?: String
  status?: String
}

export interface ShippingMethodProperties {
  state?: ShippingMethodState
  cartinfo?: CheckoutCartInfo
}

export interface SkuItemInfo {
  flags?: LabelValue[]
  additionalimages?: LabelValue[]
  additionalinfo?: LabelValue[]
  specifications?: LabelValue[]
}

export interface ShippingMethodState {
  status?: String
}

export interface SortingType {
  options?: LabelValue[]
  sortedBy?: String
}

export interface CheckoutCartInfo {
  totaltax?: String
  total?: String
  quantity?: String
  subtotal?: String
  estsubtotal?: String
  discounttotal?: String
  discount?: LabelValue[]
  giftwrap?: String
  shippingmethods?: ShippingMethods[]
}

export interface Facets {
  name?: String
  values: FacetValue[]
}

export interface ShippingMethods {
  shippingmethods?: ShippingMethod[]
  type?: String
}

export interface Refine {
  productSort?: SortingType
  productFilter?: FacetType
}

export interface ImageName {
  image?: String
  name?: String
}

export interface ListResponseChildren {
  lists?: List[]
}

export interface SkuProps {
  color?: ImageName[]
  size1?: Name[]
  style?: Name[]
}

export interface ListProperties {
  iteminfo?: ListItemInfo
}

export interface SetShippingResponse {
  responseCode?: String
  properties?: ShippingProperties
}

export interface ListResponseProperties {
  iteminfo?: ListResponseItemInfo
  state?: ListResponseState
}

export interface ShippingProperties {
  cartinfo?: CheckoutCartInfo
  state?: ShippingState
}

export interface ListResponseState {
  count?: String
}

export interface ShippingState {
  status?: String
}

export interface FavoritesList {
  lists?: FavoriteProduct[]
}

export interface RegistrationResponse {
  responseCode?: String
  responseMessage?: String
  type?: String
  properties?: RegistrationProperties
  cookies?: String[]
}

export interface FavoriteProductProperties {
  buyinfo?: SkuBuyInfo
  cartinfo?: FavoriteCartInfo
  iteminfo?: FavoritesItemInfo
  reviewrating?: ReviewRating
  state?: FavoritesState
  userinfo?: FavoritesUserInfo
}

export interface RegistrationProperties {
  state?: RegistrationState
  userinfo?: UserInfoProperties
}

export interface FavoritesItemInfo {
  itemid?: String
  flags?: LabelValue[]
  list?: ListIds[]
  sku?: String
}

export interface RegistrationState {
  statuscode?: String
  starttime?: String
  status?: String
}

export interface FavoritesState {
  starttime?: String
}

export interface UserInfoProperties {
  userid?: String
  username?: String
}

export interface UserInfoData {
  userid?: String
  username?: String
  type?: String
}

export interface CountValue {
  count?: String
  value?: String
}

export interface FavoritesPropertiesItemInfo {
  flags?: LabelValue[]
}

export interface ReviewRating {
  reviewcount?: String
  recommendedcount?: String
  reviews?: CountValue[]
  rating?: String
  ratingrange?: String
}

export interface LogOut {
  responseCode?: String
  responseMessage?: String
  properties?: LogOutProperties
  type?: String
}

export interface EstimateShippingProperties {
  math?: EstimateShippingMath
}

export interface LogOutState {
  status?: String
}

export interface ServerResponse {
  responseCode?: String
  responseMessage?: String
  type?: String
  cookies?: String[]
}

export interface Cart {
  contactus?: ContactUsNotReal
  giftproducts?: CartProduct[]
  saveforlater?: CartProduct[]
  promocodes?: CartProduct[]
  products?: CartProduct[]
  status?: String
  shippingmethodtype?: String
  shippingmethods?: ShippingMethod[]
  buyinfo?: CartBuyInfo
  cartinfo?: CartInfo
  iteminfo?: CartItemInfo
  math?: Math
  paymentcardinfo?: CartPaymentCardInfo
  state?: CartState
  properties?: CartStateProperties
  userinfo?: CartUserInfo[]
  type?: String
  cookies?: String[]
}

export interface CancelOrder {
  type?: String
  properties?: OrderProperties
}

export interface CartProduct {
  identifier?: String
  image?: String
  name?: String
  type?: String
  properties?: CartProductProperties
  productOptions?: TypeValue[]
}

export interface OrderProperties {
  state?: OrderState
}

export interface CartProductItemInfo {
  additionalinfo?: LabelValue[]
  category?: String
  categoryids?: Value[]
  description?: Value[]
  shortdescription?: LabelValue[]
  flags?: LabelValue[]
  specifications?: LabelValue[]
  isgiftcard?: String
  itemid?: String
  prices?: LabelValueType[]
  sku?: String
}

export interface OrderState {
  statuscode?: String
  status?: String
}

export interface PaymentCardInfo {
  amount?: String
  type?: String
}

export interface ReturnOrder {
  type?: String
  properties?: OrderProperties
}

export interface CartItemInfo {
  giftoption?: GiftOption
}

export interface PromoResponse {
  type?: String
  properties?: PromoProperties
}

export interface CartPaymentCardInfo {
  adjustedamount?: String
  amount?: String
  type?: String
}

export interface OrderAgainResponse {
  state?: OrderAgainState
}

export interface CartStateProperties {
  state?: CartState
}

export interface OrderAgainState {
  status?: String
}

export interface AddressInfo {
  addresstype?: String
  city?: String
  country?: String
  county?: String
  state?: String
  zipcode?: String
  firstname?: String
  lastname?: String
  addressline1?: String
  addressline2?: String
  phonenumber?: String
  email?: String
}

export interface ProductItemInfo {
  categoryids?: LabelValue[]
  flags?: LabelValue[]
  videos?: LabelValue[]
  additionalimages?: LabelValue[]
  description?: LabelValue[]
  ismasterproduct?: Boolean
  iscollection?: Boolean
  isgroupproduct?: Boolean
  brand?: String
}

export interface TransactionList {
  type?: String
  count?: Int
  transactionList?: Points[]
  earnedloyaltypoints?: Points[]
  loyaltypackages?: LoyaltyPackage[]
}

export interface Label {
  label?: String
}

export interface LoyaltyPackage {
  identifier?: String
  properties?: LoyaltyProperties
}

export interface Availability {
  instore?: String
}

export interface LoyaltyBuyInfo {
  loyalty?: BuyInfoLoyalty
}

export interface MinMaxQuantity {
  minquantity?: String
  maxquantity?: String
}

export interface NameValue {
  name?: String
  value?: String
}

export interface PricedWithRange {
  type?: String
  label?: String
  value?: String
  ismin?: String
  ismax?: String
}

export interface LoyaltyItemInfo {
  additionalinfo?: LabelValue[]
  flags?: LabelValue[]
  itemid?: String
}

export interface AddPaymentResponse {
  type?: String
  children?: RecalculateProducts
  properties?: AddPaymentProperties
  identifier?: String
}

export interface LoyaltyStoreInfo {
  identifier?: String
}

export interface RecalculateProducts {
  products?: RecalculateProduct[]
}

export interface LoyaltyUserInfo {
  additionalinfo?: LabelValue[]
  preferences?: LabelValue[]
  startdate?: String
  userid?: String
}

export interface RecalculateProduct {
  identifier?: String
  image?: String
  name?: String
  type?: String
  properties?: RecalculateProperties
}

export interface SuggestionResponse {
  type?: String
  suggestions?: Suggestion[]
}

export interface RecalculateProperties {
  buyinfo?: RecalculateBuyInfo
  iteminfo?: CartItemInfo
  cartinfo?: CartInfo
  state?: CartState
  userinfo?: CartUserInfo
  creditcardinfo?: CreditCardData
  paymentcardinfo?: PaymentCardInfo
  math?: Math
}

export interface StoreLocator {
  type?: String
  offset?: String
  limit?: String
  storeinfo?: StoreList[]
}

export interface RecalculateBuyInfo {
  pricing?: Pricing
}

export interface TokenResponse {
  responseCode?: Int
  responseMessage?: String
  key?: String
  serviceTokens?: ServiceTokens
}

export interface CreditCardData {
  cards?: Card[]
}

export interface ServiceToken {
  responseCode?: Int
  responseMessage?: String
  serviceTokens?: ServiceTokens
}

export interface Card {
  isvalidated?: String
  expirationyear?: String
  cardid?: String
  cardbrand?: String
  cardtype?: String
  cardnumber?: String
  expirationmonth?: String
}

export interface SkuChildren {
  offers?: SkuOffers[]
}

export interface AddPaymentProperties {
  state?: AddPaymentState
}

export interface Product {
  identifier: ID_Output
  image?: String
  type?: String
  name?: String
  children?: ProductChildren
  properties?: ProductProperties
  additional?: LabelValue[]
  specifications?: LabelValue[]
}

export interface AddPaymentState {
  status?: String
}

export interface GuestOrderList {
  orders?: OrderDetail[]
  state?: OrderListState
}

export interface Pricing {
  currencycode?: String
  prices?: PricedWithRange[]
  buymoresavemore?: MinMaxQuantity[]
}

export interface OrderProduct {
  identifier?: String
  name?: String
  image?: String
  skuid?: String
  price?: String
  properties?: OrderProductProperties
  quantity?: String
  skuinfo?: SkuInfo
  category?: LabelValue[]
  shippingmethod?: String
  shippingaddress?: ShippingAddress[]
}

export interface ProductBuyInfo extends IBuyInfo {
  pricing?: Pricing
  inventorystatus?: String
  instock?: String
  preorder?: String
  preorderdate?: String
  deliverydate?: String
  availablequantity?: String
  availability?: Availability[]
  promomessages?: Label[]
}

export interface ShippingMethod {
  estdate?: String
  esttime?: String
  notes?: String
  name?: String
  selected?: String
  code?: String
  date?: String
  identifier?: String
  notification?: String
  prices?: LabelValue[]
  time?: String
  type?: String
}

export interface DeletePaymentResponse {
  type?: String
  properties?: DeletePaymentProperties
}

export interface CartInfoValues {
  shiptotal?: String
}

export interface DeletePaymentProperties {
  state?: DeletePaymentState
}

export interface OrderInfo {
  orderid?: String
}

export interface DeletePaymentState {
  status?: String
}

export interface PaymentCardDetail {
  carddetails?: CardDetail
  name?: LabelValue
}

export interface ProductProperties {
  buyinfo?: ProductBuyInfo
  iteminfo?: ProductItemInfo
  reviewrating?: ReviewRating
  skuprops?: SkuProps
  state?: State
}

export interface CreditCardInfo {
  cards?: CardInfo[]
}

export interface GuestProfileResponse {
  type?: String
}

export interface OrderPaymentCardDetail {
  amount?: String
  additionalinfo?: LabelValue[]
}

export interface SubmitOrderResponse {
  type?: String
  responseMessage?: String
  properties?: SubmitOrderProperties
}

export interface ProductList {
  identifier?: ID_Output
  image?: String
  name?: String
  products?: Product[]
  link?: String
  categoryIds?: LabelValue[]
  productCount?: Int
  searchterm?: String
  productSort?: SortingType
  productFilter?: FacetType
  additional?: LabelValue[]
}

export interface SubmitOrderProperties {
  orderinfo?: SubmitOrderOrderinfo
}

export interface FacetValue {
  identifier?: String
  name?: String
  count?: Int
}

export interface SubmitOrderOrderinfo {
  orderid?: String
}

export interface List {
  identifier: ID_Output
  properties?: ListProperties
}

export interface RecalculateOrderResponse {
  type?: String
  responseMessage?: String
  properties?: RecalculateProperties
  children?: RecalculateProducts
}

export interface ListResponseItemInfo {
  flags?: LabelValue[]
}

export interface FeatureTabValues {
  additional?: LabelValue[]
  specifications?: LabelValue[]
  identifier?: String
  image?: String
  type?: String
  name?: String
  properties?: ProductProperties
  url?: String
  children?: ProductChildren
}

export interface FavoriteProduct {
  identifier: ID_Output
  image?: String
  name?: String
  properties?: FavoriteProductProperties
}

export interface ResetPasswordResponse {
  type?: String
  properties?: ResetPasswordProperties
}

export interface ListIds {
  id?: String
}

export interface ResetPasswordProperties {
  state?: ResetPasswordState
  userinfo?: UserIdParams
}

export interface FavoritesProperties {
  iteminfo?: FavoritesPropertiesItemInfo
  state?: FavoritesCount
}

export interface ResetPasswordState {
  status?: String
}

export interface LogOutProperties {
  state?: LogOutState
  userinfo?: UserIdParams
}

export interface FeatureTabMeta {
  title?: String
  image?: String
  viewAll?: String
  url?: String
  qa?: String
}

export interface ContactUsNotReal {
  description?: String
  telephone?: String
  workinghour?: LabelValue
}

export interface GetSecurityQuestionResponse {
  type?: String
  properties?: GetSecurityQuestionProperties
}

export interface LabelValueType {
  label?: String
  value?: String
  type?: String
}

export interface GetSecurityQuestionProperties {
  state?: StateProperties
  userinfo?: SecurityQuestionUserInfoProperties[]
}

export interface GiftOption {
  giftwraptax?: String
  giftwrapcost?: String
}

export interface StateProperties {
  statuscode: String
  starttime: String
  status: String
}

export interface CartUserInfo {
  guid?: String
  userid?: String
  addressinfo?: AddressInfo[]
}

export interface SecurityQuestionUserInfoProperties {
  country?: String
  userphoto?: String
  firstname?: String
  preferences?: LabelValue[]
  gender?: String
  city?: String
  phonenumber?: String
  userid?: ID_Output
  additionalinfo?: LabelValue[]
  lastname?: String
  dob?: String
  state?: String
  usertimezone?: String
  email?: String
  username?: String
  securityanswer?: String
  securityquestion?: String
}

export interface Points {
  adjustedPoints?: String
  balancedPoints?: String
  date?: String
  earnedPoints?: String
  redeemedPoints?: String
  startPoints?: String
  transactionDate?: String
}

export interface FeatureTab {
  title?: String
  image?: String
  viewAll?: String
  url?: String
  qa?: String
  meta?: FeatureTabMeta
  values?: FeatureTabValues[]
}

export interface BuyInfoLoyalty {
  loyaltypoints?: String
  points?: NameValue[]
}

export interface ResetBySecurityQuestionsResponse {
  type?: String
  properties?: SecurityQuestionsProperties
}

export interface LoyaltyState {
  additionalinfo?: LabelValue[]
  count?: String
  expirytime?: String
  starttime?: String
  status?: String
}

export interface SecurityQuestionsProperties {
  state?: SecurityQuestionsState
  userinfo?: UserIdProperty
}

export interface LoyaltyPoints {
  type?: String
  status?: String
  count?: String
  points?: LabelValue[]
  currentpoints?: LabelValue
  earnedpoints?: LabelValue
  testpoints?: String
}

export interface SecurityQuestionsState {
  status?: String
}

export interface StoreList {
  identifier?: ID_Output
  country?: String
  distance?: Float
  city?: String
  address1?: String
  latitude?: Float
  additionalinfo?: LabelValue[]
  zipcode?: String
  altidentifier?: String
  phone?: String
  name?: String
  state?: String
  distanceunit?: String
  email?: String
  longitude?: Float
}

export interface UserIdProperty {
  userid: String
}

export interface SkuInfo {
  color?: ImageName
  size1?: Name
  style?: Name
}

export interface TabbedFeaturedProductList {
  tabs?: FeatureTab[]
}

export interface HomePageTitleText {
  title?: String
  subtitle?: String
  text?: String
}

export interface BrandLandingPage {
  banner?: String
  backgroundImageUrl?: String
  learnMore?: String
  sliderLeft?: String
  sliderRight?: String
  sliderLeftMobile?: String
  sliderRightMobile?: String
  promoBanner1?: String
  promoBanner2?: String
  hempTankJade?: String
  hempTankStone?: String
  hempTankMidnight?: String
}

export interface CartBuyInfo extends IBuyInfo {
  pricing?: Pricing
  inventorystatus?: String
  instock?: String
  preorder?: String
  preorderdate?: String
  deliverydate?: String
  availablequantity?: String
  availability?: Availability[]
  promomessages?: Label[]
}

export interface UpdatePasswordResponse {
  type?: String
  properties?: UpdatePasswordProperties
}

export interface OrderProductState {
  timings?: LabelValue[]
  locale?: String
  additionalinfo?: LabelValue[]
  status?: String
}

export interface UpdatePasswordProperties {
  state?: StateProperties
  userinfo?: UserIdProperty
}

export interface OrderPayment {
  properties?: OrderPaymentProperties
}

export interface CategoryBlock {
  name: String
  backgroundImage?: String
  heroImage?: String
  previewImage?: String
}

export interface OrderList {
  orders?: OrderDetail[]
  state?: OrderListState
}

export interface Category {
  _identifier: ID_Output
  identifier?: String
  image?: String
  video?: String
  name?: String
  type?: String
  description?: String
  categories?: Category[]
  categoryids?: LabelValue[]
  sortingoptions?: LabelValue[]
}

export interface ListResponse {
  children?: ListResponseChildren
  properties?: ListResponseProperties
  type?: String
  responseMessage?: String
  responseCode?: String
}

export interface CategoryList {
  categories?: Category[]
  type?: String
}

export interface Favorites {
  children?: FavoritesList
  properties?: FavoritesProperties
  type?: String
  responseMessage?: String
  responseCode?: String
}

export interface PhoneDetails {
  phonenumber?: String
}

export interface FavoritesUserInfo {
  userinfo?: UserInfoData[]
}

export interface UserAddressInfo {
  addressid: ID_Output
  addresstype?: String
  isdefaultaddress?: String
  firstname?: String
  lastname?: String
  email?: String
  addressline1?: String
  addressline2?: String
  city?: String
  state?: String
  county?: String
  country?: String
  zipcode?: String
  additionaldetails?: LabelValue[]
  phonedetails?: PhoneDetails[]
}

export interface UserIdParams {
  userid?: String
}

export interface ShippingAddressResponse {
  responseCode?: String
  responseMessage?: String
  type?: String
  properties?: AddressStateProperties
}

export interface CartProductState {
  errormessage?: String
}

export interface AddressStateProperties {
  state?: RegistrationState
}

export interface UserResponse {
  type?: String
  properties?: UserResponseProperties
  responseMessage?: String
  responseCode?: String
  cookies?: String[]
}

export interface UserIdentityList {
  id: ID_Output
  partner?: String
  name?: String
  type?: String
  userid?: String
  tags?: LabelValue[]
}

export interface LoyaltyCartInfo {
  total?: String
}

export interface LabelValue {
  label?: String
  value?: String
}

export interface Suggestion {
  parent: String
  child: String
}

export interface EstimateShippingResponse {
  type?: String
  properties?: EstimateShippingProperties
}

export interface SkuOfferProperties {
  iteminfo?: OfferItemInfo
}

export interface UserProfileInfo {
  userid?: ID_Output
  email?: String
  username?: String
  firstname?: String
  lastname?: String
  userphoto?: String
  phonenumber?: String
  gender?: String
  dob?: String
  city?: String
  state?: String
  country?: String
  usertimezone?: String
  preferences?: LabelValue[]
  additionalinfo?: LabelValue[]
  list?: UserIdentityList[]
  addressinfo?: UserAddressInfo[]
}

export interface OrderProductItemInfo {
  categoryids?: LabelValue[]
  cartinfo?: CartInfo
  flags?: LabelValue[]
  isgiftwrap?: String
  description?: Value[]
  specifications?: LabelValue[]
  psvid?: String
  isgiftcard?: String
  additionalinfo?: LabelValue[]
}

export interface UserState {
  starttime?: String
  status?: String
}

export interface CardAddressInfo {
  country?: String
  firstname?: String
  phonedetails?: PhoneDetail[]
  city?: String
  county?: String
  middlename?: String
  lastname?: String
  addressid?: String
  zipcode?: String
  addressline3?: String
  addressline2?: String
  addressline1?: String
  state?: String
  email?: String
}

export interface CreditCardAddressInfo {
  addressid?: String
}

export interface ListItemInfo {
  additionalinfo?: LabelValue[]
}

export interface TwitterAuthTokenResponse {
  type?: String
  responseMessage?: String
}

export interface FavoritesCount {
  count?: String
}

export interface CreditCardDetails {
  cardid: String
  identifier: String
  addressinfo?: CreditCardAddressInfo[]
  cardnumber?: String
  cardtype?: String
  expirationmonth?: String
  expirationyear?: String
  isdefault?: String
  isvalidated?: String
  lastfourdigits?: String
  nameoncard?: String
  type?: String
}

export interface CartState {
  additionalinfo?: LabelValue[]
  status?: String
  count?: String
}

export interface AddCardResponse {
  type?: String
  properties?: AddPaymentProperties
}

export interface TransactionDetails {
  transactiondetails?: NameValue[]
}

export interface UserCreditCardInfo {
  cards?: CreditCardDetails[]
}

export interface OrderPackage {
  math?: OrderMath
  orderCreatedTime?: String
  orderId?: String
  orderTotalAmount?: String
  orderTotalItems?: String
  products?: OrderProduct[]
  shipping?: ShippingDetail[]
  properties?: OrderProductProperties
  status?: String
}

export interface FacetType {
  facets: Facets[]
  selectedFilters: LabelValue[]
}

export interface ChangeDefaultState {
  status?: String
}

export interface ChangeDefaultPaymentProperties {
  state?: ChangeDefaultState
}

export interface ChangeDefaultCardResponse {
  type?: String
  properties?: ChangeDefaultPaymentProperties
}

export interface DeleteCardResponse {
  type?: String
  properties?: DeletePaymentProperties
}

export interface FavoriteCartInfo {
  quantity?: String
}

export interface ShippingAddress {
  address1?: String
  address2?: String
  zipcode?: String
  city?: String
  state?: String
  country?: String
  phonenumber?: String
  email?: String
  lastname?: String
  firstname?: String
}

export interface ServiceTokens {
  pim?: String
}

export interface LoyaltyProperties {
  buyinfo?: LoyaltyBuyInfo
  cartInfo?: LoyaltyCartInfo
  iteminfo?: LoyaltyItemInfo
  state?: LoyaltyState
  storeinfo?: LoyaltyStoreInfo[]
  transactioninfo?: TransactionDetails[]
  userinfo?: LoyaltyUserInfo[]
}

export interface CartProductProperties {
  buyinfo?: CartBuyInfo
  cartinfo?: CartInfo
  iteminfo?: CartProductItemInfo
  creditcardinfo?: CreditCardInfo[]
  paymentcardinfo?: PaymentCardInfo
  state?: CartProductState
  math?: Math
  type?: String
}

/*
The `String` scalar type represents textual data, represented as UTF-8 character sequences. The String type is most often used by GraphQL to represent free-form human-readable text.
*/
export type String = string

/*
The `Int` scalar type represents non-fractional signed whole numeric values. Int can represent values between -(2^31) and 2^31 - 1. 
*/
export type Int = number

/*
The `Float` scalar type represents signed double-precision fractional values as specified by [IEEE 754](http://en.wikipedia.org/wiki/IEEE_floating_point). 
*/
export type Float = number

/*
The `Boolean` scalar type represents `true` or `false`.
*/
export type Boolean = boolean

/*
The `ID` scalar type represents a unique identifier, often used to refetch an object or as key for a cache. The ID type appears in a JSON response as a String; however, it is not intended to be human-readable. When expected as an input type, any string (such as `"4"`) or integer (such as `4`) input value will be accepted as an ID.
*/
export type ID_Input = string | number
export type ID_Output = string

export interface Schema {
  query: Query
  mutation: Mutation
}

export type Query = {
  profile: (args: { enablePaymentRetrival?: String }, context: { [key: string]: any }, info?: GraphQLResolveInfo | string) => Promise<UserResponse | null>
  categoryList: (args: {}, context: { [key: string]: any }, info?: GraphQLResolveInfo | string) => Promise<CategoryList | null>
  categoryLandingPage: (args: { categoryId: String }, context: { [key: string]: any }, info?: GraphQLResolveInfo | string) => Promise<CategoryBlock | null>
  brandLandingPage: (args: {}, context: { [key: string]: any }, info?: GraphQLResolveInfo | string) => Promise<BrandLandingPage | null>
  tabbedFeaturedProductList: (args: { input?: TabbedFeaturedProductListInput }, context: { [key: string]: any }, info?: GraphQLResolveInfo | string) => Promise<TabbedFeaturedProductList | null>
  homePage: (args: {}, context: { [key: string]: any }, info?: GraphQLResolveInfo | string) => Promise<HomePage | null>
  orderLookupList: (args: { lastname: String, orderNumber: String, zipcode: String }, context: { [key: string]: any }, info?: GraphQLResolveInfo | string) => Promise<GuestOrderList | null>
  orderList: (args: { orderid: String, customerid: String, limit?: Int, offset?: Int, fromdate?: String, todate?: String, status?: String }, context: { [key: string]: any }, info?: GraphQLResolveInfo | string) => Promise<OrderList | null>
  orderDetail: (args: { orderid?: String }, context: { [key: string]: any }, info?: GraphQLResolveInfo | string) => Promise<OrderDetail | null>
  productDetail: (args: { productId: String }, context: { [key: string]: any }, info?: GraphQLResolveInfo | string) => Promise<Product | null>
  productList: (args: { categoryId: String, limit?: Int, offset?: Int, sort?: String, selectedFacets?: FacetsInput[] }, context: { [key: string]: any }, info?: GraphQLResolveInfo | string) => Promise<ProductList | null>
  productFilter: (args: { categoryId: String, limit?: Int, offset?: Int, selectedFacets?: FacetsInput[] }, context: { [key: string]: any }, info?: GraphQLResolveInfo | string) => Promise<FacetType | null>
  productSort: (args: { categoryId: String, limit?: Int, offset?: Int, sort?: String }, context: { [key: string]: any }, info?: GraphQLResolveInfo | string) => Promise<SortingType | null>
  productRefine: (args: { categoryId: String, limit?: Int, offset?: Int, sort?: String, selectedFacets?: FacetsInput[] }, context: { [key: string]: any }, info?: GraphQLResolveInfo | string) => Promise<Refine | null>
  searchRefine: (args: { search: String, limit?: Int, offset?: Int, sort?: String, selectedFacets?: FacetsInput[] }, context: { [key: string]: any }, info?: GraphQLResolveInfo | string) => Promise<Refine | null>
  search: (args: { search: String, limit?: Int, offset?: Int, sort?: String, selectedFacets?: FacetsInput[] }, context: { [key: string]: any }, info?: GraphQLResolveInfo | string) => Promise<ProductList | null>
  getLists: (args: {}, context: { [key: string]: any }, info?: GraphQLResolveInfo | string) => Promise<ListResponse | null>
  favorites: (args: { favoriteId: String }, context: { [key: string]: any }, info?: GraphQLResolveInfo | string) => Promise<Favorites | null>
  logOut: (args: {}, context: { [key: string]: any }, info?: GraphQLResolveInfo | string) => Promise<LogOut | null>
  listItems: (args: { listId: String }, context: { [key: string]: any }, info?: GraphQLResolveInfo | string) => Promise<Favorites | null>
  cart: (args: {}, context: { [key: string]: any }, info?: GraphQLResolveInfo | string) => Promise<Cart | null>
  loyalty: (args: {}, context: { [key: string]: any }, info?: GraphQLResolveInfo | string) => Promise<Loyalty | null>
  suggestion: (args: { searchTerm: String }, context: { [key: string]: any }, info?: GraphQLResolveInfo | string) => Promise<SuggestionResponse | null>
  storeLocator: (args: { latitude: Float, longitude: Float }, context: { [key: string]: any }, info?: GraphQLResolveInfo | string) => Promise<StoreLocator | null>
  getKeyToken: (args: { alias: String, requestor: String }, context: { [key: string]: any }, info?: GraphQLResolveInfo | string) => Promise<TokenResponse | null>
  getServiceToken: (args: {}, context: { [key: string]: any }, info?: GraphQLResolveInfo | string) => Promise<ServiceToken | null>
  productReview: (args: { productId: String }, context: { [key: string]: any }, info?: GraphQLResolveInfo | string) => Promise<ReviewResponse | null>
  productRating: (args: {}, context: { [key: string]: any }, info?: GraphQLResolveInfo | string) => Promise<RatingResponse | null>
}

export type Mutation = {
  addToBag: (args: { input: AddToBagInput }, context: { [key: string]: any }, info?: GraphQLResolveInfo | string) => Promise<AddToBagResponse | null>
  updateBag: (args: { input: UpdateBagInput }, context: { [key: string]: any }, info?: GraphQLResolveInfo | string) => Promise<UpdateBagResponse | null>
  deleteFromBag: (args: { input: DeleteFromBagInput }, context: { [key: string]: any }, info?: GraphQLResolveInfo | string) => Promise<DeleteFromBagResponse | null>
  updateShippingMethods: (args: { shippingMethod: String }, context: { [key: string]: any }, info?: GraphQLResolveInfo | string) => Promise<ShippingMethodResponse>
  setShipping: (args: { shippingAddress: PaymentAddress }, context: { [key: string]: any }, info?: GraphQLResolveInfo | string) => Promise<SetShippingResponse>
  registerGuest: (args: {}, context: { [key: string]: any }, info?: GraphQLResolveInfo | string) => Promise<RegistrationResponse | null>
  registerUser: (args: { input: RegisterUserInput }, context: { [key: string]: any }, info?: GraphQLResolveInfo | string) => Promise<RegistrationResponse | null>
  login: (args: { input: UserLoginInput }, context: { [key: string]: any }, info?: GraphQLResolveInfo | string) => Promise<RegistrationResponse | null>
  socialLogin: (args: { input: UserLoginInput }, context: { [key: string]: any }, info?: GraphQLResolveInfo | string) => Promise<RegistrationResponse | null>
  updateSecurity: (args: { input: UpdateSecurityInput }, context: { [key: string]: any }, info?: GraphQLResolveInfo | string) => Promise<RegistrationResponse | null>
  createList: (args: {}, context: { [key: string]: any }, info?: GraphQLResolveInfo | string) => Promise<ServerResponse>
  createSaveForLater: (args: {}, context: { [key: string]: any }, info?: GraphQLResolveInfo | string) => Promise<ServerResponse>
  addItem: (args: { skuid: String, identifier: String }, context: { [key: string]: any }, info?: GraphQLResolveInfo | string) => Promise<ServerResponse>
  deleteItem: (args: { skuid: String }, context: { [key: string]: any }, info?: GraphQLResolveInfo | string) => Promise<ServerResponse>
  cancelOrder: (args: { orderId: String }, context: { [key: string]: any }, info?: GraphQLResolveInfo | string) => Promise<CancelOrder>
  returnOrder: (args: { orderId: String }, context: { [key: string]: any }, info?: GraphQLResolveInfo | string) => Promise<ReturnOrder>
  addPromo: (args: { promoCode: String }, context: { [key: string]: any }, info?: GraphQLResolveInfo | string) => Promise<PromoResponse>
  orderAgain: (args: { orderid: String, lastname: String, zipcode: String }, context: { [key: string]: any }, info?: GraphQLResolveInfo | string) => Promise<OrderAgainResponse>
  deletePromo: (args: { identifier: String }, context: { [key: string]: any }, info?: GraphQLResolveInfo | string) => Promise<PromoResponse>
  addPaymentMethod: (args: { paymentdetails: PaymentDetails }, context: { [key: string]: any }, info?: GraphQLResolveInfo | string) => Promise<AddPaymentResponse>
  deletePaymentMethod: (args: { paymentdetails: DeletePaymentDetails }, context: { [key: string]: any }, info?: GraphQLResolveInfo | string) => Promise<DeletePaymentResponse>
  setGuestDetails: (args: { input: GuestProfileAddressDetails }, context: { [key: string]: any }, info?: GraphQLResolveInfo | string) => Promise<GuestProfileResponse>
  submitOrder: (args: { email: String }, context: { [key: string]: any }, info?: GraphQLResolveInfo | string) => Promise<SubmitOrderResponse>
  recalculateOrder: (args: { paymentdetails: PaymentDetails }, context: { [key: string]: any }, info?: GraphQLResolveInfo | string) => Promise<RecalculateOrderResponse>
  resetByEmail: (args: { input: ResetByEmailInput }, context: { [key: string]: any }, info?: GraphQLResolveInfo | string) => Promise<ResetPasswordResponse>
  validateByEmail: (args: { input: ValidateByEmailInput }, context: { [key: string]: any }, info?: GraphQLResolveInfo | string) => Promise<ResetPasswordResponse>
  getSecurityQuestions: (args: { emailId: String }, context: { [key: string]: any }, info?: GraphQLResolveInfo | string) => Promise<GetSecurityQuestionResponse>
  resetPasswordBySecurityQuestions: (args: { input: ResetBySecurityQuestions }, context: { [key: string]: any }, info?: GraphQLResolveInfo | string) => Promise<ResetBySecurityQuestionsResponse>
  updateProfile: (args: { input: UpdateProfileInput }, context: { [key: string]: any }, info?: GraphQLResolveInfo | string) => Promise<RegistrationResponse>
  updatePassword: (args: { input: UpdatePasswordParams }, context: { [key: string]: any }, info?: GraphQLResolveInfo | string) => Promise<UpdatePasswordResponse>
  addAddressToProfile: (args: { input: AddAddressInput }, context: { [key: string]: any }, info?: GraphQLResolveInfo | string) => Promise<ShippingAddressResponse | null>
  removeAddressFromProfile: (args: { input: RemoveAddressInput }, context: { [key: string]: any }, info?: GraphQLResolveInfo | string) => Promise<ShippingAddressResponse | null>
  updateShippingAddress: (args: { input: UpdateShippingInput }, context: { [key: string]: any }, info?: GraphQLResolveInfo | string) => Promise<ShippingAddressResponse | null>
  defaultShippingAddress: (args: { input: UpdateShippingInput }, context: { [key: string]: any }, info?: GraphQLResolveInfo | string) => Promise<ShippingAddressResponse | null>
  resetBySms: (args: { email: String }, context: { [key: string]: any }, info?: GraphQLResolveInfo | string) => Promise<ResetPasswordResponse>
  twitterAuthToken: (args: {}, context: { [key: string]: any }, info?: GraphQLResolveInfo | string) => Promise<TwitterAuthTokenResponse>
  addCard: (args: { serialized: AddCardInput, email: String }, context: { [key: string]: any }, info?: GraphQLResolveInfo | string) => Promise<AddCardResponse>
  deleteCard: (args: { params: DeleteCardInput }, context: { [key: string]: any }, info?: GraphQLResolveInfo | string) => Promise<DeleteCardResponse>
  changeDefaultCard: (args: { defaultPaymentParams: String, messageCampaignId: String }, context: { [key: string]: any }, info?: GraphQLResolveInfo | string) => Promise<ChangeDefaultCardResponse>
  estimateShipping: (args: { estimateinfo: EstimateInfoInput }, context: { [key: string]: any }, info?: GraphQLResolveInfo | string) => Promise<EstimateShippingResponse>
}

export class Binding extends BaseBinding {
  
  constructor({ schema, fragmentReplacements }: BindingOptions) {
    super({ schema, fragmentReplacements });
  }
  
  query: Query = {
    profile: (args, context, info): Promise<UserResponse | null> => super.delegate('query', 'profile', args, context, info),
    categoryList: (args, context, info): Promise<CategoryList | null> => super.delegate('query', 'categoryList', args, context, info),
    categoryLandingPage: (args, context, info): Promise<CategoryBlock | null> => super.delegate('query', 'categoryLandingPage', args, context, info),
    brandLandingPage: (args, context, info): Promise<BrandLandingPage | null> => super.delegate('query', 'brandLandingPage', args, context, info),
    tabbedFeaturedProductList: (args, context, info): Promise<TabbedFeaturedProductList | null> => super.delegate('query', 'tabbedFeaturedProductList', args, context, info),
    homePage: (args, context, info): Promise<HomePage | null> => super.delegate('query', 'homePage', args, context, info),
    orderLookupList: (args, context, info): Promise<GuestOrderList | null> => super.delegate('query', 'orderLookupList', args, context, info),
    orderList: (args, context, info): Promise<OrderList | null> => super.delegate('query', 'orderList', args, context, info),
    orderDetail: (args, context, info): Promise<OrderDetail | null> => super.delegate('query', 'orderDetail', args, context, info),
    productDetail: (args, context, info): Promise<Product | null> => super.delegate('query', 'productDetail', args, context, info),
    productList: (args, context, info): Promise<ProductList | null> => super.delegate('query', 'productList', args, context, info),
    productFilter: (args, context, info): Promise<FacetType | null> => super.delegate('query', 'productFilter', args, context, info),
    productSort: (args, context, info): Promise<SortingType | null> => super.delegate('query', 'productSort', args, context, info),
    productRefine: (args, context, info): Promise<Refine | null> => super.delegate('query', 'productRefine', args, context, info),
    searchRefine: (args, context, info): Promise<Refine | null> => super.delegate('query', 'searchRefine', args, context, info),
    search: (args, context, info): Promise<ProductList | null> => super.delegate('query', 'search', args, context, info),
    getLists: (args, context, info): Promise<ListResponse | null> => super.delegate('query', 'getLists', args, context, info),
    favorites: (args, context, info): Promise<Favorites | null> => super.delegate('query', 'favorites', args, context, info),
    logOut: (args, context, info): Promise<LogOut | null> => super.delegate('query', 'logOut', args, context, info),
    listItems: (args, context, info): Promise<Favorites | null> => super.delegate('query', 'listItems', args, context, info),
    cart: (args, context, info): Promise<Cart | null> => super.delegate('query', 'cart', args, context, info),
    loyalty: (args, context, info): Promise<Loyalty | null> => super.delegate('query', 'loyalty', args, context, info),
    suggestion: (args, context, info): Promise<SuggestionResponse | null> => super.delegate('query', 'suggestion', args, context, info),
    storeLocator: (args, context, info): Promise<StoreLocator | null> => super.delegate('query', 'storeLocator', args, context, info),
    getKeyToken: (args, context, info): Promise<TokenResponse | null> => super.delegate('query', 'getKeyToken', args, context, info),
    getServiceToken: (args, context, info): Promise<ServiceToken | null> => super.delegate('query', 'getServiceToken', args, context, info),
    productReview: (args, context, info): Promise<ReviewResponse | null> => super.delegate('query', 'productReview', args, context, info),
    productRating: (args, context, info): Promise<RatingResponse | null> => super.delegate('query', 'productRating', args, context, info)
  }

  mutation: Mutation = {
    addToBag: (args, context, info): Promise<AddToBagResponse | null> => super.delegate('mutation', 'addToBag', args, context, info),
    updateBag: (args, context, info): Promise<UpdateBagResponse | null> => super.delegate('mutation', 'updateBag', args, context, info),
    deleteFromBag: (args, context, info): Promise<DeleteFromBagResponse | null> => super.delegate('mutation', 'deleteFromBag', args, context, info),
    updateShippingMethods: (args, context, info): Promise<ShippingMethodResponse> => super.delegate('mutation', 'updateShippingMethods', args, context, info),
    setShipping: (args, context, info): Promise<SetShippingResponse> => super.delegate('mutation', 'setShipping', args, context, info),
    registerGuest: (args, context, info): Promise<RegistrationResponse | null> => super.delegate('mutation', 'registerGuest', args, context, info),
    registerUser: (args, context, info): Promise<RegistrationResponse | null> => super.delegate('mutation', 'registerUser', args, context, info),
    login: (args, context, info): Promise<RegistrationResponse | null> => super.delegate('mutation', 'login', args, context, info),
    socialLogin: (args, context, info): Promise<RegistrationResponse | null> => super.delegate('mutation', 'socialLogin', args, context, info),
    updateSecurity: (args, context, info): Promise<RegistrationResponse | null> => super.delegate('mutation', 'updateSecurity', args, context, info),
    createList: (args, context, info): Promise<ServerResponse> => super.delegate('mutation', 'createList', args, context, info),
    createSaveForLater: (args, context, info): Promise<ServerResponse> => super.delegate('mutation', 'createSaveForLater', args, context, info),
    addItem: (args, context, info): Promise<ServerResponse> => super.delegate('mutation', 'addItem', args, context, info),
    deleteItem: (args, context, info): Promise<ServerResponse> => super.delegate('mutation', 'deleteItem', args, context, info),
    cancelOrder: (args, context, info): Promise<CancelOrder> => super.delegate('mutation', 'cancelOrder', args, context, info),
    returnOrder: (args, context, info): Promise<ReturnOrder> => super.delegate('mutation', 'returnOrder', args, context, info),
    addPromo: (args, context, info): Promise<PromoResponse> => super.delegate('mutation', 'addPromo', args, context, info),
    orderAgain: (args, context, info): Promise<OrderAgainResponse> => super.delegate('mutation', 'orderAgain', args, context, info),
    deletePromo: (args, context, info): Promise<PromoResponse> => super.delegate('mutation', 'deletePromo', args, context, info),
    addPaymentMethod: (args, context, info): Promise<AddPaymentResponse> => super.delegate('mutation', 'addPaymentMethod', args, context, info),
    deletePaymentMethod: (args, context, info): Promise<DeletePaymentResponse> => super.delegate('mutation', 'deletePaymentMethod', args, context, info),
    setGuestDetails: (args, context, info): Promise<GuestProfileResponse> => super.delegate('mutation', 'setGuestDetails', args, context, info),
    submitOrder: (args, context, info): Promise<SubmitOrderResponse> => super.delegate('mutation', 'submitOrder', args, context, info),
    recalculateOrder: (args, context, info): Promise<RecalculateOrderResponse> => super.delegate('mutation', 'recalculateOrder', args, context, info),
    resetByEmail: (args, context, info): Promise<ResetPasswordResponse> => super.delegate('mutation', 'resetByEmail', args, context, info),
    validateByEmail: (args, context, info): Promise<ResetPasswordResponse> => super.delegate('mutation', 'validateByEmail', args, context, info),
    getSecurityQuestions: (args, context, info): Promise<GetSecurityQuestionResponse> => super.delegate('mutation', 'getSecurityQuestions', args, context, info),
    resetPasswordBySecurityQuestions: (args, context, info): Promise<ResetBySecurityQuestionsResponse> => super.delegate('mutation', 'resetPasswordBySecurityQuestions', args, context, info),
    updateProfile: (args, context, info): Promise<RegistrationResponse> => super.delegate('mutation', 'updateProfile', args, context, info),
    updatePassword: (args, context, info): Promise<UpdatePasswordResponse> => super.delegate('mutation', 'updatePassword', args, context, info),
    addAddressToProfile: (args, context, info): Promise<ShippingAddressResponse | null> => super.delegate('mutation', 'addAddressToProfile', args, context, info),
    removeAddressFromProfile: (args, context, info): Promise<ShippingAddressResponse | null> => super.delegate('mutation', 'removeAddressFromProfile', args, context, info),
    updateShippingAddress: (args, context, info): Promise<ShippingAddressResponse | null> => super.delegate('mutation', 'updateShippingAddress', args, context, info),
    defaultShippingAddress: (args, context, info): Promise<ShippingAddressResponse | null> => super.delegate('mutation', 'defaultShippingAddress', args, context, info),
    resetBySms: (args, context, info): Promise<ResetPasswordResponse> => super.delegate('mutation', 'resetBySms', args, context, info),
    twitterAuthToken: (args, context, info): Promise<TwitterAuthTokenResponse> => super.delegate('mutation', 'twitterAuthToken', args, context, info),
    addCard: (args, context, info): Promise<AddCardResponse> => super.delegate('mutation', 'addCard', args, context, info),
    deleteCard: (args, context, info): Promise<DeleteCardResponse> => super.delegate('mutation', 'deleteCard', args, context, info),
    changeDefaultCard: (args, context, info): Promise<ChangeDefaultCardResponse> => super.delegate('mutation', 'changeDefaultCard', args, context, info),
    estimateShipping: (args, context, info): Promise<EstimateShippingResponse> => super.delegate('mutation', 'estimateShipping', args, context, info)
  }
}