web-frontend/app/composables/graphql/generated.ts

import gql from 'graphql-tag';
import * as VueApolloComposable from '@vue/apollo-composable';
import type * as VueCompositionApi from '@vue/composition-api';
export type Maybe<T> = T | null;
export type InputMaybe<T> = Maybe<T>;
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]> };
export type MakeEmpty<T extends { [key: string]: unknown }, K extends keyof T> = { [_ in K]?: never };
export type Incremental<T> = T | { [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never };
export type ReactiveFunction<TParam> = () => TParam;
/** All built-in and custom scalars, mapped to their actual values */
export type Scalars = {
  ID: { input: string; output: string; }
  String: { input: string; output: string; }
  Boolean: { input: boolean; output: boolean; }
  Int: { input: number; output: number; }
  Float: { input: number; output: number; }
  DateTime: { input: any; output: any; }
  JSON: { input: any; output: any; }
};

export type AcceptInvitationInput = {
  fullName: Scalars['String']['input'];
  token: Scalars['String']['input'];
};

export type AddBonusTransactionInput = {
  amount: Scalars['Float']['input'];
  orderId?: InputMaybe<Scalars['ID']['input']>;
  reason: Scalars['String']['input'];
  userId: Scalars['ID']['input'];
};

export type AuthCodeRequestResult = {
  __typename?: 'AuthCodeRequestResult';
  challengeToken: Scalars['String']['output'];
  channel: LoginChannel;
  destination: Scalars['String']['output'];
  expiresAt: Scalars['DateTime']['output'];
};

export type AuthSession = {
  __typename?: 'AuthSession';
  accessToken: Scalars['String']['output'];
  expiresAt: Scalars['DateTime']['output'];
  user: User;
};

export type BonusProgramLink = {
  __typename?: 'BonusProgramLink';
  expiresAt: Scalars['DateTime']['output'];
  token: Scalars['String']['output'];
  url: Scalars['String']['output'];
  userId: Scalars['ID']['output'];
};

export type BonusTransaction = {
  __typename?: 'BonusTransaction';
  amount: Scalars['Float']['output'];
  createdAt: Scalars['DateTime']['output'];
  id: Scalars['ID']['output'];
  orderId?: Maybe<Scalars['ID']['output']>;
  reason: Scalars['String']['output'];
  userId: Scalars['ID']['output'];
};

export type Cart = {
  __typename?: 'Cart';
  createdAt: Scalars['DateTime']['output'];
  deliveryAddress?: Maybe<DeliveryAddress>;
  deliveryAddressId?: Maybe<Scalars['ID']['output']>;
  id: Scalars['ID']['output'];
  items: Array<CartItem>;
  updatedAt: Scalars['DateTime']['output'];
  userId: Scalars['ID']['output'];
};

export type CartItem = {
  __typename?: 'CartItem';
  createdAt: Scalars['DateTime']['output'];
  id: Scalars['ID']['output'];
  isCustomizable: Scalars['Boolean']['output'];
  parameters: Scalars['JSON']['output'];
  productId: Scalars['ID']['output'];
  productName: Scalars['String']['output'];
  quantity: Scalars['Float']['output'];
  sku: Scalars['String']['output'];
  updatedAt: Scalars['DateTime']['output'];
};

export type CatalogProductTypeSetting = {
  __typename?: 'CatalogProductTypeSetting';
  allowCustomLabel: Scalars['Boolean']['output'];
  allowCustomLength: Scalars['Boolean']['output'];
  allowCustomSleeveBrand: Scalars['Boolean']['output'];
  colorOptions: Array<Scalars['String']['output']>;
  customLengthMaxM?: Maybe<Scalars['Int']['output']>;
  customLengthMinM?: Maybe<Scalars['Int']['output']>;
  customLengthStepM?: Maybe<Scalars['Int']['output']>;
  labelOptions: Array<Scalars['String']['output']>;
  lengthOptionsM: Array<Scalars['Int']['output']>;
  productType: Scalars['String']['output'];
  showQuantityPerBox: Scalars['Boolean']['output'];
  sleeveOptions: Array<Scalars['String']['output']>;
  thicknessOptionsMicron: Array<Scalars['Int']['output']>;
  widthOptionsMm: Array<Scalars['Int']['output']>;
};

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

export type ConnectMessengerInput = {
  channelId: Scalars['String']['input'];
  type: MessengerType;
};

export type CounterpartyProfile = {
  __typename?: 'CounterpartyProfile';
  bankName: Scalars['String']['output'];
  bik: Scalars['String']['output'];
  checkingAccount: Scalars['String']['output'];
  companyFullName: Scalars['String']['output'];
  companyName: Scalars['String']['output'];
  correspondentAccount: Scalars['String']['output'];
  createdAt: Scalars['DateTime']['output'];
  id: Scalars['ID']['output'];
  inn: Scalars['String']['output'];
  isComplete: Scalars['Boolean']['output'];
  kpp?: Maybe<Scalars['String']['output']>;
  legalAddress: Scalars['String']['output'];
  ogrn?: Maybe<Scalars['String']['output']>;
  signerBasis: Scalars['String']['output'];
  signerFullName: Scalars['String']['output'];
  signerPosition: Scalars['String']['output'];
  updatedAt: Scalars['DateTime']['output'];
  userId: Scalars['ID']['output'];
};

export type CreateInvitationInput = {
  companyName: Scalars['String']['input'];
  email: Scalars['String']['input'];
  expiresInDays?: InputMaybe<Scalars['Int']['input']>;
};

export type CreateMyDeliveryAddressInput = {
  address: Scalars['String']['input'];
  fiasId?: InputMaybe<Scalars['String']['input']>;
  label?: InputMaybe<Scalars['String']['input']>;
  unrestrictedValue?: InputMaybe<Scalars['String']['input']>;
};

export type CreateReferralInput = {
  bonusPercent: Scalars['Float']['input'];
  refereeUserId: Scalars['ID']['input'];
  referrerUserId: Scalars['ID']['input'];
};

export enum Decision {
  Approve = 'APPROVE',
  Reject = 'REJECT'
}

export type DeliveryAddress = {
  __typename?: 'DeliveryAddress';
  address: Scalars['String']['output'];
  createdAt: Scalars['DateTime']['output'];
  fiasId?: Maybe<Scalars['String']['output']>;
  id: Scalars['ID']['output'];
  isDefault: Scalars['Boolean']['output'];
  label?: Maybe<Scalars['String']['output']>;
  unrestrictedValue?: Maybe<Scalars['String']['output']>;
  updatedAt: Scalars['DateTime']['output'];
  userId: Scalars['ID']['output'];
};

export type IntegrationSyncDashboard = {
  __typename?: 'IntegrationSyncDashboard';
  generatedAt: Scalars['DateTime']['output'];
  items: Array<IntegrationSyncItem>;
  lastActivityAt?: Maybe<Scalars['DateTime']['output']>;
  totalClients: Scalars['Int']['output'];
  totalOrders: Scalars['Int']['output'];
  totalProducts: Scalars['Int']['output'];
};

export type IntegrationSyncItem = {
  __typename?: 'IntegrationSyncItem';
  description: Scalars['String']['output'];
  id: Scalars['ID']['output'];
  lastSyncedAt?: Maybe<Scalars['DateTime']['output']>;
  note: Scalars['String']['output'];
  source: Scalars['String']['output'];
  status: Scalars['String']['output'];
  syncedCount: Scalars['Int']['output'];
  title: Scalars['String']['output'];
};

export type Invitation = {
  __typename?: 'Invitation';
  acceptedAt?: Maybe<Scalars['DateTime']['output']>;
  acceptedById?: Maybe<Scalars['ID']['output']>;
  companyName: Scalars['String']['output'];
  createdAt: Scalars['DateTime']['output'];
  email: Scalars['String']['output'];
  expiresAt: Scalars['DateTime']['output'];
  id: Scalars['ID']['output'];
  managerId: Scalars['ID']['output'];
  token: Scalars['String']['output'];
};

export enum LoginChannel {
  Email = 'EMAIL',
  Max = 'MAX',
  Telegram = 'TELEGRAM'
}

export type ManagerBonusAccount = {
  __typename?: 'ManagerBonusAccount';
  balance: Scalars['Float']['output'];
  companyName?: Maybe<Scalars['String']['output']>;
  earnedAmount: Scalars['Float']['output'];
  email: Scalars['String']['output'];
  fullName: Scalars['String']['output'];
  pendingWithdrawalAmount: Scalars['Float']['output'];
  pendingWithdrawals: Array<RewardWithdrawalRequest>;
  referralLinks: Array<ManagerReferralLink>;
  referralsCount: Scalars['Int']['output'];
  transactions: Array<BonusTransaction>;
  transactionsCount: Scalars['Int']['output'];
  userId: Scalars['ID']['output'];
};

export type ManagerBonusBalance = {
  __typename?: 'ManagerBonusBalance';
  balance: Scalars['Float']['output'];
  companyName?: Maybe<Scalars['String']['output']>;
  email: Scalars['String']['output'];
  fullName: Scalars['String']['output'];
  pendingWithdrawalAmount: Scalars['Float']['output'];
  transactionsCount: Scalars['Int']['output'];
  userId: Scalars['ID']['output'];
};

export type ManagerReferralLink = {
  __typename?: 'ManagerReferralLink';
  bonusPercent: Scalars['Float']['output'];
  createdAt: Scalars['DateTime']['output'];
  createdById: Scalars['ID']['output'];
  id: Scalars['ID']['output'];
  refereeCompanyName?: Maybe<Scalars['String']['output']>;
  refereeEmail: Scalars['String']['output'];
  refereeId: Scalars['ID']['output'];
  refereeName: Scalars['String']['output'];
  referrerCompanyName?: Maybe<Scalars['String']['output']>;
  referrerEmail: Scalars['String']['output'];
  referrerId: Scalars['ID']['output'];
  referrerName: Scalars['String']['output'];
};

export type ManagerUser = {
  __typename?: 'ManagerUser';
  companyName?: Maybe<Scalars['String']['output']>;
  createdAt: Scalars['DateTime']['output'];
  email: Scalars['String']['output'];
  fullName: Scalars['String']['output'];
  id: Scalars['ID']['output'];
  inn?: Maybe<Scalars['String']['output']>;
  lastOrderAt?: Maybe<Scalars['DateTime']['output']>;
  orderCount: Scalars['Int']['output'];
  role: UserRole;
  telegramConnection?: Maybe<MessengerConnection>;
};

export type ManagerWithdrawalRequest = {
  __typename?: 'ManagerWithdrawalRequest';
  amount: Scalars['Float']['output'];
  companyName?: Maybe<Scalars['String']['output']>;
  createdAt: Scalars['DateTime']['output'];
  id: Scalars['ID']['output'];
  requesterEmail: Scalars['String']['output'];
  requesterFullName: Scalars['String']['output'];
  requesterId: Scalars['ID']['output'];
  reviewComment?: Maybe<Scalars['String']['output']>;
  reviewedById?: Maybe<Scalars['ID']['output']>;
  status: WithdrawalStatus;
  updatedAt: Scalars['DateTime']['output'];
};

export type MessengerConnection = {
  __typename?: 'MessengerConnection';
  avatarAvailable: Scalars['Boolean']['output'];
  channelId: Scalars['String']['output'];
  displayName?: Maybe<Scalars['String']['output']>;
  id: Scalars['ID']['output'];
  isActive: Scalars['Boolean']['output'];
  type: MessengerType;
  userId: Scalars['ID']['output'];
  username?: Maybe<Scalars['String']['output']>;
};

export type MessengerDispatchResult = {
  __typename?: 'MessengerDispatchResult';
  channelId: Scalars['String']['output'];
  detail: Scalars['String']['output'];
  sentAt: Scalars['DateTime']['output'];
  success: Scalars['Boolean']['output'];
  type: MessengerType;
};

export enum MessengerType {
  Max = 'MAX',
  Telegram = 'TELEGRAM'
}

export type Mutation = {
  __typename?: 'Mutation';
  acceptInvitation: User;
  addBonusTransaction: BonusTransaction;
  addProductToCart: Cart;
  clearCart: Cart;
  clientReviewOrder: Order;
  connectMessenger: MessengerConnection;
  consumeLoginToken: AuthSession;
  createBonusProgramLink: BonusProgramLink;
  createInvitation: Invitation;
  createMyDeliveryAddress: DeliveryAddress;
  createReferral: ReferralLink;
  deleteMyDeliveryAddress: Scalars['Boolean']['output'];
  deleteMyMessengerConnection: Scalars['Boolean']['output'];
  managerSetOrderOffer: Order;
  managerSetOrderStatus: Order;
  registerSelf: RegistrationRequest;
  removeCartItem: Cart;
  requestLoginCode: AuthCodeRequestResult;
  requestRewardWithdrawal: RewardWithdrawalRequest;
  reviewRegistrationRequest: RegistrationRequest;
  reviewRewardWithdrawal: RewardWithdrawalRequest;
  sendTestMessengerMessage: MessengerDispatchResult;
  setCartDeliveryAddress: Cart;
  setMyDefaultDeliveryAddress: DeliveryAddress;
  submitCalculationOrder: Order;
  submitReadyOrder: Order;
  updateCartItemQuantity: Cart;
  upsertCatalogProductTypeSetting: CatalogProductTypeSetting;
  upsertMyCounterpartyProfile: CounterpartyProfile;
  verifyLoginCode: AuthSession;
};


export type MutationAcceptInvitationArgs = {
  input: AcceptInvitationInput;
};


export type MutationAddBonusTransactionArgs = {
  input: AddBonusTransactionInput;
};


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


export type MutationClientReviewOrderArgs = {
  decision: Decision;
  orderId: Scalars['ID']['input'];
};


export type MutationConnectMessengerArgs = {
  input: ConnectMessengerInput;
};


export type MutationConsumeLoginTokenArgs = {
  token: Scalars['String']['input'];
};


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


export type MutationCreateInvitationArgs = {
  input: CreateInvitationInput;
};


export type MutationCreateMyDeliveryAddressArgs = {
  input: CreateMyDeliveryAddressInput;
};


export type MutationCreateReferralArgs = {
  input: CreateReferralInput;
};


export type MutationDeleteMyDeliveryAddressArgs = {
  addressId: Scalars['ID']['input'];
};


export type MutationDeleteMyMessengerConnectionArgs = {
  connectionId: Scalars['ID']['input'];
};


export type MutationManagerSetOrderOfferArgs = {
  input: SetOrderOfferInput;
};


export type MutationManagerSetOrderStatusArgs = {
  orderId: Scalars['ID']['input'];
  status: OrderStatus;
};


export type MutationRegisterSelfArgs = {
  input: RegisterSelfInput;
};


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


export type MutationRequestLoginCodeArgs = {
  input: RequestLoginCodeInput;
};


export type MutationRequestRewardWithdrawalArgs = {
  input: RequestRewardWithdrawalInput;
};


export type MutationReviewRegistrationRequestArgs = {
  input: ReviewRegistrationRequestInput;
};


export type MutationReviewRewardWithdrawalArgs = {
  input: ReviewRewardWithdrawalInput;
};


export type MutationSendTestMessengerMessageArgs = {
  channelId?: InputMaybe<Scalars['String']['input']>;
  message?: InputMaybe<Scalars['String']['input']>;
  type: MessengerType;
};


export type MutationSetCartDeliveryAddressArgs = {
  addressId?: InputMaybe<Scalars['ID']['input']>;
};


export type MutationSetMyDefaultDeliveryAddressArgs = {
  addressId: Scalars['ID']['input'];
};


export type MutationSubmitCalculationOrderArgs = {
  input: SubmitCalculationOrderInput;
};


export type MutationSubmitReadyOrderArgs = {
  input: SubmitReadyOrderInput;
};


export type MutationUpdateCartItemQuantityArgs = {
  input: UpdateCartItemQuantityInput;
};


export type MutationUpsertCatalogProductTypeSettingArgs = {
  input: UpsertCatalogProductTypeSettingInput;
};


export type MutationUpsertMyCounterpartyProfileArgs = {
  input: UpsertMyCounterpartyProfileInput;
};


export type MutationVerifyLoginCodeArgs = {
  input: VerifyLoginCodeInput;
};

export type NotificationHistoryItem = {
  __typename?: 'NotificationHistoryItem';
  channel: MessengerType;
  createdAt: Scalars['DateTime']['output'];
  id: Scalars['ID']['output'];
  message: Scalars['String']['output'];
  orderId?: Maybe<Scalars['ID']['output']>;
  title: Scalars['String']['output'];
};

export type NotificationTemplate = {
  __typename?: 'NotificationTemplate';
  channels: Array<NotificationTemplateChannel>;
  id: Scalars['ID']['output'];
  title: Scalars['String']['output'];
};

export type NotificationTemplateChannel = {
  __typename?: 'NotificationTemplateChannel';
  body: Array<Scalars['String']['output']>;
  buttonText?: Maybe<Scalars['String']['output']>;
  buttonUrl?: Maybe<Scalars['String']['output']>;
  channel: LoginChannel;
  implemented: Scalars['Boolean']['output'];
  subject?: Maybe<Scalars['String']['output']>;
};

export type Order = {
  __typename?: 'Order';
  blockReason?: Maybe<Scalars['String']['output']>;
  calculationPayload?: Maybe<Scalars['JSON']['output']>;
  clientApproved?: Maybe<Scalars['Boolean']['output']>;
  code: Scalars['String']['output'];
  createdAt: Scalars['DateTime']['output'];
  customerId: Scalars['ID']['output'];
  deliveryAddress?: Maybe<Scalars['String']['output']>;
  deliveryFee?: Maybe<Scalars['Float']['output']>;
  deliveryTerms?: Maybe<Scalars['String']['output']>;
  history: Array<OrderStatusEvent>;
  id: Scalars['ID']['output'];
  items: Array<OrderItem>;
  kind: OrderKind;
  managerApproved?: Maybe<Scalars['Boolean']['output']>;
  managerId?: Maybe<Scalars['ID']['output']>;
  status: OrderStatus;
  totalPrice?: Maybe<Scalars['Float']['output']>;
  updatedAt: Scalars['DateTime']['output'];
};

export type OrderItem = {
  __typename?: 'OrderItem';
  id: Scalars['ID']['output'];
  lineTotal?: Maybe<Scalars['Float']['output']>;
  productId?: Maybe<Scalars['ID']['output']>;
  productName: Scalars['String']['output'];
  quantity: Scalars['Float']['output'];
  unitPrice?: Maybe<Scalars['Float']['output']>;
};

export type OrderItemPriceInput = {
  itemId: Scalars['ID']['input'];
  unitPrice?: InputMaybe<Scalars['Float']['input']>;
};

export enum OrderKind {
  Calculation = 'CALCULATION',
  Ready = 'READY'
}

export enum OrderStatus {
  ClientRejected = 'CLIENT_REJECTED',
  Completed = 'COMPLETED',
  Confirmed = 'CONFIRMED',
  InProgress = 'IN_PROGRESS',
  ManagerBlocked = 'MANAGER_BLOCKED',
  ManagerProcessing = 'MANAGER_PROCESSING',
  ManagerRejected = 'MANAGER_REJECTED',
  New = 'NEW',
  WaitingDoubleConfirm = 'WAITING_DOUBLE_CONFIRM'
}

export type OrderStatusEvent = {
  __typename?: 'OrderStatusEvent';
  actorUserId: Scalars['ID']['output'];
  createdAt: Scalars['DateTime']['output'];
  id: Scalars['ID']['output'];
  note?: Maybe<Scalars['String']['output']>;
  status: OrderStatus;
};

export type Product = {
  __typename?: 'Product';
  availableInWarehouses: Array<ProductWarehouseBalance>;
  description?: Maybe<Scalars['String']['output']>;
  id: Scalars['ID']['output'];
  isActive: Scalars['Boolean']['output'];
  isCustomizable: Scalars['Boolean']['output'];
  lengthM?: Maybe<Scalars['Int']['output']>;
  name: Scalars['String']['output'];
  productType?: Maybe<Scalars['String']['output']>;
  quantityPerBox?: Maybe<Scalars['String']['output']>;
  sku: Scalars['String']['output'];
  sleeveBrand?: Maybe<Scalars['String']['output']>;
  tags: Array<Scalars['String']['output']>;
  thicknessMicron?: Maybe<Scalars['Int']['output']>;
  widthMm?: Maybe<Scalars['Int']['output']>;
};

export type ProductWarehouseBalance = {
  __typename?: 'ProductWarehouseBalance';
  availableQty: Scalars['Float']['output'];
  warehouse: Warehouse;
};

export type Query = {
  __typename?: 'Query';
  catalogProductTypeSettings: Array<CatalogProductTypeSetting>;
  clientProducts: Array<Product>;
  healthcheck: Scalars['String']['output'];
  integrationSyncDashboard: IntegrationSyncDashboard;
  managerBonusAccount: ManagerBonusAccount;
  managerBonusBalances: Array<ManagerBonusBalance>;
  managerNotificationHistory: Array<NotificationHistoryItem>;
  managerOrders: Array<Order>;
  managerReferralLinks: Array<ManagerReferralLink>;
  managerUsers: Array<ManagerUser>;
  managerWithdrawalRequests: Array<ManagerWithdrawalRequest>;
  me?: Maybe<User>;
  myCart: Cart;
  myCounterpartyProfile?: Maybe<CounterpartyProfile>;
  myCurrentOrders: Array<Order>;
  myDeliveryAddresses: Array<DeliveryAddress>;
  myMessengerConnections: Array<MessengerConnection>;
  myNotificationHistory: Array<NotificationHistoryItem>;
  myOrders: Array<Order>;
  notificationTemplates: Array<NotificationTemplate>;
  order?: Maybe<Order>;
  referralStats: ReferralStats;
  registrationRequests: Array<RegistrationRequest>;
};


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


export type QueryManagerNotificationHistoryArgs = {
  channel: MessengerType;
  limit?: InputMaybe<Scalars['Int']['input']>;
  userId: Scalars['ID']['input'];
};


export type QueryManagerOrdersArgs = {
  customerId?: InputMaybe<Scalars['ID']['input']>;
  status?: InputMaybe<OrderStatus>;
};


export type QueryManagerWithdrawalRequestsArgs = {
  status?: InputMaybe<WithdrawalStatus>;
};


export type QueryMyNotificationHistoryArgs = {
  channel: MessengerType;
  limit?: InputMaybe<Scalars['Int']['input']>;
};


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


export type QueryRegistrationRequestsArgs = {
  status?: InputMaybe<RegistrationStatus>;
};

export type ReadyOrderItemInput = {
  productId: Scalars['ID']['input'];
  quantity: Scalars['Float']['input'];
};

export type ReferralLink = {
  __typename?: 'ReferralLink';
  bonusPercent: Scalars['Float']['output'];
  createdAt: Scalars['DateTime']['output'];
  createdById: Scalars['ID']['output'];
  id: Scalars['ID']['output'];
  refereeId: Scalars['ID']['output'];
  referrerId: Scalars['ID']['output'];
};

export type ReferralStats = {
  __typename?: 'ReferralStats';
  availableBalance: Scalars['Float']['output'];
  pendingWithdrawals: Array<RewardWithdrawalRequest>;
  referralsCount: Scalars['Int']['output'];
  referrerId: Scalars['ID']['output'];
  transactions: Array<BonusTransaction>;
};

export type RegisterSelfInput = {
  companyName: Scalars['String']['input'];
  contactName: Scalars['String']['input'];
  email: Scalars['String']['input'];
  inn?: InputMaybe<Scalars['String']['input']>;
};

export type RegistrationRequest = {
  __typename?: 'RegistrationRequest';
  companyName: Scalars['String']['output'];
  contactName: Scalars['String']['output'];
  createdAt: Scalars['DateTime']['output'];
  email: Scalars['String']['output'];
  id: Scalars['ID']['output'];
  inn?: Maybe<Scalars['String']['output']>;
  rejectionReason?: Maybe<Scalars['String']['output']>;
  reviewedById?: Maybe<Scalars['ID']['output']>;
  status: RegistrationStatus;
  updatedAt: Scalars['DateTime']['output'];
};

export enum RegistrationStatus {
  Approved = 'APPROVED',
  Pending = 'PENDING',
  Rejected = 'REJECTED'
}

export type RequestLoginCodeInput = {
  channel: LoginChannel;
  destination: Scalars['String']['input'];
};

export type RequestRewardWithdrawalInput = {
  amount: Scalars['Float']['input'];
};

export type ReviewRegistrationRequestInput = {
  decision: Decision;
  rejectionReason?: InputMaybe<Scalars['String']['input']>;
  requestId: Scalars['ID']['input'];
};

export type ReviewRewardWithdrawalInput = {
  decision: Decision;
  reviewComment?: InputMaybe<Scalars['String']['input']>;
  withdrawalId: Scalars['ID']['input'];
};

export type RewardWithdrawalRequest = {
  __typename?: 'RewardWithdrawalRequest';
  amount: Scalars['Float']['output'];
  createdAt: Scalars['DateTime']['output'];
  id: Scalars['ID']['output'];
  requesterId: Scalars['ID']['output'];
  reviewComment?: Maybe<Scalars['String']['output']>;
  reviewedById?: Maybe<Scalars['ID']['output']>;
  status: WithdrawalStatus;
  updatedAt: Scalars['DateTime']['output'];
};

export type SetOrderOfferInput = {
  deliveryFee?: InputMaybe<Scalars['Float']['input']>;
  deliveryTerms: Scalars['String']['input'];
  itemPrices: Array<OrderItemPriceInput>;
  orderId: Scalars['ID']['input'];
};

export type SubmitCalculationOrderInput = {
  deliveryAddressId?: InputMaybe<Scalars['ID']['input']>;
  parameters: Scalars['JSON']['input'];
  productName: Scalars['String']['input'];
  quantity: Scalars['Float']['input'];
};

export type SubmitReadyOrderInput = {
  deliveryAddressId?: InputMaybe<Scalars['ID']['input']>;
  items: Array<ReadyOrderItemInput>;
};

export type UpdateCartItemQuantityInput = {
  productId: Scalars['ID']['input'];
  quantity: Scalars['Float']['input'];
};

export type UpsertCatalogProductTypeSettingInput = {
  allowCustomLabel: Scalars['Boolean']['input'];
  allowCustomLength: Scalars['Boolean']['input'];
  allowCustomSleeveBrand: Scalars['Boolean']['input'];
  colorOptions: Array<Scalars['String']['input']>;
  customLengthMaxM?: InputMaybe<Scalars['Int']['input']>;
  customLengthMinM?: InputMaybe<Scalars['Int']['input']>;
  customLengthStepM?: InputMaybe<Scalars['Int']['input']>;
  labelOptions: Array<Scalars['String']['input']>;
  lengthOptionsM: Array<Scalars['Int']['input']>;
  productType: Scalars['String']['input'];
  showQuantityPerBox: Scalars['Boolean']['input'];
  sleeveOptions: Array<Scalars['String']['input']>;
  thicknessOptionsMicron: Array<Scalars['Int']['input']>;
  widthOptionsMm: Array<Scalars['Int']['input']>;
};

export type UpsertMyCounterpartyProfileInput = {
  bankName: Scalars['String']['input'];
  bik: Scalars['String']['input'];
  checkingAccount: Scalars['String']['input'];
  companyFullName: Scalars['String']['input'];
  companyName: Scalars['String']['input'];
  correspondentAccount: Scalars['String']['input'];
  inn: Scalars['String']['input'];
  kpp?: InputMaybe<Scalars['String']['input']>;
  legalAddress: Scalars['String']['input'];
  ogrn?: InputMaybe<Scalars['String']['input']>;
  signerBasis: Scalars['String']['input'];
  signerFullName: Scalars['String']['input'];
  signerPosition: Scalars['String']['input'];
};

export type User = {
  __typename?: 'User';
  company?: Maybe<Company>;
  email: Scalars['String']['output'];
  fullName: Scalars['String']['output'];
  id: Scalars['ID']['output'];
  role: UserRole;
};

export enum UserRole {
  Client = 'CLIENT',
  Manager = 'MANAGER',
  SuperManager = 'SUPER_MANAGER'
}

export type VerifyLoginCodeInput = {
  challengeToken: Scalars['String']['input'];
  code: Scalars['String']['input'];
};

export type Warehouse = {
  __typename?: 'Warehouse';
  code: Scalars['String']['output'];
  id: Scalars['ID']['output'];
  name: Scalars['String']['output'];
};

export enum WithdrawalStatus {
  Approved = 'APPROVED',
  Pending = 'PENDING',
  Rejected = 'REJECTED'
}

export type ConsumeLoginTokenMutationVariables = Exact<{
  token: Scalars['String']['input'];
}>;


export type ConsumeLoginTokenMutation = { __typename?: 'Mutation', consumeLoginToken: { __typename?: 'AuthSession', accessToken: string, expiresAt: any, user: { __typename?: 'User', id: string, email: string, fullName: string, role: UserRole, company?: { __typename?: 'Company', id: string } | null } } };

export type MeQueryVariables = Exact<{ [key: string]: never; }>;


export type MeQuery = { __typename?: 'Query', me?: { __typename?: 'User', id: string, email: string, fullName: string, role: UserRole } | null };

export type RegisterSelfMutationVariables = Exact<{
  input: RegisterSelfInput;
}>;


export type RegisterSelfMutation = { __typename?: 'Mutation', registerSelf: { __typename?: 'RegistrationRequest', id: string, companyName: string, contactName: string, email: string, status: RegistrationStatus, createdAt: any } };

export type RequestLoginCodeMutationVariables = Exact<{
  input: RequestLoginCodeInput;
}>;


export type RequestLoginCodeMutation = { __typename?: 'Mutation', requestLoginCode: { __typename?: 'AuthCodeRequestResult', challengeToken: string, channel: LoginChannel, destination: string, expiresAt: any } };

export type VerifyLoginCodeMutationVariables = Exact<{
  input: VerifyLoginCodeInput;
}>;


export type VerifyLoginCodeMutation = { __typename?: 'Mutation', verifyLoginCode: { __typename?: 'AuthSession', accessToken: string, expiresAt: any, user: { __typename?: 'User', id: string, email: string, fullName: string, role: UserRole, company?: { __typename?: 'Company', id: string } | null } } };

export type CreateBonusProgramLinkMutationVariables = Exact<{
  userId: Scalars['ID']['input'];
}>;


export type CreateBonusProgramLinkMutation = { __typename?: 'Mutation', createBonusProgramLink: { __typename?: 'BonusProgramLink', userId: string, token: string, url: string, expiresAt: any } };

export type RequestRewardWithdrawalMutationVariables = Exact<{
  input: RequestRewardWithdrawalInput;
}>;


export type RequestRewardWithdrawalMutation = { __typename?: 'Mutation', requestRewardWithdrawal: { __typename?: 'RewardWithdrawalRequest', id: string, amount: number, status: WithdrawalStatus, createdAt: any, updatedAt: any, reviewComment?: string | null } };

export type AddProductToCartMutationVariables = Exact<{
  productId: Scalars['ID']['input'];
}>;


export type AddProductToCartMutation = { __typename?: 'Mutation', addProductToCart: { __typename?: 'Cart', id: string, userId: string, deliveryAddressId?: string | null, updatedAt: any, items: Array<{ __typename?: 'CartItem', id: string, productId: string, productName: string, sku: string, isCustomizable: boolean, quantity: number, parameters: any, updatedAt: any }> } };

export type ClearCartMutationVariables = Exact<{ [key: string]: never; }>;


export type ClearCartMutation = { __typename?: 'Mutation', clearCart: { __typename?: 'Cart', id: string, userId: string, deliveryAddressId?: string | null, updatedAt: any, items: Array<{ __typename?: 'CartItem', id: string, productId: string, productName: string, sku: string, isCustomizable: boolean, quantity: number, parameters: any, updatedAt: any }> } };

export type MyCartQueryVariables = Exact<{ [key: string]: never; }>;


export type MyCartQuery = { __typename?: 'Query', myCart: { __typename?: 'Cart', id: string, userId: string, deliveryAddressId?: string | null, updatedAt: any, items: Array<{ __typename?: 'CartItem', id: string, productId: string, productName: string, sku: string, isCustomizable: boolean, quantity: number, parameters: any, updatedAt: any }> } };

export type RemoveCartItemMutationVariables = Exact<{
  productId: Scalars['ID']['input'];
}>;


export type RemoveCartItemMutation = { __typename?: 'Mutation', removeCartItem: { __typename?: 'Cart', id: string, userId: string, deliveryAddressId?: string | null, updatedAt: any, items: Array<{ __typename?: 'CartItem', id: string, productId: string, productName: string, sku: string, isCustomizable: boolean, quantity: number, parameters: any, updatedAt: any }> } };

export type SetCartDeliveryAddressMutationVariables = Exact<{
  addressId?: InputMaybe<Scalars['ID']['input']>;
}>;


export type SetCartDeliveryAddressMutation = { __typename?: 'Mutation', setCartDeliveryAddress: { __typename?: 'Cart', id: string, userId: string, deliveryAddressId?: string | null, updatedAt: any, items: Array<{ __typename?: 'CartItem', id: string, productId: string, productName: string, sku: string, isCustomizable: boolean, quantity: number, parameters: any, updatedAt: any }> } };

export type UpdateCartItemQuantityMutationVariables = Exact<{
  input: UpdateCartItemQuantityInput;
}>;


export type UpdateCartItemQuantityMutation = { __typename?: 'Mutation', updateCartItemQuantity: { __typename?: 'Cart', id: string, userId: string, deliveryAddressId?: string | null, updatedAt: any, items: Array<{ __typename?: 'CartItem', id: string, productId: string, productName: string, sku: string, isCustomizable: boolean, quantity: number, parameters: any, updatedAt: any }> } };

export type ClientProductsQueryVariables = Exact<{ [key: string]: never; }>;


export type ClientProductsQuery = { __typename?: 'Query', clientProducts: Array<{ __typename?: 'Product', id: string, sku: string, name: string, description?: string | null, productType?: string | null, widthMm?: number | null, lengthM?: number | null, thicknessMicron?: number | null, sleeveBrand?: string | null, quantityPerBox?: string | null, tags: Array<string>, isCustomizable: boolean, availableInWarehouses: Array<{ __typename?: 'ProductWarehouseBalance', availableQty: number, warehouse: { __typename?: 'Warehouse', id: string, code: string, name: string } }> }> };

export type AddBonusTransactionMutationVariables = Exact<{
  input: AddBonusTransactionInput;
}>;


export type AddBonusTransactionMutation = { __typename?: 'Mutation', addBonusTransaction: { __typename?: 'BonusTransaction', id: string, userId: string, amount: number, reason: string, createdAt: any } };

export type CreateInvitationMutationVariables = Exact<{
  input: CreateInvitationInput;
}>;


export type CreateInvitationMutation = { __typename?: 'Mutation', createInvitation: { __typename?: 'Invitation', id: string, token: string, email: string, companyName: string, expiresAt: any } };

export type CreateReferralMutationVariables = Exact<{
  input: CreateReferralInput;
}>;


export type CreateReferralMutation = { __typename?: 'Mutation', createReferral: { __typename?: 'ReferralLink', id: string, referrerId: string, refereeId: string, createdById: string, bonusPercent: number, createdAt: any } };

export type ManagerBonusAccountQueryVariables = Exact<{
  userId: Scalars['ID']['input'];
}>;


export type ManagerBonusAccountQuery = { __typename?: 'Query', managerBonusAccount: { __typename?: 'ManagerBonusAccount', userId: string, email: string, fullName: string, companyName?: string | null, balance: number, earnedAmount: number, pendingWithdrawalAmount: number, transactionsCount: number, referralsCount: number, referralLinks: Array<{ __typename?: 'ManagerReferralLink', id: string, referrerId: string, referrerName: string, referrerEmail: string, referrerCompanyName?: string | null, refereeId: string, refereeName: string, refereeEmail: string, refereeCompanyName?: string | null, createdById: string, bonusPercent: number, createdAt: any }>, transactions: Array<{ __typename?: 'BonusTransaction', id: string, userId: string, amount: number, reason: string, orderId?: string | null, createdAt: any }>, pendingWithdrawals: Array<{ __typename?: 'RewardWithdrawalRequest', id: string, requesterId: string, amount: number, status: WithdrawalStatus, reviewComment?: string | null, createdAt: any, updatedAt: any }> } };

export type ManagerBonusBalancesQueryVariables = Exact<{ [key: string]: never; }>;


export type ManagerBonusBalancesQuery = { __typename?: 'Query', managerBonusBalances: Array<{ __typename?: 'ManagerBonusBalance', userId: string, email: string, fullName: string, companyName?: string | null, balance: number, pendingWithdrawalAmount: number, transactionsCount: number }> };

export type ManagerOrdersQueryVariables = Exact<{
  status?: InputMaybe<OrderStatus>;
  customerId?: InputMaybe<Scalars['ID']['input']>;
}>;


export type ManagerOrdersQuery = { __typename?: 'Query', managerOrders: Array<{ __typename?: 'Order', id: string, code: string, status: OrderStatus, kind: OrderKind, customerId: string, deliveryAddress?: string | null, deliveryTerms?: string | null, deliveryFee?: number | null, totalPrice?: number | null, createdAt: any, items: Array<{ __typename?: 'OrderItem', id: string, productName: string, quantity: number, unitPrice?: number | null, lineTotal?: number | null }> }> };

export type ManagerReferralLinksQueryVariables = Exact<{ [key: string]: never; }>;


export type ManagerReferralLinksQuery = { __typename?: 'Query', managerReferralLinks: Array<{ __typename?: 'ManagerReferralLink', id: string, referrerId: string, referrerName: string, referrerEmail: string, referrerCompanyName?: string | null, refereeId: string, refereeName: string, refereeEmail: string, refereeCompanyName?: string | null, createdById: string, bonusPercent: number, createdAt: any }> };

export type ManagerSetOrderStatusMutationVariables = Exact<{
  orderId: Scalars['ID']['input'];
  status: OrderStatus;
}>;


export type ManagerSetOrderStatusMutation = { __typename?: 'Mutation', managerSetOrderStatus: { __typename?: 'Order', id: string, status: OrderStatus } };

export type ManagerUsersDetailQueryVariables = Exact<{ [key: string]: never; }>;


export type ManagerUsersDetailQuery = { __typename?: 'Query', managerUsers: Array<{ __typename?: 'ManagerUser', id: string, email: string, fullName: string, companyName?: string | null, inn?: string | null, createdAt: any, orderCount: number, lastOrderAt?: any | null, telegramConnection?: { __typename?: 'MessengerConnection', id: string, type: MessengerType, channelId: string, displayName?: string | null, username?: string | null, avatarAvailable: boolean } | null }> };

export type ManagerUsersQueryVariables = Exact<{ [key: string]: never; }>;


export type ManagerUsersQuery = { __typename?: 'Query', managerUsers: Array<{ __typename?: 'ManagerUser', id: string, email: string, fullName: string, role: UserRole, companyName?: string | null, telegramConnection?: { __typename?: 'MessengerConnection', id: string, type: MessengerType, channelId: string, displayName?: string | null, username?: string | null, avatarAvailable: boolean } | null }> };

export type ManagerWithdrawalRequestsQueryVariables = Exact<{
  status?: InputMaybe<WithdrawalStatus>;
}>;


export type ManagerWithdrawalRequestsQuery = { __typename?: 'Query', managerWithdrawalRequests: Array<{ __typename?: 'ManagerWithdrawalRequest', id: string, requesterId: string, requesterEmail: string, requesterFullName: string, companyName?: string | null, amount: number, status: WithdrawalStatus, reviewedById?: string | null, reviewComment?: string | null, createdAt: any, updatedAt: any }> };

export type ReferralStatsQueryVariables = Exact<{ [key: string]: never; }>;


export type ReferralStatsQuery = { __typename?: 'Query', referralStats: { __typename?: 'ReferralStats', referrerId: string, availableBalance: number, referralsCount: number, transactions: Array<{ __typename?: 'BonusTransaction', id: string, userId: string, amount: number, reason: string, orderId?: string | null, createdAt: any }>, pendingWithdrawals: Array<{ __typename?: 'RewardWithdrawalRequest', id: string, requesterId: string, amount: number, status: WithdrawalStatus, reviewComment?: string | null, createdAt: any, updatedAt: any }> } };

export type RegistrationRequestsQueryVariables = Exact<{
  status?: InputMaybe<RegistrationStatus>;
}>;


export type RegistrationRequestsQuery = { __typename?: 'Query', registrationRequests: Array<{ __typename?: 'RegistrationRequest', id: string, companyName: string, contactName: string, email: string, status: RegistrationStatus, createdAt: any }> };

export type ReviewRegistrationRequestMutationVariables = Exact<{
  input: ReviewRegistrationRequestInput;
}>;


export type ReviewRegistrationRequestMutation = { __typename?: 'Mutation', reviewRegistrationRequest: { __typename?: 'RegistrationRequest', id: string, status: RegistrationStatus, rejectionReason?: string | null, reviewedById?: string | null } };

export type ReviewRewardWithdrawalMutationVariables = Exact<{
  input: ReviewRewardWithdrawalInput;
}>;


export type ReviewRewardWithdrawalMutation = { __typename?: 'Mutation', reviewRewardWithdrawal: { __typename?: 'RewardWithdrawalRequest', id: string, status: WithdrawalStatus, reviewComment?: string | null, reviewedById?: string | null } };

export type ManagerSetOrderOfferMutationVariables = Exact<{
  input: SetOrderOfferInput;
}>;


export type ManagerSetOrderOfferMutation = { __typename?: 'Mutation', managerSetOrderOffer: { __typename?: 'Order', id: string, code: string, status: OrderStatus, deliveryTerms?: string | null, deliveryFee?: number | null, totalPrice?: number | null, items: Array<{ __typename?: 'OrderItem', id: string, unitPrice?: number | null, lineTotal?: number | null }> } };

export type ManagerNotificationHistoryQueryVariables = Exact<{
  userId: Scalars['ID']['input'];
  channel: MessengerType;
  limit?: InputMaybe<Scalars['Int']['input']>;
}>;


export type ManagerNotificationHistoryQuery = { __typename?: 'Query', managerNotificationHistory: Array<{ __typename?: 'NotificationHistoryItem', id: string, channel: MessengerType, title: string, message: string, createdAt: any, orderId?: string | null }> };

export type MyMessengerConnectionsQueryVariables = Exact<{ [key: string]: never; }>;


export type MyMessengerConnectionsQuery = { __typename?: 'Query', myMessengerConnections: Array<{ __typename?: 'MessengerConnection', id: string, type: MessengerType, channelId: string, displayName?: string | null, username?: string | null, avatarAvailable: boolean, isActive: boolean }> };

export type MyNotificationHistoryQueryVariables = Exact<{
  channel: MessengerType;
  limit?: InputMaybe<Scalars['Int']['input']>;
}>;


export type MyNotificationHistoryQuery = { __typename?: 'Query', myNotificationHistory: Array<{ __typename?: 'NotificationHistoryItem', id: string, channel: MessengerType, title: string, message: string, createdAt: any, orderId?: string | null }> };

export type NotificationTemplatesQueryVariables = Exact<{ [key: string]: never; }>;


export type NotificationTemplatesQuery = { __typename?: 'Query', notificationTemplates: Array<{ __typename?: 'NotificationTemplate', id: string, title: string, channels: Array<{ __typename?: 'NotificationTemplateChannel', channel: LoginChannel, implemented: boolean, subject?: string | null, body: Array<string>, buttonText?: string | null, buttonUrl?: string | null }> }> };

export type SendTestMessengerMessageMutationVariables = Exact<{
  type: MessengerType;
  channelId?: InputMaybe<Scalars['String']['input']>;
  message?: InputMaybe<Scalars['String']['input']>;
}>;


export type SendTestMessengerMessageMutation = { __typename?: 'Mutation', sendTestMessengerMessage: { __typename?: 'MessengerDispatchResult', type: MessengerType, channelId: string, success: boolean, detail: string, sentAt: any } };

export type MyCurrentOrdersQueryVariables = Exact<{ [key: string]: never; }>;


export type MyCurrentOrdersQuery = { __typename?: 'Query', myCurrentOrders: Array<{ __typename?: 'Order', id: string, code: string, kind: OrderKind, status: OrderStatus, createdAt: any, items: Array<{ __typename?: 'OrderItem', id: string, productName: string, quantity: number }> }> };

export type MyOrdersQueryVariables = Exact<{ [key: string]: never; }>;


export type MyOrdersQuery = { __typename?: 'Query', myOrders: Array<{ __typename?: 'Order', id: string, code: string, kind: OrderKind, status: OrderStatus, deliveryAddress?: string | null, totalPrice?: number | null, deliveryTerms?: string | null, deliveryFee?: number | null, createdAt: any, items: Array<{ __typename?: 'OrderItem', id: string, productName: string, quantity: number, unitPrice?: number | null, lineTotal?: number | null }> }> };

export type OrderDetailQueryVariables = Exact<{
  id: Scalars['ID']['input'];
}>;


export type OrderDetailQuery = { __typename?: 'Query', order?: { __typename?: 'Order', id: string, code: string, kind: OrderKind, status: OrderStatus, customerId: string, deliveryAddress?: string | null, deliveryTerms?: string | null, deliveryFee?: number | null, totalPrice?: number | null, calculationPayload?: any | null, createdAt: any, items: Array<{ __typename?: 'OrderItem', id: string, productName: string, quantity: number, unitPrice?: number | null, lineTotal?: number | null }> } | null };

export type SubmitCalculationOrderMutationVariables = Exact<{
  input: SubmitCalculationOrderInput;
}>;


export type SubmitCalculationOrderMutation = { __typename?: 'Mutation', submitCalculationOrder: { __typename?: 'Order', id: string, code: string, status: OrderStatus, createdAt: any } };

export type SubmitReadyOrderMutationVariables = Exact<{
  input: SubmitReadyOrderInput;
}>;


export type SubmitReadyOrderMutation = { __typename?: 'Mutation', submitReadyOrder: { __typename?: 'Order', id: string, code: string, status: OrderStatus, createdAt: any } };

export type ConnectMessengerMutationVariables = Exact<{
  input: ConnectMessengerInput;
}>;


export type ConnectMessengerMutation = { __typename?: 'Mutation', connectMessenger: { __typename?: 'MessengerConnection', id: string, type: MessengerType, channelId: string, isActive: boolean } };

export type CreateMyDeliveryAddressMutationVariables = Exact<{
  input: CreateMyDeliveryAddressInput;
}>;


export type CreateMyDeliveryAddressMutation = { __typename?: 'Mutation', createMyDeliveryAddress: { __typename?: 'DeliveryAddress', id: string, label?: string | null, address: string, unrestrictedValue?: string | null, fiasId?: string | null, isDefault: boolean, updatedAt: any } };

export type DeleteMyDeliveryAddressMutationVariables = Exact<{
  addressId: Scalars['ID']['input'];
}>;


export type DeleteMyDeliveryAddressMutation = { __typename?: 'Mutation', deleteMyDeliveryAddress: boolean };

export type DeleteMyMessengerConnectionMutationVariables = Exact<{
  connectionId: Scalars['ID']['input'];
}>;


export type DeleteMyMessengerConnectionMutation = { __typename?: 'Mutation', deleteMyMessengerConnection: boolean };

export type MyCounterpartyProfileQueryVariables = Exact<{ [key: string]: never; }>;


export type MyCounterpartyProfileQuery = { __typename?: 'Query', myCounterpartyProfile?: { __typename?: 'CounterpartyProfile', id: string, companyName: string, companyFullName: string, inn: string, kpp?: string | null, ogrn?: string | null, legalAddress: string, bankName: string, bik: string, correspondentAccount: string, checkingAccount: string, signerFullName: string, signerPosition: string, signerBasis: string, isComplete: boolean, updatedAt: any } | null };

export type MyDeliveryAddressesQueryVariables = Exact<{ [key: string]: never; }>;


export type MyDeliveryAddressesQuery = { __typename?: 'Query', myDeliveryAddresses: Array<{ __typename?: 'DeliveryAddress', id: string, label?: string | null, address: string, unrestrictedValue?: string | null, fiasId?: string | null, isDefault: boolean, updatedAt: any }> };

export type SetMyDefaultDeliveryAddressMutationVariables = Exact<{
  addressId: Scalars['ID']['input'];
}>;


export type SetMyDefaultDeliveryAddressMutation = { __typename?: 'Mutation', setMyDefaultDeliveryAddress: { __typename?: 'DeliveryAddress', id: string, label?: string | null, address: string, unrestrictedValue?: string | null, fiasId?: string | null, isDefault: boolean, updatedAt: any } };

export type UpsertMyCounterpartyProfileMutationVariables = Exact<{
  input: UpsertMyCounterpartyProfileInput;
}>;


export type UpsertMyCounterpartyProfileMutation = { __typename?: 'Mutation', upsertMyCounterpartyProfile: { __typename?: 'CounterpartyProfile', id: string, companyName: string, companyFullName: string, inn: string, kpp?: string | null, ogrn?: string | null, legalAddress: string, bankName: string, bik: string, correspondentAccount: string, checkingAccount: string, signerFullName: string, signerPosition: string, signerBasis: string, isComplete: boolean, updatedAt: any } };

export type CatalogProductTypeSettingsQueryVariables = Exact<{ [key: string]: never; }>;


export type CatalogProductTypeSettingsQuery = { __typename?: 'Query', catalogProductTypeSettings: Array<{ __typename?: 'CatalogProductTypeSetting', productType: string, showQuantityPerBox: boolean, allowCustomLength: boolean, customLengthMinM?: number | null, customLengthMaxM?: number | null, customLengthStepM?: number | null, allowCustomSleeveBrand: boolean, allowCustomLabel: boolean, widthOptionsMm: Array<number>, lengthOptionsM: Array<number>, thicknessOptionsMicron: Array<number>, sleeveOptions: Array<string>, colorOptions: Array<string>, labelOptions: Array<string> }> };

export type IntegrationSyncDashboardQueryVariables = Exact<{ [key: string]: never; }>;


export type IntegrationSyncDashboardQuery = { __typename?: 'Query', integrationSyncDashboard: { __typename?: 'IntegrationSyncDashboard', generatedAt: any, lastActivityAt?: any | null, totalOrders: number, totalProducts: number, totalClients: number, items: Array<{ __typename?: 'IntegrationSyncItem', id: string, title: string, description: string, source: string, syncedCount: number, lastSyncedAt?: any | null, status: string, note: string }> } };

export type UpsertCatalogProductTypeSettingMutationVariables = Exact<{
  input: UpsertCatalogProductTypeSettingInput;
}>;


export type UpsertCatalogProductTypeSettingMutation = { __typename?: 'Mutation', upsertCatalogProductTypeSetting: { __typename?: 'CatalogProductTypeSetting', productType: string, showQuantityPerBox: boolean, allowCustomLength: boolean, customLengthMinM?: number | null, customLengthMaxM?: number | null, customLengthStepM?: number | null, allowCustomSleeveBrand: boolean, allowCustomLabel: boolean, widthOptionsMm: Array<number>, lengthOptionsM: Array<number>, thicknessOptionsMicron: Array<number>, sleeveOptions: Array<string>, colorOptions: Array<string>, labelOptions: Array<string> } };


export const ConsumeLoginTokenDocument = gql`
    mutation ConsumeLoginToken($token: String!) {
  consumeLoginToken(token: $token) {
    accessToken
    expiresAt
    user {
      id
      email
      fullName
      role
      company {
        id
      }
    }
  }
}
    `;

/**
 * __useConsumeLoginTokenMutation__
 *
 * To run a mutation, you first call `useConsumeLoginTokenMutation` within a Vue component and pass it any options that fit your needs.
 * When your component renders, `useConsumeLoginTokenMutation` returns an object that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - Several other properties: https://v4.apollo.vuejs.org/api/use-mutation.html#return
 *
 * @param options that will be passed into the mutation, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/mutation.html#options;
 *
 * @example
 * const { mutate, loading, error, onDone } = useConsumeLoginTokenMutation({
 *   variables: {
 *     token: // value for 'token'
 *   },
 * });
 */
export function useConsumeLoginTokenMutation(options: VueApolloComposable.UseMutationOptions<ConsumeLoginTokenMutation, ConsumeLoginTokenMutationVariables> | ReactiveFunction<VueApolloComposable.UseMutationOptions<ConsumeLoginTokenMutation, ConsumeLoginTokenMutationVariables>> = {}) {
  return VueApolloComposable.useMutation<ConsumeLoginTokenMutation, ConsumeLoginTokenMutationVariables>(ConsumeLoginTokenDocument, options);
}
export type ConsumeLoginTokenMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<ConsumeLoginTokenMutation, ConsumeLoginTokenMutationVariables>;
export const MeDocument = gql`
    query Me {
  me {
    id
    email
    fullName
    role
  }
}
    `;

/**
 * __useMeQuery__
 *
 * To run a query within a Vue component, call `useMeQuery` and pass it any options that fit your needs.
 * When your component renders, `useMeQuery` returns an object from Apollo Client that contains result, loading and error properties
 * you can use to render your UI.
 *
 * @param options that will be passed into the query, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/query.html#options;
 *
 * @example
 * const { result, loading, error } = useMeQuery();
 */
export function useMeQuery(options: VueApolloComposable.UseQueryOptions<MeQuery, MeQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<MeQuery, MeQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<MeQuery, MeQueryVariables>> = {}) {
  return VueApolloComposable.useQuery<MeQuery, MeQueryVariables>(MeDocument, {}, options);
}
export function useMeLazyQuery(options: VueApolloComposable.UseQueryOptions<MeQuery, MeQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<MeQuery, MeQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<MeQuery, MeQueryVariables>> = {}) {
  return VueApolloComposable.useLazyQuery<MeQuery, MeQueryVariables>(MeDocument, {}, options);
}
export type MeQueryCompositionFunctionResult = VueApolloComposable.UseQueryReturn<MeQuery, MeQueryVariables>;
export const RegisterSelfDocument = gql`
    mutation RegisterSelf($input: RegisterSelfInput!) {
  registerSelf(input: $input) {
    id
    companyName
    contactName
    email
    status
    createdAt
  }
}
    `;

/**
 * __useRegisterSelfMutation__
 *
 * To run a mutation, you first call `useRegisterSelfMutation` within a Vue component and pass it any options that fit your needs.
 * When your component renders, `useRegisterSelfMutation` returns an object that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - Several other properties: https://v4.apollo.vuejs.org/api/use-mutation.html#return
 *
 * @param options that will be passed into the mutation, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/mutation.html#options;
 *
 * @example
 * const { mutate, loading, error, onDone } = useRegisterSelfMutation({
 *   variables: {
 *     input: // value for 'input'
 *   },
 * });
 */
export function useRegisterSelfMutation(options: VueApolloComposable.UseMutationOptions<RegisterSelfMutation, RegisterSelfMutationVariables> | ReactiveFunction<VueApolloComposable.UseMutationOptions<RegisterSelfMutation, RegisterSelfMutationVariables>> = {}) {
  return VueApolloComposable.useMutation<RegisterSelfMutation, RegisterSelfMutationVariables>(RegisterSelfDocument, options);
}
export type RegisterSelfMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<RegisterSelfMutation, RegisterSelfMutationVariables>;
export const RequestLoginCodeDocument = gql`
    mutation RequestLoginCode($input: RequestLoginCodeInput!) {
  requestLoginCode(input: $input) {
    challengeToken
    channel
    destination
    expiresAt
  }
}
    `;

/**
 * __useRequestLoginCodeMutation__
 *
 * To run a mutation, you first call `useRequestLoginCodeMutation` within a Vue component and pass it any options that fit your needs.
 * When your component renders, `useRequestLoginCodeMutation` returns an object that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - Several other properties: https://v4.apollo.vuejs.org/api/use-mutation.html#return
 *
 * @param options that will be passed into the mutation, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/mutation.html#options;
 *
 * @example
 * const { mutate, loading, error, onDone } = useRequestLoginCodeMutation({
 *   variables: {
 *     input: // value for 'input'
 *   },
 * });
 */
export function useRequestLoginCodeMutation(options: VueApolloComposable.UseMutationOptions<RequestLoginCodeMutation, RequestLoginCodeMutationVariables> | ReactiveFunction<VueApolloComposable.UseMutationOptions<RequestLoginCodeMutation, RequestLoginCodeMutationVariables>> = {}) {
  return VueApolloComposable.useMutation<RequestLoginCodeMutation, RequestLoginCodeMutationVariables>(RequestLoginCodeDocument, options);
}
export type RequestLoginCodeMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<RequestLoginCodeMutation, RequestLoginCodeMutationVariables>;
export const VerifyLoginCodeDocument = gql`
    mutation VerifyLoginCode($input: VerifyLoginCodeInput!) {
  verifyLoginCode(input: $input) {
    accessToken
    expiresAt
    user {
      id
      email
      fullName
      role
      company {
        id
      }
    }
  }
}
    `;

/**
 * __useVerifyLoginCodeMutation__
 *
 * To run a mutation, you first call `useVerifyLoginCodeMutation` within a Vue component and pass it any options that fit your needs.
 * When your component renders, `useVerifyLoginCodeMutation` returns an object that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - Several other properties: https://v4.apollo.vuejs.org/api/use-mutation.html#return
 *
 * @param options that will be passed into the mutation, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/mutation.html#options;
 *
 * @example
 * const { mutate, loading, error, onDone } = useVerifyLoginCodeMutation({
 *   variables: {
 *     input: // value for 'input'
 *   },
 * });
 */
export function useVerifyLoginCodeMutation(options: VueApolloComposable.UseMutationOptions<VerifyLoginCodeMutation, VerifyLoginCodeMutationVariables> | ReactiveFunction<VueApolloComposable.UseMutationOptions<VerifyLoginCodeMutation, VerifyLoginCodeMutationVariables>> = {}) {
  return VueApolloComposable.useMutation<VerifyLoginCodeMutation, VerifyLoginCodeMutationVariables>(VerifyLoginCodeDocument, options);
}
export type VerifyLoginCodeMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<VerifyLoginCodeMutation, VerifyLoginCodeMutationVariables>;
export const CreateBonusProgramLinkDocument = gql`
    mutation CreateBonusProgramLink($userId: ID!) {
  createBonusProgramLink(userId: $userId) {
    userId
    token
    url
    expiresAt
  }
}
    `;

/**
 * __useCreateBonusProgramLinkMutation__
 *
 * To run a mutation, you first call `useCreateBonusProgramLinkMutation` within a Vue component and pass it any options that fit your needs.
 * When your component renders, `useCreateBonusProgramLinkMutation` returns an object that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - Several other properties: https://v4.apollo.vuejs.org/api/use-mutation.html#return
 *
 * @param options that will be passed into the mutation, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/mutation.html#options;
 *
 * @example
 * const { mutate, loading, error, onDone } = useCreateBonusProgramLinkMutation({
 *   variables: {
 *     userId: // value for 'userId'
 *   },
 * });
 */
export function useCreateBonusProgramLinkMutation(options: VueApolloComposable.UseMutationOptions<CreateBonusProgramLinkMutation, CreateBonusProgramLinkMutationVariables> | ReactiveFunction<VueApolloComposable.UseMutationOptions<CreateBonusProgramLinkMutation, CreateBonusProgramLinkMutationVariables>> = {}) {
  return VueApolloComposable.useMutation<CreateBonusProgramLinkMutation, CreateBonusProgramLinkMutationVariables>(CreateBonusProgramLinkDocument, options);
}
export type CreateBonusProgramLinkMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<CreateBonusProgramLinkMutation, CreateBonusProgramLinkMutationVariables>;
export const RequestRewardWithdrawalDocument = gql`
    mutation RequestRewardWithdrawal($input: RequestRewardWithdrawalInput!) {
  requestRewardWithdrawal(input: $input) {
    id
    amount
    status
    createdAt
    updatedAt
    reviewComment
  }
}
    `;

/**
 * __useRequestRewardWithdrawalMutation__
 *
 * To run a mutation, you first call `useRequestRewardWithdrawalMutation` within a Vue component and pass it any options that fit your needs.
 * When your component renders, `useRequestRewardWithdrawalMutation` returns an object that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - Several other properties: https://v4.apollo.vuejs.org/api/use-mutation.html#return
 *
 * @param options that will be passed into the mutation, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/mutation.html#options;
 *
 * @example
 * const { mutate, loading, error, onDone } = useRequestRewardWithdrawalMutation({
 *   variables: {
 *     input: // value for 'input'
 *   },
 * });
 */
export function useRequestRewardWithdrawalMutation(options: VueApolloComposable.UseMutationOptions<RequestRewardWithdrawalMutation, RequestRewardWithdrawalMutationVariables> | ReactiveFunction<VueApolloComposable.UseMutationOptions<RequestRewardWithdrawalMutation, RequestRewardWithdrawalMutationVariables>> = {}) {
  return VueApolloComposable.useMutation<RequestRewardWithdrawalMutation, RequestRewardWithdrawalMutationVariables>(RequestRewardWithdrawalDocument, options);
}
export type RequestRewardWithdrawalMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<RequestRewardWithdrawalMutation, RequestRewardWithdrawalMutationVariables>;
export const AddProductToCartDocument = gql`
    mutation AddProductToCart($productId: ID!) {
  addProductToCart(productId: $productId) {
    id
    userId
    deliveryAddressId
    items {
      id
      productId
      productName
      sku
      isCustomizable
      quantity
      parameters
      updatedAt
    }
    updatedAt
  }
}
    `;

/**
 * __useAddProductToCartMutation__
 *
 * To run a mutation, you first call `useAddProductToCartMutation` within a Vue component and pass it any options that fit your needs.
 * When your component renders, `useAddProductToCartMutation` returns an object that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - Several other properties: https://v4.apollo.vuejs.org/api/use-mutation.html#return
 *
 * @param options that will be passed into the mutation, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/mutation.html#options;
 *
 * @example
 * const { mutate, loading, error, onDone } = useAddProductToCartMutation({
 *   variables: {
 *     productId: // value for 'productId'
 *   },
 * });
 */
export function useAddProductToCartMutation(options: VueApolloComposable.UseMutationOptions<AddProductToCartMutation, AddProductToCartMutationVariables> | ReactiveFunction<VueApolloComposable.UseMutationOptions<AddProductToCartMutation, AddProductToCartMutationVariables>> = {}) {
  return VueApolloComposable.useMutation<AddProductToCartMutation, AddProductToCartMutationVariables>(AddProductToCartDocument, options);
}
export type AddProductToCartMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<AddProductToCartMutation, AddProductToCartMutationVariables>;
export const ClearCartDocument = gql`
    mutation ClearCart {
  clearCart {
    id
    userId
    deliveryAddressId
    items {
      id
      productId
      productName
      sku
      isCustomizable
      quantity
      parameters
      updatedAt
    }
    updatedAt
  }
}
    `;

/**
 * __useClearCartMutation__
 *
 * To run a mutation, you first call `useClearCartMutation` within a Vue component and pass it any options that fit your needs.
 * When your component renders, `useClearCartMutation` returns an object that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - Several other properties: https://v4.apollo.vuejs.org/api/use-mutation.html#return
 *
 * @param options that will be passed into the mutation, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/mutation.html#options;
 *
 * @example
 * const { mutate, loading, error, onDone } = useClearCartMutation();
 */
export function useClearCartMutation(options: VueApolloComposable.UseMutationOptions<ClearCartMutation, ClearCartMutationVariables> | ReactiveFunction<VueApolloComposable.UseMutationOptions<ClearCartMutation, ClearCartMutationVariables>> = {}) {
  return VueApolloComposable.useMutation<ClearCartMutation, ClearCartMutationVariables>(ClearCartDocument, options);
}
export type ClearCartMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<ClearCartMutation, ClearCartMutationVariables>;
export const MyCartDocument = gql`
    query MyCart {
  myCart {
    id
    userId
    deliveryAddressId
    items {
      id
      productId
      productName
      sku
      isCustomizable
      quantity
      parameters
      updatedAt
    }
    updatedAt
  }
}
    `;

/**
 * __useMyCartQuery__
 *
 * To run a query within a Vue component, call `useMyCartQuery` and pass it any options that fit your needs.
 * When your component renders, `useMyCartQuery` returns an object from Apollo Client that contains result, loading and error properties
 * you can use to render your UI.
 *
 * @param options that will be passed into the query, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/query.html#options;
 *
 * @example
 * const { result, loading, error } = useMyCartQuery();
 */
export function useMyCartQuery(options: VueApolloComposable.UseQueryOptions<MyCartQuery, MyCartQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<MyCartQuery, MyCartQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<MyCartQuery, MyCartQueryVariables>> = {}) {
  return VueApolloComposable.useQuery<MyCartQuery, MyCartQueryVariables>(MyCartDocument, {}, options);
}
export function useMyCartLazyQuery(options: VueApolloComposable.UseQueryOptions<MyCartQuery, MyCartQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<MyCartQuery, MyCartQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<MyCartQuery, MyCartQueryVariables>> = {}) {
  return VueApolloComposable.useLazyQuery<MyCartQuery, MyCartQueryVariables>(MyCartDocument, {}, options);
}
export type MyCartQueryCompositionFunctionResult = VueApolloComposable.UseQueryReturn<MyCartQuery, MyCartQueryVariables>;
export const RemoveCartItemDocument = gql`
    mutation RemoveCartItem($productId: ID!) {
  removeCartItem(productId: $productId) {
    id
    userId
    deliveryAddressId
    items {
      id
      productId
      productName
      sku
      isCustomizable
      quantity
      parameters
      updatedAt
    }
    updatedAt
  }
}
    `;

/**
 * __useRemoveCartItemMutation__
 *
 * To run a mutation, you first call `useRemoveCartItemMutation` within a Vue component and pass it any options that fit your needs.
 * When your component renders, `useRemoveCartItemMutation` returns an object that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - Several other properties: https://v4.apollo.vuejs.org/api/use-mutation.html#return
 *
 * @param options that will be passed into the mutation, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/mutation.html#options;
 *
 * @example
 * const { mutate, loading, error, onDone } = useRemoveCartItemMutation({
 *   variables: {
 *     productId: // value for 'productId'
 *   },
 * });
 */
export function useRemoveCartItemMutation(options: VueApolloComposable.UseMutationOptions<RemoveCartItemMutation, RemoveCartItemMutationVariables> | ReactiveFunction<VueApolloComposable.UseMutationOptions<RemoveCartItemMutation, RemoveCartItemMutationVariables>> = {}) {
  return VueApolloComposable.useMutation<RemoveCartItemMutation, RemoveCartItemMutationVariables>(RemoveCartItemDocument, options);
}
export type RemoveCartItemMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<RemoveCartItemMutation, RemoveCartItemMutationVariables>;
export const SetCartDeliveryAddressDocument = gql`
    mutation SetCartDeliveryAddress($addressId: ID) {
  setCartDeliveryAddress(addressId: $addressId) {
    id
    userId
    deliveryAddressId
    items {
      id
      productId
      productName
      sku
      isCustomizable
      quantity
      parameters
      updatedAt
    }
    updatedAt
  }
}
    `;

/**
 * __useSetCartDeliveryAddressMutation__
 *
 * To run a mutation, you first call `useSetCartDeliveryAddressMutation` within a Vue component and pass it any options that fit your needs.
 * When your component renders, `useSetCartDeliveryAddressMutation` returns an object that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - Several other properties: https://v4.apollo.vuejs.org/api/use-mutation.html#return
 *
 * @param options that will be passed into the mutation, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/mutation.html#options;
 *
 * @example
 * const { mutate, loading, error, onDone } = useSetCartDeliveryAddressMutation({
 *   variables: {
 *     addressId: // value for 'addressId'
 *   },
 * });
 */
export function useSetCartDeliveryAddressMutation(options: VueApolloComposable.UseMutationOptions<SetCartDeliveryAddressMutation, SetCartDeliveryAddressMutationVariables> | ReactiveFunction<VueApolloComposable.UseMutationOptions<SetCartDeliveryAddressMutation, SetCartDeliveryAddressMutationVariables>> = {}) {
  return VueApolloComposable.useMutation<SetCartDeliveryAddressMutation, SetCartDeliveryAddressMutationVariables>(SetCartDeliveryAddressDocument, options);
}
export type SetCartDeliveryAddressMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<SetCartDeliveryAddressMutation, SetCartDeliveryAddressMutationVariables>;
export const UpdateCartItemQuantityDocument = gql`
    mutation UpdateCartItemQuantity($input: UpdateCartItemQuantityInput!) {
  updateCartItemQuantity(input: $input) {
    id
    userId
    deliveryAddressId
    items {
      id
      productId
      productName
      sku
      isCustomizable
      quantity
      parameters
      updatedAt
    }
    updatedAt
  }
}
    `;

/**
 * __useUpdateCartItemQuantityMutation__
 *
 * To run a mutation, you first call `useUpdateCartItemQuantityMutation` within a Vue component and pass it any options that fit your needs.
 * When your component renders, `useUpdateCartItemQuantityMutation` returns an object that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - Several other properties: https://v4.apollo.vuejs.org/api/use-mutation.html#return
 *
 * @param options that will be passed into the mutation, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/mutation.html#options;
 *
 * @example
 * const { mutate, loading, error, onDone } = useUpdateCartItemQuantityMutation({
 *   variables: {
 *     input: // value for 'input'
 *   },
 * });
 */
export function useUpdateCartItemQuantityMutation(options: VueApolloComposable.UseMutationOptions<UpdateCartItemQuantityMutation, UpdateCartItemQuantityMutationVariables> | ReactiveFunction<VueApolloComposable.UseMutationOptions<UpdateCartItemQuantityMutation, UpdateCartItemQuantityMutationVariables>> = {}) {
  return VueApolloComposable.useMutation<UpdateCartItemQuantityMutation, UpdateCartItemQuantityMutationVariables>(UpdateCartItemQuantityDocument, options);
}
export type UpdateCartItemQuantityMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<UpdateCartItemQuantityMutation, UpdateCartItemQuantityMutationVariables>;
export const ClientProductsDocument = gql`
    query ClientProducts {
  clientProducts {
    id
    sku
    name
    description
    productType
    widthMm
    lengthM
    thicknessMicron
    sleeveBrand
    quantityPerBox
    tags
    isCustomizable
    availableInWarehouses {
      availableQty
      warehouse {
        id
        code
        name
      }
    }
  }
}
    `;

/**
 * __useClientProductsQuery__
 *
 * To run a query within a Vue component, call `useClientProductsQuery` and pass it any options that fit your needs.
 * When your component renders, `useClientProductsQuery` returns an object from Apollo Client that contains result, loading and error properties
 * you can use to render your UI.
 *
 * @param options that will be passed into the query, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/query.html#options;
 *
 * @example
 * const { result, loading, error } = useClientProductsQuery();
 */
export function useClientProductsQuery(options: VueApolloComposable.UseQueryOptions<ClientProductsQuery, ClientProductsQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<ClientProductsQuery, ClientProductsQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<ClientProductsQuery, ClientProductsQueryVariables>> = {}) {
  return VueApolloComposable.useQuery<ClientProductsQuery, ClientProductsQueryVariables>(ClientProductsDocument, {}, options);
}
export function useClientProductsLazyQuery(options: VueApolloComposable.UseQueryOptions<ClientProductsQuery, ClientProductsQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<ClientProductsQuery, ClientProductsQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<ClientProductsQuery, ClientProductsQueryVariables>> = {}) {
  return VueApolloComposable.useLazyQuery<ClientProductsQuery, ClientProductsQueryVariables>(ClientProductsDocument, {}, options);
}
export type ClientProductsQueryCompositionFunctionResult = VueApolloComposable.UseQueryReturn<ClientProductsQuery, ClientProductsQueryVariables>;
export const AddBonusTransactionDocument = gql`
    mutation AddBonusTransaction($input: AddBonusTransactionInput!) {
  addBonusTransaction(input: $input) {
    id
    userId
    amount
    reason
    createdAt
  }
}
    `;

/**
 * __useAddBonusTransactionMutation__
 *
 * To run a mutation, you first call `useAddBonusTransactionMutation` within a Vue component and pass it any options that fit your needs.
 * When your component renders, `useAddBonusTransactionMutation` returns an object that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - Several other properties: https://v4.apollo.vuejs.org/api/use-mutation.html#return
 *
 * @param options that will be passed into the mutation, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/mutation.html#options;
 *
 * @example
 * const { mutate, loading, error, onDone } = useAddBonusTransactionMutation({
 *   variables: {
 *     input: // value for 'input'
 *   },
 * });
 */
export function useAddBonusTransactionMutation(options: VueApolloComposable.UseMutationOptions<AddBonusTransactionMutation, AddBonusTransactionMutationVariables> | ReactiveFunction<VueApolloComposable.UseMutationOptions<AddBonusTransactionMutation, AddBonusTransactionMutationVariables>> = {}) {
  return VueApolloComposable.useMutation<AddBonusTransactionMutation, AddBonusTransactionMutationVariables>(AddBonusTransactionDocument, options);
}
export type AddBonusTransactionMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<AddBonusTransactionMutation, AddBonusTransactionMutationVariables>;
export const CreateInvitationDocument = gql`
    mutation CreateInvitation($input: CreateInvitationInput!) {
  createInvitation(input: $input) {
    id
    token
    email
    companyName
    expiresAt
  }
}
    `;

/**
 * __useCreateInvitationMutation__
 *
 * To run a mutation, you first call `useCreateInvitationMutation` within a Vue component and pass it any options that fit your needs.
 * When your component renders, `useCreateInvitationMutation` returns an object that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - Several other properties: https://v4.apollo.vuejs.org/api/use-mutation.html#return
 *
 * @param options that will be passed into the mutation, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/mutation.html#options;
 *
 * @example
 * const { mutate, loading, error, onDone } = useCreateInvitationMutation({
 *   variables: {
 *     input: // value for 'input'
 *   },
 * });
 */
export function useCreateInvitationMutation(options: VueApolloComposable.UseMutationOptions<CreateInvitationMutation, CreateInvitationMutationVariables> | ReactiveFunction<VueApolloComposable.UseMutationOptions<CreateInvitationMutation, CreateInvitationMutationVariables>> = {}) {
  return VueApolloComposable.useMutation<CreateInvitationMutation, CreateInvitationMutationVariables>(CreateInvitationDocument, options);
}
export type CreateInvitationMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<CreateInvitationMutation, CreateInvitationMutationVariables>;
export const CreateReferralDocument = gql`
    mutation CreateReferral($input: CreateReferralInput!) {
  createReferral(input: $input) {
    id
    referrerId
    refereeId
    createdById
    bonusPercent
    createdAt
  }
}
    `;

/**
 * __useCreateReferralMutation__
 *
 * To run a mutation, you first call `useCreateReferralMutation` within a Vue component and pass it any options that fit your needs.
 * When your component renders, `useCreateReferralMutation` returns an object that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - Several other properties: https://v4.apollo.vuejs.org/api/use-mutation.html#return
 *
 * @param options that will be passed into the mutation, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/mutation.html#options;
 *
 * @example
 * const { mutate, loading, error, onDone } = useCreateReferralMutation({
 *   variables: {
 *     input: // value for 'input'
 *   },
 * });
 */
export function useCreateReferralMutation(options: VueApolloComposable.UseMutationOptions<CreateReferralMutation, CreateReferralMutationVariables> | ReactiveFunction<VueApolloComposable.UseMutationOptions<CreateReferralMutation, CreateReferralMutationVariables>> = {}) {
  return VueApolloComposable.useMutation<CreateReferralMutation, CreateReferralMutationVariables>(CreateReferralDocument, options);
}
export type CreateReferralMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<CreateReferralMutation, CreateReferralMutationVariables>;
export const ManagerBonusAccountDocument = gql`
    query ManagerBonusAccount($userId: ID!) {
  managerBonusAccount(userId: $userId) {
    userId
    email
    fullName
    companyName
    balance
    earnedAmount
    pendingWithdrawalAmount
    transactionsCount
    referralsCount
    referralLinks {
      id
      referrerId
      referrerName
      referrerEmail
      referrerCompanyName
      refereeId
      refereeName
      refereeEmail
      refereeCompanyName
      createdById
      bonusPercent
      createdAt
    }
    transactions {
      id
      userId
      amount
      reason
      orderId
      createdAt
    }
    pendingWithdrawals {
      id
      requesterId
      amount
      status
      reviewComment
      createdAt
      updatedAt
    }
  }
}
    `;

/**
 * __useManagerBonusAccountQuery__
 *
 * To run a query within a Vue component, call `useManagerBonusAccountQuery` and pass it any options that fit your needs.
 * When your component renders, `useManagerBonusAccountQuery` returns an object from Apollo Client that contains result, loading and error properties
 * you can use to render your UI.
 *
 * @param variables that will be passed into the query
 * @param options that will be passed into the query, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/query.html#options;
 *
 * @example
 * const { result, loading, error } = useManagerBonusAccountQuery({
 *   userId: // value for 'userId'
 * });
 */
export function useManagerBonusAccountQuery(variables: ManagerBonusAccountQueryVariables | VueCompositionApi.Ref<ManagerBonusAccountQueryVariables> | ReactiveFunction<ManagerBonusAccountQueryVariables>, options: VueApolloComposable.UseQueryOptions<ManagerBonusAccountQuery, ManagerBonusAccountQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<ManagerBonusAccountQuery, ManagerBonusAccountQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<ManagerBonusAccountQuery, ManagerBonusAccountQueryVariables>> = {}) {
  return VueApolloComposable.useQuery<ManagerBonusAccountQuery, ManagerBonusAccountQueryVariables>(ManagerBonusAccountDocument, variables, options);
}
export function useManagerBonusAccountLazyQuery(variables?: ManagerBonusAccountQueryVariables | VueCompositionApi.Ref<ManagerBonusAccountQueryVariables> | ReactiveFunction<ManagerBonusAccountQueryVariables>, options: VueApolloComposable.UseQueryOptions<ManagerBonusAccountQuery, ManagerBonusAccountQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<ManagerBonusAccountQuery, ManagerBonusAccountQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<ManagerBonusAccountQuery, ManagerBonusAccountQueryVariables>> = {}) {
  return VueApolloComposable.useLazyQuery<ManagerBonusAccountQuery, ManagerBonusAccountQueryVariables>(ManagerBonusAccountDocument, variables, options);
}
export type ManagerBonusAccountQueryCompositionFunctionResult = VueApolloComposable.UseQueryReturn<ManagerBonusAccountQuery, ManagerBonusAccountQueryVariables>;
export const ManagerBonusBalancesDocument = gql`
    query ManagerBonusBalances {
  managerBonusBalances {
    userId
    email
    fullName
    companyName
    balance
    pendingWithdrawalAmount
    transactionsCount
  }
}
    `;

/**
 * __useManagerBonusBalancesQuery__
 *
 * To run a query within a Vue component, call `useManagerBonusBalancesQuery` and pass it any options that fit your needs.
 * When your component renders, `useManagerBonusBalancesQuery` returns an object from Apollo Client that contains result, loading and error properties
 * you can use to render your UI.
 *
 * @param options that will be passed into the query, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/query.html#options;
 *
 * @example
 * const { result, loading, error } = useManagerBonusBalancesQuery();
 */
export function useManagerBonusBalancesQuery(options: VueApolloComposable.UseQueryOptions<ManagerBonusBalancesQuery, ManagerBonusBalancesQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<ManagerBonusBalancesQuery, ManagerBonusBalancesQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<ManagerBonusBalancesQuery, ManagerBonusBalancesQueryVariables>> = {}) {
  return VueApolloComposable.useQuery<ManagerBonusBalancesQuery, ManagerBonusBalancesQueryVariables>(ManagerBonusBalancesDocument, {}, options);
}
export function useManagerBonusBalancesLazyQuery(options: VueApolloComposable.UseQueryOptions<ManagerBonusBalancesQuery, ManagerBonusBalancesQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<ManagerBonusBalancesQuery, ManagerBonusBalancesQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<ManagerBonusBalancesQuery, ManagerBonusBalancesQueryVariables>> = {}) {
  return VueApolloComposable.useLazyQuery<ManagerBonusBalancesQuery, ManagerBonusBalancesQueryVariables>(ManagerBonusBalancesDocument, {}, options);
}
export type ManagerBonusBalancesQueryCompositionFunctionResult = VueApolloComposable.UseQueryReturn<ManagerBonusBalancesQuery, ManagerBonusBalancesQueryVariables>;
export const ManagerOrdersDocument = gql`
    query ManagerOrders($status: OrderStatus, $customerId: ID) {
  managerOrders(status: $status, customerId: $customerId) {
    id
    code
    status
    kind
    customerId
    deliveryAddress
    deliveryTerms
    deliveryFee
    totalPrice
    createdAt
    items {
      id
      productName
      quantity
      unitPrice
      lineTotal
    }
  }
}
    `;

/**
 * __useManagerOrdersQuery__
 *
 * To run a query within a Vue component, call `useManagerOrdersQuery` and pass it any options that fit your needs.
 * When your component renders, `useManagerOrdersQuery` returns an object from Apollo Client that contains result, loading and error properties
 * you can use to render your UI.
 *
 * @param variables that will be passed into the query
 * @param options that will be passed into the query, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/query.html#options;
 *
 * @example
 * const { result, loading, error } = useManagerOrdersQuery({
 *   status: // value for 'status'
 *   customerId: // value for 'customerId'
 * });
 */
export function useManagerOrdersQuery(variables: ManagerOrdersQueryVariables | VueCompositionApi.Ref<ManagerOrdersQueryVariables> | ReactiveFunction<ManagerOrdersQueryVariables> = {}, options: VueApolloComposable.UseQueryOptions<ManagerOrdersQuery, ManagerOrdersQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<ManagerOrdersQuery, ManagerOrdersQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<ManagerOrdersQuery, ManagerOrdersQueryVariables>> = {}) {
  return VueApolloComposable.useQuery<ManagerOrdersQuery, ManagerOrdersQueryVariables>(ManagerOrdersDocument, variables, options);
}
export function useManagerOrdersLazyQuery(variables: ManagerOrdersQueryVariables | VueCompositionApi.Ref<ManagerOrdersQueryVariables> | ReactiveFunction<ManagerOrdersQueryVariables> = {}, options: VueApolloComposable.UseQueryOptions<ManagerOrdersQuery, ManagerOrdersQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<ManagerOrdersQuery, ManagerOrdersQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<ManagerOrdersQuery, ManagerOrdersQueryVariables>> = {}) {
  return VueApolloComposable.useLazyQuery<ManagerOrdersQuery, ManagerOrdersQueryVariables>(ManagerOrdersDocument, variables, options);
}
export type ManagerOrdersQueryCompositionFunctionResult = VueApolloComposable.UseQueryReturn<ManagerOrdersQuery, ManagerOrdersQueryVariables>;
export const ManagerReferralLinksDocument = gql`
    query ManagerReferralLinks {
  managerReferralLinks {
    id
    referrerId
    referrerName
    referrerEmail
    referrerCompanyName
    refereeId
    refereeName
    refereeEmail
    refereeCompanyName
    createdById
    bonusPercent
    createdAt
  }
}
    `;

/**
 * __useManagerReferralLinksQuery__
 *
 * To run a query within a Vue component, call `useManagerReferralLinksQuery` and pass it any options that fit your needs.
 * When your component renders, `useManagerReferralLinksQuery` returns an object from Apollo Client that contains result, loading and error properties
 * you can use to render your UI.
 *
 * @param options that will be passed into the query, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/query.html#options;
 *
 * @example
 * const { result, loading, error } = useManagerReferralLinksQuery();
 */
export function useManagerReferralLinksQuery(options: VueApolloComposable.UseQueryOptions<ManagerReferralLinksQuery, ManagerReferralLinksQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<ManagerReferralLinksQuery, ManagerReferralLinksQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<ManagerReferralLinksQuery, ManagerReferralLinksQueryVariables>> = {}) {
  return VueApolloComposable.useQuery<ManagerReferralLinksQuery, ManagerReferralLinksQueryVariables>(ManagerReferralLinksDocument, {}, options);
}
export function useManagerReferralLinksLazyQuery(options: VueApolloComposable.UseQueryOptions<ManagerReferralLinksQuery, ManagerReferralLinksQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<ManagerReferralLinksQuery, ManagerReferralLinksQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<ManagerReferralLinksQuery, ManagerReferralLinksQueryVariables>> = {}) {
  return VueApolloComposable.useLazyQuery<ManagerReferralLinksQuery, ManagerReferralLinksQueryVariables>(ManagerReferralLinksDocument, {}, options);
}
export type ManagerReferralLinksQueryCompositionFunctionResult = VueApolloComposable.UseQueryReturn<ManagerReferralLinksQuery, ManagerReferralLinksQueryVariables>;
export const ManagerSetOrderStatusDocument = gql`
    mutation ManagerSetOrderStatus($orderId: ID!, $status: OrderStatus!) {
  managerSetOrderStatus(orderId: $orderId, status: $status) {
    id
    status
  }
}
    `;

/**
 * __useManagerSetOrderStatusMutation__
 *
 * To run a mutation, you first call `useManagerSetOrderStatusMutation` within a Vue component and pass it any options that fit your needs.
 * When your component renders, `useManagerSetOrderStatusMutation` returns an object that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - Several other properties: https://v4.apollo.vuejs.org/api/use-mutation.html#return
 *
 * @param options that will be passed into the mutation, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/mutation.html#options;
 *
 * @example
 * const { mutate, loading, error, onDone } = useManagerSetOrderStatusMutation({
 *   variables: {
 *     orderId: // value for 'orderId'
 *     status: // value for 'status'
 *   },
 * });
 */
export function useManagerSetOrderStatusMutation(options: VueApolloComposable.UseMutationOptions<ManagerSetOrderStatusMutation, ManagerSetOrderStatusMutationVariables> | ReactiveFunction<VueApolloComposable.UseMutationOptions<ManagerSetOrderStatusMutation, ManagerSetOrderStatusMutationVariables>> = {}) {
  return VueApolloComposable.useMutation<ManagerSetOrderStatusMutation, ManagerSetOrderStatusMutationVariables>(ManagerSetOrderStatusDocument, options);
}
export type ManagerSetOrderStatusMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<ManagerSetOrderStatusMutation, ManagerSetOrderStatusMutationVariables>;
export const ManagerUsersDetailDocument = gql`
    query ManagerUsersDetail {
  managerUsers {
    id
    email
    fullName
    companyName
    inn
    createdAt
    orderCount
    lastOrderAt
    telegramConnection {
      id
      type
      channelId
      displayName
      username
      avatarAvailable
    }
  }
}
    `;

/**
 * __useManagerUsersDetailQuery__
 *
 * To run a query within a Vue component, call `useManagerUsersDetailQuery` and pass it any options that fit your needs.
 * When your component renders, `useManagerUsersDetailQuery` returns an object from Apollo Client that contains result, loading and error properties
 * you can use to render your UI.
 *
 * @param options that will be passed into the query, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/query.html#options;
 *
 * @example
 * const { result, loading, error } = useManagerUsersDetailQuery();
 */
export function useManagerUsersDetailQuery(options: VueApolloComposable.UseQueryOptions<ManagerUsersDetailQuery, ManagerUsersDetailQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<ManagerUsersDetailQuery, ManagerUsersDetailQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<ManagerUsersDetailQuery, ManagerUsersDetailQueryVariables>> = {}) {
  return VueApolloComposable.useQuery<ManagerUsersDetailQuery, ManagerUsersDetailQueryVariables>(ManagerUsersDetailDocument, {}, options);
}
export function useManagerUsersDetailLazyQuery(options: VueApolloComposable.UseQueryOptions<ManagerUsersDetailQuery, ManagerUsersDetailQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<ManagerUsersDetailQuery, ManagerUsersDetailQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<ManagerUsersDetailQuery, ManagerUsersDetailQueryVariables>> = {}) {
  return VueApolloComposable.useLazyQuery<ManagerUsersDetailQuery, ManagerUsersDetailQueryVariables>(ManagerUsersDetailDocument, {}, options);
}
export type ManagerUsersDetailQueryCompositionFunctionResult = VueApolloComposable.UseQueryReturn<ManagerUsersDetailQuery, ManagerUsersDetailQueryVariables>;
export const ManagerUsersDocument = gql`
    query ManagerUsers {
  managerUsers {
    id
    email
    fullName
    role
    companyName
    telegramConnection {
      id
      type
      channelId
      displayName
      username
      avatarAvailable
    }
  }
}
    `;

/**
 * __useManagerUsersQuery__
 *
 * To run a query within a Vue component, call `useManagerUsersQuery` and pass it any options that fit your needs.
 * When your component renders, `useManagerUsersQuery` returns an object from Apollo Client that contains result, loading and error properties
 * you can use to render your UI.
 *
 * @param options that will be passed into the query, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/query.html#options;
 *
 * @example
 * const { result, loading, error } = useManagerUsersQuery();
 */
export function useManagerUsersQuery(options: VueApolloComposable.UseQueryOptions<ManagerUsersQuery, ManagerUsersQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<ManagerUsersQuery, ManagerUsersQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<ManagerUsersQuery, ManagerUsersQueryVariables>> = {}) {
  return VueApolloComposable.useQuery<ManagerUsersQuery, ManagerUsersQueryVariables>(ManagerUsersDocument, {}, options);
}
export function useManagerUsersLazyQuery(options: VueApolloComposable.UseQueryOptions<ManagerUsersQuery, ManagerUsersQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<ManagerUsersQuery, ManagerUsersQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<ManagerUsersQuery, ManagerUsersQueryVariables>> = {}) {
  return VueApolloComposable.useLazyQuery<ManagerUsersQuery, ManagerUsersQueryVariables>(ManagerUsersDocument, {}, options);
}
export type ManagerUsersQueryCompositionFunctionResult = VueApolloComposable.UseQueryReturn<ManagerUsersQuery, ManagerUsersQueryVariables>;
export const ManagerWithdrawalRequestsDocument = gql`
    query ManagerWithdrawalRequests($status: WithdrawalStatus) {
  managerWithdrawalRequests(status: $status) {
    id
    requesterId
    requesterEmail
    requesterFullName
    companyName
    amount
    status
    reviewedById
    reviewComment
    createdAt
    updatedAt
  }
}
    `;

/**
 * __useManagerWithdrawalRequestsQuery__
 *
 * To run a query within a Vue component, call `useManagerWithdrawalRequestsQuery` and pass it any options that fit your needs.
 * When your component renders, `useManagerWithdrawalRequestsQuery` returns an object from Apollo Client that contains result, loading and error properties
 * you can use to render your UI.
 *
 * @param variables that will be passed into the query
 * @param options that will be passed into the query, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/query.html#options;
 *
 * @example
 * const { result, loading, error } = useManagerWithdrawalRequestsQuery({
 *   status: // value for 'status'
 * });
 */
export function useManagerWithdrawalRequestsQuery(variables: ManagerWithdrawalRequestsQueryVariables | VueCompositionApi.Ref<ManagerWithdrawalRequestsQueryVariables> | ReactiveFunction<ManagerWithdrawalRequestsQueryVariables> = {}, options: VueApolloComposable.UseQueryOptions<ManagerWithdrawalRequestsQuery, ManagerWithdrawalRequestsQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<ManagerWithdrawalRequestsQuery, ManagerWithdrawalRequestsQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<ManagerWithdrawalRequestsQuery, ManagerWithdrawalRequestsQueryVariables>> = {}) {
  return VueApolloComposable.useQuery<ManagerWithdrawalRequestsQuery, ManagerWithdrawalRequestsQueryVariables>(ManagerWithdrawalRequestsDocument, variables, options);
}
export function useManagerWithdrawalRequestsLazyQuery(variables: ManagerWithdrawalRequestsQueryVariables | VueCompositionApi.Ref<ManagerWithdrawalRequestsQueryVariables> | ReactiveFunction<ManagerWithdrawalRequestsQueryVariables> = {}, options: VueApolloComposable.UseQueryOptions<ManagerWithdrawalRequestsQuery, ManagerWithdrawalRequestsQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<ManagerWithdrawalRequestsQuery, ManagerWithdrawalRequestsQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<ManagerWithdrawalRequestsQuery, ManagerWithdrawalRequestsQueryVariables>> = {}) {
  return VueApolloComposable.useLazyQuery<ManagerWithdrawalRequestsQuery, ManagerWithdrawalRequestsQueryVariables>(ManagerWithdrawalRequestsDocument, variables, options);
}
export type ManagerWithdrawalRequestsQueryCompositionFunctionResult = VueApolloComposable.UseQueryReturn<ManagerWithdrawalRequestsQuery, ManagerWithdrawalRequestsQueryVariables>;
export const ReferralStatsDocument = gql`
    query ReferralStats {
  referralStats {
    referrerId
    availableBalance
    referralsCount
    transactions {
      id
      userId
      amount
      reason
      orderId
      createdAt
    }
    pendingWithdrawals {
      id
      requesterId
      amount
      status
      reviewComment
      createdAt
      updatedAt
    }
  }
}
    `;

/**
 * __useReferralStatsQuery__
 *
 * To run a query within a Vue component, call `useReferralStatsQuery` and pass it any options that fit your needs.
 * When your component renders, `useReferralStatsQuery` returns an object from Apollo Client that contains result, loading and error properties
 * you can use to render your UI.
 *
 * @param options that will be passed into the query, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/query.html#options;
 *
 * @example
 * const { result, loading, error } = useReferralStatsQuery();
 */
export function useReferralStatsQuery(options: VueApolloComposable.UseQueryOptions<ReferralStatsQuery, ReferralStatsQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<ReferralStatsQuery, ReferralStatsQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<ReferralStatsQuery, ReferralStatsQueryVariables>> = {}) {
  return VueApolloComposable.useQuery<ReferralStatsQuery, ReferralStatsQueryVariables>(ReferralStatsDocument, {}, options);
}
export function useReferralStatsLazyQuery(options: VueApolloComposable.UseQueryOptions<ReferralStatsQuery, ReferralStatsQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<ReferralStatsQuery, ReferralStatsQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<ReferralStatsQuery, ReferralStatsQueryVariables>> = {}) {
  return VueApolloComposable.useLazyQuery<ReferralStatsQuery, ReferralStatsQueryVariables>(ReferralStatsDocument, {}, options);
}
export type ReferralStatsQueryCompositionFunctionResult = VueApolloComposable.UseQueryReturn<ReferralStatsQuery, ReferralStatsQueryVariables>;
export const RegistrationRequestsDocument = gql`
    query RegistrationRequests($status: RegistrationStatus) {
  registrationRequests(status: $status) {
    id
    companyName
    contactName
    email
    status
    createdAt
  }
}
    `;

/**
 * __useRegistrationRequestsQuery__
 *
 * To run a query within a Vue component, call `useRegistrationRequestsQuery` and pass it any options that fit your needs.
 * When your component renders, `useRegistrationRequestsQuery` returns an object from Apollo Client that contains result, loading and error properties
 * you can use to render your UI.
 *
 * @param variables that will be passed into the query
 * @param options that will be passed into the query, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/query.html#options;
 *
 * @example
 * const { result, loading, error } = useRegistrationRequestsQuery({
 *   status: // value for 'status'
 * });
 */
export function useRegistrationRequestsQuery(variables: RegistrationRequestsQueryVariables | VueCompositionApi.Ref<RegistrationRequestsQueryVariables> | ReactiveFunction<RegistrationRequestsQueryVariables> = {}, options: VueApolloComposable.UseQueryOptions<RegistrationRequestsQuery, RegistrationRequestsQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<RegistrationRequestsQuery, RegistrationRequestsQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<RegistrationRequestsQuery, RegistrationRequestsQueryVariables>> = {}) {
  return VueApolloComposable.useQuery<RegistrationRequestsQuery, RegistrationRequestsQueryVariables>(RegistrationRequestsDocument, variables, options);
}
export function useRegistrationRequestsLazyQuery(variables: RegistrationRequestsQueryVariables | VueCompositionApi.Ref<RegistrationRequestsQueryVariables> | ReactiveFunction<RegistrationRequestsQueryVariables> = {}, options: VueApolloComposable.UseQueryOptions<RegistrationRequestsQuery, RegistrationRequestsQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<RegistrationRequestsQuery, RegistrationRequestsQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<RegistrationRequestsQuery, RegistrationRequestsQueryVariables>> = {}) {
  return VueApolloComposable.useLazyQuery<RegistrationRequestsQuery, RegistrationRequestsQueryVariables>(RegistrationRequestsDocument, variables, options);
}
export type RegistrationRequestsQueryCompositionFunctionResult = VueApolloComposable.UseQueryReturn<RegistrationRequestsQuery, RegistrationRequestsQueryVariables>;
export const ReviewRegistrationRequestDocument = gql`
    mutation ReviewRegistrationRequest($input: ReviewRegistrationRequestInput!) {
  reviewRegistrationRequest(input: $input) {
    id
    status
    rejectionReason
    reviewedById
  }
}
    `;

/**
 * __useReviewRegistrationRequestMutation__
 *
 * To run a mutation, you first call `useReviewRegistrationRequestMutation` within a Vue component and pass it any options that fit your needs.
 * When your component renders, `useReviewRegistrationRequestMutation` returns an object that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - Several other properties: https://v4.apollo.vuejs.org/api/use-mutation.html#return
 *
 * @param options that will be passed into the mutation, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/mutation.html#options;
 *
 * @example
 * const { mutate, loading, error, onDone } = useReviewRegistrationRequestMutation({
 *   variables: {
 *     input: // value for 'input'
 *   },
 * });
 */
export function useReviewRegistrationRequestMutation(options: VueApolloComposable.UseMutationOptions<ReviewRegistrationRequestMutation, ReviewRegistrationRequestMutationVariables> | ReactiveFunction<VueApolloComposable.UseMutationOptions<ReviewRegistrationRequestMutation, ReviewRegistrationRequestMutationVariables>> = {}) {
  return VueApolloComposable.useMutation<ReviewRegistrationRequestMutation, ReviewRegistrationRequestMutationVariables>(ReviewRegistrationRequestDocument, options);
}
export type ReviewRegistrationRequestMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<ReviewRegistrationRequestMutation, ReviewRegistrationRequestMutationVariables>;
export const ReviewRewardWithdrawalDocument = gql`
    mutation ReviewRewardWithdrawal($input: ReviewRewardWithdrawalInput!) {
  reviewRewardWithdrawal(input: $input) {
    id
    status
    reviewComment
    reviewedById
  }
}
    `;

/**
 * __useReviewRewardWithdrawalMutation__
 *
 * To run a mutation, you first call `useReviewRewardWithdrawalMutation` within a Vue component and pass it any options that fit your needs.
 * When your component renders, `useReviewRewardWithdrawalMutation` returns an object that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - Several other properties: https://v4.apollo.vuejs.org/api/use-mutation.html#return
 *
 * @param options that will be passed into the mutation, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/mutation.html#options;
 *
 * @example
 * const { mutate, loading, error, onDone } = useReviewRewardWithdrawalMutation({
 *   variables: {
 *     input: // value for 'input'
 *   },
 * });
 */
export function useReviewRewardWithdrawalMutation(options: VueApolloComposable.UseMutationOptions<ReviewRewardWithdrawalMutation, ReviewRewardWithdrawalMutationVariables> | ReactiveFunction<VueApolloComposable.UseMutationOptions<ReviewRewardWithdrawalMutation, ReviewRewardWithdrawalMutationVariables>> = {}) {
  return VueApolloComposable.useMutation<ReviewRewardWithdrawalMutation, ReviewRewardWithdrawalMutationVariables>(ReviewRewardWithdrawalDocument, options);
}
export type ReviewRewardWithdrawalMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<ReviewRewardWithdrawalMutation, ReviewRewardWithdrawalMutationVariables>;
export const ManagerSetOrderOfferDocument = gql`
    mutation ManagerSetOrderOffer($input: SetOrderOfferInput!) {
  managerSetOrderOffer(input: $input) {
    id
    code
    status
    deliveryTerms
    deliveryFee
    totalPrice
    items {
      id
      unitPrice
      lineTotal
    }
  }
}
    `;

/**
 * __useManagerSetOrderOfferMutation__
 *
 * To run a mutation, you first call `useManagerSetOrderOfferMutation` within a Vue component and pass it any options that fit your needs.
 * When your component renders, `useManagerSetOrderOfferMutation` returns an object that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - Several other properties: https://v4.apollo.vuejs.org/api/use-mutation.html#return
 *
 * @param options that will be passed into the mutation, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/mutation.html#options;
 *
 * @example
 * const { mutate, loading, error, onDone } = useManagerSetOrderOfferMutation({
 *   variables: {
 *     input: // value for 'input'
 *   },
 * });
 */
export function useManagerSetOrderOfferMutation(options: VueApolloComposable.UseMutationOptions<ManagerSetOrderOfferMutation, ManagerSetOrderOfferMutationVariables> | ReactiveFunction<VueApolloComposable.UseMutationOptions<ManagerSetOrderOfferMutation, ManagerSetOrderOfferMutationVariables>> = {}) {
  return VueApolloComposable.useMutation<ManagerSetOrderOfferMutation, ManagerSetOrderOfferMutationVariables>(ManagerSetOrderOfferDocument, options);
}
export type ManagerSetOrderOfferMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<ManagerSetOrderOfferMutation, ManagerSetOrderOfferMutationVariables>;
export const ManagerNotificationHistoryDocument = gql`
    query ManagerNotificationHistory($userId: ID!, $channel: MessengerType!, $limit: Int) {
  managerNotificationHistory(userId: $userId, channel: $channel, limit: $limit) {
    id
    channel
    title
    message
    createdAt
    orderId
  }
}
    `;

/**
 * __useManagerNotificationHistoryQuery__
 *
 * To run a query within a Vue component, call `useManagerNotificationHistoryQuery` and pass it any options that fit your needs.
 * When your component renders, `useManagerNotificationHistoryQuery` returns an object from Apollo Client that contains result, loading and error properties
 * you can use to render your UI.
 *
 * @param variables that will be passed into the query
 * @param options that will be passed into the query, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/query.html#options;
 *
 * @example
 * const { result, loading, error } = useManagerNotificationHistoryQuery({
 *   userId: // value for 'userId'
 *   channel: // value for 'channel'
 *   limit: // value for 'limit'
 * });
 */
export function useManagerNotificationHistoryQuery(variables: ManagerNotificationHistoryQueryVariables | VueCompositionApi.Ref<ManagerNotificationHistoryQueryVariables> | ReactiveFunction<ManagerNotificationHistoryQueryVariables>, options: VueApolloComposable.UseQueryOptions<ManagerNotificationHistoryQuery, ManagerNotificationHistoryQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<ManagerNotificationHistoryQuery, ManagerNotificationHistoryQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<ManagerNotificationHistoryQuery, ManagerNotificationHistoryQueryVariables>> = {}) {
  return VueApolloComposable.useQuery<ManagerNotificationHistoryQuery, ManagerNotificationHistoryQueryVariables>(ManagerNotificationHistoryDocument, variables, options);
}
export function useManagerNotificationHistoryLazyQuery(variables?: ManagerNotificationHistoryQueryVariables | VueCompositionApi.Ref<ManagerNotificationHistoryQueryVariables> | ReactiveFunction<ManagerNotificationHistoryQueryVariables>, options: VueApolloComposable.UseQueryOptions<ManagerNotificationHistoryQuery, ManagerNotificationHistoryQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<ManagerNotificationHistoryQuery, ManagerNotificationHistoryQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<ManagerNotificationHistoryQuery, ManagerNotificationHistoryQueryVariables>> = {}) {
  return VueApolloComposable.useLazyQuery<ManagerNotificationHistoryQuery, ManagerNotificationHistoryQueryVariables>(ManagerNotificationHistoryDocument, variables, options);
}
export type ManagerNotificationHistoryQueryCompositionFunctionResult = VueApolloComposable.UseQueryReturn<ManagerNotificationHistoryQuery, ManagerNotificationHistoryQueryVariables>;
export const MyMessengerConnectionsDocument = gql`
    query MyMessengerConnections {
  myMessengerConnections {
    id
    type
    channelId
    displayName
    username
    avatarAvailable
    isActive
  }
}
    `;

/**
 * __useMyMessengerConnectionsQuery__
 *
 * To run a query within a Vue component, call `useMyMessengerConnectionsQuery` and pass it any options that fit your needs.
 * When your component renders, `useMyMessengerConnectionsQuery` returns an object from Apollo Client that contains result, loading and error properties
 * you can use to render your UI.
 *
 * @param options that will be passed into the query, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/query.html#options;
 *
 * @example
 * const { result, loading, error } = useMyMessengerConnectionsQuery();
 */
export function useMyMessengerConnectionsQuery(options: VueApolloComposable.UseQueryOptions<MyMessengerConnectionsQuery, MyMessengerConnectionsQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<MyMessengerConnectionsQuery, MyMessengerConnectionsQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<MyMessengerConnectionsQuery, MyMessengerConnectionsQueryVariables>> = {}) {
  return VueApolloComposable.useQuery<MyMessengerConnectionsQuery, MyMessengerConnectionsQueryVariables>(MyMessengerConnectionsDocument, {}, options);
}
export function useMyMessengerConnectionsLazyQuery(options: VueApolloComposable.UseQueryOptions<MyMessengerConnectionsQuery, MyMessengerConnectionsQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<MyMessengerConnectionsQuery, MyMessengerConnectionsQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<MyMessengerConnectionsQuery, MyMessengerConnectionsQueryVariables>> = {}) {
  return VueApolloComposable.useLazyQuery<MyMessengerConnectionsQuery, MyMessengerConnectionsQueryVariables>(MyMessengerConnectionsDocument, {}, options);
}
export type MyMessengerConnectionsQueryCompositionFunctionResult = VueApolloComposable.UseQueryReturn<MyMessengerConnectionsQuery, MyMessengerConnectionsQueryVariables>;
export const MyNotificationHistoryDocument = gql`
    query MyNotificationHistory($channel: MessengerType!, $limit: Int) {
  myNotificationHistory(channel: $channel, limit: $limit) {
    id
    channel
    title
    message
    createdAt
    orderId
  }
}
    `;

/**
 * __useMyNotificationHistoryQuery__
 *
 * To run a query within a Vue component, call `useMyNotificationHistoryQuery` and pass it any options that fit your needs.
 * When your component renders, `useMyNotificationHistoryQuery` returns an object from Apollo Client that contains result, loading and error properties
 * you can use to render your UI.
 *
 * @param variables that will be passed into the query
 * @param options that will be passed into the query, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/query.html#options;
 *
 * @example
 * const { result, loading, error } = useMyNotificationHistoryQuery({
 *   channel: // value for 'channel'
 *   limit: // value for 'limit'
 * });
 */
export function useMyNotificationHistoryQuery(variables: MyNotificationHistoryQueryVariables | VueCompositionApi.Ref<MyNotificationHistoryQueryVariables> | ReactiveFunction<MyNotificationHistoryQueryVariables>, options: VueApolloComposable.UseQueryOptions<MyNotificationHistoryQuery, MyNotificationHistoryQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<MyNotificationHistoryQuery, MyNotificationHistoryQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<MyNotificationHistoryQuery, MyNotificationHistoryQueryVariables>> = {}) {
  return VueApolloComposable.useQuery<MyNotificationHistoryQuery, MyNotificationHistoryQueryVariables>(MyNotificationHistoryDocument, variables, options);
}
export function useMyNotificationHistoryLazyQuery(variables?: MyNotificationHistoryQueryVariables | VueCompositionApi.Ref<MyNotificationHistoryQueryVariables> | ReactiveFunction<MyNotificationHistoryQueryVariables>, options: VueApolloComposable.UseQueryOptions<MyNotificationHistoryQuery, MyNotificationHistoryQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<MyNotificationHistoryQuery, MyNotificationHistoryQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<MyNotificationHistoryQuery, MyNotificationHistoryQueryVariables>> = {}) {
  return VueApolloComposable.useLazyQuery<MyNotificationHistoryQuery, MyNotificationHistoryQueryVariables>(MyNotificationHistoryDocument, variables, options);
}
export type MyNotificationHistoryQueryCompositionFunctionResult = VueApolloComposable.UseQueryReturn<MyNotificationHistoryQuery, MyNotificationHistoryQueryVariables>;
export const NotificationTemplatesDocument = gql`
    query NotificationTemplates {
  notificationTemplates {
    id
    title
    channels {
      channel
      implemented
      subject
      body
      buttonText
      buttonUrl
    }
  }
}
    `;

/**
 * __useNotificationTemplatesQuery__
 *
 * To run a query within a Vue component, call `useNotificationTemplatesQuery` and pass it any options that fit your needs.
 * When your component renders, `useNotificationTemplatesQuery` returns an object from Apollo Client that contains result, loading and error properties
 * you can use to render your UI.
 *
 * @param options that will be passed into the query, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/query.html#options;
 *
 * @example
 * const { result, loading, error } = useNotificationTemplatesQuery();
 */
export function useNotificationTemplatesQuery(options: VueApolloComposable.UseQueryOptions<NotificationTemplatesQuery, NotificationTemplatesQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<NotificationTemplatesQuery, NotificationTemplatesQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<NotificationTemplatesQuery, NotificationTemplatesQueryVariables>> = {}) {
  return VueApolloComposable.useQuery<NotificationTemplatesQuery, NotificationTemplatesQueryVariables>(NotificationTemplatesDocument, {}, options);
}
export function useNotificationTemplatesLazyQuery(options: VueApolloComposable.UseQueryOptions<NotificationTemplatesQuery, NotificationTemplatesQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<NotificationTemplatesQuery, NotificationTemplatesQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<NotificationTemplatesQuery, NotificationTemplatesQueryVariables>> = {}) {
  return VueApolloComposable.useLazyQuery<NotificationTemplatesQuery, NotificationTemplatesQueryVariables>(NotificationTemplatesDocument, {}, options);
}
export type NotificationTemplatesQueryCompositionFunctionResult = VueApolloComposable.UseQueryReturn<NotificationTemplatesQuery, NotificationTemplatesQueryVariables>;
export const SendTestMessengerMessageDocument = gql`
    mutation SendTestMessengerMessage($type: MessengerType!, $channelId: String, $message: String) {
  sendTestMessengerMessage(type: $type, channelId: $channelId, message: $message) {
    type
    channelId
    success
    detail
    sentAt
  }
}
    `;

/**
 * __useSendTestMessengerMessageMutation__
 *
 * To run a mutation, you first call `useSendTestMessengerMessageMutation` within a Vue component and pass it any options that fit your needs.
 * When your component renders, `useSendTestMessengerMessageMutation` returns an object that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - Several other properties: https://v4.apollo.vuejs.org/api/use-mutation.html#return
 *
 * @param options that will be passed into the mutation, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/mutation.html#options;
 *
 * @example
 * const { mutate, loading, error, onDone } = useSendTestMessengerMessageMutation({
 *   variables: {
 *     type: // value for 'type'
 *     channelId: // value for 'channelId'
 *     message: // value for 'message'
 *   },
 * });
 */
export function useSendTestMessengerMessageMutation(options: VueApolloComposable.UseMutationOptions<SendTestMessengerMessageMutation, SendTestMessengerMessageMutationVariables> | ReactiveFunction<VueApolloComposable.UseMutationOptions<SendTestMessengerMessageMutation, SendTestMessengerMessageMutationVariables>> = {}) {
  return VueApolloComposable.useMutation<SendTestMessengerMessageMutation, SendTestMessengerMessageMutationVariables>(SendTestMessengerMessageDocument, options);
}
export type SendTestMessengerMessageMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<SendTestMessengerMessageMutation, SendTestMessengerMessageMutationVariables>;
export const MyCurrentOrdersDocument = gql`
    query MyCurrentOrders {
  myCurrentOrders {
    id
    code
    kind
    status
    createdAt
    items {
      id
      productName
      quantity
    }
  }
}
    `;

/**
 * __useMyCurrentOrdersQuery__
 *
 * To run a query within a Vue component, call `useMyCurrentOrdersQuery` and pass it any options that fit your needs.
 * When your component renders, `useMyCurrentOrdersQuery` returns an object from Apollo Client that contains result, loading and error properties
 * you can use to render your UI.
 *
 * @param options that will be passed into the query, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/query.html#options;
 *
 * @example
 * const { result, loading, error } = useMyCurrentOrdersQuery();
 */
export function useMyCurrentOrdersQuery(options: VueApolloComposable.UseQueryOptions<MyCurrentOrdersQuery, MyCurrentOrdersQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<MyCurrentOrdersQuery, MyCurrentOrdersQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<MyCurrentOrdersQuery, MyCurrentOrdersQueryVariables>> = {}) {
  return VueApolloComposable.useQuery<MyCurrentOrdersQuery, MyCurrentOrdersQueryVariables>(MyCurrentOrdersDocument, {}, options);
}
export function useMyCurrentOrdersLazyQuery(options: VueApolloComposable.UseQueryOptions<MyCurrentOrdersQuery, MyCurrentOrdersQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<MyCurrentOrdersQuery, MyCurrentOrdersQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<MyCurrentOrdersQuery, MyCurrentOrdersQueryVariables>> = {}) {
  return VueApolloComposable.useLazyQuery<MyCurrentOrdersQuery, MyCurrentOrdersQueryVariables>(MyCurrentOrdersDocument, {}, options);
}
export type MyCurrentOrdersQueryCompositionFunctionResult = VueApolloComposable.UseQueryReturn<MyCurrentOrdersQuery, MyCurrentOrdersQueryVariables>;
export const MyOrdersDocument = gql`
    query MyOrders {
  myOrders {
    id
    code
    kind
    status
    deliveryAddress
    totalPrice
    deliveryTerms
    deliveryFee
    createdAt
    items {
      id
      productName
      quantity
      unitPrice
      lineTotal
    }
  }
}
    `;

/**
 * __useMyOrdersQuery__
 *
 * To run a query within a Vue component, call `useMyOrdersQuery` and pass it any options that fit your needs.
 * When your component renders, `useMyOrdersQuery` returns an object from Apollo Client that contains result, loading and error properties
 * you can use to render your UI.
 *
 * @param options that will be passed into the query, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/query.html#options;
 *
 * @example
 * const { result, loading, error } = useMyOrdersQuery();
 */
export function useMyOrdersQuery(options: VueApolloComposable.UseQueryOptions<MyOrdersQuery, MyOrdersQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<MyOrdersQuery, MyOrdersQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<MyOrdersQuery, MyOrdersQueryVariables>> = {}) {
  return VueApolloComposable.useQuery<MyOrdersQuery, MyOrdersQueryVariables>(MyOrdersDocument, {}, options);
}
export function useMyOrdersLazyQuery(options: VueApolloComposable.UseQueryOptions<MyOrdersQuery, MyOrdersQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<MyOrdersQuery, MyOrdersQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<MyOrdersQuery, MyOrdersQueryVariables>> = {}) {
  return VueApolloComposable.useLazyQuery<MyOrdersQuery, MyOrdersQueryVariables>(MyOrdersDocument, {}, options);
}
export type MyOrdersQueryCompositionFunctionResult = VueApolloComposable.UseQueryReturn<MyOrdersQuery, MyOrdersQueryVariables>;
export const OrderDetailDocument = gql`
    query OrderDetail($id: ID!) {
  order(id: $id) {
    id
    code
    kind
    status
    customerId
    deliveryAddress
    deliveryTerms
    deliveryFee
    totalPrice
    calculationPayload
    createdAt
    items {
      id
      productName
      quantity
      unitPrice
      lineTotal
    }
  }
}
    `;

/**
 * __useOrderDetailQuery__
 *
 * To run a query within a Vue component, call `useOrderDetailQuery` and pass it any options that fit your needs.
 * When your component renders, `useOrderDetailQuery` returns an object from Apollo Client that contains result, loading and error properties
 * you can use to render your UI.
 *
 * @param variables that will be passed into the query
 * @param options that will be passed into the query, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/query.html#options;
 *
 * @example
 * const { result, loading, error } = useOrderDetailQuery({
 *   id: // value for 'id'
 * });
 */
export function useOrderDetailQuery(variables: OrderDetailQueryVariables | VueCompositionApi.Ref<OrderDetailQueryVariables> | ReactiveFunction<OrderDetailQueryVariables>, options: VueApolloComposable.UseQueryOptions<OrderDetailQuery, OrderDetailQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<OrderDetailQuery, OrderDetailQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<OrderDetailQuery, OrderDetailQueryVariables>> = {}) {
  return VueApolloComposable.useQuery<OrderDetailQuery, OrderDetailQueryVariables>(OrderDetailDocument, variables, options);
}
export function useOrderDetailLazyQuery(variables?: OrderDetailQueryVariables | VueCompositionApi.Ref<OrderDetailQueryVariables> | ReactiveFunction<OrderDetailQueryVariables>, options: VueApolloComposable.UseQueryOptions<OrderDetailQuery, OrderDetailQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<OrderDetailQuery, OrderDetailQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<OrderDetailQuery, OrderDetailQueryVariables>> = {}) {
  return VueApolloComposable.useLazyQuery<OrderDetailQuery, OrderDetailQueryVariables>(OrderDetailDocument, variables, options);
}
export type OrderDetailQueryCompositionFunctionResult = VueApolloComposable.UseQueryReturn<OrderDetailQuery, OrderDetailQueryVariables>;
export const SubmitCalculationOrderDocument = gql`
    mutation SubmitCalculationOrder($input: SubmitCalculationOrderInput!) {
  submitCalculationOrder(input: $input) {
    id
    code
    status
    createdAt
  }
}
    `;

/**
 * __useSubmitCalculationOrderMutation__
 *
 * To run a mutation, you first call `useSubmitCalculationOrderMutation` within a Vue component and pass it any options that fit your needs.
 * When your component renders, `useSubmitCalculationOrderMutation` returns an object that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - Several other properties: https://v4.apollo.vuejs.org/api/use-mutation.html#return
 *
 * @param options that will be passed into the mutation, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/mutation.html#options;
 *
 * @example
 * const { mutate, loading, error, onDone } = useSubmitCalculationOrderMutation({
 *   variables: {
 *     input: // value for 'input'
 *   },
 * });
 */
export function useSubmitCalculationOrderMutation(options: VueApolloComposable.UseMutationOptions<SubmitCalculationOrderMutation, SubmitCalculationOrderMutationVariables> | ReactiveFunction<VueApolloComposable.UseMutationOptions<SubmitCalculationOrderMutation, SubmitCalculationOrderMutationVariables>> = {}) {
  return VueApolloComposable.useMutation<SubmitCalculationOrderMutation, SubmitCalculationOrderMutationVariables>(SubmitCalculationOrderDocument, options);
}
export type SubmitCalculationOrderMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<SubmitCalculationOrderMutation, SubmitCalculationOrderMutationVariables>;
export const SubmitReadyOrderDocument = gql`
    mutation SubmitReadyOrder($input: SubmitReadyOrderInput!) {
  submitReadyOrder(input: $input) {
    id
    code
    status
    createdAt
  }
}
    `;

/**
 * __useSubmitReadyOrderMutation__
 *
 * To run a mutation, you first call `useSubmitReadyOrderMutation` within a Vue component and pass it any options that fit your needs.
 * When your component renders, `useSubmitReadyOrderMutation` returns an object that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - Several other properties: https://v4.apollo.vuejs.org/api/use-mutation.html#return
 *
 * @param options that will be passed into the mutation, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/mutation.html#options;
 *
 * @example
 * const { mutate, loading, error, onDone } = useSubmitReadyOrderMutation({
 *   variables: {
 *     input: // value for 'input'
 *   },
 * });
 */
export function useSubmitReadyOrderMutation(options: VueApolloComposable.UseMutationOptions<SubmitReadyOrderMutation, SubmitReadyOrderMutationVariables> | ReactiveFunction<VueApolloComposable.UseMutationOptions<SubmitReadyOrderMutation, SubmitReadyOrderMutationVariables>> = {}) {
  return VueApolloComposable.useMutation<SubmitReadyOrderMutation, SubmitReadyOrderMutationVariables>(SubmitReadyOrderDocument, options);
}
export type SubmitReadyOrderMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<SubmitReadyOrderMutation, SubmitReadyOrderMutationVariables>;
export const ConnectMessengerDocument = gql`
    mutation ConnectMessenger($input: ConnectMessengerInput!) {
  connectMessenger(input: $input) {
    id
    type
    channelId
    isActive
  }
}
    `;

/**
 * __useConnectMessengerMutation__
 *
 * To run a mutation, you first call `useConnectMessengerMutation` within a Vue component and pass it any options that fit your needs.
 * When your component renders, `useConnectMessengerMutation` returns an object that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - Several other properties: https://v4.apollo.vuejs.org/api/use-mutation.html#return
 *
 * @param options that will be passed into the mutation, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/mutation.html#options;
 *
 * @example
 * const { mutate, loading, error, onDone } = useConnectMessengerMutation({
 *   variables: {
 *     input: // value for 'input'
 *   },
 * });
 */
export function useConnectMessengerMutation(options: VueApolloComposable.UseMutationOptions<ConnectMessengerMutation, ConnectMessengerMutationVariables> | ReactiveFunction<VueApolloComposable.UseMutationOptions<ConnectMessengerMutation, ConnectMessengerMutationVariables>> = {}) {
  return VueApolloComposable.useMutation<ConnectMessengerMutation, ConnectMessengerMutationVariables>(ConnectMessengerDocument, options);
}
export type ConnectMessengerMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<ConnectMessengerMutation, ConnectMessengerMutationVariables>;
export const CreateMyDeliveryAddressDocument = gql`
    mutation CreateMyDeliveryAddress($input: CreateMyDeliveryAddressInput!) {
  createMyDeliveryAddress(input: $input) {
    id
    label
    address
    unrestrictedValue
    fiasId
    isDefault
    updatedAt
  }
}
    `;

/**
 * __useCreateMyDeliveryAddressMutation__
 *
 * To run a mutation, you first call `useCreateMyDeliveryAddressMutation` within a Vue component and pass it any options that fit your needs.
 * When your component renders, `useCreateMyDeliveryAddressMutation` returns an object that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - Several other properties: https://v4.apollo.vuejs.org/api/use-mutation.html#return
 *
 * @param options that will be passed into the mutation, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/mutation.html#options;
 *
 * @example
 * const { mutate, loading, error, onDone } = useCreateMyDeliveryAddressMutation({
 *   variables: {
 *     input: // value for 'input'
 *   },
 * });
 */
export function useCreateMyDeliveryAddressMutation(options: VueApolloComposable.UseMutationOptions<CreateMyDeliveryAddressMutation, CreateMyDeliveryAddressMutationVariables> | ReactiveFunction<VueApolloComposable.UseMutationOptions<CreateMyDeliveryAddressMutation, CreateMyDeliveryAddressMutationVariables>> = {}) {
  return VueApolloComposable.useMutation<CreateMyDeliveryAddressMutation, CreateMyDeliveryAddressMutationVariables>(CreateMyDeliveryAddressDocument, options);
}
export type CreateMyDeliveryAddressMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<CreateMyDeliveryAddressMutation, CreateMyDeliveryAddressMutationVariables>;
export const DeleteMyDeliveryAddressDocument = gql`
    mutation DeleteMyDeliveryAddress($addressId: ID!) {
  deleteMyDeliveryAddress(addressId: $addressId)
}
    `;

/**
 * __useDeleteMyDeliveryAddressMutation__
 *
 * To run a mutation, you first call `useDeleteMyDeliveryAddressMutation` within a Vue component and pass it any options that fit your needs.
 * When your component renders, `useDeleteMyDeliveryAddressMutation` returns an object that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - Several other properties: https://v4.apollo.vuejs.org/api/use-mutation.html#return
 *
 * @param options that will be passed into the mutation, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/mutation.html#options;
 *
 * @example
 * const { mutate, loading, error, onDone } = useDeleteMyDeliveryAddressMutation({
 *   variables: {
 *     addressId: // value for 'addressId'
 *   },
 * });
 */
export function useDeleteMyDeliveryAddressMutation(options: VueApolloComposable.UseMutationOptions<DeleteMyDeliveryAddressMutation, DeleteMyDeliveryAddressMutationVariables> | ReactiveFunction<VueApolloComposable.UseMutationOptions<DeleteMyDeliveryAddressMutation, DeleteMyDeliveryAddressMutationVariables>> = {}) {
  return VueApolloComposable.useMutation<DeleteMyDeliveryAddressMutation, DeleteMyDeliveryAddressMutationVariables>(DeleteMyDeliveryAddressDocument, options);
}
export type DeleteMyDeliveryAddressMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<DeleteMyDeliveryAddressMutation, DeleteMyDeliveryAddressMutationVariables>;
export const DeleteMyMessengerConnectionDocument = gql`
    mutation DeleteMyMessengerConnection($connectionId: ID!) {
  deleteMyMessengerConnection(connectionId: $connectionId)
}
    `;

/**
 * __useDeleteMyMessengerConnectionMutation__
 *
 * To run a mutation, you first call `useDeleteMyMessengerConnectionMutation` within a Vue component and pass it any options that fit your needs.
 * When your component renders, `useDeleteMyMessengerConnectionMutation` returns an object that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - Several other properties: https://v4.apollo.vuejs.org/api/use-mutation.html#return
 *
 * @param options that will be passed into the mutation, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/mutation.html#options;
 *
 * @example
 * const { mutate, loading, error, onDone } = useDeleteMyMessengerConnectionMutation({
 *   variables: {
 *     connectionId: // value for 'connectionId'
 *   },
 * });
 */
export function useDeleteMyMessengerConnectionMutation(options: VueApolloComposable.UseMutationOptions<DeleteMyMessengerConnectionMutation, DeleteMyMessengerConnectionMutationVariables> | ReactiveFunction<VueApolloComposable.UseMutationOptions<DeleteMyMessengerConnectionMutation, DeleteMyMessengerConnectionMutationVariables>> = {}) {
  return VueApolloComposable.useMutation<DeleteMyMessengerConnectionMutation, DeleteMyMessengerConnectionMutationVariables>(DeleteMyMessengerConnectionDocument, options);
}
export type DeleteMyMessengerConnectionMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<DeleteMyMessengerConnectionMutation, DeleteMyMessengerConnectionMutationVariables>;
export const MyCounterpartyProfileDocument = gql`
    query MyCounterpartyProfile {
  myCounterpartyProfile {
    id
    companyName
    companyFullName
    inn
    kpp
    ogrn
    legalAddress
    bankName
    bik
    correspondentAccount
    checkingAccount
    signerFullName
    signerPosition
    signerBasis
    isComplete
    updatedAt
  }
}
    `;

/**
 * __useMyCounterpartyProfileQuery__
 *
 * To run a query within a Vue component, call `useMyCounterpartyProfileQuery` and pass it any options that fit your needs.
 * When your component renders, `useMyCounterpartyProfileQuery` returns an object from Apollo Client that contains result, loading and error properties
 * you can use to render your UI.
 *
 * @param options that will be passed into the query, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/query.html#options;
 *
 * @example
 * const { result, loading, error } = useMyCounterpartyProfileQuery();
 */
export function useMyCounterpartyProfileQuery(options: VueApolloComposable.UseQueryOptions<MyCounterpartyProfileQuery, MyCounterpartyProfileQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<MyCounterpartyProfileQuery, MyCounterpartyProfileQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<MyCounterpartyProfileQuery, MyCounterpartyProfileQueryVariables>> = {}) {
  return VueApolloComposable.useQuery<MyCounterpartyProfileQuery, MyCounterpartyProfileQueryVariables>(MyCounterpartyProfileDocument, {}, options);
}
export function useMyCounterpartyProfileLazyQuery(options: VueApolloComposable.UseQueryOptions<MyCounterpartyProfileQuery, MyCounterpartyProfileQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<MyCounterpartyProfileQuery, MyCounterpartyProfileQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<MyCounterpartyProfileQuery, MyCounterpartyProfileQueryVariables>> = {}) {
  return VueApolloComposable.useLazyQuery<MyCounterpartyProfileQuery, MyCounterpartyProfileQueryVariables>(MyCounterpartyProfileDocument, {}, options);
}
export type MyCounterpartyProfileQueryCompositionFunctionResult = VueApolloComposable.UseQueryReturn<MyCounterpartyProfileQuery, MyCounterpartyProfileQueryVariables>;
export const MyDeliveryAddressesDocument = gql`
    query MyDeliveryAddresses {
  myDeliveryAddresses {
    id
    label
    address
    unrestrictedValue
    fiasId
    isDefault
    updatedAt
  }
}
    `;

/**
 * __useMyDeliveryAddressesQuery__
 *
 * To run a query within a Vue component, call `useMyDeliveryAddressesQuery` and pass it any options that fit your needs.
 * When your component renders, `useMyDeliveryAddressesQuery` returns an object from Apollo Client that contains result, loading and error properties
 * you can use to render your UI.
 *
 * @param options that will be passed into the query, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/query.html#options;
 *
 * @example
 * const { result, loading, error } = useMyDeliveryAddressesQuery();
 */
export function useMyDeliveryAddressesQuery(options: VueApolloComposable.UseQueryOptions<MyDeliveryAddressesQuery, MyDeliveryAddressesQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<MyDeliveryAddressesQuery, MyDeliveryAddressesQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<MyDeliveryAddressesQuery, MyDeliveryAddressesQueryVariables>> = {}) {
  return VueApolloComposable.useQuery<MyDeliveryAddressesQuery, MyDeliveryAddressesQueryVariables>(MyDeliveryAddressesDocument, {}, options);
}
export function useMyDeliveryAddressesLazyQuery(options: VueApolloComposable.UseQueryOptions<MyDeliveryAddressesQuery, MyDeliveryAddressesQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<MyDeliveryAddressesQuery, MyDeliveryAddressesQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<MyDeliveryAddressesQuery, MyDeliveryAddressesQueryVariables>> = {}) {
  return VueApolloComposable.useLazyQuery<MyDeliveryAddressesQuery, MyDeliveryAddressesQueryVariables>(MyDeliveryAddressesDocument, {}, options);
}
export type MyDeliveryAddressesQueryCompositionFunctionResult = VueApolloComposable.UseQueryReturn<MyDeliveryAddressesQuery, MyDeliveryAddressesQueryVariables>;
export const SetMyDefaultDeliveryAddressDocument = gql`
    mutation SetMyDefaultDeliveryAddress($addressId: ID!) {
  setMyDefaultDeliveryAddress(addressId: $addressId) {
    id
    label
    address
    unrestrictedValue
    fiasId
    isDefault
    updatedAt
  }
}
    `;

/**
 * __useSetMyDefaultDeliveryAddressMutation__
 *
 * To run a mutation, you first call `useSetMyDefaultDeliveryAddressMutation` within a Vue component and pass it any options that fit your needs.
 * When your component renders, `useSetMyDefaultDeliveryAddressMutation` returns an object that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - Several other properties: https://v4.apollo.vuejs.org/api/use-mutation.html#return
 *
 * @param options that will be passed into the mutation, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/mutation.html#options;
 *
 * @example
 * const { mutate, loading, error, onDone } = useSetMyDefaultDeliveryAddressMutation({
 *   variables: {
 *     addressId: // value for 'addressId'
 *   },
 * });
 */
export function useSetMyDefaultDeliveryAddressMutation(options: VueApolloComposable.UseMutationOptions<SetMyDefaultDeliveryAddressMutation, SetMyDefaultDeliveryAddressMutationVariables> | ReactiveFunction<VueApolloComposable.UseMutationOptions<SetMyDefaultDeliveryAddressMutation, SetMyDefaultDeliveryAddressMutationVariables>> = {}) {
  return VueApolloComposable.useMutation<SetMyDefaultDeliveryAddressMutation, SetMyDefaultDeliveryAddressMutationVariables>(SetMyDefaultDeliveryAddressDocument, options);
}
export type SetMyDefaultDeliveryAddressMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<SetMyDefaultDeliveryAddressMutation, SetMyDefaultDeliveryAddressMutationVariables>;
export const UpsertMyCounterpartyProfileDocument = gql`
    mutation UpsertMyCounterpartyProfile($input: UpsertMyCounterpartyProfileInput!) {
  upsertMyCounterpartyProfile(input: $input) {
    id
    companyName
    companyFullName
    inn
    kpp
    ogrn
    legalAddress
    bankName
    bik
    correspondentAccount
    checkingAccount
    signerFullName
    signerPosition
    signerBasis
    isComplete
    updatedAt
  }
}
    `;

/**
 * __useUpsertMyCounterpartyProfileMutation__
 *
 * To run a mutation, you first call `useUpsertMyCounterpartyProfileMutation` within a Vue component and pass it any options that fit your needs.
 * When your component renders, `useUpsertMyCounterpartyProfileMutation` returns an object that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - Several other properties: https://v4.apollo.vuejs.org/api/use-mutation.html#return
 *
 * @param options that will be passed into the mutation, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/mutation.html#options;
 *
 * @example
 * const { mutate, loading, error, onDone } = useUpsertMyCounterpartyProfileMutation({
 *   variables: {
 *     input: // value for 'input'
 *   },
 * });
 */
export function useUpsertMyCounterpartyProfileMutation(options: VueApolloComposable.UseMutationOptions<UpsertMyCounterpartyProfileMutation, UpsertMyCounterpartyProfileMutationVariables> | ReactiveFunction<VueApolloComposable.UseMutationOptions<UpsertMyCounterpartyProfileMutation, UpsertMyCounterpartyProfileMutationVariables>> = {}) {
  return VueApolloComposable.useMutation<UpsertMyCounterpartyProfileMutation, UpsertMyCounterpartyProfileMutationVariables>(UpsertMyCounterpartyProfileDocument, options);
}
export type UpsertMyCounterpartyProfileMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<UpsertMyCounterpartyProfileMutation, UpsertMyCounterpartyProfileMutationVariables>;
export const CatalogProductTypeSettingsDocument = gql`
    query CatalogProductTypeSettings {
  catalogProductTypeSettings {
    productType
    showQuantityPerBox
    allowCustomLength
    customLengthMinM
    customLengthMaxM
    customLengthStepM
    allowCustomSleeveBrand
    allowCustomLabel
    widthOptionsMm
    lengthOptionsM
    thicknessOptionsMicron
    sleeveOptions
    colorOptions
    labelOptions
  }
}
    `;

/**
 * __useCatalogProductTypeSettingsQuery__
 *
 * To run a query within a Vue component, call `useCatalogProductTypeSettingsQuery` and pass it any options that fit your needs.
 * When your component renders, `useCatalogProductTypeSettingsQuery` returns an object from Apollo Client that contains result, loading and error properties
 * you can use to render your UI.
 *
 * @param options that will be passed into the query, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/query.html#options;
 *
 * @example
 * const { result, loading, error } = useCatalogProductTypeSettingsQuery();
 */
export function useCatalogProductTypeSettingsQuery(options: VueApolloComposable.UseQueryOptions<CatalogProductTypeSettingsQuery, CatalogProductTypeSettingsQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<CatalogProductTypeSettingsQuery, CatalogProductTypeSettingsQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<CatalogProductTypeSettingsQuery, CatalogProductTypeSettingsQueryVariables>> = {}) {
  return VueApolloComposable.useQuery<CatalogProductTypeSettingsQuery, CatalogProductTypeSettingsQueryVariables>(CatalogProductTypeSettingsDocument, {}, options);
}
export function useCatalogProductTypeSettingsLazyQuery(options: VueApolloComposable.UseQueryOptions<CatalogProductTypeSettingsQuery, CatalogProductTypeSettingsQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<CatalogProductTypeSettingsQuery, CatalogProductTypeSettingsQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<CatalogProductTypeSettingsQuery, CatalogProductTypeSettingsQueryVariables>> = {}) {
  return VueApolloComposable.useLazyQuery<CatalogProductTypeSettingsQuery, CatalogProductTypeSettingsQueryVariables>(CatalogProductTypeSettingsDocument, {}, options);
}
export type CatalogProductTypeSettingsQueryCompositionFunctionResult = VueApolloComposable.UseQueryReturn<CatalogProductTypeSettingsQuery, CatalogProductTypeSettingsQueryVariables>;
export const IntegrationSyncDashboardDocument = gql`
    query IntegrationSyncDashboard {
  integrationSyncDashboard {
    generatedAt
    lastActivityAt
    totalOrders
    totalProducts
    totalClients
    items {
      id
      title
      description
      source
      syncedCount
      lastSyncedAt
      status
      note
    }
  }
}
    `;

/**
 * __useIntegrationSyncDashboardQuery__
 *
 * To run a query within a Vue component, call `useIntegrationSyncDashboardQuery` and pass it any options that fit your needs.
 * When your component renders, `useIntegrationSyncDashboardQuery` returns an object from Apollo Client that contains result, loading and error properties
 * you can use to render your UI.
 *
 * @param options that will be passed into the query, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/query.html#options;
 *
 * @example
 * const { result, loading, error } = useIntegrationSyncDashboardQuery();
 */
export function useIntegrationSyncDashboardQuery(options: VueApolloComposable.UseQueryOptions<IntegrationSyncDashboardQuery, IntegrationSyncDashboardQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<IntegrationSyncDashboardQuery, IntegrationSyncDashboardQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<IntegrationSyncDashboardQuery, IntegrationSyncDashboardQueryVariables>> = {}) {
  return VueApolloComposable.useQuery<IntegrationSyncDashboardQuery, IntegrationSyncDashboardQueryVariables>(IntegrationSyncDashboardDocument, {}, options);
}
export function useIntegrationSyncDashboardLazyQuery(options: VueApolloComposable.UseQueryOptions<IntegrationSyncDashboardQuery, IntegrationSyncDashboardQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<IntegrationSyncDashboardQuery, IntegrationSyncDashboardQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<IntegrationSyncDashboardQuery, IntegrationSyncDashboardQueryVariables>> = {}) {
  return VueApolloComposable.useLazyQuery<IntegrationSyncDashboardQuery, IntegrationSyncDashboardQueryVariables>(IntegrationSyncDashboardDocument, {}, options);
}
export type IntegrationSyncDashboardQueryCompositionFunctionResult = VueApolloComposable.UseQueryReturn<IntegrationSyncDashboardQuery, IntegrationSyncDashboardQueryVariables>;
export const UpsertCatalogProductTypeSettingDocument = gql`
    mutation UpsertCatalogProductTypeSetting($input: UpsertCatalogProductTypeSettingInput!) {
  upsertCatalogProductTypeSetting(input: $input) {
    productType
    showQuantityPerBox
    allowCustomLength
    customLengthMinM
    customLengthMaxM
    customLengthStepM
    allowCustomSleeveBrand
    allowCustomLabel
    widthOptionsMm
    lengthOptionsM
    thicknessOptionsMicron
    sleeveOptions
    colorOptions
    labelOptions
  }
}
    `;

/**
 * __useUpsertCatalogProductTypeSettingMutation__
 *
 * To run a mutation, you first call `useUpsertCatalogProductTypeSettingMutation` within a Vue component and pass it any options that fit your needs.
 * When your component renders, `useUpsertCatalogProductTypeSettingMutation` returns an object that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - Several other properties: https://v4.apollo.vuejs.org/api/use-mutation.html#return
 *
 * @param options that will be passed into the mutation, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/mutation.html#options;
 *
 * @example
 * const { mutate, loading, error, onDone } = useUpsertCatalogProductTypeSettingMutation({
 *   variables: {
 *     input: // value for 'input'
 *   },
 * });
 */
export function useUpsertCatalogProductTypeSettingMutation(options: VueApolloComposable.UseMutationOptions<UpsertCatalogProductTypeSettingMutation, UpsertCatalogProductTypeSettingMutationVariables> | ReactiveFunction<VueApolloComposable.UseMutationOptions<UpsertCatalogProductTypeSettingMutation, UpsertCatalogProductTypeSettingMutationVariables>> = {}) {
  return VueApolloComposable.useMutation<UpsertCatalogProductTypeSettingMutation, UpsertCatalogProductTypeSettingMutationVariables>(UpsertCatalogProductTypeSettingDocument, options);
}
export type UpsertCatalogProductTypeSettingMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<UpsertCatalogProductTypeSettingMutation, UpsertCatalogProductTypeSettingMutationVariables>;