2372 lines
104 KiB
TypeScript
2372 lines
104 KiB
TypeScript
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 BlockOrderInput = {
|
|
orderId: Scalars['ID']['input'];
|
|
reason: Scalars['String']['input'];
|
|
};
|
|
|
|
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 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 = {
|
|
refereeUserId: 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 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 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;
|
|
blockOrder: Order;
|
|
clearCart: Cart;
|
|
clientReviewOrder: Order;
|
|
completeOrder: Order;
|
|
connectMessenger: MessengerConnection;
|
|
consumeLoginToken: AuthSession;
|
|
createInvitation: Invitation;
|
|
createMyDeliveryAddress: DeliveryAddress;
|
|
createReferral: ReferralLink;
|
|
deleteMyDeliveryAddress: Scalars['Boolean']['output'];
|
|
managerFinalizeOrder: Order;
|
|
managerSetOrderOffer: Order;
|
|
registerSelf: RegistrationRequest;
|
|
removeCartItem: Cart;
|
|
requestLoginCode: AuthCodeRequestResult;
|
|
requestRewardWithdrawal: RewardWithdrawalRequest;
|
|
reviewRegistrationRequest: RegistrationRequest;
|
|
reviewRewardWithdrawal: RewardWithdrawalRequest;
|
|
sendTestMessengerMessage: MessengerDispatchResult;
|
|
setCartDeliveryAddress: Cart;
|
|
setMyDefaultDeliveryAddress: DeliveryAddress;
|
|
startOrderWork: Order;
|
|
submitCalculationOrder: Order;
|
|
submitReadyOrder: Order;
|
|
updateCartItemQuantity: Cart;
|
|
upsertMyCounterpartyProfile: CounterpartyProfile;
|
|
verifyLoginCode: AuthSession;
|
|
};
|
|
|
|
|
|
export type MutationAcceptInvitationArgs = {
|
|
input: AcceptInvitationInput;
|
|
};
|
|
|
|
|
|
export type MutationAddBonusTransactionArgs = {
|
|
input: AddBonusTransactionInput;
|
|
};
|
|
|
|
|
|
export type MutationAddProductToCartArgs = {
|
|
productId: Scalars['ID']['input'];
|
|
};
|
|
|
|
|
|
export type MutationBlockOrderArgs = {
|
|
input: BlockOrderInput;
|
|
};
|
|
|
|
|
|
export type MutationClientReviewOrderArgs = {
|
|
decision: Decision;
|
|
orderId: Scalars['ID']['input'];
|
|
};
|
|
|
|
|
|
export type MutationCompleteOrderArgs = {
|
|
orderId: Scalars['ID']['input'];
|
|
};
|
|
|
|
|
|
export type MutationConnectMessengerArgs = {
|
|
input: ConnectMessengerInput;
|
|
};
|
|
|
|
|
|
export type MutationConsumeLoginTokenArgs = {
|
|
token: Scalars['String']['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 MutationManagerFinalizeOrderArgs = {
|
|
decision: Decision;
|
|
orderId: Scalars['ID']['input'];
|
|
};
|
|
|
|
|
|
export type MutationManagerSetOrderOfferArgs = {
|
|
input: SetOrderOfferInput;
|
|
};
|
|
|
|
|
|
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 MutationStartOrderWorkArgs = {
|
|
orderId: Scalars['ID']['input'];
|
|
};
|
|
|
|
|
|
export type MutationSubmitCalculationOrderArgs = {
|
|
input: SubmitCalculationOrderInput;
|
|
};
|
|
|
|
|
|
export type MutationSubmitReadyOrderArgs = {
|
|
input: SubmitReadyOrderInput;
|
|
};
|
|
|
|
|
|
export type MutationUpdateCartItemQuantityArgs = {
|
|
input: UpdateCartItemQuantityInput;
|
|
};
|
|
|
|
|
|
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 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'];
|
|
productId?: Maybe<Scalars['ID']['output']>;
|
|
productName: Scalars['String']['output'];
|
|
quantity: Scalars['Float']['output'];
|
|
};
|
|
|
|
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']>;
|
|
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';
|
|
clientProducts: Array<Product>;
|
|
healthcheck: Scalars['String']['output'];
|
|
managerNotificationHistory: Array<NotificationHistoryItem>;
|
|
managerOrders: Array<Order>;
|
|
me?: Maybe<User>;
|
|
myCart: Cart;
|
|
myCounterpartyProfile?: Maybe<CounterpartyProfile>;
|
|
myCurrentOrders: Array<Order>;
|
|
myDeliveryAddresses: Array<DeliveryAddress>;
|
|
myMessengerConnections: Array<MessengerConnection>;
|
|
myNotificationHistory: Array<NotificationHistoryItem>;
|
|
myOrders: Array<Order>;
|
|
referralStats: ReferralStats;
|
|
registrationRequests: Array<RegistrationRequest>;
|
|
};
|
|
|
|
|
|
export type QueryManagerNotificationHistoryArgs = {
|
|
channel: MessengerType;
|
|
limit?: InputMaybe<Scalars['Int']['input']>;
|
|
userId: Scalars['ID']['input'];
|
|
};
|
|
|
|
|
|
export type QueryManagerOrdersArgs = {
|
|
status?: InputMaybe<OrderStatus>;
|
|
};
|
|
|
|
|
|
export type QueryMyNotificationHistoryArgs = {
|
|
channel: MessengerType;
|
|
limit?: InputMaybe<Scalars['Int']['input']>;
|
|
};
|
|
|
|
|
|
export type QueryRegistrationRequestsArgs = {
|
|
status?: InputMaybe<RegistrationStatus>;
|
|
};
|
|
|
|
export type ReadyOrderItemInput = {
|
|
productId: Scalars['ID']['input'];
|
|
quantity: Scalars['Float']['input'];
|
|
};
|
|
|
|
export type ReferralLink = {
|
|
__typename?: 'ReferralLink';
|
|
createdAt: Scalars['DateTime']['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: Scalars['Float']['input'];
|
|
deliveryTerms: Scalars['String']['input'];
|
|
orderId: Scalars['ID']['input'];
|
|
totalPrice: Scalars['Float']['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 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'
|
|
}
|
|
|
|
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 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, 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 BlockOrderMutationVariables = Exact<{
|
|
input: BlockOrderInput;
|
|
}>;
|
|
|
|
|
|
export type BlockOrderMutation = { __typename?: 'Mutation', blockOrder: { __typename?: 'Order', id: string, status: OrderStatus, blockReason?: string | null } };
|
|
|
|
export type CompleteOrderMutationVariables = Exact<{
|
|
orderId: Scalars['ID']['input'];
|
|
}>;
|
|
|
|
|
|
export type CompleteOrderMutation = { __typename?: 'Mutation', completeOrder: { __typename?: 'Order', id: string, status: OrderStatus } };
|
|
|
|
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, createdAt: any } };
|
|
|
|
export type ManagerFinalizeOrderMutationVariables = Exact<{
|
|
orderId: Scalars['ID']['input'];
|
|
decision: Decision;
|
|
}>;
|
|
|
|
|
|
export type ManagerFinalizeOrderMutation = { __typename?: 'Mutation', managerFinalizeOrder: { __typename?: 'Order', id: string, status: OrderStatus, managerApproved?: boolean | null } };
|
|
|
|
export type ManagerOrdersQueryVariables = Exact<{
|
|
status?: InputMaybe<OrderStatus>;
|
|
}>;
|
|
|
|
|
|
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 }> }> };
|
|
|
|
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, totalPrice?: number | null } };
|
|
|
|
export type StartOrderWorkMutationVariables = Exact<{
|
|
orderId: Scalars['ID']['input'];
|
|
}>;
|
|
|
|
|
|
export type StartOrderWorkMutation = { __typename?: 'Mutation', startOrderWork: { __typename?: 'Order', id: string, status: OrderStatus } };
|
|
|
|
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 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, createdAt: any, items: Array<{ __typename?: 'OrderItem', id: string, productName: string, quantity: number }> }> };
|
|
|
|
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 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 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 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
|
|
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 BlockOrderDocument = gql`
|
|
mutation BlockOrder($input: BlockOrderInput!) {
|
|
blockOrder(input: $input) {
|
|
id
|
|
status
|
|
blockReason
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __useBlockOrderMutation__
|
|
*
|
|
* To run a mutation, you first call `useBlockOrderMutation` within a Vue component and pass it any options that fit your needs.
|
|
* When your component renders, `useBlockOrderMutation` 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 } = useBlockOrderMutation({
|
|
* variables: {
|
|
* input: // value for 'input'
|
|
* },
|
|
* });
|
|
*/
|
|
export function useBlockOrderMutation(options: VueApolloComposable.UseMutationOptions<BlockOrderMutation, BlockOrderMutationVariables> | ReactiveFunction<VueApolloComposable.UseMutationOptions<BlockOrderMutation, BlockOrderMutationVariables>> = {}) {
|
|
return VueApolloComposable.useMutation<BlockOrderMutation, BlockOrderMutationVariables>(BlockOrderDocument, options);
|
|
}
|
|
export type BlockOrderMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<BlockOrderMutation, BlockOrderMutationVariables>;
|
|
export const CompleteOrderDocument = gql`
|
|
mutation CompleteOrder($orderId: ID!) {
|
|
completeOrder(orderId: $orderId) {
|
|
id
|
|
status
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __useCompleteOrderMutation__
|
|
*
|
|
* To run a mutation, you first call `useCompleteOrderMutation` within a Vue component and pass it any options that fit your needs.
|
|
* When your component renders, `useCompleteOrderMutation` 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 } = useCompleteOrderMutation({
|
|
* variables: {
|
|
* orderId: // value for 'orderId'
|
|
* },
|
|
* });
|
|
*/
|
|
export function useCompleteOrderMutation(options: VueApolloComposable.UseMutationOptions<CompleteOrderMutation, CompleteOrderMutationVariables> | ReactiveFunction<VueApolloComposable.UseMutationOptions<CompleteOrderMutation, CompleteOrderMutationVariables>> = {}) {
|
|
return VueApolloComposable.useMutation<CompleteOrderMutation, CompleteOrderMutationVariables>(CompleteOrderDocument, options);
|
|
}
|
|
export type CompleteOrderMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<CompleteOrderMutation, CompleteOrderMutationVariables>;
|
|
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
|
|
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 ManagerFinalizeOrderDocument = gql`
|
|
mutation ManagerFinalizeOrder($orderId: ID!, $decision: Decision!) {
|
|
managerFinalizeOrder(orderId: $orderId, decision: $decision) {
|
|
id
|
|
status
|
|
managerApproved
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __useManagerFinalizeOrderMutation__
|
|
*
|
|
* To run a mutation, you first call `useManagerFinalizeOrderMutation` within a Vue component and pass it any options that fit your needs.
|
|
* When your component renders, `useManagerFinalizeOrderMutation` 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 } = useManagerFinalizeOrderMutation({
|
|
* variables: {
|
|
* orderId: // value for 'orderId'
|
|
* decision: // value for 'decision'
|
|
* },
|
|
* });
|
|
*/
|
|
export function useManagerFinalizeOrderMutation(options: VueApolloComposable.UseMutationOptions<ManagerFinalizeOrderMutation, ManagerFinalizeOrderMutationVariables> | ReactiveFunction<VueApolloComposable.UseMutationOptions<ManagerFinalizeOrderMutation, ManagerFinalizeOrderMutationVariables>> = {}) {
|
|
return VueApolloComposable.useMutation<ManagerFinalizeOrderMutation, ManagerFinalizeOrderMutationVariables>(ManagerFinalizeOrderDocument, options);
|
|
}
|
|
export type ManagerFinalizeOrderMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<ManagerFinalizeOrderMutation, ManagerFinalizeOrderMutationVariables>;
|
|
export const ManagerOrdersDocument = gql`
|
|
query ManagerOrders($status: OrderStatus) {
|
|
managerOrders(status: $status) {
|
|
id
|
|
code
|
|
status
|
|
kind
|
|
customerId
|
|
deliveryAddress
|
|
deliveryTerms
|
|
deliveryFee
|
|
totalPrice
|
|
createdAt
|
|
items {
|
|
id
|
|
productName
|
|
quantity
|
|
}
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __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'
|
|
* });
|
|
*/
|
|
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 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
|
|
totalPrice
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __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 StartOrderWorkDocument = gql`
|
|
mutation StartOrderWork($orderId: ID!) {
|
|
startOrderWork(orderId: $orderId) {
|
|
id
|
|
status
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __useStartOrderWorkMutation__
|
|
*
|
|
* To run a mutation, you first call `useStartOrderWorkMutation` within a Vue component and pass it any options that fit your needs.
|
|
* When your component renders, `useStartOrderWorkMutation` 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 } = useStartOrderWorkMutation({
|
|
* variables: {
|
|
* orderId: // value for 'orderId'
|
|
* },
|
|
* });
|
|
*/
|
|
export function useStartOrderWorkMutation(options: VueApolloComposable.UseMutationOptions<StartOrderWorkMutation, StartOrderWorkMutationVariables> | ReactiveFunction<VueApolloComposable.UseMutationOptions<StartOrderWorkMutation, StartOrderWorkMutationVariables>> = {}) {
|
|
return VueApolloComposable.useMutation<StartOrderWorkMutation, StartOrderWorkMutationVariables>(StartOrderWorkDocument, options);
|
|
}
|
|
export type StartOrderWorkMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<StartOrderWorkMutation, StartOrderWorkMutationVariables>;
|
|
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 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
|
|
createdAt
|
|
items {
|
|
id
|
|
productName
|
|
quantity
|
|
}
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __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 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 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>; |