hiu cho

mail@pastecode.io avatar
unknown
tsx
2 years ago
92 kB
5
Indexable
Never
import * as Types from '../../graphql/types.generated';

import { gql } from '@apollo/client';
import * as Apollo from '@apollo/client';
export type Maybe<T> = T | null | undefined;
export type InputMaybe<T> = T | null | undefined;
export type Exact<T extends { [key: string]: unknown }> = { [K in keyof T]: T[K] };
export type MakeOptional<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]?: Maybe<T[SubKey]> };
export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]: Maybe<T[SubKey]> };
const defaultOptions = {} as const;
/** All built-in and custom scalars, mapped to their actual values */
export type Scalars = {
  ID: string;
  String: string;
  Boolean: boolean;
  Int: number;
  Float: number;
  /**
   * Represents non-fractional signed whole numeric values. Since the value may
   * exceed the size of a 32-bit integer, it's encoded as a string.
   */
  BigInt: any;
  /** An ISO 8601-encoded date */
  ISO8601Date: any;
  /** An ISO 8601-encoded datetime */
  ISO8601DateTime: any;
  /** Represents untyped JSON */
  JSON: any;
};

export type AddToListInput = {
  listId: Scalars['ID'];
  orderItemIds: Array<Scalars['ID']>;
};

export type Address = {
  addressType: Scalars['String'];
  body: Scalars['String'];
  createdAt: Scalars['ISO8601DateTime'];
  customer: Customer;
  id: Scalars['ID'];
  receiver?: Maybe<Scalars['String']>;
  receiverPhoneNumber?: Maybe<Scalars['String']>;
  updatedAt: Scalars['ISO8601DateTime'];
};

export type ApplyListToCartInput = {
  listId: Scalars['ID'];
};

export type Authentication = {
  token: Scalars['String'];
  user: User;
};

export type Balance = {
  amount: Scalars['BigInt'];
  incurredDebt?: Maybe<Scalars['BigInt']>;
  nextPaymentDate?: Maybe<Scalars['ISO8601Date']>;
};

export type BankAccount = {
  accountName: Scalars['String'];
  accountNo: Scalars['String'];
  bankName: Scalars['String'];
  id: Scalars['ID'];
};

export type Banner = {
  createdAt: Scalars['ISO8601DateTime'];
  fromDate: Scalars['ISO8601Date'];
  id: Scalars['ID'];
  imageUrl?: Maybe<Scalars['String']>;
  order?: Maybe<Scalars['Int']>;
  position?: Maybe<Scalars['String']>;
  toDate: Scalars['ISO8601Date'];
  updatedAt: Scalars['ISO8601DateTime'];
  url?: Maybe<Scalars['String']>;
};

export type Brand = {
  code: Scalars['String'];
  createdAt: Scalars['ISO8601DateTime'];
  id: Scalars['ID'];
  name: Scalars['String'];
  updatedAt: Scalars['ISO8601DateTime'];
};

export type BuildOrderItemsInWarehouseInput = {
  orderId: Scalars['ID'];
};

export type CampaignPropratedPrice = {
  id: Scalars['ID'];
  propratedPrice: Scalars['Int'];
};

export type CancelOrderInput = {
  orderId: Scalars['ID'];
  reasons: Array<Scalars['String']>;
};

export type Category = {
  children?: Maybe<Array<Category>>;
  createdAt: Scalars['ISO8601DateTime'];
  id: Scalars['ID'];
  imageUrl?: Maybe<Scalars['String']>;
  isDeepestChild?: Maybe<Scalars['Boolean']>;
  name: Scalars['String'];
  parent?: Maybe<Category>;
  products?: Maybe<ProductConnection>;
  updatedAt: Scalars['ISO8601DateTime'];
};


export type CategoryProductsArgs = {
  after?: InputMaybe<Scalars['String']>;
  attributes?: InputMaybe<Array<Scalars['String']>>;
  before?: InputMaybe<Scalars['String']>;
  brandIds?: InputMaybe<Array<Scalars['ID']>>;
  categoryIds?: InputMaybe<Array<Scalars['ID']>>;
  first?: InputMaybe<Scalars['Int']>;
  last?: InputMaybe<Scalars['Int']>;
  optionValueIds?: InputMaybe<Array<Scalars['ID']>>;
  priceGte?: InputMaybe<Scalars['Int']>;
  priceLte?: InputMaybe<Scalars['Int']>;
};

export type CategoryDiscount = {
  appliedVariants?: Maybe<VariantConnection>;
  id: Scalars['ID'];
  name: Scalars['String'];
  type?: Maybe<Scalars['String']>;
};


export type CategoryDiscountAppliedVariantsArgs = {
  after?: InputMaybe<Scalars['String']>;
  before?: InputMaybe<Scalars['String']>;
  categoryId: Scalars['ID'];
  discountProgramId?: InputMaybe<Scalars['ID']>;
  first?: InputMaybe<Scalars['Int']>;
  last?: InputMaybe<Scalars['Int']>;
};

export type ChangePasswordInput = {
  otp: Scalars['String'];
  password: Scalars['String'];
  passwordConfirmation: Scalars['String'];
  resetPasswordToken: Scalars['String'];
};

export type ChangeUserStatusInput = {
  selectedUserId: Scalars['ID'];
  status: Scalars['String'];
};

export type ChangeUserTypeInput = {
  selectedUserId: Scalars['ID'];
  userType: Scalars['String'];
};

export type CheckoutGiftInput = {
  note?: InputMaybe<Scalars['String']>;
  selectedGiftIds?: InputMaybe<Array<Scalars['ID']>>;
  shippingAddressId: Scalars['ID'];
  slocId?: InputMaybe<Scalars['ID']>;
};

export type CheckoutInput = {
  estimateDeliveredAt: Scalars['String'];
  note?: InputMaybe<Scalars['String']>;
  orderId: Scalars['ID'];
  selectedGiftIds?: InputMaybe<Array<Scalars['ID']>>;
  shippingAddressId: Scalars['ID'];
  slocId?: InputMaybe<Scalars['ID']>;
};

export type Company = {
  address?: Maybe<Scalars['String']>;
  id: Scalars['ID'];
  name?: Maybe<Scalars['String']>;
  sapCode: Scalars['String'];
};

export type Country = {
  code: Scalars['String'];
  createdAt: Scalars['ISO8601DateTime'];
  id: Scalars['ID'];
  name: Scalars['String'];
  updatedAt: Scalars['ISO8601DateTime'];
};

export type CreatePasswordInput = {
  createPasswordToken: Scalars['String'];
  password: Scalars['String'];
  passwordConfirmation: Scalars['String'];
  userId: Scalars['ID'];
};

export type CreateShippingAddressInput = {
  body: Scalars['String'];
  receiver: Scalars['String'];
  receiverPhoneNumber: Scalars['String'];
};

export type CreateUserInput = {
  companyDepartment?: InputMaybe<Scalars['String']>;
  function?: InputMaybe<Scalars['String']>;
  name: Scalars['String'];
  phoneNumber: Scalars['String'];
  userType: Scalars['String'];
};

export type Customer = {
  billingAddress?: Maybe<Address>;
  createdAt: Scalars['ISO8601DateTime'];
  emails: Array<Scalars['String']>;
  id: Scalars['ID'];
  name: Scalars['String'];
  phoneNumbers?: Maybe<Array<Scalars['String']>>;
  salesOrg?: Maybe<SalesOrg>;
  sapId: Scalars['String'];
  shippingAddresses: Array<Address>;
  shortName: Scalars['String'];
  taxNumber?: Maybe<Scalars['String']>;
  updatedAt: Scalars['ISO8601DateTime'];
  users?: Maybe<Array<User>>;
};

/** The connection type for Customer. */
export type CustomerConnection = {
  /** A list of edges. */
  edges?: Maybe<Array<Maybe<CustomerEdge>>>;
  /** A list of nodes. */
  nodes?: Maybe<Array<Maybe<Customer>>>;
  /** Information to aid in pagination. */
  pageInfo: PageInfo;
  totalCount: Scalars['Int'];
};

/** An edge in a connection. */
export type CustomerEdge = {
  /** A cursor for use in pagination. */
  cursor: Scalars['String'];
  /** The item at the end of the edge. */
  node?: Maybe<Customer>;
};

export type DeleteItemsInListInput = {
  itemIds: Array<Scalars['ID']>;
  listId: Scalars['ID'];
};

export type DeleteSelectedGiftsInput = {
  campaignIds: Array<Scalars['ID']>;
};

export type DeleteShoppingListsInput = {
  shoppingListIds: Array<Scalars['ID']>;
};

export type Discount = {
  discountType?: Maybe<Scalars['String']>;
  discountValue?: Maybe<Scalars['Int']>;
  vatDiscountValue?: Maybe<Scalars['Float']>;
};

export type DiscountDetails = {
  adjustment: Scalars['Float'];
  applied?: Maybe<Scalars['Boolean']>;
  flatAmount?: Maybe<Scalars['Int']>;
  fromDate: Scalars['ISO8601Date'];
  id: Scalars['ID'];
  name: Scalars['String'];
  percent?: Maybe<Scalars['Int']>;
  requirements?: Maybe<Scalars['JSON']>;
  sapCode?: Maybe<Scalars['String']>;
  toDate: Scalars['ISO8601Date'];
  type?: Maybe<Scalars['String']>;
  vatAdjustment: Scalars['Float'];
};

export type DispatchCheckoutInput = {
  note?: InputMaybe<Scalars['String']>;
  orderId: Scalars['ID'];
  selectedGiftIds?: InputMaybe<Array<Scalars['ID']>>;
  shippingAddressId: Scalars['ID'];
  slocId?: InputMaybe<Scalars['ID']>;
};

export type EmptyInput = {
  emptyInput: Scalars['Boolean'];
};

export type EstimateDetails = {
  availableQuantity?: Maybe<Scalars['Int']>;
  dateArrival?: Maybe<Scalars['ISO8601Date']>;
  dispatchedQuantity?: Maybe<Scalars['Int']>;
  eta?: Maybe<Scalars['ISO8601Date']>;
  id: Scalars['ID'];
  notEnoughInventory?: Maybe<Scalars['Boolean']>;
  priority?: Maybe<Scalars['Int']>;
  totalDayDispatch?: Maybe<Scalars['Int']>;
  warehouseDelivery?: Maybe<Sloc>;
};

export type EstimateTimeArrival = {
  estimateTimeArrivalItems: Array<EstimateTimeArrivalItem>;
  id: Scalars['ID'];
  warehouseReceipt: Sloc;
};

export type EstimateTimeArrivalItem = {
  availableInBranch?: Maybe<Scalars['Boolean']>;
  availableInWarehouse?: Maybe<Scalars['Boolean']>;
  availableQuantity?: Maybe<Scalars['Int']>;
  dispatchedQuantity?: Maybe<Scalars['Int']>;
  estimateDetails: Array<EstimateDetails>;
  eta?: Maybe<Scalars['ISO8601Date']>;
  giftQuantity: Scalars['Int'];
  notEnoughInventory?: Maybe<Scalars['Boolean']>;
  orderQuantity: Scalars['Int'];
  variant: Variant;
};

export type ExecutionOrder = {
  createdAt: Scalars['ISO8601DateTime'];
  eta?: Maybe<Scalars['ISO8601Date']>;
  executionOrderGiftItems: Array<ExecutionOrderGiftItem>;
  executionOrderItems: Array<ExecutionOrderItem>;
  id: Scalars['ID'];
  order: Order;
  orderIdInWarehouse?: Maybe<Scalars['ID']>;
  selectedGiftsTypeBInWarehouse?: Maybe<Array<SelectedGift>>;
  total: Scalars['BigInt'];
  totalQuantity: Scalars['Int'];
  type?: Maybe<Scalars['String']>;
  updatedAt: Scalars['ISO8601DateTime'];
};

export type ExecutionOrderGiftItem = {
  createdAt: Scalars['ISO8601DateTime'];
  eta?: Maybe<Scalars['ISO8601Date']>;
  executionOrder: ExecutionOrder;
  id: Scalars['ID'];
  quantity: Scalars['Int'];
  status: Scalars['String'];
  typeACampaignId?: Maybe<Scalars['ID']>;
  updatedAt: Scalars['ISO8601DateTime'];
  variant: Variant;
};

export type ExecutionOrderItem = {
  createdAt: Scalars['ISO8601DateTime'];
  eta?: Maybe<Scalars['ISO8601Date']>;
  executionOrder: ExecutionOrder;
  id: Scalars['ID'];
  quantity: Scalars['Int'];
  retailPrice: Scalars['BigInt'];
  status: Scalars['String'];
  totalPrice: Scalars['BigInt'];
  totalPriceBeforeVat: Scalars['BigInt'];
  typeACampaignId?: Maybe<Scalars['ID']>;
  updatedAt: Scalars['ISO8601DateTime'];
  variant: Variant;
  vatRetailPrice: Scalars['BigInt'];
  vatWholesalePrice: Scalars['BigInt'];
  wholesalePrice: Scalars['BigInt'];
};

export type ExtraDataFile = {
  createdAt: Scalars['ISO8601DateTime'];
  fileUrl?: Maybe<Scalars['String']>;
  id: Scalars['ID'];
  title?: Maybe<Scalars['String']>;
  updatedAt: Scalars['ISO8601DateTime'];
};

export type ForgotPasswordInput = {
  phoneNumber: Scalars['String'];
};

export type GiftCampaign = {
  applied: Scalars['Boolean'];
  bestDeal: Scalars['Boolean'];
  campaignName: Scalars['String'];
  canCheckOutRewards: Scalars['Int'];
  checkedOutRewards: Scalars['Int'];
  conditionCount: Scalars['Int'];
  confirmedData?: Maybe<GiftCampaignProgress>;
  confirmedProgressData?: Maybe<Array<GiftCampaignProgressItem>>;
  description: Scalars['String'];
  duplicatedFrom?: Maybe<Scalars['ID']>;
  fromDate: Scalars['ISO8601Date'];
  giftInvoiceType?: Maybe<Scalars['Int']>;
  gifts: Array<GiftSelection>;
  id: Scalars['ID'];
  importableSameOrder: Scalars['Boolean'];
  level?: Maybe<Scalars['Int']>;
  multiplyBy: Scalars['Int'];
  multiplyByTypeB?: Maybe<Scalars['Int']>;
  noncombinable: Scalars['Boolean'];
  noncombinableParentId?: Maybe<Scalars['ID']>;
  parentId?: Maybe<Scalars['ID']>;
  progressData?: Maybe<Array<GiftCampaignProgressItem>>;
  progressDataWithoutCart?: Maybe<Array<GiftCampaignProgressItem>>;
  remainingRewardTimes: Scalars['Int'];
  remainingRewardTimesInCart?: Maybe<Scalars['Int']>;
  requirements: Array<VariantGiftCondition>;
  selectedGift?: Maybe<SelectedGift>;
  selectedGifts?: Maybe<Array<SelectedGift>>;
  selectedGiftsInCart?: Maybe<Array<SelectedGift>>;
  selectedGiftsTypeBInWarehouse?: Maybe<Array<SelectedGift>>;
  toDate: Scalars['ISO8601Date'];
  totalConfirmedRewards: Scalars['Int'];
  totalRewardsInCart?: Maybe<Scalars['Int']>;
  totalRewardsWithCart: Scalars['Int'];
  totalRewardsWithoutCart?: Maybe<Scalars['Int']>;
  totalUnconfirmedRewards: Scalars['Int'];
  type: Scalars['String'];
  typeDescription: Scalars['String'];
  unconfirmedRewardTimesInCart?: Maybe<Scalars['Int']>;
};

/** The connection type for GiftCampaign. */
export type GiftCampaignConnection = {
  /** A list of edges. */
  edges?: Maybe<Array<Maybe<GiftCampaignEdge>>>;
  /** A list of nodes. */
  nodes?: Maybe<Array<Maybe<GiftCampaign>>>;
  /** Information to aid in pagination. */
  pageInfo: PageInfo;
  totalCount: Scalars['Int'];
};

/** An edge in a connection. */
export type GiftCampaignEdge = {
  /** A cursor for use in pagination. */
  cursor: Scalars['String'];
  /** The item at the end of the edge. */
  node?: Maybe<GiftCampaign>;
};

export type GiftCampaignProgress = {
  confirmedQuantity?: Maybe<Scalars['Int']>;
  confirmedRevenue?: Maybe<Scalars['BigInt']>;
  confirmedRewards?: Maybe<Scalars['Int']>;
  id: Scalars['ID'];
  totalQuantity?: Maybe<Scalars['Int']>;
  totalRevenue?: Maybe<Scalars['BigInt']>;
  totalRewards?: Maybe<Scalars['Int']>;
  unconfirmedQuantity?: Maybe<Scalars['Int']>;
  unconfirmedRevenue?: Maybe<Scalars['BigInt']>;
};

export type GiftCampaignProgressItem = {
  confirmedQuantity: Scalars['Int'];
  confirmedRevenue: Scalars['BigInt'];
  id: Scalars['ID'];
  materialNumber?: Maybe<Scalars['String']>;
  name: Scalars['String'];
  quantity: Scalars['Int'];
  revenue: Scalars['BigInt'];
};

export type GiftConditionItem = {
  createdAt: Scalars['ISO8601DateTime'];
  id: Scalars['ID'];
  materialNumber: Scalars['String'];
  name: Scalars['String'];
  propratedPrice?: Maybe<Scalars['BigInt']>;
  quantityThreshold?: Maybe<Scalars['Int']>;
  revenueThreshold?: Maybe<Scalars['BigInt']>;
  updatedAt: Scalars['ISO8601DateTime'];
  variant: Variant;
  variantId: Scalars['ID'];
  wholesalePrice: Scalars['BigInt'];
};

/** The connection type for GiftConditionItem. */
export type GiftConditionItemConnection = {
  /** A list of edges. */
  edges?: Maybe<Array<Maybe<GiftConditionItemEdge>>>;
  /** A list of nodes. */
  nodes?: Maybe<Array<Maybe<GiftConditionItem>>>;
  /** Information to aid in pagination. */
  pageInfo: PageInfo;
  totalCount: Scalars['Int'];
};

/** An edge in a connection. */
export type GiftConditionItemEdge = {
  /** A cursor for use in pagination. */
  cursor: Scalars['String'];
  /** The item at the end of the edge. */
  node?: Maybe<GiftConditionItem>;
};

export type GiftSelection = {
  description?: Maybe<Scalars['String']>;
  giftSelectionItemGroups: Array<GiftSelectionItemGroup>;
  id: Scalars['ID'];
  name?: Maybe<Scalars['String']>;
};

export type GiftSelectionItem = {
  groupId?: Maybe<Scalars['Int']>;
  id: Scalars['ID'];
  occupiedQuantity?: Maybe<Scalars['Int']>;
  quantity?: Maybe<Scalars['Int']>;
  quantityInWarehouse?: Maybe<Scalars['Int']>;
  totalValue?: Maybe<Scalars['Int']>;
  variant: Variant;
};


export type GiftSelectionItemOccupiedQuantityArgs = {
  orderId?: InputMaybe<Scalars['ID']>;
};

export type GiftSelectionItemGroup = {
  giftSelectionItems: Array<GiftSelectionItem>;
  groupId: Scalars['ID'];
  itemCount: Scalars['Int'];
  quantity: Scalars['Int'];
};

export type GroupedDiscount = {
  applicableDiscounts: Array<Discount>;
  id: Scalars['ID'];
  name: Scalars['String'];
  type?: Maybe<Scalars['String']>;
};

export type InventoryByVariant = {
  available?: Maybe<Scalars['Int']>;
  dateList: Array<Scalars['ISO8601Date']>;
  internalTransfer?: Maybe<Scalars['Int']>;
  lockedTimeTo?: Maybe<Scalars['ISO8601DateTime']>;
  totalStock?: Maybe<Scalars['Int']>;
};

export type ItemCategory = {
  codeItemCategory?: Maybe<Scalars['String']>;
  createdAt: Scalars['ISO8601DateTime'];
  giftItemCategory?: Maybe<Scalars['String']>;
  id: Scalars['ID'];
  name?: Maybe<Scalars['String']>;
  orderType?: Maybe<Scalars['String']>;
  updatedAt: Scalars['ISO8601DateTime'];
};

export type LevelableGiftCampaign = {
  applied: Scalars['Boolean'];
  bestDeal: Scalars['Boolean'];
  campaignName: Scalars['String'];
  canCheckOutRewards: Scalars['Int'];
  checkedOutRewards: Scalars['Int'];
  conditionCount: Scalars['Int'];
  confirmedData?: Maybe<GiftCampaignProgress>;
  confirmedProgressData?: Maybe<Array<GiftCampaignProgressItem>>;
  description: Scalars['String'];
  duplicatedFrom?: Maybe<Scalars['ID']>;
  fromDate: Scalars['ISO8601Date'];
  giftCampaignChildren?: Maybe<Array<GiftCampaign>>;
  giftInvoiceType?: Maybe<Scalars['Int']>;
  gifts: Array<GiftSelection>;
  id: Scalars['ID'];
  importableSameOrder: Scalars['Boolean'];
  level?: Maybe<Scalars['Int']>;
  multiplyBy: Scalars['Int'];
  multiplyByTypeB?: Maybe<Scalars['Int']>;
  noncombinable: Scalars['Boolean'];
  noncombinableParentId?: Maybe<Scalars['ID']>;
  parentId?: Maybe<Scalars['ID']>;
  progressData?: Maybe<Array<GiftCampaignProgressItem>>;
  progressDataWithoutCart?: Maybe<Array<GiftCampaignProgressItem>>;
  remainingRewardTimes: Scalars['Int'];
  remainingRewardTimesInCart?: Maybe<Scalars['Int']>;
  requirements: Array<VariantGiftCondition>;
  selectedGift?: Maybe<SelectedGift>;
  selectedGifts?: Maybe<Array<SelectedGift>>;
  selectedGiftsInCart?: Maybe<Array<SelectedGift>>;
  selectedGiftsTypeBInWarehouse?: Maybe<Array<SelectedGift>>;
  toDate: Scalars['ISO8601Date'];
  totalConfirmedRewards: Scalars['Int'];
  totalRewardsInCart?: Maybe<Scalars['Int']>;
  totalRewardsWithCart: Scalars['Int'];
  totalRewardsWithoutCart?: Maybe<Scalars['Int']>;
  totalUnconfirmedRewards: Scalars['Int'];
  type: Scalars['String'];
  typeDescription: Scalars['String'];
  unconfirmedRewardTimesInCart?: Maybe<Scalars['Int']>;
};

export type ListBillings = {
  billings: SapBillingConnection;
  totalBillingAmount: Scalars['BigInt'];
};


export type ListBillingsBillingsArgs = {
  after?: InputMaybe<Scalars['String']>;
  before?: InputMaybe<Scalars['String']>;
  first?: InputMaybe<Scalars['Int']>;
  last?: InputMaybe<Scalars['Int']>;
};

export type ListNotification = {
  /** filter argument can be 'unread', 'read', '' == all */
  notifications: NotificationConnection;
  unreadCount: Scalars['Int'];
};


export type ListNotificationNotificationsArgs = {
  after?: InputMaybe<Scalars['String']>;
  before?: InputMaybe<Scalars['String']>;
  filter?: InputMaybe<Scalars['String']>;
  first?: InputMaybe<Scalars['Int']>;
  last?: InputMaybe<Scalars['Int']>;
};

export type ListPaymentHistories = {
  paymentHistories: PaymentHistoryConnection;
  totalPaidAmount: Scalars['BigInt'];
  totalReturnedAmount: Scalars['BigInt'];
};


export type ListPaymentHistoriesPaymentHistoriesArgs = {
  after?: InputMaybe<Scalars['String']>;
  before?: InputMaybe<Scalars['String']>;
  first?: InputMaybe<Scalars['Int']>;
  last?: InputMaybe<Scalars['Int']>;
};

export type LoginInput = {
  password: Scalars['String'];
  phoneNumber: Scalars['String'];
};

export type MarkNotificationsAsReadInput = {
  readNotificationIds: Array<Scalars['ID']>;
};

export type MarkPopupBannerAsShownInput = {
  popupBannerId: Scalars['ID'];
};

export type Mutation = {
  addToList?: Maybe<ShoppingList>;
  applyListToCart?: Maybe<Order>;
  buildOrderItemsInWarehouse?: Maybe<Order>;
  cancelOrder?: Maybe<Order>;
  changePassword?: Maybe<User>;
  changeUserStatus?: Maybe<User>;
  changeUserType?: Maybe<User>;
  checkout?: Maybe<Order>;
  checkoutGift?: Maybe<Order>;
  checkoutWithInternalDispatch?: Maybe<Array<Order>>;
  createPassword?: Maybe<User>;
  createShippingAddress?: Maybe<Address>;
  createShoppingList?: Maybe<ShoppingList>;
  createUser?: Maybe<User>;
  deleteItemsInList?: Maybe<ShoppingList>;
  deleteSelectedGifts?: Maybe<Array<SelectedGift>>;
  deleteShoppingLists?: Maybe<Array<ShoppingList>>;
  forgotPassword?: Maybe<User>;
  login?: Maybe<Authentication>;
  markAllNotificationsAsRead?: Maybe<Scalars['JSON']>;
  markNotificationsAsRead?: Maybe<Scalars['JSON']>;
  markPopupBannerAsShown?: Maybe<Scalars['JSON']>;
  register?: Maybe<User>;
  removeOrderItems?: Maybe<Order>;
  removeSelectedGiftsTypeBInWarehouse?: Maybe<RemoveSelectedGiftsTypeBInWarehousePayload>;
  removeUser?: Maybe<RemoveUserMutationPayload>;
  reorder?: Maybe<Order>;
  resendOtp?: Maybe<User>;
  resetPassword?: Maybe<User>;
  saveProduct?: Maybe<Product>;
  searchConversion?: Maybe<Scalars['JSON']>;
  selectGift?: Maybe<SelectedGift>;
  selectGiftItem?: Maybe<SelectedGiftItem>;
  unsaveProduct?: Maybe<Product>;
  updateCart?: Maybe<Order>;
  updateExecutionOrderItem?: Maybe<Array<ExecutionOrder>>;
  updateOrderItem?: Maybe<OrderItem>;
  verifyPhoneLogin?: Maybe<Authentication>;
  verifyPhoneRegistration?: Maybe<User>;
  webpushTokens?: Maybe<Scalars['JSON']>;
};


export type MutationAddToListArgs = {
  input: AddToListInput;
};


export type MutationApplyListToCartArgs = {
  input: ApplyListToCartInput;
};


export type MutationBuildOrderItemsInWarehouseArgs = {
  input: BuildOrderItemsInWarehouseInput;
};


export type MutationCancelOrderArgs = {
  input: CancelOrderInput;
};


export type MutationChangePasswordArgs = {
  input: ChangePasswordInput;
};


export type MutationChangeUserStatusArgs = {
  input: ChangeUserStatusInput;
};


export type MutationChangeUserTypeArgs = {
  input: ChangeUserTypeInput;
};


export type MutationCheckoutArgs = {
  input: CheckoutInput;
};


export type MutationCheckoutGiftArgs = {
  input: CheckoutGiftInput;
};


export type MutationCheckoutWithInternalDispatchArgs = {
  input: DispatchCheckoutInput;
};


export type MutationCreatePasswordArgs = {
  input: CreatePasswordInput;
};


export type MutationCreateShippingAddressArgs = {
  input: CreateShippingAddressInput;
};


export type MutationCreateShoppingListArgs = {
  input: ShoppingListInput;
};


export type MutationCreateUserArgs = {
  input: CreateUserInput;
};


export type MutationDeleteItemsInListArgs = {
  input: DeleteItemsInListInput;
};


export type MutationDeleteSelectedGiftsArgs = {
  input: DeleteSelectedGiftsInput;
};


export type MutationDeleteShoppingListsArgs = {
  input: DeleteShoppingListsInput;
};


export type MutationForgotPasswordArgs = {
  input: ForgotPasswordInput;
};


export type MutationLoginArgs = {
  input: LoginInput;
};


export type MutationMarkAllNotificationsAsReadArgs = {
  input: EmptyInput;
};


export type MutationMarkNotificationsAsReadArgs = {
  input: MarkNotificationsAsReadInput;
};


export type MutationMarkPopupBannerAsShownArgs = {
  input: MarkPopupBannerAsShownInput;
};


export type MutationRegisterArgs = {
  input: RegistrationInput;
};


export type MutationRemoveOrderItemsArgs = {
  input: RemoveOrderItemsInput;
};


export type MutationRemoveSelectedGiftsTypeBInWarehouseArgs = {
  input: RemoveSelectGiftsTypeBInWarehouseInput;
};


export type MutationRemoveUserArgs = {
  input: RemoveUserInput;
};


export type MutationReorderArgs = {
  input: ReorderInput;
};


export type MutationResendOtpArgs = {
  input: ResendOtpInput;
};


export type MutationResetPasswordArgs = {
  input: ResetPasswordInput;
};


export type MutationSaveProductArgs = {
  input: SaveProductInput;
};


export type MutationSearchConversionArgs = {
  input: SearchConversionInput;
};


export type MutationSelectGiftArgs = {
  input: SelectGiftInput;
};


export type MutationSelectGiftItemArgs = {
  input: SelectGiftItemInput;
};


export type MutationUnsaveProductArgs = {
  input: UnsaveProductInput;
};


export type MutationUpdateCartArgs = {
  input: UpdateCartInput;
};


export type MutationUpdateExecutionOrderItemArgs = {
  input: UpdateExecutionOrderItemInput;
};


export type MutationUpdateOrderItemArgs = {
  input: UpdateOrderItemInput;
};


export type MutationVerifyPhoneLoginArgs = {
  input: VerifyPhoneNumberInput;
};


export type MutationVerifyPhoneRegistrationArgs = {
  input: VerifyPhoneNumberInput;
};


export type MutationWebpushTokensArgs = {
  input: WebpushTokenInput;
};

export type NoncombinableGiftCampaign = {
  giftCampaignGroups?: Maybe<Array<GiftCampaign>>;
  groupId: Scalars['ID'];
};

export type Notification = {
  createdAt: Scalars['ISO8601DateTime'];
  id: Scalars['ID'];
  message: Scalars['String'];
  params: Scalars['JSON'];
  readAt?: Maybe<Scalars['ISO8601DateTime']>;
  title: Scalars['String'];
  type: Scalars['String'];
};

/** The connection type for Notification. */
export type NotificationConnection = {
  /** A list of edges. */
  edges?: Maybe<Array<Maybe<NotificationEdge>>>;
  /** A list of nodes. */
  nodes?: Maybe<Array<Maybe<Notification>>>;
  /** Information to aid in pagination. */
  pageInfo: PageInfo;
  totalCount: Scalars['Int'];
};

/** An edge in a connection. */
export type NotificationEdge = {
  /** A cursor for use in pagination. */
  cursor: Scalars['String'];
  /** The item at the end of the edge. */
  node?: Maybe<Notification>;
};

export type OptionType = {
  createdAt: Scalars['ISO8601DateTime'];
  id: Scalars['ID'];
  name: Scalars['String'];
  optionValues: Array<OptionValue>;
  optionValuesByCategory: Array<OptionValue>;
  optionValuesByProduct: Array<OptionValue>;
  updatedAt: Scalars['ISO8601DateTime'];
};


export type OptionTypeOptionValuesByCategoryArgs = {
  categoryId: Scalars['ID'];
};


export type OptionTypeOptionValuesByProductArgs = {
  productId: Scalars['ID'];
};

export type OptionValue = {
  createdAt: Scalars['ISO8601DateTime'];
  id: Scalars['ID'];
  optionType: OptionType;
  updatedAt: Scalars['ISO8601DateTime'];
  value: Scalars['String'];
};

export type Order = {
  canceledAt?: Maybe<Scalars['ISO8601DateTime']>;
  checkedOutAt?: Maybe<Scalars['ISO8601DateTime']>;
  completedAt?: Maybe<Scalars['ISO8601DateTime']>;
  confirmedAt?: Maybe<Scalars['ISO8601DateTime']>;
  createdAt: Scalars['ISO8601DateTime'];
  customer: Customer;
  dispatchedAt?: Maybe<Scalars['ISO8601DateTime']>;
  eoTotal?: Maybe<Scalars['BigInt']>;
  eoTotalQuantity?: Maybe<Scalars['Int']>;
  estimateDeliveredAt?: Maybe<Scalars['ISO8601DateTime']>;
  eta?: Maybe<Scalars['ISO8601Date']>;
  fromExportGift?: Maybe<Scalars['Boolean']>;
  id: Scalars['ID'];
  invoiceNumbers: Array<Scalars['String']>;
  isReturn: Scalars['Boolean'];
  itemCount: Scalars['Int'];
  note?: Maybe<Scalars['String']>;
  orderGifts?: Maybe<OrderGiftConnection>;
  orderItems?: Maybe<OrderItemConnection>;
  orderType?: Maybe<Scalars['String']>;
  returnedGifts?: Maybe<ReturnedGiftConnection>;
  returnedItems?: Maybe<ReturnedItemConnection>;
  salesOrg: SalesOrg;
  sapId?: Maybe<Scalars['ID']>;
  shippingAddress?: Maybe<Address>;
  slocAddress?: Maybe<Sloc>;
  status: Scalars['String'];
  total: Scalars['BigInt'];
  totalQuantity: Scalars['Int'];
  updatedAt: Scalars['ISO8601DateTime'];
  user: User;
  userCheckout?: Maybe<User>;
};


export type OrderOrderGiftsArgs = {
  after?: InputMaybe<Scalars['String']>;
  before?: InputMaybe<Scalars['String']>;
  first?: InputMaybe<Scalars['Int']>;
  last?: InputMaybe<Scalars['Int']>;
};


export type OrderOrderItemsArgs = {
  after?: InputMaybe<Scalars['String']>;
  before?: InputMaybe<Scalars['String']>;
  first?: InputMaybe<Scalars['Int']>;
  last?: InputMaybe<Scalars['Int']>;
  timeOrder?: InputMaybe<Scalars['String']>;
};


export type OrderReturnedGiftsArgs = {
  after?: InputMaybe<Scalars['String']>;
  before?: InputMaybe<Scalars['String']>;
  first?: InputMaybe<Scalars['Int']>;
  last?: InputMaybe<Scalars['Int']>;
};


export type OrderReturnedItemsArgs = {
  after?: InputMaybe<Scalars['String']>;
  before?: InputMaybe<Scalars['String']>;
  first?: InputMaybe<Scalars['Int']>;
  last?: InputMaybe<Scalars['Int']>;
};

/** The connection type for Order. */
export type OrderConnection = {
  /** A list of edges. */
  edges?: Maybe<Array<Maybe<OrderEdge>>>;
  /** A list of nodes. */
  nodes?: Maybe<Array<Maybe<Order>>>;
  /** Information to aid in pagination. */
  pageInfo: PageInfo;
  totalCount: Scalars['Int'];
};

/** An edge in a connection. */
export type OrderEdge = {
  /** A cursor for use in pagination. */
  cursor: Scalars['String'];
  /** The item at the end of the edge. */
  node?: Maybe<Order>;
};

export type OrderGift = {
  createdAt: Scalars['ISO8601DateTime'];
  giftInvoiceType?: Maybe<Scalars['Boolean']>;
  id: Scalars['ID'];
  order: Order;
  price: Scalars['BigInt'];
  quantity: Scalars['Int'];
  updatedAt: Scalars['ISO8601DateTime'];
  variant: Variant;
};

/** The connection type for OrderGift. */
export type OrderGiftConnection = {
  /** A list of edges. */
  edges?: Maybe<Array<Maybe<OrderGiftEdge>>>;
  /** A list of nodes. */
  nodes?: Maybe<Array<Maybe<OrderGift>>>;
  /** Information to aid in pagination. */
  pageInfo: PageInfo;
  totalCount: Scalars['Int'];
};

/** An edge in a connection. */
export type OrderGiftEdge = {
  /** A cursor for use in pagination. */
  cursor: Scalars['String'];
  /** The item at the end of the edge. */
  node?: Maybe<OrderGift>;
};

export type OrderItem = {
  adjustmentTotal: Scalars['Float'];
  anyImportableSameOrder: Scalars['Boolean'];
  createdAt: Scalars['ISO8601DateTime'];
  discounts: Array<DiscountDetails>;
  firstGiftCampaignId?: Maybe<Scalars['ID']>;
  firstLevelableCampaignId?: Maybe<Scalars['ID']>;
  firstNoncombinableCampaignId?: Maybe<Scalars['ID']>;
  giftCampaigns?: Maybe<Array<GiftCampaign>>;
  hasAllGiftsSelected: Scalars['Boolean'];
  id: Scalars['ID'];
  levelableGiftCampaigns?: Maybe<Array<LevelableGiftCampaign>>;
  noncombinableGiftCampaigns?: Maybe<Array<NoncombinableGiftCampaign>>;
  order: Order;
  ownCampaignTypeA: Scalars['Boolean'];
  price: Scalars['BigInt'];
  quantity: Scalars['Int'];
  retailPrice: Scalars['BigInt'];
  totalPrice: Scalars['BigInt'];
  totalPriceBeforeVat: Scalars['BigInt'];
  updatedAt: Scalars['ISO8601DateTime'];
  userCreator?: Maybe<User>;
  userUpdater?: Maybe<User>;
  variant: Variant;
  vat: Scalars['BigInt'];
  vatRetailPrice: Scalars['BigInt'];
  vatWholesalePrice: Scalars['BigInt'];
  wholesalePrice: Scalars['BigInt'];
};

/** The connection type for OrderItem. */
export type OrderItemConnection = {
  /** A list of edges. */
  edges?: Maybe<Array<Maybe<OrderItemEdge>>>;
  /** A list of nodes. */
  nodes?: Maybe<Array<Maybe<OrderItem>>>;
  /** Information to aid in pagination. */
  pageInfo: PageInfo;
  totalCount: Scalars['Int'];
};

/** An edge in a connection. */
export type OrderItemEdge = {
  /** A cursor for use in pagination. */
  cursor: Scalars['String'];
  /** The item at the end of the edge. */
  node?: Maybe<OrderItem>;
};

/** Information about pagination in a connection. */
export type PageInfo = {
  /** When paginating forwards, the cursor to continue. */
  endCursor?: Maybe<Scalars['String']>;
  /** When paginating forwards, are there more items? */
  hasNextPage: Scalars['Boolean'];
  /** When paginating backwards, are there more items? */
  hasPreviousPage: Scalars['Boolean'];
  /** When paginating backwards, the cursor to continue. */
  startCursor?: Maybe<Scalars['String']>;
};

export type PaymentHistory = {
  amount: Scalars['BigInt'];
  documentDate: Scalars['ISO8601Date'];
  documentNumber: Scalars['String'];
  documentType: Scalars['String'];
};

/** The connection type for PaymentHistory. */
export type PaymentHistoryConnection = {
  /** A list of edges. */
  edges?: Maybe<Array<Maybe<PaymentHistoryEdge>>>;
  /** A list of nodes. */
  nodes?: Maybe<Array<Maybe<PaymentHistory>>>;
  /** Information to aid in pagination. */
  pageInfo: PageInfo;
  totalCount: Scalars['Int'];
};

/** An edge in a connection. */
export type PaymentHistoryEdge = {
  /** A cursor for use in pagination. */
  cursor: Scalars['String'];
  /** The item at the end of the edge. */
  node?: Maybe<PaymentHistory>;
};

export type Product = {
  baseUnit: Unit;
  brand?: Maybe<Brand>;
  categories?: Maybe<Array<Category>>;
  createdAt: Scalars['ISO8601DateTime'];
  defaultVariant: Variant;
  filterVariant?: Maybe<Variant>;
  id: Scalars['ID'];
  isSaved?: Maybe<Scalars['Boolean']>;
  name: Scalars['String'];
  optionTypes: Array<OptionType>;
  promotedVariant?: Maybe<Variant>;
  updatedAt: Scalars['ISO8601DateTime'];
  variants: Array<Variant>;
};


export type ProductFilterVariantArgs = {
  attributes?: InputMaybe<Array<Scalars['String']>>;
  priceGte?: InputMaybe<Scalars['Int']>;
  priceLte?: InputMaybe<Scalars['Int']>;
};

/** The connection type for Product. */
export type ProductConnection = {
  /** A list of edges. */
  edges?: Maybe<Array<Maybe<ProductEdge>>>;
  /** A list of nodes. */
  nodes?: Maybe<Array<Maybe<Product>>>;
  /** Information to aid in pagination. */
  pageInfo: PageInfo;
  totalCount: Scalars['Int'];
};

/** An edge in a connection. */
export type ProductEdge = {
  /** A cursor for use in pagination. */
  cursor: Scalars['String'];
  /** The item at the end of the edge. */
  node?: Maybe<Product>;
};

export type Query = {
  /** Return list of gift campaigns for User with or without in_progress */
  allGiftCampaigns: GiftCampaignConnection;
  /** Return list of products that are on sale */
  allPromotedProducts: ProductConnection;
  /** Return list of noncombinable gift campaigns in same group */
  allSameGroupNcCampaigns: GiftCampaignConnection;
  /** Return list of applied variant of discount */
  appliedVariantsDiscount: VariantConnection;
  /** Return list of banner */
  banners: Array<Banner>;
  /** Return details of a gift campaign with respect to the provided order */
  campaignDetailsByOrder: GiftCampaign;
  /** query gift campaigns by  list of Ids */
  campaigns: Array<GiftCampaign>;
  /** Return cart data for the current user */
  cart: Order;
  /** list all gift campaigns applied to the current cart */
  cartGiftCampaigns: Array<GiftCampaign>;
  /** Return the top level product categories */
  categories: Array<Category>;
  /** Return a specific product category */
  category: Category;
  /** Return list of discounts for a category */
  categoryDiscounts: Array<CategoryDiscount>;
  /** Return list of gift campaigns for a category */
  categoryGiftCampaigns: GiftCampaignConnection;
  /** Return list of condition items for a group condition */
  conditionItems: GiftConditionItemConnection;
  /** Return balance of the current user's customer */
  currentBalance?: Maybe<Balance>;
  /** Return customer details */
  customer: Customer;
  /** Return list customers of a specific sales org */
  customers: Array<Customer>;
  /** Return estimate time arrival for items in order */
  estimateTimeArrival: EstimateTimeArrival;
  /** Return list of execution order of order */
  executionOrders: Array<ExecutionOrder>;
  /** Return ID of unshown banner for expiring promotions */
  expiringPromotionsBanner?: Maybe<Scalars['ID']>;
  /** Details of a particular  shopping list */
  fetchListItems: ShoppingList;
  /** Return all Campaign Group for type B gift campaigns */
  getCampaignGroups: Array<ItemCategory>;
  /** List all shopping lists of current customers */
  getLists: ShoppingListConnection;
  /** Return all Category's option types */
  getOptionTypes: Array<OptionType>;
  /** Details of a particular gift campaign */
  giftCampaignDetails: GiftCampaign;
  /** Return list of orders who concerns with the gift campaigns (only applied for type B) */
  giftCampaignOrders: OrderConnection;
  /** Return list of discount */
  groupedDiscounts: Array<GroupedDiscount>;
  /** Return inventory of all gift selection items */
  inventoryByGiftSelection: GiftSelection;
  /** Return inventory information for variant */
  inventoryByVariant?: Maybe<InventoryByVariant>;
  /** List all billing of the current customer */
  listBillings: ListBillings;
  /** Return all available brands of system */
  listBrand: Array<Brand>;
  /** Return all available colors of system */
  listColor: Array<OptionValue>;
  /** Return list of execution order of order */
  listExecutionOrders: Array<ExecutionOrder>;
  /** Return notifications of current users */
  listNotifications: ListNotification;
  /**  Return all Option Type's option values */
  listOptionValues: Array<OptionValue>;
  /** List all payment histories of the current customer */
  listPaymentHistories: ListPaymentHistories;
  /** Return list of noncombinable gift campaigns in the same group with respect to an order */
  ncCampaignsByGroupInOrder: GiftCampaignConnection;
  /** Return notifications from current user with ids */
  notifications: Array<Notification>;
  /** Return data for a particular order by id */
  order: Order;
  /** Return order item by id */
  orderItem: OrderItem;
  /** Return list of condition items ordered by purchase quantity */
  orderedConditionItems: GiftConditionItemConnection;
  /** List all orders of the current user, with optional search/sort query */
  orders: OrderConnection;
  /** Returns a list of products purchased within 90 days ago in sales org */
  popularProducts: ProductConnection;
  /** Return a specific product by id */
  product: Product;
  /** Return list promotions of product */
  productPromotions?: Maybe<Array<GiftCampaign>>;
  /** Return list of type B gift campaigns in progress and the progress does not count in Cart */
  progressGiftCampaigns: GiftCampaignConnection;
  /** Return products that are on sale */
  promotedProducts: Array<Product>;
  /** Returns a list of favorite products or purchased within 90 days ago */
  recommendedProducts: ProductConnection;
  /** List all products related to the current variant */
  relatedProducts: ProductConnection;
  /** Show sales org details */
  salesOrgDetails: SalesOrg;
  /** Return list sales orgs */
  salesOrgs: Array<SalesOrg>;
  /** Return the current user's saved products */
  savedProducts: ProductConnection;
  selectedGiftsTypeBInWarehouse: Array<SelectedGift>;
  /** Return all shipping addresses of the current user's customer */
  shippingAddresses?: Maybe<Array<Address>>;
  /** List all products of the same categories as the input product */
  similarProducts: ProductConnection;
  /** Return all sloc addresses of sales org of the current user's customer */
  slocAddresses?: Maybe<Array<Sloc>>;
  trip: TmsTrip;
  /** Return list of trips of order */
  trips: Array<TmsTrip>;
  /** Get user's information */
  userProfile?: Maybe<User>;
  /** Return all users of the current customer */
  users: Array<User>;
  /** Return a Product's variant matching the chosen option values */
  variant?: Maybe<Variant>;
  /** Return the variant with the chosen ID */
  variantById?: Maybe<Variant>;
  /** Return a product's variant matching the chosen option values */
  variantByOptionValues?: Maybe<Variant>;
  /** Return list of gift campaigns for a variant */
  variantCampaigns: Array<GiftCampaign>;
  /** List all variants whose name, category, or brand match the query */
  variantSearch: VariantSearch;
  /** list all type b gift campaigns applied to the order that items is available in warehouse */
  warehouseTypeBCampaigns: Array<GiftCampaign>;
};


export type QueryAllGiftCampaignsArgs = {
  after?: InputMaybe<Scalars['String']>;
  before?: InputMaybe<Scalars['String']>;
  first?: InputMaybe<Scalars['Int']>;
  inProgress: Scalars['Boolean'];
  last?: InputMaybe<Scalars['Int']>;
};


export type QueryAllPromotedProductsArgs = {
  after?: InputMaybe<Scalars['String']>;
  before?: InputMaybe<Scalars['String']>;
  first?: InputMaybe<Scalars['Int']>;
  last?: InputMaybe<Scalars['Int']>;
};


export type QueryAllSameGroupNcCampaignsArgs = {
  after?: InputMaybe<Scalars['String']>;
  before?: InputMaybe<Scalars['String']>;
  first?: InputMaybe<Scalars['Int']>;
  id: Scalars['ID'];
  last?: InputMaybe<Scalars['Int']>;
};


export type QueryAppliedVariantsDiscountArgs = {
  after?: InputMaybe<Scalars['String']>;
  before?: InputMaybe<Scalars['String']>;
  discountProgramId: Scalars['ID'];
  discountType?: InputMaybe<Scalars['String']>;
  discountValue: Scalars['Int'];
  first?: InputMaybe<Scalars['Int']>;
  last?: InputMaybe<Scalars['Int']>;
};


export type QueryCampaignDetailsByOrderArgs = {
  campaignId: Scalars['ID'];
  orderId: Scalars['ID'];
};


export type QueryCampaignsArgs = {
  ids: Array<Scalars['ID']>;
};


export type QueryCartGiftCampaignsArgs = {
  filter?: InputMaybe<Scalars['Boolean']>;
};


export type QueryCategoryArgs = {
  id: Scalars['ID'];
};


export type QueryCategoryDiscountsArgs = {
  categoryId: Scalars['ID'];
  discountProgramId?: InputMaybe<Scalars['ID']>;
};


export type QueryCategoryGiftCampaignsArgs = {
  after?: InputMaybe<Scalars['String']>;
  before?: InputMaybe<Scalars['String']>;
  categoryId: Scalars['ID'];
  first?: InputMaybe<Scalars['Int']>;
  last?: InputMaybe<Scalars['Int']>;
};


export type QueryConditionItemsArgs = {
  after?: InputMaybe<Scalars['String']>;
  before?: InputMaybe<Scalars['String']>;
  first?: InputMaybe<Scalars['Int']>;
  id: Scalars['ID'];
  last?: InputMaybe<Scalars['Int']>;
};


export type QueryCustomerArgs = {
  id: Scalars['ID'];
};


export type QueryCustomersArgs = {
  salesOrgId: Scalars['ID'];
};


export type QueryEstimateTimeArrivalArgs = {
  orderId: Scalars['ID'];
};


export type QueryExecutionOrdersArgs = {
  orderId: Scalars['ID'];
};


export type QueryFetchListItemsArgs = {
  listId: Scalars['ID'];
};


export type QueryGetListsArgs = {
  after?: InputMaybe<Scalars['String']>;
  before?: InputMaybe<Scalars['String']>;
  first?: InputMaybe<Scalars['Int']>;
  last?: InputMaybe<Scalars['Int']>;
};


export type QueryGetOptionTypesArgs = {
  id: Scalars['ID'];
};


export type QueryGiftCampaignDetailsArgs = {
  id: Scalars['ID'];
};


export type QueryGiftCampaignOrdersArgs = {
  after?: InputMaybe<Scalars['String']>;
  before?: InputMaybe<Scalars['String']>;
  first?: InputMaybe<Scalars['Int']>;
  id: Scalars['ID'];
  last?: InputMaybe<Scalars['Int']>;
};


export type QueryInventoryByGiftSelectionArgs = {
  giftSelectionId: Scalars['ID'];
};


export type QueryInventoryByVariantArgs = {
  count?: InputMaybe<Scalars['Boolean']>;
  quantity: Scalars['Int'];
  variantId: Scalars['ID'];
};


export type QueryListBillingsArgs = {
  endDate?: InputMaybe<Scalars['String']>;
  startDate?: InputMaybe<Scalars['String']>;
};


export type QueryListExecutionOrdersArgs = {
  orderId: Scalars['ID'];
};


export type QueryListOptionValuesArgs = {
  categoryId?: InputMaybe<Scalars['ID']>;
  id: Scalars['ID'];
};


export type QueryListPaymentHistoriesArgs = {
  endDate?: InputMaybe<Scalars['String']>;
  startDate?: InputMaybe<Scalars['String']>;
};


export type QueryNcCampaignsByGroupInOrderArgs = {
  after?: InputMaybe<Scalars['String']>;
  before?: InputMaybe<Scalars['String']>;
  campaignId: Scalars['ID'];
  first?: InputMaybe<Scalars['Int']>;
  last?: InputMaybe<Scalars['Int']>;
  orderId: Scalars['ID'];
};


export type QueryNotificationsArgs = {
  ids: Array<Scalars['ID']>;
};


export type QueryOrderArgs = {
  id: Scalars['ID'];
};


export type QueryOrderItemArgs = {
  id: Scalars['ID'];
};


export type QueryOrderedConditionItemsArgs = {
  after?: InputMaybe<Scalars['String']>;
  before?: InputMaybe<Scalars['String']>;
  first?: InputMaybe<Scalars['Int']>;
  id: Scalars['ID'];
  keyword?: InputMaybe<Scalars['String']>;
  last?: InputMaybe<Scalars['Int']>;
  variantIds: Array<Scalars['ID']>;
};


export type QueryOrdersArgs = {
  after?: InputMaybe<Scalars['String']>;
  before?: InputMaybe<Scalars['String']>;
  endDate?: InputMaybe<Scalars['String']>;
  first?: InputMaybe<Scalars['Int']>;
  id?: InputMaybe<Scalars['ID']>;
  last?: InputMaybe<Scalars['Int']>;
  sapId?: InputMaybe<Scalars['String']>;
  startDate?: InputMaybe<Scalars['String']>;
  status?: InputMaybe<Scalars['String']>;
};


export type QueryPopularProductsArgs = {
  after?: InputMaybe<Scalars['String']>;
  before?: InputMaybe<Scalars['String']>;
  first?: InputMaybe<Scalars['Int']>;
  last?: InputMaybe<Scalars['Int']>;
};


export type QueryProductArgs = {
  id: Scalars['ID'];
};


export type QueryProductPromotionsArgs = {
  productId: Scalars['ID'];
};


export type QueryProgressGiftCampaignsArgs = {
  after?: InputMaybe<Scalars['String']>;
  before?: InputMaybe<Scalars['String']>;
  codeItemCategory?: InputMaybe<Scalars['String']>;
  filter?: InputMaybe<Scalars['Boolean']>;
  first?: InputMaybe<Scalars['Int']>;
  last?: InputMaybe<Scalars['Int']>;
  validDate?: InputMaybe<Scalars['Boolean']>;
};


export type QueryRecommendedProductsArgs = {
  after?: InputMaybe<Scalars['String']>;
  before?: InputMaybe<Scalars['String']>;
  first?: InputMaybe<Scalars['Int']>;
  last?: InputMaybe<Scalars['Int']>;
};


export type QueryRelatedProductsArgs = {
  after?: InputMaybe<Scalars['String']>;
  before?: InputMaybe<Scalars['String']>;
  first?: InputMaybe<Scalars['Int']>;
  last?: InputMaybe<Scalars['Int']>;
  variantId: Scalars['ID'];
};


export type QuerySalesOrgDetailsArgs = {
  id: Scalars['ID'];
};


export type QuerySavedProductsArgs = {
  after?: InputMaybe<Scalars['String']>;
  before?: InputMaybe<Scalars['String']>;
  first?: InputMaybe<Scalars['Int']>;
  last?: InputMaybe<Scalars['Int']>;
};


export type QuerySelectedGiftsTypeBInWarehouseArgs = {
  orderId: Scalars['ID'];
};


export type QuerySimilarProductsArgs = {
  after?: InputMaybe<Scalars['String']>;
  before?: InputMaybe<Scalars['String']>;
  first?: InputMaybe<Scalars['Int']>;
  last?: InputMaybe<Scalars['Int']>;
  productId: Scalars['ID'];
};


export type QueryTripArgs = {
  id: Scalars['ID'];
};


export type QueryTripsArgs = {
  orderId: Scalars['ID'];
};


export type QueryVariantArgs = {
  optionValueIds: Array<Scalars['ID']>;
  productId: Scalars['ID'];
};


export type QueryVariantByIdArgs = {
  id: Scalars['ID'];
};


export type QueryVariantByOptionValuesArgs = {
  newOptionValueId?: InputMaybe<Scalars['ID']>;
  optionValueIds?: InputMaybe<Array<Scalars['ID']>>;
  productId: Scalars['ID'];
};


export type QueryVariantCampaignsArgs = {
  variantId: Scalars['ID'];
};


export type QueryVariantSearchArgs = {
  attributes?: InputMaybe<Array<Scalars['String']>>;
  brandIds?: InputMaybe<Array<Scalars['ID']>>;
  categoryIds?: InputMaybe<Array<Scalars['ID']>>;
  optionValueIds?: InputMaybe<Array<Scalars['ID']>>;
  priceGte?: InputMaybe<Scalars['Int']>;
  priceLte?: InputMaybe<Scalars['Int']>;
  query: Scalars['String'];
  source?: InputMaybe<Scalars['String']>;
};


export type QueryWarehouseTypeBCampaignsArgs = {
  filter?: InputMaybe<Scalars['Boolean']>;
};

export type RegistrationInput = {
  phoneNumber: Scalars['String'];
};

export type RemoveOrderItemsInput = {
  orderItemIds: Array<Scalars['ID']>;
};

export type RemoveSelectGiftsTypeBInWarehouseInput = {
  orderId: Scalars['ID'];
};

/** Autogenerated return type of RemoveSelectedGiftsTypeBInWarehouse */
export type RemoveSelectedGiftsTypeBInWarehousePayload = {
  /** A unique identifier for the client performing the mutation. */
  clientMutationId?: Maybe<Scalars['String']>;
  status: Scalars['String'];
};

export type RemoveUserInput = {
  selectedUserId: Scalars['ID'];
};

/** Autogenerated return type of RemoveUserMutation */
export type RemoveUserMutationPayload = {
  /** A unique identifier for the client performing the mutation. */
  clientMutationId?: Maybe<Scalars['String']>;
  status: Scalars['String'];
};

export type ReorderInput = {
  orderId: Scalars['ID'];
};

export type ResendOtpInput = {
  userId: Scalars['ID'];
};

export type ResetPasswordInput = {
  password: Scalars['String'];
  passwordConfirmation: Scalars['String'];
  resetPasswordToken: Scalars['String'];
  userId: Scalars['ID'];
};

export type ReturnedGift = {
  createdAt: Scalars['ISO8601DateTime'];
  giftInvoiceType?: Maybe<Scalars['Boolean']>;
  id: Scalars['ID'];
  itemCategory: Scalars['String'];
  order: Order;
  original?: Maybe<OrderItem>;
  price: Scalars['BigInt'];
  progressRevertedAt?: Maybe<Scalars['ISO8601DateTime']>;
  progressUpdatedAt?: Maybe<Scalars['ISO8601DateTime']>;
  quantity: Scalars['Int'];
  retailPrice: Scalars['BigInt'];
  salesDeal: Scalars['String'];
  totalPrice: Scalars['BigInt'];
  updatedAt: Scalars['ISO8601DateTime'];
  variant: Variant;
  vat: Scalars['BigInt'];
  vatWholesalePrice: Scalars['BigInt'];
  wholesalePrice: Scalars['BigInt'];
};

/** The connection type for ReturnedGift. */
export type ReturnedGiftConnection = {
  /** A list of edges. */
  edges?: Maybe<Array<Maybe<ReturnedGiftEdge>>>;
  /** A list of nodes. */
  nodes?: Maybe<Array<Maybe<ReturnedGift>>>;
  /** Information to aid in pagination. */
  pageInfo: PageInfo;
  totalCount: Scalars['Int'];
};

/** An edge in a connection. */
export type ReturnedGiftEdge = {
  /** A cursor for use in pagination. */
  cursor: Scalars['String'];
  /** The item at the end of the edge. */
  node?: Maybe<ReturnedGift>;
};

export type ReturnedItem = {
  createdAt: Scalars['ISO8601DateTime'];
  id: Scalars['ID'];
  itemCategory: Scalars['String'];
  order: Order;
  original?: Maybe<OrderItem>;
  originalCheckoutTime?: Maybe<Scalars['ISO8601DateTime']>;
  price: Scalars['BigInt'];
  progressRevertedAt?: Maybe<Scalars['ISO8601DateTime']>;
  progressUpdatedAt?: Maybe<Scalars['ISO8601DateTime']>;
  quantity: Scalars['Int'];
  retailPrice: Scalars['BigInt'];
  totalPrice: Scalars['BigInt'];
  updatedAt: Scalars['ISO8601DateTime'];
  variant: Variant;
  vat: Scalars['BigInt'];
  vatWholesalePrice: Scalars['BigInt'];
  wholesalePrice: Scalars['BigInt'];
};

/** The connection type for ReturnedItem. */
export type ReturnedItemConnection = {
  /** A list of edges. */
  edges?: Maybe<Array<Maybe<ReturnedItemEdge>>>;
  /** A list of nodes. */
  nodes?: Maybe<Array<Maybe<ReturnedItem>>>;
  /** Information to aid in pagination. */
  pageInfo: PageInfo;
  totalCount: Scalars['Int'];
};

/** An edge in a connection. */
export type ReturnedItemEdge = {
  /** A cursor for use in pagination. */
  cursor: Scalars['String'];
  /** The item at the end of the edge. */
  node?: Maybe<ReturnedItem>;
};

export type SalesOrg = {
  bankAccount?: Maybe<BankAccount>;
  company: Company;
  customers: CustomerConnection;
  email?: Maybe<Scalars['String']>;
  id: Scalars['ID'];
  name: Scalars['String'];
  sapCode?: Maybe<Scalars['String']>;
  warehouseAddress?: Maybe<Scalars['String']>;
};


export type SalesOrgCustomersArgs = {
  after?: InputMaybe<Scalars['String']>;
  before?: InputMaybe<Scalars['String']>;
  first?: InputMaybe<Scalars['Int']>;
  last?: InputMaybe<Scalars['Int']>;
};

export type SapBilling = {
  billingDate: Scalars['ISO8601Date'];
  billingTypeSapCode: Scalars['String'];
  invoiceNo: Scalars['String'];
  orderId: Scalars['ID'];
  returnedAmount?: Maybe<Scalars['BigInt']>;
  sapBillingId: Scalars['String'];
  sapOdId: Scalars['String'];
  vatTotalValue?: Maybe<Scalars['BigInt']>;
};

/** The connection type for SapBilling. */
export type SapBillingConnection = {
  /** A list of edges. */
  edges?: Maybe<Array<Maybe<SapBillingEdge>>>;
  /** A list of nodes. */
  nodes?: Maybe<Array<Maybe<SapBilling>>>;
  /** Information to aid in pagination. */
  pageInfo: PageInfo;
  totalCount: Scalars['Int'];
};

/** An edge in a connection. */
export type SapBillingEdge = {
  /** A cursor for use in pagination. */
  cursor: Scalars['String'];
  /** The item at the end of the edge. */
  node?: Maybe<SapBilling>;
};

export type SaveProductInput = {
  productId: Scalars['ID'];
};

export type SearchConversionInput = {
  convertableId: Scalars['ID'];
  convertableType: Scalars['String'];
  searchId: Scalars['ID'];
  source?: InputMaybe<Scalars['String']>;
};

export type SelectGiftInput = {
  bWithOrder?: InputMaybe<Scalars['Boolean']>;
  giftSelectionId: Scalars['ID'];
  multiplyBy: Scalars['Int'];
  orderId?: InputMaybe<Scalars['ID']>;
};

export type SelectGiftItemInput = {
  giftSelectionItemId: Scalars['ID'];
  quantity: Scalars['Int'];
  selectedGiftId: Scalars['ID'];
};

export type SelectedGift = {
  createdAt: Scalars['ISO8601DateTime'];
  giftBillingOption: Scalars['String'];
  giftSelection: GiftSelection;
  id: Scalars['ID'];
  multiplyBy: Scalars['Int'];
  orderId?: Maybe<Scalars['ID']>;
  selectedGiftItems: Array<SelectedGiftItem>;
  status: Scalars['String'];
  totalValue?: Maybe<Scalars['Int']>;
  updatedAt: Scalars['ISO8601DateTime'];
  userId?: Maybe<Scalars['ID']>;
  variantGiftId: Scalars['ID'];
};

export type SelectedGiftItem = {
  createdAt: Scalars['ISO8601DateTime'];
  giftSelectionItem: GiftSelectionItem;
  id: Scalars['ID'];
  quantity: Scalars['Int'];
  quantityBilled: Scalars['Int'];
  selectedGift: SelectedGift;
  updatedAt: Scalars['ISO8601DateTime'];
};

export type ShoppingList = {
  createdAt: Scalars['ISO8601DateTime'];
  id: Scalars['ID'];
  name?: Maybe<Scalars['ID']>;
  shoppingListItems?: Maybe<ShoppingListItemConnection>;
  updatedAt: Scalars['ISO8601DateTime'];
};


export type ShoppingListShoppingListItemsArgs = {
  after?: InputMaybe<Scalars['String']>;
  before?: InputMaybe<Scalars['String']>;
  first?: InputMaybe<Scalars['Int']>;
  last?: InputMaybe<Scalars['Int']>;
};

/** The connection type for ShoppingList. */
export type ShoppingListConnection = {
  /** A list of edges. */
  edges?: Maybe<Array<Maybe<ShoppingListEdge>>>;
  /** A list of nodes. */
  nodes?: Maybe<Array<Maybe<ShoppingList>>>;
  /** Information to aid in pagination. */
  pageInfo: PageInfo;
  totalCount: Scalars['Int'];
};

/** An edge in a connection. */
export type ShoppingListEdge = {
  /** A cursor for use in pagination. */
  cursor: Scalars['String'];
  /** The item at the end of the edge. */
  node?: Maybe<ShoppingList>;
};

export type ShoppingListInput = {
  name: Scalars['String'];
};

export type ShoppingListItem = {
  createdAt: Scalars['ISO8601DateTime'];
  id: Scalars['ID'];
  quantity: Scalars['Int'];
  shoppingList: ShoppingList;
  updatedAt: Scalars['ISO8601DateTime'];
  variant: Variant;
};

/** The connection type for ShoppingListItem. */
export type ShoppingListItemConnection = {
  /** A list of edges. */
  edges?: Maybe<Array<Maybe<ShoppingListItemEdge>>>;
  /** A list of nodes. */
  nodes?: Maybe<Array<Maybe<ShoppingListItem>>>;
  /** Information to aid in pagination. */
  pageInfo: PageInfo;
  totalCount: Scalars['Int'];
};

/** An edge in a connection. */
export type ShoppingListItemEdge = {
  /** A cursor for use in pagination. */
  cursor: Scalars['String'];
  /** The item at the end of the edge. */
  node?: Maybe<ShoppingListItem>;
};

/** Autogenerated return type of ShowPopupBannerForExpiringPromotions */
export type ShowPopupBannerForExpiringPromotionsPayload = {
  popupBannerId?: Maybe<Scalars['ID']>;
};

export type Sloc = {
  address?: Maybe<Scalars['String']>;
  createdAt: Scalars['ISO8601DateTime'];
  description?: Maybe<Scalars['String']>;
  id: Scalars['ID'];
  sapCode?: Maybe<Scalars['String']>;
  updatedAt: Scalars['ISO8601DateTime'];
};

export type Subscription = {
  newUserNotification?: Maybe<Notification>;
  orderItemWasUpdated?: Maybe<OrderItem>;
  showPopupBannerForExpiringPromotions?: Maybe<ShowPopupBannerForExpiringPromotionsPayload>;
};

export type TmsCargoDetail = {
  deliveryAddress: Scalars['String'];
  id: Scalars['ID'];
  materialNumber: Scalars['String'];
  name: Scalars['String'];
  price: Scalars['BigInt'];
  quantity: Scalars['Int'];
  receiptAddress: Scalars['String'];
};

/** The connection type for TmsCargoDetail. */
export type TmsCargoDetailConnection = {
  /** A list of edges. */
  edges?: Maybe<Array<Maybe<TmsCargoDetailEdge>>>;
  /** A list of nodes. */
  nodes?: Maybe<Array<Maybe<TmsCargoDetail>>>;
  /** Information to aid in pagination. */
  pageInfo: PageInfo;
  totalCount: Scalars['Int'];
};

/** An edge in a connection. */
export type TmsCargoDetailEdge = {
  /** A cursor for use in pagination. */
  cursor: Scalars['String'];
  /** The item at the end of the edge. */
  node?: Maybe<TmsCargoDetail>;
};

export type TmsTrip = {
  arrivedDeliveryAddressAt?: Maybe<Scalars['ISO8601DateTime']>;
  arrivedReceiptAddressAt?: Maybe<Scalars['ISO8601DateTime']>;
  canceledAt?: Maybe<Scalars['ISO8601DateTime']>;
  contactFullname: Scalars['String'];
  contactMobilephone: Scalars['String'];
  deliverySuccessfulAt?: Maybe<Scalars['ISO8601DateTime']>;
  deliveryUnsuccessfulAt?: Maybe<Scalars['ISO8601DateTime']>;
  driverName: Scalars['String'];
  id: Scalars['ID'];
  itemCount: Scalars['Int'];
  items?: Maybe<TmsCargoDetailConnection>;
  locations: Array<TmsTripLocation>;
  startedAt?: Maybe<Scalars['ISO8601DateTime']>;
  status?: Maybe<Scalars['String']>;
  total: Scalars['BigInt'];
  totalQuantity: Scalars['Int'];
  tripId: Scalars['String'];
  vehicleCode: Scalars['String'];
};


export type TmsTripItemsArgs = {
  after?: InputMaybe<Scalars['String']>;
  before?: InputMaybe<Scalars['String']>;
  first?: InputMaybe<Scalars['Int']>;
  last?: InputMaybe<Scalars['Int']>;
};

export type TmsTripLocation = {
  address: Scalars['String'];
  description: Scalars['String'];
  id: Scalars['ID'];
  latitude?: Maybe<Scalars['Float']>;
  longitude?: Maybe<Scalars['Float']>;
  tmsUpdatedAt?: Maybe<Scalars['ISO8601DateTime']>;
  tripStatus: Scalars['String'];
};

export type Unit = {
  code: Scalars['String'];
  createdAt: Scalars['ISO8601DateTime'];
  englishName: Scalars['String'];
  id: Scalars['ID'];
  updatedAt: Scalars['ISO8601DateTime'];
  vietnameseName: Scalars['String'];
};

export type UnsaveProductInput = {
  productId: Scalars['ID'];
};

export type UpdateCartInput = {
  quantity: Scalars['Int'];
  variantId: Scalars['ID'];
};

export type UpdateExecutionOrderItemInput = {
  executionOrderItemIds: Array<Scalars['ID']>;
};

export type UpdateOrderItemInput = {
  id: Scalars['ID'];
  quantity: Scalars['Int'];
};

export type User = {
  active: Scalars['Boolean'];
  createPasswordToken?: Maybe<Scalars['String']>;
  customer: Customer;
  email?: Maybe<Scalars['String']>;
  id: Scalars['ID'];
  name?: Maybe<Scalars['String']>;
  phoneNumber: Scalars['String'];
  resetPasswordToken?: Maybe<Scalars['String']>;
  userType?: Maybe<Scalars['String']>;
  verified?: Maybe<Scalars['Boolean']>;
};

export type Variant = {
  available?: Maybe<Scalars['Boolean']>;
  bestDeal?: Maybe<GiftCampaign>;
  campaignIds?: Maybe<Array<Scalars['ID']>>;
  campaignPropratedPrices?: Maybe<Array<CampaignPropratedPrice>>;
  countryOfOrigin?: Maybe<Country>;
  createdAt: Scalars['ISO8601DateTime'];
  defaultImageUrl?: Maybe<Scalars['String']>;
  description?: Maybe<Scalars['String']>;
  discount?: Maybe<DiscountDetails>;
  discounts: Array<DiscountDetails>;
  exhausted?: Maybe<Scalars['Boolean']>;
  extraDataFiles?: Maybe<Array<ExtraDataFile>>;
  firstOrderDiscount?: Maybe<DiscountDetails>;
  giftCampaigns?: Maybe<Array<GiftCampaign>>;
  grossWeight?: Maybe<Scalars['Int']>;
  id: Scalars['ID'];
  imageUrls: Array<Scalars['String']>;
  inventoryQuantity?: Maybe<Scalars['Int']>;
  levelableGiftCampaigns?: Maybe<Array<LevelableGiftCampaign>>;
  maintenanceDetails?: Maybe<Scalars['String']>;
  materialNumber: Scalars['String'];
  minimumOrderQuantity: Scalars['Int'];
  mustBuyWithVariant?: Maybe<Variant>;
  name: Scalars['String'];
  netPrice?: Maybe<Scalars['Int']>;
  netWeight?: Maybe<Scalars['Int']>;
  noncombinableGiftCampaigns?: Maybe<Array<NoncombinableGiftCampaign>>;
  optionValues: Array<OptionValue>;
  packagingDescription?: Maybe<Scalars['String']>;
  product?: Maybe<Product>;
  regionalNames: Array<Scalars['String']>;
  specifications?: Maybe<Scalars['JSON']>;
  unavailableOptionValues: Scalars['JSON'];
  updatedAt: Scalars['ISO8601DateTime'];
  vatPrice?: Maybe<Scalars['Int']>;
  vatWholesalePrice?: Maybe<Scalars['Int']>;
  volume?: Maybe<Scalars['Int']>;
  volumeUnit: Unit;
  warranty?: Maybe<Warranty>;
  weightUnit: Unit;
  wholesalePrice?: Maybe<Scalars['Int']>;
};


export type VariantDiscountArgs = {
  discountProgramId?: InputMaybe<Scalars['ID']>;
};

/** The connection type for Variant. */
export type VariantConnection = {
  /** A list of edges. */
  edges?: Maybe<Array<Maybe<VariantEdge>>>;
  /** A list of nodes. */
  nodes?: Maybe<Array<Maybe<Variant>>>;
  /** Information to aid in pagination. */
  pageInfo: PageInfo;
  totalCount: Scalars['Int'];
};

/** An edge in a connection. */
export type VariantEdge = {
  /** A cursor for use in pagination. */
  cursor: Scalars['String'];
  /** The item at the end of the edge. */
  node?: Maybe<Variant>;
};

export type VariantGiftCondition = {
  conditionItemSummary: Array<GiftConditionItem>;
  createdAt: Scalars['ISO8601DateTime'];
  giftConditionItemCount?: Maybe<Scalars['Int']>;
  giftConditionItems: Array<GiftConditionItem>;
  id: Scalars['ID'];
  totalGiftConditionItemsQuantityThreshold?: Maybe<Scalars['Int']>;
  totalGiftConditionItemsRevenueThreshold?: Maybe<Scalars['Int']>;
  totalQuantityThreshold?: Maybe<Scalars['Int']>;
  totalRevenueThreshold?: Maybe<Scalars['BigInt']>;
  updatedAt: Scalars['ISO8601DateTime'];
};

export type VariantSearch = {
  results: VariantConnection;
  searchId: Scalars['ID'];
};


export type VariantSearchResultsArgs = {
  after?: InputMaybe<Scalars['String']>;
  before?: InputMaybe<Scalars['String']>;
  first?: InputMaybe<Scalars['Int']>;
  last?: InputMaybe<Scalars['Int']>;
};

export type VerifyPhoneNumberInput = {
  otp: Scalars['String'];
  userId: Scalars['ID'];
};

export type Warranty = {
  exchangePolicy?: Maybe<Scalars['String']>;
  id: Scalars['ID'];
  warrantyPolicy?: Maybe<Scalars['String']>;
};

export type WebpushTokenInput = {
  device?: InputMaybe<Scalars['String']>;
  endpoint: Scalars['String'];
  keysAuth: Scalars['String'];
  keysP256dh: Scalars['String'];
  oldKeysP256dh?: InputMaybe<Scalars['String']>;
};

export type LoginMutationVariables = Types.Exact<{
  input: Types.LoginInput;
}>;


export type LoginMutation = { login?: { token: string, user: { id: string, phoneNumber: string, verified?: boolean | null | undefined, name?: string | null | undefined, userType?: string | null | undefined, customer: { id: string, name: string, emails: Array<string> } } } | null | undefined };

export type RegisterMutationVariables = Types.Exact<{
  input: Types.RegistrationInput;
}>;


export type RegisterMutation = { register?: { id: string, phoneNumber: string, verified?: boolean | null | undefined, createPasswordToken?: string | null | undefined } | null | undefined };

export type ForgotPasswordMutationVariables = Types.Exact<{
  input: Types.ForgotPasswordInput;
}>;


export type ForgotPasswordMutation = { forgotPassword?: { id: string, phoneNumber: string, verified?: boolean | null | undefined, resetPasswordToken?: string | null | undefined } | null | undefined };

export type ResendOtpMutationVariables = Types.Exact<{
  input: Types.ResendOtpInput;
}>;


export type ResendOtpMutation = { resendOtp?: { id: string, phoneNumber: string, verified?: boolean | null | undefined } | null | undefined };

export type VerifyPhoneRegistrationMutationVariables = Types.Exact<{
  input: Types.VerifyPhoneNumberInput;
}>;


export type VerifyPhoneRegistrationMutation = { verifyPhoneRegistration?: { id: string, phoneNumber: string, verified?: boolean | null | undefined } | null | undefined };

export type VerifyPhoneLoginMutationVariables = Types.Exact<{
  input: Types.VerifyPhoneNumberInput;
}>;


export type VerifyPhoneLoginMutation = { verifyPhoneLogin?: { token: string, user: { id: string, phoneNumber: string, verified?: boolean | null | undefined } } | null | undefined };

export type CreatePasswordMutationVariables = Types.Exact<{
  input: Types.CreatePasswordInput;
}>;


export type CreatePasswordMutation = { createPassword?: { id: string, phoneNumber: string, verified?: boolean | null | undefined } | null | undefined };

export type ResetPasswordMutationVariables = Types.Exact<{
  input: Types.ResetPasswordInput;
}>;


export type ResetPasswordMutation = { resetPassword?: { id: string, phoneNumber: string, verified?: boolean | null | undefined } | null | undefined };

export type ChangePasswordMutationVariables = Types.Exact<{
  input: Types.ChangePasswordInput;
}>;


export type ChangePasswordMutation = { changePassword?: { id: string, phoneNumber: string, verified?: boolean | null | undefined } | null | undefined };

export type ChangeUserTypeMutationVariables = Types.Exact<{
  input: Types.ChangeUserTypeInput;
}>;


export type ChangeUserTypeMutation = { changeUserType?: { id: string, name?: string | null | undefined, phoneNumber: string, active: boolean, userType?: string | null | undefined } | null | undefined };

export type ChangeUserStatusMutationVariables = Types.Exact<{
  input: Types.ChangeUserStatusInput;
}>;


export type ChangeUserStatusMutation = { changeUserStatus?: { id: string, name?: string | null | undefined, phoneNumber: string, active: boolean } | null | undefined };

export type RemoveUserMutationVariables = Types.Exact<{
  input: Types.RemoveUserInput;
}>;


export type RemoveUserMutation = { removeUser?: { status: string } | null | undefined };

export type GetUsersQueryVariables = Types.Exact<{ [key: string]: never; }>;


export type GetUsersQuery = { users: Array<{ id: string, name?: string | null | undefined, phoneNumber: string, active: boolean, userType?: string | null | undefined }> };

export type CreateUserMutationVariables = Types.Exact<{
  input: Types.CreateUserInput;
}>;


export type CreateUserMutation = { createUser?: { id: string, userType?: string | null | undefined, phoneNumber: string, name?: string | null | undefined } | null | undefined };


export const LoginDocument = gql`
    mutation Login($input: LoginInput!) {
  login(input: $input) {
    user {
      id
      phoneNumber
      verified
      name
      userType
      customer {
        id
        name
        emails
      }
    }
    token
  }
}
    `;
export type LoginMutationFn = Apollo.MutationFunction<LoginMutation, LoginMutationVariables>;

/**
 * __useLoginMutation__
 *
 * To run a mutation, you first call `useLoginMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useLoginMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [loginMutation, { data, loading, error }] = useLoginMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export function useLoginMutation(baseOptions?: Apollo.MutationHookOptions<LoginMutation, LoginMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<LoginMutation, LoginMutationVariables>(LoginDocument, options);
      }
export type LoginMutationHookResult = ReturnType<typeof useLoginMutation>;
export type LoginMutationResult = Apollo.MutationResult<LoginMutation>;
export type LoginMutationOptions = Apollo.BaseMutationOptions<LoginMutation, LoginMutationVariables>;
export const RegisterDocument = gql`
    mutation Register($input: RegistrationInput!) {
  register(input: $input) {
    id
    phoneNumber
    verified
    createPasswordToken
  }
}
    `;
export type RegisterMutationFn = Apollo.MutationFunction<RegisterMutation, RegisterMutationVariables>;

/**
 * __useRegisterMutation__
 *
 * To run a mutation, you first call `useRegisterMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useRegisterMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [registerMutation, { data, loading, error }] = useRegisterMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export function useRegisterMutation(baseOptions?: Apollo.MutationHookOptions<RegisterMutation, RegisterMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<RegisterMutation, RegisterMutationVariables>(RegisterDocument, options);
      }
export type RegisterMutationHookResult = ReturnType<typeof useRegisterMutation>;
export type RegisterMutationResult = Apollo.MutationResult<RegisterMutation>;
export type RegisterMutationOptions = Apollo.BaseMutationOptions<RegisterMutation, RegisterMutationVariables>;
export const ForgotPasswordDocument = gql`
    mutation ForgotPassword($input: ForgotPasswordInput!) {
  forgotPassword(input: $input) {
    id
    phoneNumber
    verified
    resetPasswordToken
  }
}
    `;
export type ForgotPasswordMutationFn = Apollo.MutationFunction<ForgotPasswordMutation, ForgotPasswordMutationVariables>;

/**
 * __useForgotPasswordMutation__
 *
 * To run a mutation, you first call `useForgotPasswordMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useForgotPasswordMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [forgotPasswordMutation, { data, loading, error }] = useForgotPasswordMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export function useForgotPasswordMutation(baseOptions?: Apollo.MutationHookOptions<ForgotPasswordMutation, ForgotPasswordMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<ForgotPasswordMutation, ForgotPasswordMutationVariables>(ForgotPasswordDocument, options);
      }
export type ForgotPasswordMutationHookResult = ReturnType<typeof useForgotPasswordMutation>;
export type ForgotPasswordMutationResult = Apollo.MutationResult<ForgotPasswordMutation>;
export type ForgotPasswordMutationOptions = Apollo.BaseMutationOptions<ForgotPasswordMutation, ForgotPasswordMutationVariables>;
export const ResendOtpDocument = gql`
    mutation ResendOtp($input: ResendOtpInput!) {
  resendOtp(input: $input) {
    id
    phoneNumber
    verified
  }
}
    `;
export type ResendOtpMutationFn = Apollo.MutationFunction<ResendOtpMutation, ResendOtpMutationVariables>;

/**
 * __useResendOtpMutation__
 *
 * To run a mutation, you first call `useResendOtpMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useResendOtpMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [resendOtpMutation, { data, loading, error }] = useResendOtpMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export function useResendOtpMutation(baseOptions?: Apollo.MutationHookOptions<ResendOtpMutation, ResendOtpMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<ResendOtpMutation, ResendOtpMutationVariables>(ResendOtpDocument, options);
      }
export type ResendOtpMutationHookResult = ReturnType<typeof useResendOtpMutation>;
export type ResendOtpMutationResult = Apollo.MutationResult<ResendOtpMutation>;
export type ResendOtpMutationOptions = Apollo.BaseMutationOptions<ResendOtpMutation, ResendOtpMutationVariables>;
export const VerifyPhoneRegistrationDocument = gql`
    mutation VerifyPhoneRegistration($input: VerifyPhoneNumberInput!) {
  verifyPhoneRegistration(input: $input) {
    id
    phoneNumber
    verified
  }
}
    `;
export type VerifyPhoneRegistrationMutationFn = Apollo.MutationFunction<VerifyPhoneRegistrationMutation, VerifyPhoneRegistrationMutationVariables>;

/**
 * __useVerifyPhoneRegistrationMutation__
 *
 * To run a mutation, you first call `useVerifyPhoneRegistrationMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useVerifyPhoneRegistrationMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [verifyPhoneRegistrationMutation, { data, loading, error }] = useVerifyPhoneRegistrationMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export function useVerifyPhoneRegistrationMutation(baseOptions?: Apollo.MutationHookOptions<VerifyPhoneRegistrationMutation, VerifyPhoneRegistrationMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<VerifyPhoneRegistrationMutation, VerifyPhoneRegistrationMutationVariables>(VerifyPhoneRegistrationDocument, options);
      }
export type VerifyPhoneRegistrationMutationHookResult = ReturnType<typeof useVerifyPhoneRegistrationMutation>;
export type VerifyPhoneRegistrationMutationResult = Apollo.MutationResult<VerifyPhoneRegistrationMutation>;
export type VerifyPhoneRegistrationMutationOptions = Apollo.BaseMutationOptions<VerifyPhoneRegistrationMutation, VerifyPhoneRegistrationMutationVariables>;
export const VerifyPhoneLoginDocument = gql`
    mutation VerifyPhoneLogin($input: VerifyPhoneNumberInput!) {
  verifyPhoneLogin(input: $input) {
    user {
      id
      phoneNumber
      verified
    }
    token
  }
}
    `;
export type VerifyPhoneLoginMutationFn = Apollo.MutationFunction<VerifyPhoneLoginMutation, VerifyPhoneLoginMutationVariables>;

/**
 * __useVerifyPhoneLoginMutation__
 *
 * To run a mutation, you first call `useVerifyPhoneLoginMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useVerifyPhoneLoginMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [verifyPhoneLoginMutation, { data, loading, error }] = useVerifyPhoneLoginMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export function useVerifyPhoneLoginMutation(baseOptions?: Apollo.MutationHookOptions<VerifyPhoneLoginMutation, VerifyPhoneLoginMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<VerifyPhoneLoginMutation, VerifyPhoneLoginMutationVariables>(VerifyPhoneLoginDocument, options);
      }
export type VerifyPhoneLoginMutationHookResult = ReturnType<typeof useVerifyPhoneLoginMutation>;
export type VerifyPhoneLoginMutationResult = Apollo.MutationResult<VerifyPhoneLoginMutation>;
export type VerifyPhoneLoginMutationOptions = Apollo.BaseMutationOptions<VerifyPhoneLoginMutation, VerifyPhoneLoginMutationVariables>;
export const CreatePasswordDocument = gql`
    mutation CreatePassword($input: CreatePasswordInput!) {
  createPassword(input: $input) {
    id
    phoneNumber
    verified
  }
}
    `;
export type CreatePasswordMutationFn = Apollo.MutationFunction<CreatePasswordMutation, CreatePasswordMutationVariables>;

/**
 * __useCreatePasswordMutation__
 *
 * To run a mutation, you first call `useCreatePasswordMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCreatePasswordMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [createPasswordMutation, { data, loading, error }] = useCreatePasswordMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export function useCreatePasswordMutation(baseOptions?: Apollo.MutationHookOptions<CreatePasswordMutation, CreatePasswordMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<CreatePasswordMutation, CreatePasswordMutationVariables>(CreatePasswordDocument, options);
      }
export type CreatePasswordMutationHookResult = ReturnType<typeof useCreatePasswordMutation>;
export type CreatePasswordMutationResult = Apollo.MutationResult<CreatePasswordMutation>;
export type CreatePasswordMutationOptions = Apollo.BaseMutationOptions<CreatePasswordMutation, CreatePasswordMutationVariables>;
export const ResetPasswordDocument = gql`
    mutation ResetPassword($input: ResetPasswordInput!) {
  resetPassword(input: $input) {
    id
    phoneNumber
    verified
  }
}
    `;
export type ResetPasswordMutationFn = Apollo.MutationFunction<ResetPasswordMutation, ResetPasswordMutationVariables>;

/**
 * __useResetPasswordMutation__
 *
 * To run a mutation, you first call `useResetPasswordMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useResetPasswordMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [resetPasswordMutation, { data, loading, error }] = useResetPasswordMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export function useResetPasswordMutation(baseOptions?: Apollo.MutationHookOptions<ResetPasswordMutation, ResetPasswordMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<ResetPasswordMutation, ResetPasswordMutationVariables>(ResetPasswordDocument, options);
      }
export type ResetPasswordMutationHookResult = ReturnType<typeof useResetPasswordMutation>;
export type ResetPasswordMutationResult = Apollo.MutationResult<ResetPasswordMutation>;
export type ResetPasswordMutationOptions = Apollo.BaseMutationOptions<ResetPasswordMutation, ResetPasswordMutationVariables>;
export const ChangePasswordDocument = gql`
    mutation ChangePassword($input: ChangePasswordInput!) {
  changePassword(input: $input) {
    id
    phoneNumber
    verified
  }
}
    `;
export type ChangePasswordMutationFn = Apollo.MutationFunction<ChangePasswordMutation, ChangePasswordMutationVariables>;

/**
 * __useChangePasswordMutation__
 *
 * To run a mutation, you first call `useChangePasswordMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useChangePasswordMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [changePasswordMutation, { data, loading, error }] = useChangePasswordMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export function useChangePasswordMutation(baseOptions?: Apollo.MutationHookOptions<ChangePasswordMutation, ChangePasswordMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<ChangePasswordMutation, ChangePasswordMutationVariables>(ChangePasswordDocument, options);
      }
export type ChangePasswordMutationHookResult = ReturnType<typeof useChangePasswordMutation>;
export type ChangePasswordMutationResult = Apollo.MutationResult<ChangePasswordMutation>;
export type ChangePasswordMutationOptions = Apollo.BaseMutationOptions<ChangePasswordMutation, ChangePasswordMutationVariables>;
export const ChangeUserTypeDocument = gql`
    mutation ChangeUserType($input: ChangeUserTypeInput!) {
  changeUserType(input: $input) {
    id
    name
    phoneNumber
    active
    userType
  }
}
    `;
export type ChangeUserTypeMutationFn = Apollo.MutationFunction<ChangeUserTypeMutation, ChangeUserTypeMutationVariables>;

/**
 * __useChangeUserTypeMutation__
 *
 * To run a mutation, you first call `useChangeUserTypeMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useChangeUserTypeMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [changeUserTypeMutation, { data, loading, error }] = useChangeUserTypeMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export function useChangeUserTypeMutation(baseOptions?: Apollo.MutationHookOptions<ChangeUserTypeMutation, ChangeUserTypeMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<ChangeUserTypeMutation, ChangeUserTypeMutationVariables>(ChangeUserTypeDocument, options);
      }
export type ChangeUserTypeMutationHookResult = ReturnType<typeof useChangeUserTypeMutation>;
export type ChangeUserTypeMutationResult = Apollo.MutationResult<ChangeUserTypeMutation>;
export type ChangeUserTypeMutationOptions = Apollo.BaseMutationOptions<ChangeUserTypeMutation, ChangeUserTypeMutationVariables>;
export const ChangeUserStatusDocument = gql`
    mutation ChangeUserStatus($input: ChangeUserStatusInput!) {
  changeUserStatus(input: $input) {
    id
    name
    phoneNumber
    active
  }
}
    `;
export type ChangeUserStatusMutationFn = Apollo.MutationFunction<ChangeUserStatusMutation, ChangeUserStatusMutationVariables>;

/**
 * __useChangeUserStatusMutation__
 *
 * To run a mutation, you first call `useChangeUserStatusMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useChangeUserStatusMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [changeUserStatusMutation, { data, loading, error }] = useChangeUserStatusMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export function useChangeUserStatusMutation(baseOptions?: Apollo.MutationHookOptions<ChangeUserStatusMutation, ChangeUserStatusMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<ChangeUserStatusMutation, ChangeUserStatusMutationVariables>(ChangeUserStatusDocument, options);
      }
export type ChangeUserStatusMutationHookResult = ReturnType<typeof useChangeUserStatusMutation>;
export type ChangeUserStatusMutationResult = Apollo.MutationResult<ChangeUserStatusMutation>;
export type ChangeUserStatusMutationOptions = Apollo.BaseMutationOptions<ChangeUserStatusMutation, ChangeUserStatusMutationVariables>;
export const RemoveUserDocument = gql`
    mutation RemoveUser($input: RemoveUserInput!) {
  removeUser(input: $input) {
    status
  }
}
    `;
export type RemoveUserMutationFn = Apollo.MutationFunction<RemoveUserMutation, RemoveUserMutationVariables>;

/**
 * __useRemoveUserMutation__
 *
 * To run a mutation, you first call `useRemoveUserMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useRemoveUserMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [removeUserMutation, { data, loading, error }] = useRemoveUserMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export function useRemoveUserMutation(baseOptions?: Apollo.MutationHookOptions<RemoveUserMutation, RemoveUserMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<RemoveUserMutation, RemoveUserMutationVariables>(RemoveUserDocument, options);
      }
export type RemoveUserMutationHookResult = ReturnType<typeof useRemoveUserMutation>;
export type RemoveUserMutationResult = Apollo.MutationResult<RemoveUserMutation>;
export type RemoveUserMutationOptions = Apollo.BaseMutationOptions<RemoveUserMutation, RemoveUserMutationVariables>;
export const GetUsersDocument = gql`
    query GetUsers {
  users {
    id
    name
    phoneNumber
    active
    userType
  }
}
    `;

/**
 * __useGetUsersQuery__
 *
 * To run a query within a React component, call `useGetUsersQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetUsersQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useGetUsersQuery({
 *   variables: {
 *   },
 * });
 */
export function useGetUsersQuery(baseOptions?: Apollo.QueryHookOptions<GetUsersQuery, GetUsersQueryVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useQuery<GetUsersQuery, GetUsersQueryVariables>(GetUsersDocument, options);
      }
export function useGetUsersLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetUsersQuery, GetUsersQueryVariables>) {
          const options = {...defaultOptions, ...baseOptions}
          return Apollo.useLazyQuery<GetUsersQuery, GetUsersQueryVariables>(GetUsersDocument, options);
        }
export type GetUsersQueryHookResult = ReturnType<typeof useGetUsersQuery>;
export type GetUsersLazyQueryHookResult = ReturnType<typeof useGetUsersLazyQuery>;
export type GetUsersQueryResult = Apollo.QueryResult<GetUsersQuery, GetUsersQueryVariables>;
export const CreateUserDocument = gql`
    mutation CreateUser($input: CreateUserInput!) {
  createUser(input: $input) {
    id
    userType
    phoneNumber
    name
  }
}
    `;
export type CreateUserMutationFn = Apollo.MutationFunction<CreateUserMutation, CreateUserMutationVariables>;

/**
 * __useCreateUserMutation__
 *
 * To run a mutation, you first call `useCreateUserMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCreateUserMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [createUserMutation, { data, loading, error }] = useCreateUserMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export function useCreateUserMutation(baseOptions?: Apollo.MutationHookOptions<CreateUserMutation, CreateUserMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<CreateUserMutation, CreateUserMutationVariables>(CreateUserDocument, options);
      }
export type CreateUserMutationHookResult = ReturnType<typeof useCreateUserMutation>;
export type CreateUserMutationResult = Apollo.MutationResult<CreateUserMutation>;
export type CreateUserMutationOptions = Apollo.BaseMutationOptions<CreateUserMutation, CreateUserMutationVariables>;