4
0
forked from crowetic/commerce
Luis Alvarez D 0afe686fe9
Monorepo with Turborepo ()
* Moved everything

* Figuring out how to make imports work

* Updated exports

* Added missing exports

* Added @vercel/commerce-local to `site`

* Updated commerce config

* Updated exports and commerce config

* Updated commerce hoc

* Fixed exports in local

* Added publish config

* Updated imports in site

* It's actually working

* Don't use debugger in dev for better speeds

* Improved DX when editing packages

* Set up eslint with husky

* Updated prettier config

* Added prettier setup to every package

* Moved bigcommerce

* Moved Bigcommerce to src and package updates

* Updated setup of bigcommerce

* Moved definitions script

* Moved commercejs

* Move to src

* Fixed types in commercejs

* Moved kibocommerce

* Moved kibocommerce to src

* Added package/tsconfig to kibocommerce

* Fixed imports and other things

* Moved ordercloud

* Moved ordercloud to src

* Fixed imports

* Added missing prettier files

* Moved Saleor

* Moved Saleor to src

* Fixed imports

* Replaced all imports to @commerce

* Added prettierignore/rc to all providers

* Moved shopify to src

* Build shopify in packages

* Moved Spree

* Moved spree to src

* Updated spree

* Moved swell

* Moved swell to src

* Fixed type imports in swell

* Moved Vendure to packages

* Moved vendure to src

* Fixed imports in vendure

* Added codegen to saleor

* Updated codegen setup for shopify

* Added codegen to vendure

* Added codegen to kibocommerce

* Added all packages to site's deps

* Updated codegen setup in bigcommerce

* Minor fixes

* Updated providers' names in site

* Updated packages based on Bel's changes

* Updated turbo to latest

* Fixed ts complains

* Set npm engine in root

* New lockfile install

* remove engines

* Regen lockfile

* Switched from npm to yarn

* Updated typesVersions in all packages

* Moved dep

* Updated SWR to the just released 1.2.0

* Removed "isolatedModules" from packages

* Updated list of providers and default

* Updated swell declaration

* Removed next import from kibocommerce

* Added COMMERCE_PROVIDER log

* Added another log

* Updated turbo config

* Updated docs

* Removed test logs

Co-authored-by: Jared Palmer <jared@jaredpalmer.com>
2022-02-01 14:14:05 -05:00

3258 lines
90 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

export type Maybe<T> = T | null
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]> }
/** All built-in and custom scalars, mapped to their actual values */
export type Scalars = {
ID: string
String: string
Boolean: boolean
Int: number
Float: number
/** The `JSON` scalar type represents JSON values as specified by [ECMA-404](http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf). */
JSON: any
/** A date-time string at UTC, such as 2007-12-03T10:15:30Z, compliant with the `date-time` format outlined in section 5.6 of the RFC 3339 profile of the ISO 8601 standard for representation of dates and times using the Gregorian calendar. */
DateTime: any
/** The `Upload` scalar type represents a file upload. */
Upload: any
}
export type Query = {
__typename?: 'Query'
/** The active Channel */
activeChannel: Channel
/** The active Customer */
activeCustomer?: Maybe<Customer>
/**
* The active Order. Will be `null` until an Order is created via `addItemToOrder`. Once an Order reaches the
* state of `PaymentApproved` or `PaymentSettled`, then that Order is no longer considered "active" and this
* query will once again return `null`.
*/
activeOrder?: Maybe<Order>
/** An array of supported Countries */
availableCountries: Array<Country>
/** A list of Collections available to the shop */
collections: CollectionList
/** Returns a Collection either by its id or slug. If neither 'id' nor 'slug' is speicified, an error will result. */
collection?: Maybe<Collection>
/** Returns a list of eligible shipping methods based on the current active Order */
eligibleShippingMethods: Array<ShippingMethodQuote>
/** Returns a list of payment methods and their eligibility based on the current active Order */
eligiblePaymentMethods: Array<PaymentMethodQuote>
/** Returns information about the current authenticated User */
me?: Maybe<CurrentUser>
/** Returns the possible next states that the activeOrder can transition to */
nextOrderStates: Array<Scalars['String']>
/**
* Returns an Order based on the id. Note that in the Shop API, only orders belonging to the
* currently-authenticated User may be queried.
*/
order?: Maybe<Order>
/**
* Returns an Order based on the order `code`. For guest Orders (i.e. Orders placed by non-authenticated Customers)
* this query will only return the Order within 2 hours of the Order being placed. This allows an Order confirmation
* screen to be shown immediately after completion of a guest checkout, yet prevents security risks of allowing
* general anonymous access to Order data.
*/
orderByCode?: Maybe<Order>
/** Get a Product either by id or slug. If neither 'id' nor 'slug' is speicified, an error will result. */
product?: Maybe<Product>
/** Get a list of Products */
products: ProductList
/** Search Products based on the criteria set by the `SearchInput` */
search: SearchResponse
}
export type QueryCollectionsArgs = {
options?: Maybe<CollectionListOptions>
}
export type QueryCollectionArgs = {
id?: Maybe<Scalars['ID']>
slug?: Maybe<Scalars['String']>
}
export type QueryOrderArgs = {
id: Scalars['ID']
}
export type QueryOrderByCodeArgs = {
code: Scalars['String']
}
export type QueryProductArgs = {
id?: Maybe<Scalars['ID']>
slug?: Maybe<Scalars['String']>
}
export type QueryProductsArgs = {
options?: Maybe<ProductListOptions>
}
export type QuerySearchArgs = {
input: SearchInput
}
export type Mutation = {
__typename?: 'Mutation'
/** Adds an item to the order. If custom fields are defined on the OrderLine entity, a third argument 'customFields' will be available. */
addItemToOrder: UpdateOrderItemsResult
/** Remove an OrderLine from the Order */
removeOrderLine: RemoveOrderItemsResult
/** Remove all OrderLine from the Order */
removeAllOrderLines: RemoveOrderItemsResult
/** Adjusts an OrderLine. If custom fields are defined on the OrderLine entity, a third argument 'customFields' of type `OrderLineCustomFieldsInput` will be available. */
adjustOrderLine: UpdateOrderItemsResult
/** Applies the given coupon code to the active Order */
applyCouponCode: ApplyCouponCodeResult
/** Removes the given coupon code from the active Order */
removeCouponCode?: Maybe<Order>
/** Transitions an Order to a new state. Valid next states can be found by querying `nextOrderStates` */
transitionOrderToState?: Maybe<TransitionOrderToStateResult>
/** Sets the shipping address for this order */
setOrderShippingAddress: ActiveOrderResult
/** Sets the billing address for this order */
setOrderBillingAddress: ActiveOrderResult
/** Allows any custom fields to be set for the active order */
setOrderCustomFields: ActiveOrderResult
/** Sets the shipping method by id, which can be obtained with the `eligibleShippingMethods` query */
setOrderShippingMethod: SetOrderShippingMethodResult
/** Add a Payment to the Order */
addPaymentToOrder: AddPaymentToOrderResult
/** Set the Customer for the Order. Required only if the Customer is not currently logged in */
setCustomerForOrder: SetCustomerForOrderResult
/** Authenticates the user using the native authentication strategy. This mutation is an alias for `authenticate({ native: { ... }})` */
login: NativeAuthenticationResult
/** Authenticates the user using a named authentication strategy */
authenticate: AuthenticationResult
/** End the current authenticated session */
logout: Success
/**
* Register a Customer account with the given credentials. There are three possible registration flows:
*
* _If `authOptions.requireVerification` is set to `true`:_
*
* 1. **The Customer is registered _with_ a password**. A verificationToken will be created (and typically emailed to the Customer). That
* verificationToken would then be passed to the `verifyCustomerAccount` mutation _without_ a password. The Customer is then
* verified and authenticated in one step.
* 2. **The Customer is registered _without_ a password**. A verificationToken will be created (and typically emailed to the Customer). That
* verificationToken would then be passed to the `verifyCustomerAccount` mutation _with_ the chosed password of the Customer. The Customer is then
* verified and authenticated in one step.
*
* _If `authOptions.requireVerification` is set to `false`:_
*
* 3. The Customer _must_ be registered _with_ a password. No further action is needed - the Customer is able to authenticate immediately.
*/
registerCustomerAccount: RegisterCustomerAccountResult
/** Regenerate and send a verification token for a new Customer registration. Only applicable if `authOptions.requireVerification` is set to true. */
refreshCustomerVerification: RefreshCustomerVerificationResult
/** Update an existing Customer */
updateCustomer: Customer
/** Create a new Customer Address */
createCustomerAddress: Address
/** Update an existing Address */
updateCustomerAddress: Address
/** Delete an existing Address */
deleteCustomerAddress: Success
/**
* Verify a Customer email address with the token sent to that address. Only applicable if `authOptions.requireVerification` is set to true.
*
* If the Customer was not registered with a password in the `registerCustomerAccount` mutation, the a password _must_ be
* provided here.
*/
verifyCustomerAccount: VerifyCustomerAccountResult
/** Update the password of the active Customer */
updateCustomerPassword: UpdateCustomerPasswordResult
/**
* Request to update the emailAddress of the active Customer. If `authOptions.requireVerification` is enabled
* (as is the default), then the `identifierChangeToken` will be assigned to the current User and
* a IdentifierChangeRequestEvent will be raised. This can then be used e.g. by the EmailPlugin to email
* that verification token to the Customer, which is then used to verify the change of email address.
*/
requestUpdateCustomerEmailAddress: RequestUpdateCustomerEmailAddressResult
/**
* Confirm the update of the emailAddress with the provided token, which has been generated by the
* `requestUpdateCustomerEmailAddress` mutation.
*/
updateCustomerEmailAddress: UpdateCustomerEmailAddressResult
/** Requests a password reset email to be sent */
requestPasswordReset?: Maybe<RequestPasswordResetResult>
/** Resets a Customer's password based on the provided token */
resetPassword: ResetPasswordResult
}
export type MutationAddItemToOrderArgs = {
productVariantId: Scalars['ID']
quantity: Scalars['Int']
}
export type MutationRemoveOrderLineArgs = {
orderLineId: Scalars['ID']
}
export type MutationAdjustOrderLineArgs = {
orderLineId: Scalars['ID']
quantity: Scalars['Int']
}
export type MutationApplyCouponCodeArgs = {
couponCode: Scalars['String']
}
export type MutationRemoveCouponCodeArgs = {
couponCode: Scalars['String']
}
export type MutationTransitionOrderToStateArgs = {
state: Scalars['String']
}
export type MutationSetOrderShippingAddressArgs = {
input: CreateAddressInput
}
export type MutationSetOrderBillingAddressArgs = {
input: CreateAddressInput
}
export type MutationSetOrderCustomFieldsArgs = {
input: UpdateOrderInput
}
export type MutationSetOrderShippingMethodArgs = {
shippingMethodId: Scalars['ID']
}
export type MutationAddPaymentToOrderArgs = {
input: PaymentInput
}
export type MutationSetCustomerForOrderArgs = {
input: CreateCustomerInput
}
export type MutationLoginArgs = {
username: Scalars['String']
password: Scalars['String']
rememberMe?: Maybe<Scalars['Boolean']>
}
export type MutationAuthenticateArgs = {
input: AuthenticationInput
rememberMe?: Maybe<Scalars['Boolean']>
}
export type MutationRegisterCustomerAccountArgs = {
input: RegisterCustomerInput
}
export type MutationRefreshCustomerVerificationArgs = {
emailAddress: Scalars['String']
}
export type MutationUpdateCustomerArgs = {
input: UpdateCustomerInput
}
export type MutationCreateCustomerAddressArgs = {
input: CreateAddressInput
}
export type MutationUpdateCustomerAddressArgs = {
input: UpdateAddressInput
}
export type MutationDeleteCustomerAddressArgs = {
id: Scalars['ID']
}
export type MutationVerifyCustomerAccountArgs = {
token: Scalars['String']
password?: Maybe<Scalars['String']>
}
export type MutationUpdateCustomerPasswordArgs = {
currentPassword: Scalars['String']
newPassword: Scalars['String']
}
export type MutationRequestUpdateCustomerEmailAddressArgs = {
password: Scalars['String']
newEmailAddress: Scalars['String']
}
export type MutationUpdateCustomerEmailAddressArgs = {
token: Scalars['String']
}
export type MutationRequestPasswordResetArgs = {
emailAddress: Scalars['String']
}
export type MutationResetPasswordArgs = {
token: Scalars['String']
password: Scalars['String']
}
export type Address = Node & {
__typename?: 'Address'
id: Scalars['ID']
createdAt: Scalars['DateTime']
updatedAt: Scalars['DateTime']
fullName?: Maybe<Scalars['String']>
company?: Maybe<Scalars['String']>
streetLine1: Scalars['String']
streetLine2?: Maybe<Scalars['String']>
city?: Maybe<Scalars['String']>
province?: Maybe<Scalars['String']>
postalCode?: Maybe<Scalars['String']>
country: Country
phoneNumber?: Maybe<Scalars['String']>
defaultShippingAddress?: Maybe<Scalars['Boolean']>
defaultBillingAddress?: Maybe<Scalars['Boolean']>
customFields?: Maybe<Scalars['JSON']>
}
export type Asset = Node & {
__typename?: 'Asset'
id: Scalars['ID']
createdAt: Scalars['DateTime']
updatedAt: Scalars['DateTime']
name: Scalars['String']
type: AssetType
fileSize: Scalars['Int']
mimeType: Scalars['String']
width: Scalars['Int']
height: Scalars['Int']
source: Scalars['String']
preview: Scalars['String']
focalPoint?: Maybe<Coordinate>
customFields?: Maybe<Scalars['JSON']>
}
export type Coordinate = {
__typename?: 'Coordinate'
x: Scalars['Float']
y: Scalars['Float']
}
export type AssetList = PaginatedList & {
__typename?: 'AssetList'
items: Array<Asset>
totalItems: Scalars['Int']
}
export enum AssetType {
Image = 'IMAGE',
Video = 'VIDEO',
Binary = 'BINARY',
}
export type CurrentUser = {
__typename?: 'CurrentUser'
id: Scalars['ID']
identifier: Scalars['String']
channels: Array<CurrentUserChannel>
}
export type CurrentUserChannel = {
__typename?: 'CurrentUserChannel'
id: Scalars['ID']
token: Scalars['String']
code: Scalars['String']
permissions: Array<Permission>
}
export type Channel = Node & {
__typename?: 'Channel'
id: Scalars['ID']
createdAt: Scalars['DateTime']
updatedAt: Scalars['DateTime']
code: Scalars['String']
token: Scalars['String']
defaultTaxZone?: Maybe<Zone>
defaultShippingZone?: Maybe<Zone>
defaultLanguageCode: LanguageCode
currencyCode: CurrencyCode
pricesIncludeTax: Scalars['Boolean']
customFields?: Maybe<Scalars['JSON']>
}
export type Collection = Node & {
__typename?: 'Collection'
id: Scalars['ID']
createdAt: Scalars['DateTime']
updatedAt: Scalars['DateTime']
languageCode?: Maybe<LanguageCode>
name: Scalars['String']
slug: Scalars['String']
breadcrumbs: Array<CollectionBreadcrumb>
position: Scalars['Int']
description: Scalars['String']
featuredAsset?: Maybe<Asset>
assets: Array<Asset>
parent?: Maybe<Collection>
children?: Maybe<Array<Collection>>
filters: Array<ConfigurableOperation>
translations: Array<CollectionTranslation>
productVariants: ProductVariantList
customFields?: Maybe<Scalars['JSON']>
}
export type CollectionProductVariantsArgs = {
options?: Maybe<ProductVariantListOptions>
}
export type CollectionBreadcrumb = {
__typename?: 'CollectionBreadcrumb'
id: Scalars['ID']
name: Scalars['String']
slug: Scalars['String']
}
export type CollectionTranslation = {
__typename?: 'CollectionTranslation'
id: Scalars['ID']
createdAt: Scalars['DateTime']
updatedAt: Scalars['DateTime']
languageCode: LanguageCode
name: Scalars['String']
slug: Scalars['String']
description: Scalars['String']
}
export type CollectionList = PaginatedList & {
__typename?: 'CollectionList'
items: Array<Collection>
totalItems: Scalars['Int']
}
export type ProductVariantList = PaginatedList & {
__typename?: 'ProductVariantList'
items: Array<ProductVariant>
totalItems: Scalars['Int']
}
export type ProductVariantListOptions = {
skip?: Maybe<Scalars['Int']>
take?: Maybe<Scalars['Int']>
sort?: Maybe<ProductVariantSortParameter>
filter?: Maybe<ProductVariantFilterParameter>
}
export enum GlobalFlag {
True = 'TRUE',
False = 'FALSE',
Inherit = 'INHERIT',
}
export enum AdjustmentType {
Promotion = 'PROMOTION',
DistributedOrderPromotion = 'DISTRIBUTED_ORDER_PROMOTION',
}
export enum DeletionResult {
/** The entity was successfully deleted */
Deleted = 'DELETED',
/** Deletion did not take place, reason given in message */
NotDeleted = 'NOT_DELETED',
}
/**
* @description
* Permissions for administrators and customers. Used to control access to
* GraphQL resolvers via the {@link Allow} decorator.
*
* @docsCategory common
*/
export enum Permission {
Placeholder = 'Placeholder',
/** Authenticated means simply that the user is logged in */
Authenticated = 'Authenticated',
/** SuperAdmin has unrestricted access to all operations */
SuperAdmin = 'SuperAdmin',
/** Owner means the user owns this entity, e.g. a Customer's own Order */
Owner = 'Owner',
/** Public means any unauthenticated user may perform the operation */
Public = 'Public',
/** Grants permission to update GlobalSettings */
UpdateGlobalSettings = 'UpdateGlobalSettings',
/** Grants permission to create Products, Facets, Assets, Collections */
CreateCatalog = 'CreateCatalog',
/** Grants permission to read Products, Facets, Assets, Collections */
ReadCatalog = 'ReadCatalog',
/** Grants permission to update Products, Facets, Assets, Collections */
UpdateCatalog = 'UpdateCatalog',
/** Grants permission to delete Products, Facets, Assets, Collections */
DeleteCatalog = 'DeleteCatalog',
/** Grants permission to create PaymentMethods, ShippingMethods, TaxCategories, TaxRates, Zones, Countries, System & GlobalSettings */
CreateSettings = 'CreateSettings',
/** Grants permission to read PaymentMethods, ShippingMethods, TaxCategories, TaxRates, Zones, Countries, System & GlobalSettings */
ReadSettings = 'ReadSettings',
/** Grants permission to update PaymentMethods, ShippingMethods, TaxCategories, TaxRates, Zones, Countries, System & GlobalSettings */
UpdateSettings = 'UpdateSettings',
/** Grants permission to delete PaymentMethods, ShippingMethods, TaxCategories, TaxRates, Zones, Countries, System & GlobalSettings */
DeleteSettings = 'DeleteSettings',
/** Grants permission to create Administrator */
CreateAdministrator = 'CreateAdministrator',
/** Grants permission to read Administrator */
ReadAdministrator = 'ReadAdministrator',
/** Grants permission to update Administrator */
UpdateAdministrator = 'UpdateAdministrator',
/** Grants permission to delete Administrator */
DeleteAdministrator = 'DeleteAdministrator',
/** Grants permission to create Asset */
CreateAsset = 'CreateAsset',
/** Grants permission to read Asset */
ReadAsset = 'ReadAsset',
/** Grants permission to update Asset */
UpdateAsset = 'UpdateAsset',
/** Grants permission to delete Asset */
DeleteAsset = 'DeleteAsset',
/** Grants permission to create Channel */
CreateChannel = 'CreateChannel',
/** Grants permission to read Channel */
ReadChannel = 'ReadChannel',
/** Grants permission to update Channel */
UpdateChannel = 'UpdateChannel',
/** Grants permission to delete Channel */
DeleteChannel = 'DeleteChannel',
/** Grants permission to create Collection */
CreateCollection = 'CreateCollection',
/** Grants permission to read Collection */
ReadCollection = 'ReadCollection',
/** Grants permission to update Collection */
UpdateCollection = 'UpdateCollection',
/** Grants permission to delete Collection */
DeleteCollection = 'DeleteCollection',
/** Grants permission to create Country */
CreateCountry = 'CreateCountry',
/** Grants permission to read Country */
ReadCountry = 'ReadCountry',
/** Grants permission to update Country */
UpdateCountry = 'UpdateCountry',
/** Grants permission to delete Country */
DeleteCountry = 'DeleteCountry',
/** Grants permission to create Customer */
CreateCustomer = 'CreateCustomer',
/** Grants permission to read Customer */
ReadCustomer = 'ReadCustomer',
/** Grants permission to update Customer */
UpdateCustomer = 'UpdateCustomer',
/** Grants permission to delete Customer */
DeleteCustomer = 'DeleteCustomer',
/** Grants permission to create CustomerGroup */
CreateCustomerGroup = 'CreateCustomerGroup',
/** Grants permission to read CustomerGroup */
ReadCustomerGroup = 'ReadCustomerGroup',
/** Grants permission to update CustomerGroup */
UpdateCustomerGroup = 'UpdateCustomerGroup',
/** Grants permission to delete CustomerGroup */
DeleteCustomerGroup = 'DeleteCustomerGroup',
/** Grants permission to create Facet */
CreateFacet = 'CreateFacet',
/** Grants permission to read Facet */
ReadFacet = 'ReadFacet',
/** Grants permission to update Facet */
UpdateFacet = 'UpdateFacet',
/** Grants permission to delete Facet */
DeleteFacet = 'DeleteFacet',
/** Grants permission to create Order */
CreateOrder = 'CreateOrder',
/** Grants permission to read Order */
ReadOrder = 'ReadOrder',
/** Grants permission to update Order */
UpdateOrder = 'UpdateOrder',
/** Grants permission to delete Order */
DeleteOrder = 'DeleteOrder',
/** Grants permission to create PaymentMethod */
CreatePaymentMethod = 'CreatePaymentMethod',
/** Grants permission to read PaymentMethod */
ReadPaymentMethod = 'ReadPaymentMethod',
/** Grants permission to update PaymentMethod */
UpdatePaymentMethod = 'UpdatePaymentMethod',
/** Grants permission to delete PaymentMethod */
DeletePaymentMethod = 'DeletePaymentMethod',
/** Grants permission to create Product */
CreateProduct = 'CreateProduct',
/** Grants permission to read Product */
ReadProduct = 'ReadProduct',
/** Grants permission to update Product */
UpdateProduct = 'UpdateProduct',
/** Grants permission to delete Product */
DeleteProduct = 'DeleteProduct',
/** Grants permission to create Promotion */
CreatePromotion = 'CreatePromotion',
/** Grants permission to read Promotion */
ReadPromotion = 'ReadPromotion',
/** Grants permission to update Promotion */
UpdatePromotion = 'UpdatePromotion',
/** Grants permission to delete Promotion */
DeletePromotion = 'DeletePromotion',
/** Grants permission to create ShippingMethod */
CreateShippingMethod = 'CreateShippingMethod',
/** Grants permission to read ShippingMethod */
ReadShippingMethod = 'ReadShippingMethod',
/** Grants permission to update ShippingMethod */
UpdateShippingMethod = 'UpdateShippingMethod',
/** Grants permission to delete ShippingMethod */
DeleteShippingMethod = 'DeleteShippingMethod',
/** Grants permission to create Tag */
CreateTag = 'CreateTag',
/** Grants permission to read Tag */
ReadTag = 'ReadTag',
/** Grants permission to update Tag */
UpdateTag = 'UpdateTag',
/** Grants permission to delete Tag */
DeleteTag = 'DeleteTag',
/** Grants permission to create TaxCategory */
CreateTaxCategory = 'CreateTaxCategory',
/** Grants permission to read TaxCategory */
ReadTaxCategory = 'ReadTaxCategory',
/** Grants permission to update TaxCategory */
UpdateTaxCategory = 'UpdateTaxCategory',
/** Grants permission to delete TaxCategory */
DeleteTaxCategory = 'DeleteTaxCategory',
/** Grants permission to create TaxRate */
CreateTaxRate = 'CreateTaxRate',
/** Grants permission to read TaxRate */
ReadTaxRate = 'ReadTaxRate',
/** Grants permission to update TaxRate */
UpdateTaxRate = 'UpdateTaxRate',
/** Grants permission to delete TaxRate */
DeleteTaxRate = 'DeleteTaxRate',
/** Grants permission to create System */
CreateSystem = 'CreateSystem',
/** Grants permission to read System */
ReadSystem = 'ReadSystem',
/** Grants permission to update System */
UpdateSystem = 'UpdateSystem',
/** Grants permission to delete System */
DeleteSystem = 'DeleteSystem',
/** Grants permission to create Zone */
CreateZone = 'CreateZone',
/** Grants permission to read Zone */
ReadZone = 'ReadZone',
/** Grants permission to update Zone */
UpdateZone = 'UpdateZone',
/** Grants permission to delete Zone */
DeleteZone = 'DeleteZone',
}
export enum SortOrder {
Asc = 'ASC',
Desc = 'DESC',
}
export enum ErrorCode {
UnknownError = 'UNKNOWN_ERROR',
NativeAuthStrategyError = 'NATIVE_AUTH_STRATEGY_ERROR',
InvalidCredentialsError = 'INVALID_CREDENTIALS_ERROR',
OrderStateTransitionError = 'ORDER_STATE_TRANSITION_ERROR',
EmailAddressConflictError = 'EMAIL_ADDRESS_CONFLICT_ERROR',
OrderLimitError = 'ORDER_LIMIT_ERROR',
NegativeQuantityError = 'NEGATIVE_QUANTITY_ERROR',
InsufficientStockError = 'INSUFFICIENT_STOCK_ERROR',
OrderModificationError = 'ORDER_MODIFICATION_ERROR',
IneligibleShippingMethodError = 'INELIGIBLE_SHIPPING_METHOD_ERROR',
OrderPaymentStateError = 'ORDER_PAYMENT_STATE_ERROR',
IneligiblePaymentMethodError = 'INELIGIBLE_PAYMENT_METHOD_ERROR',
PaymentFailedError = 'PAYMENT_FAILED_ERROR',
PaymentDeclinedError = 'PAYMENT_DECLINED_ERROR',
CouponCodeInvalidError = 'COUPON_CODE_INVALID_ERROR',
CouponCodeExpiredError = 'COUPON_CODE_EXPIRED_ERROR',
CouponCodeLimitError = 'COUPON_CODE_LIMIT_ERROR',
AlreadyLoggedInError = 'ALREADY_LOGGED_IN_ERROR',
MissingPasswordError = 'MISSING_PASSWORD_ERROR',
PasswordAlreadySetError = 'PASSWORD_ALREADY_SET_ERROR',
VerificationTokenInvalidError = 'VERIFICATION_TOKEN_INVALID_ERROR',
VerificationTokenExpiredError = 'VERIFICATION_TOKEN_EXPIRED_ERROR',
IdentifierChangeTokenInvalidError = 'IDENTIFIER_CHANGE_TOKEN_INVALID_ERROR',
IdentifierChangeTokenExpiredError = 'IDENTIFIER_CHANGE_TOKEN_EXPIRED_ERROR',
PasswordResetTokenInvalidError = 'PASSWORD_RESET_TOKEN_INVALID_ERROR',
PasswordResetTokenExpiredError = 'PASSWORD_RESET_TOKEN_EXPIRED_ERROR',
NotVerifiedError = 'NOT_VERIFIED_ERROR',
NoActiveOrderError = 'NO_ACTIVE_ORDER_ERROR',
}
export enum LogicalOperator {
And = 'AND',
Or = 'OR',
}
/** Retured when attempting an operation that relies on the NativeAuthStrategy, if that strategy is not configured. */
export type NativeAuthStrategyError = ErrorResult & {
__typename?: 'NativeAuthStrategyError'
errorCode: ErrorCode
message: Scalars['String']
}
/** Returned if the user authentication credentials are not valid */
export type InvalidCredentialsError = ErrorResult & {
__typename?: 'InvalidCredentialsError'
errorCode: ErrorCode
message: Scalars['String']
authenticationError: Scalars['String']
}
/** Returned if there is an error in transitioning the Order state */
export type OrderStateTransitionError = ErrorResult & {
__typename?: 'OrderStateTransitionError'
errorCode: ErrorCode
message: Scalars['String']
transitionError: Scalars['String']
fromState: Scalars['String']
toState: Scalars['String']
}
/** Retured when attemting to create a Customer with an email address already registered to an existing User. */
export type EmailAddressConflictError = ErrorResult & {
__typename?: 'EmailAddressConflictError'
errorCode: ErrorCode
message: Scalars['String']
}
/** Retured when the maximum order size limit has been reached. */
export type OrderLimitError = ErrorResult & {
__typename?: 'OrderLimitError'
errorCode: ErrorCode
message: Scalars['String']
maxItems: Scalars['Int']
}
/** Retured when attemting to set a negative OrderLine quantity. */
export type NegativeQuantityError = ErrorResult & {
__typename?: 'NegativeQuantityError'
errorCode: ErrorCode
message: Scalars['String']
}
/** Returned when attempting to add more items to the Order than are available */
export type InsufficientStockError = ErrorResult & {
__typename?: 'InsufficientStockError'
errorCode: ErrorCode
message: Scalars['String']
quantityAvailable: Scalars['Int']
order: Order
}
export type PaginatedList = {
items: Array<Node>
totalItems: Scalars['Int']
}
export type Node = {
id: Scalars['ID']
}
export type ErrorResult = {
errorCode: ErrorCode
message: Scalars['String']
}
export type Adjustment = {
__typename?: 'Adjustment'
adjustmentSource: Scalars['String']
type: AdjustmentType
description: Scalars['String']
amount: Scalars['Int']
}
export type TaxLine = {
__typename?: 'TaxLine'
description: Scalars['String']
taxRate: Scalars['Float']
}
export type ConfigArg = {
__typename?: 'ConfigArg'
name: Scalars['String']
value: Scalars['String']
}
export type ConfigArgDefinition = {
__typename?: 'ConfigArgDefinition'
name: Scalars['String']
type: Scalars['String']
list: Scalars['Boolean']
required: Scalars['Boolean']
defaultValue?: Maybe<Scalars['JSON']>
label?: Maybe<Scalars['String']>
description?: Maybe<Scalars['String']>
ui?: Maybe<Scalars['JSON']>
}
export type ConfigurableOperation = {
__typename?: 'ConfigurableOperation'
code: Scalars['String']
args: Array<ConfigArg>
}
export type ConfigurableOperationDefinition = {
__typename?: 'ConfigurableOperationDefinition'
code: Scalars['String']
args: Array<ConfigArgDefinition>
description: Scalars['String']
}
export type DeletionResponse = {
__typename?: 'DeletionResponse'
result: DeletionResult
message?: Maybe<Scalars['String']>
}
export type ConfigArgInput = {
name: Scalars['String']
/** A JSON stringified representation of the actual value */
value: Scalars['String']
}
export type ConfigurableOperationInput = {
code: Scalars['String']
arguments: Array<ConfigArgInput>
}
export type StringOperators = {
eq?: Maybe<Scalars['String']>
notEq?: Maybe<Scalars['String']>
contains?: Maybe<Scalars['String']>
notContains?: Maybe<Scalars['String']>
in?: Maybe<Array<Scalars['String']>>
notIn?: Maybe<Array<Scalars['String']>>
regex?: Maybe<Scalars['String']>
}
export type BooleanOperators = {
eq?: Maybe<Scalars['Boolean']>
}
export type NumberRange = {
start: Scalars['Float']
end: Scalars['Float']
}
export type NumberOperators = {
eq?: Maybe<Scalars['Float']>
lt?: Maybe<Scalars['Float']>
lte?: Maybe<Scalars['Float']>
gt?: Maybe<Scalars['Float']>
gte?: Maybe<Scalars['Float']>
between?: Maybe<NumberRange>
}
export type DateRange = {
start: Scalars['DateTime']
end: Scalars['DateTime']
}
export type DateOperators = {
eq?: Maybe<Scalars['DateTime']>
before?: Maybe<Scalars['DateTime']>
after?: Maybe<Scalars['DateTime']>
between?: Maybe<DateRange>
}
/**
* Used to construct boolean expressions for filtering search results
* by FacetValue ID. Examples:
*
* * ID=1 OR ID=2: `{ facetValueFilters: [{ or: [1,2] }] }`
* * ID=1 AND ID=2: `{ facetValueFilters: [{ and: 1 }, { and: 2 }] }`
* * ID=1 AND (ID=2 OR ID=3): `{ facetValueFilters: [{ and: 1 }, { or: [2,3] }] }`
*/
export type FacetValueFilterInput = {
and?: Maybe<Scalars['ID']>
or?: Maybe<Array<Scalars['ID']>>
}
export type SearchInput = {
term?: Maybe<Scalars['String']>
facetValueIds?: Maybe<Array<Scalars['ID']>>
facetValueOperator?: Maybe<LogicalOperator>
facetValueFilters?: Maybe<Array<FacetValueFilterInput>>
collectionId?: Maybe<Scalars['ID']>
collectionSlug?: Maybe<Scalars['String']>
groupByProduct?: Maybe<Scalars['Boolean']>
take?: Maybe<Scalars['Int']>
skip?: Maybe<Scalars['Int']>
sort?: Maybe<SearchResultSortParameter>
}
export type SearchResultSortParameter = {
name?: Maybe<SortOrder>
price?: Maybe<SortOrder>
}
export type CreateCustomerInput = {
title?: Maybe<Scalars['String']>
firstName: Scalars['String']
lastName: Scalars['String']
phoneNumber?: Maybe<Scalars['String']>
emailAddress: Scalars['String']
customFields?: Maybe<Scalars['JSON']>
}
export type CreateAddressInput = {
fullName?: Maybe<Scalars['String']>
company?: Maybe<Scalars['String']>
streetLine1: Scalars['String']
streetLine2?: Maybe<Scalars['String']>
city?: Maybe<Scalars['String']>
province?: Maybe<Scalars['String']>
postalCode?: Maybe<Scalars['String']>
countryCode: Scalars['String']
phoneNumber?: Maybe<Scalars['String']>
defaultShippingAddress?: Maybe<Scalars['Boolean']>
defaultBillingAddress?: Maybe<Scalars['Boolean']>
customFields?: Maybe<Scalars['JSON']>
}
export type UpdateAddressInput = {
id: Scalars['ID']
fullName?: Maybe<Scalars['String']>
company?: Maybe<Scalars['String']>
streetLine1?: Maybe<Scalars['String']>
streetLine2?: Maybe<Scalars['String']>
city?: Maybe<Scalars['String']>
province?: Maybe<Scalars['String']>
postalCode?: Maybe<Scalars['String']>
countryCode?: Maybe<Scalars['String']>
phoneNumber?: Maybe<Scalars['String']>
defaultShippingAddress?: Maybe<Scalars['Boolean']>
defaultBillingAddress?: Maybe<Scalars['Boolean']>
customFields?: Maybe<Scalars['JSON']>
}
/** Indicates that an operation succeeded, where we do not want to return any more specific information. */
export type Success = {
__typename?: 'Success'
success: Scalars['Boolean']
}
export type ShippingMethodQuote = {
__typename?: 'ShippingMethodQuote'
id: Scalars['ID']
price: Scalars['Int']
priceWithTax: Scalars['Int']
code: Scalars['String']
name: Scalars['String']
description: Scalars['String']
/** Any optional metadata returned by the ShippingCalculator in the ShippingCalculationResult */
metadata?: Maybe<Scalars['JSON']>
}
export type PaymentMethodQuote = {
__typename?: 'PaymentMethodQuote'
id: Scalars['ID']
code: Scalars['String']
name: Scalars['String']
description: Scalars['String']
isEligible: Scalars['Boolean']
eligibilityMessage?: Maybe<Scalars['String']>
}
export type Country = Node & {
__typename?: 'Country'
id: Scalars['ID']
createdAt: Scalars['DateTime']
updatedAt: Scalars['DateTime']
languageCode: LanguageCode
code: Scalars['String']
name: Scalars['String']
enabled: Scalars['Boolean']
translations: Array<CountryTranslation>
}
export type CountryTranslation = {
__typename?: 'CountryTranslation'
id: Scalars['ID']
createdAt: Scalars['DateTime']
updatedAt: Scalars['DateTime']
languageCode: LanguageCode
name: Scalars['String']
}
export type CountryList = PaginatedList & {
__typename?: 'CountryList'
items: Array<Country>
totalItems: Scalars['Int']
}
/**
* @description
* ISO 4217 currency code
*
* @docsCategory common
*/
export enum CurrencyCode {
/** United Arab Emirates dirham */
Aed = 'AED',
/** Afghan afghani */
Afn = 'AFN',
/** Albanian lek */
All = 'ALL',
/** Armenian dram */
Amd = 'AMD',
/** Netherlands Antillean guilder */
Ang = 'ANG',
/** Angolan kwanza */
Aoa = 'AOA',
/** Argentine peso */
Ars = 'ARS',
/** Australian dollar */
Aud = 'AUD',
/** Aruban florin */
Awg = 'AWG',
/** Azerbaijani manat */
Azn = 'AZN',
/** Bosnia and Herzegovina convertible mark */
Bam = 'BAM',
/** Barbados dollar */
Bbd = 'BBD',
/** Bangladeshi taka */
Bdt = 'BDT',
/** Bulgarian lev */
Bgn = 'BGN',
/** Bahraini dinar */
Bhd = 'BHD',
/** Burundian franc */
Bif = 'BIF',
/** Bermudian dollar */
Bmd = 'BMD',
/** Brunei dollar */
Bnd = 'BND',
/** Boliviano */
Bob = 'BOB',
/** Brazilian real */
Brl = 'BRL',
/** Bahamian dollar */
Bsd = 'BSD',
/** Bhutanese ngultrum */
Btn = 'BTN',
/** Botswana pula */
Bwp = 'BWP',
/** Belarusian ruble */
Byn = 'BYN',
/** Belize dollar */
Bzd = 'BZD',
/** Canadian dollar */
Cad = 'CAD',
/** Congolese franc */
Cdf = 'CDF',
/** Swiss franc */
Chf = 'CHF',
/** Chilean peso */
Clp = 'CLP',
/** Renminbi (Chinese) yuan */
Cny = 'CNY',
/** Colombian peso */
Cop = 'COP',
/** Costa Rican colon */
Crc = 'CRC',
/** Cuban convertible peso */
Cuc = 'CUC',
/** Cuban peso */
Cup = 'CUP',
/** Cape Verde escudo */
Cve = 'CVE',
/** Czech koruna */
Czk = 'CZK',
/** Djiboutian franc */
Djf = 'DJF',
/** Danish krone */
Dkk = 'DKK',
/** Dominican peso */
Dop = 'DOP',
/** Algerian dinar */
Dzd = 'DZD',
/** Egyptian pound */
Egp = 'EGP',
/** Eritrean nakfa */
Ern = 'ERN',
/** Ethiopian birr */
Etb = 'ETB',
/** Euro */
Eur = 'EUR',
/** Fiji dollar */
Fjd = 'FJD',
/** Falkland Islands pound */
Fkp = 'FKP',
/** Pound sterling */
Gbp = 'GBP',
/** Georgian lari */
Gel = 'GEL',
/** Ghanaian cedi */
Ghs = 'GHS',
/** Gibraltar pound */
Gip = 'GIP',
/** Gambian dalasi */
Gmd = 'GMD',
/** Guinean franc */
Gnf = 'GNF',
/** Guatemalan quetzal */
Gtq = 'GTQ',
/** Guyanese dollar */
Gyd = 'GYD',
/** Hong Kong dollar */
Hkd = 'HKD',
/** Honduran lempira */
Hnl = 'HNL',
/** Croatian kuna */
Hrk = 'HRK',
/** Haitian gourde */
Htg = 'HTG',
/** Hungarian forint */
Huf = 'HUF',
/** Indonesian rupiah */
Idr = 'IDR',
/** Israeli new shekel */
Ils = 'ILS',
/** Indian rupee */
Inr = 'INR',
/** Iraqi dinar */
Iqd = 'IQD',
/** Iranian rial */
Irr = 'IRR',
/** Icelandic króna */
Isk = 'ISK',
/** Jamaican dollar */
Jmd = 'JMD',
/** Jordanian dinar */
Jod = 'JOD',
/** Japanese yen */
Jpy = 'JPY',
/** Kenyan shilling */
Kes = 'KES',
/** Kyrgyzstani som */
Kgs = 'KGS',
/** Cambodian riel */
Khr = 'KHR',
/** Comoro franc */
Kmf = 'KMF',
/** North Korean won */
Kpw = 'KPW',
/** South Korean won */
Krw = 'KRW',
/** Kuwaiti dinar */
Kwd = 'KWD',
/** Cayman Islands dollar */
Kyd = 'KYD',
/** Kazakhstani tenge */
Kzt = 'KZT',
/** Lao kip */
Lak = 'LAK',
/** Lebanese pound */
Lbp = 'LBP',
/** Sri Lankan rupee */
Lkr = 'LKR',
/** Liberian dollar */
Lrd = 'LRD',
/** Lesotho loti */
Lsl = 'LSL',
/** Libyan dinar */
Lyd = 'LYD',
/** Moroccan dirham */
Mad = 'MAD',
/** Moldovan leu */
Mdl = 'MDL',
/** Malagasy ariary */
Mga = 'MGA',
/** Macedonian denar */
Mkd = 'MKD',
/** Myanmar kyat */
Mmk = 'MMK',
/** Mongolian tögrög */
Mnt = 'MNT',
/** Macanese pataca */
Mop = 'MOP',
/** Mauritanian ouguiya */
Mru = 'MRU',
/** Mauritian rupee */
Mur = 'MUR',
/** Maldivian rufiyaa */
Mvr = 'MVR',
/** Malawian kwacha */
Mwk = 'MWK',
/** Mexican peso */
Mxn = 'MXN',
/** Malaysian ringgit */
Myr = 'MYR',
/** Mozambican metical */
Mzn = 'MZN',
/** Namibian dollar */
Nad = 'NAD',
/** Nigerian naira */
Ngn = 'NGN',
/** Nicaraguan córdoba */
Nio = 'NIO',
/** Norwegian krone */
Nok = 'NOK',
/** Nepalese rupee */
Npr = 'NPR',
/** New Zealand dollar */
Nzd = 'NZD',
/** Omani rial */
Omr = 'OMR',
/** Panamanian balboa */
Pab = 'PAB',
/** Peruvian sol */
Pen = 'PEN',
/** Papua New Guinean kina */
Pgk = 'PGK',
/** Philippine peso */
Php = 'PHP',
/** Pakistani rupee */
Pkr = 'PKR',
/** Polish złoty */
Pln = 'PLN',
/** Paraguayan guaraní */
Pyg = 'PYG',
/** Qatari riyal */
Qar = 'QAR',
/** Romanian leu */
Ron = 'RON',
/** Serbian dinar */
Rsd = 'RSD',
/** Russian ruble */
Rub = 'RUB',
/** Rwandan franc */
Rwf = 'RWF',
/** Saudi riyal */
Sar = 'SAR',
/** Solomon Islands dollar */
Sbd = 'SBD',
/** Seychelles rupee */
Scr = 'SCR',
/** Sudanese pound */
Sdg = 'SDG',
/** Swedish krona/kronor */
Sek = 'SEK',
/** Singapore dollar */
Sgd = 'SGD',
/** Saint Helena pound */
Shp = 'SHP',
/** Sierra Leonean leone */
Sll = 'SLL',
/** Somali shilling */
Sos = 'SOS',
/** Surinamese dollar */
Srd = 'SRD',
/** South Sudanese pound */
Ssp = 'SSP',
/** São Tomé and Príncipe dobra */
Stn = 'STN',
/** Salvadoran colón */
Svc = 'SVC',
/** Syrian pound */
Syp = 'SYP',
/** Swazi lilangeni */
Szl = 'SZL',
/** Thai baht */
Thb = 'THB',
/** Tajikistani somoni */
Tjs = 'TJS',
/** Turkmenistan manat */
Tmt = 'TMT',
/** Tunisian dinar */
Tnd = 'TND',
/** Tongan paʻanga */
Top = 'TOP',
/** Turkish lira */
Try = 'TRY',
/** Trinidad and Tobago dollar */
Ttd = 'TTD',
/** New Taiwan dollar */
Twd = 'TWD',
/** Tanzanian shilling */
Tzs = 'TZS',
/** Ukrainian hryvnia */
Uah = 'UAH',
/** Ugandan shilling */
Ugx = 'UGX',
/** United States dollar */
Usd = 'USD',
/** Uruguayan peso */
Uyu = 'UYU',
/** Uzbekistan som */
Uzs = 'UZS',
/** Venezuelan bolívar soberano */
Ves = 'VES',
/** Vietnamese đồng */
Vnd = 'VND',
/** Vanuatu vatu */
Vuv = 'VUV',
/** Samoan tala */
Wst = 'WST',
/** CFA franc BEAC */
Xaf = 'XAF',
/** East Caribbean dollar */
Xcd = 'XCD',
/** CFA franc BCEAO */
Xof = 'XOF',
/** CFP franc (franc Pacifique) */
Xpf = 'XPF',
/** Yemeni rial */
Yer = 'YER',
/** South African rand */
Zar = 'ZAR',
/** Zambian kwacha */
Zmw = 'ZMW',
/** Zimbabwean dollar */
Zwl = 'ZWL',
}
export type CustomField = {
name: Scalars['String']
type: Scalars['String']
list: Scalars['Boolean']
label?: Maybe<Array<LocalizedString>>
description?: Maybe<Array<LocalizedString>>
readonly?: Maybe<Scalars['Boolean']>
internal?: Maybe<Scalars['Boolean']>
}
export type StringCustomFieldConfig = CustomField & {
__typename?: 'StringCustomFieldConfig'
name: Scalars['String']
type: Scalars['String']
list: Scalars['Boolean']
length?: Maybe<Scalars['Int']>
label?: Maybe<Array<LocalizedString>>
description?: Maybe<Array<LocalizedString>>
readonly?: Maybe<Scalars['Boolean']>
internal?: Maybe<Scalars['Boolean']>
pattern?: Maybe<Scalars['String']>
options?: Maybe<Array<StringFieldOption>>
}
export type StringFieldOption = {
__typename?: 'StringFieldOption'
value: Scalars['String']
label?: Maybe<Array<LocalizedString>>
}
export type LocaleStringCustomFieldConfig = CustomField & {
__typename?: 'LocaleStringCustomFieldConfig'
name: Scalars['String']
type: Scalars['String']
list: Scalars['Boolean']
length?: Maybe<Scalars['Int']>
label?: Maybe<Array<LocalizedString>>
description?: Maybe<Array<LocalizedString>>
readonly?: Maybe<Scalars['Boolean']>
internal?: Maybe<Scalars['Boolean']>
pattern?: Maybe<Scalars['String']>
}
export type IntCustomFieldConfig = CustomField & {
__typename?: 'IntCustomFieldConfig'
name: Scalars['String']
type: Scalars['String']
list: Scalars['Boolean']
label?: Maybe<Array<LocalizedString>>
description?: Maybe<Array<LocalizedString>>
readonly?: Maybe<Scalars['Boolean']>
internal?: Maybe<Scalars['Boolean']>
min?: Maybe<Scalars['Int']>
max?: Maybe<Scalars['Int']>
step?: Maybe<Scalars['Int']>
}
export type FloatCustomFieldConfig = CustomField & {
__typename?: 'FloatCustomFieldConfig'
name: Scalars['String']
type: Scalars['String']
list: Scalars['Boolean']
label?: Maybe<Array<LocalizedString>>
description?: Maybe<Array<LocalizedString>>
readonly?: Maybe<Scalars['Boolean']>
internal?: Maybe<Scalars['Boolean']>
min?: Maybe<Scalars['Float']>
max?: Maybe<Scalars['Float']>
step?: Maybe<Scalars['Float']>
}
export type BooleanCustomFieldConfig = CustomField & {
__typename?: 'BooleanCustomFieldConfig'
name: Scalars['String']
type: Scalars['String']
list: Scalars['Boolean']
label?: Maybe<Array<LocalizedString>>
description?: Maybe<Array<LocalizedString>>
readonly?: Maybe<Scalars['Boolean']>
internal?: Maybe<Scalars['Boolean']>
}
/**
* Expects the same validation formats as the `<input type="datetime-local">` HTML element.
* See https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input/datetime-local#Additional_attributes
*/
export type DateTimeCustomFieldConfig = CustomField & {
__typename?: 'DateTimeCustomFieldConfig'
name: Scalars['String']
type: Scalars['String']
list: Scalars['Boolean']
label?: Maybe<Array<LocalizedString>>
description?: Maybe<Array<LocalizedString>>
readonly?: Maybe<Scalars['Boolean']>
internal?: Maybe<Scalars['Boolean']>
min?: Maybe<Scalars['String']>
max?: Maybe<Scalars['String']>
step?: Maybe<Scalars['Int']>
}
export type RelationCustomFieldConfig = CustomField & {
__typename?: 'RelationCustomFieldConfig'
name: Scalars['String']
type: Scalars['String']
list: Scalars['Boolean']
label?: Maybe<Array<LocalizedString>>
description?: Maybe<Array<LocalizedString>>
readonly?: Maybe<Scalars['Boolean']>
internal?: Maybe<Scalars['Boolean']>
entity: Scalars['String']
scalarFields: Array<Scalars['String']>
}
export type LocalizedString = {
__typename?: 'LocalizedString'
languageCode: LanguageCode
value: Scalars['String']
}
export type CustomFieldConfig =
| StringCustomFieldConfig
| LocaleStringCustomFieldConfig
| IntCustomFieldConfig
| FloatCustomFieldConfig
| BooleanCustomFieldConfig
| DateTimeCustomFieldConfig
| RelationCustomFieldConfig
export type CustomerGroup = Node & {
__typename?: 'CustomerGroup'
id: Scalars['ID']
createdAt: Scalars['DateTime']
updatedAt: Scalars['DateTime']
name: Scalars['String']
customers: CustomerList
}
export type CustomerGroupCustomersArgs = {
options?: Maybe<CustomerListOptions>
}
export type CustomerListOptions = {
skip?: Maybe<Scalars['Int']>
take?: Maybe<Scalars['Int']>
sort?: Maybe<CustomerSortParameter>
filter?: Maybe<CustomerFilterParameter>
}
export type Customer = Node & {
__typename?: 'Customer'
id: Scalars['ID']
createdAt: Scalars['DateTime']
updatedAt: Scalars['DateTime']
title?: Maybe<Scalars['String']>
firstName: Scalars['String']
lastName: Scalars['String']
phoneNumber?: Maybe<Scalars['String']>
emailAddress: Scalars['String']
addresses?: Maybe<Array<Address>>
orders: OrderList
user?: Maybe<User>
customFields?: Maybe<Scalars['JSON']>
}
export type CustomerOrdersArgs = {
options?: Maybe<OrderListOptions>
}
export type CustomerList = PaginatedList & {
__typename?: 'CustomerList'
items: Array<Customer>
totalItems: Scalars['Int']
}
export type FacetValue = Node & {
__typename?: 'FacetValue'
id: Scalars['ID']
createdAt: Scalars['DateTime']
updatedAt: Scalars['DateTime']
languageCode: LanguageCode
facet: Facet
name: Scalars['String']
code: Scalars['String']
translations: Array<FacetValueTranslation>
customFields?: Maybe<Scalars['JSON']>
}
export type FacetValueTranslation = {
__typename?: 'FacetValueTranslation'
id: Scalars['ID']
createdAt: Scalars['DateTime']
updatedAt: Scalars['DateTime']
languageCode: LanguageCode
name: Scalars['String']
}
export type Facet = Node & {
__typename?: 'Facet'
id: Scalars['ID']
createdAt: Scalars['DateTime']
updatedAt: Scalars['DateTime']
languageCode: LanguageCode
name: Scalars['String']
code: Scalars['String']
values: Array<FacetValue>
translations: Array<FacetTranslation>
customFields?: Maybe<Scalars['JSON']>
}
export type FacetTranslation = {
__typename?: 'FacetTranslation'
id: Scalars['ID']
createdAt: Scalars['DateTime']
updatedAt: Scalars['DateTime']
languageCode: LanguageCode
name: Scalars['String']
}
export type FacetList = PaginatedList & {
__typename?: 'FacetList'
items: Array<Facet>
totalItems: Scalars['Int']
}
export type HistoryEntry = Node & {
__typename?: 'HistoryEntry'
id: Scalars['ID']
createdAt: Scalars['DateTime']
updatedAt: Scalars['DateTime']
type: HistoryEntryType
data: Scalars['JSON']
}
export enum HistoryEntryType {
CustomerRegistered = 'CUSTOMER_REGISTERED',
CustomerVerified = 'CUSTOMER_VERIFIED',
CustomerDetailUpdated = 'CUSTOMER_DETAIL_UPDATED',
CustomerAddedToGroup = 'CUSTOMER_ADDED_TO_GROUP',
CustomerRemovedFromGroup = 'CUSTOMER_REMOVED_FROM_GROUP',
CustomerAddressCreated = 'CUSTOMER_ADDRESS_CREATED',
CustomerAddressUpdated = 'CUSTOMER_ADDRESS_UPDATED',
CustomerAddressDeleted = 'CUSTOMER_ADDRESS_DELETED',
CustomerPasswordUpdated = 'CUSTOMER_PASSWORD_UPDATED',
CustomerPasswordResetRequested = 'CUSTOMER_PASSWORD_RESET_REQUESTED',
CustomerPasswordResetVerified = 'CUSTOMER_PASSWORD_RESET_VERIFIED',
CustomerEmailUpdateRequested = 'CUSTOMER_EMAIL_UPDATE_REQUESTED',
CustomerEmailUpdateVerified = 'CUSTOMER_EMAIL_UPDATE_VERIFIED',
CustomerNote = 'CUSTOMER_NOTE',
OrderStateTransition = 'ORDER_STATE_TRANSITION',
OrderPaymentTransition = 'ORDER_PAYMENT_TRANSITION',
OrderFulfillment = 'ORDER_FULFILLMENT',
OrderCancellation = 'ORDER_CANCELLATION',
OrderRefundTransition = 'ORDER_REFUND_TRANSITION',
OrderFulfillmentTransition = 'ORDER_FULFILLMENT_TRANSITION',
OrderNote = 'ORDER_NOTE',
OrderCouponApplied = 'ORDER_COUPON_APPLIED',
OrderCouponRemoved = 'ORDER_COUPON_REMOVED',
OrderModified = 'ORDER_MODIFIED',
}
export type HistoryEntryList = PaginatedList & {
__typename?: 'HistoryEntryList'
items: Array<HistoryEntry>
totalItems: Scalars['Int']
}
export type HistoryEntryListOptions = {
skip?: Maybe<Scalars['Int']>
take?: Maybe<Scalars['Int']>
sort?: Maybe<HistoryEntrySortParameter>
filter?: Maybe<HistoryEntryFilterParameter>
}
/**
* @description
* Languages in the form of a ISO 639-1 language code with optional
* region or script modifier (e.g. de_AT). The selection available is based
* on the [Unicode CLDR summary list](https://unicode-org.github.io/cldr-staging/charts/37/summary/root.html)
* and includes the major spoken languages of the world and any widely-used variants.
*
* @docsCategory common
*/
export enum LanguageCode {
/** Afrikaans */
Af = 'af',
/** Akan */
Ak = 'ak',
/** Albanian */
Sq = 'sq',
/** Amharic */
Am = 'am',
/** Arabic */
Ar = 'ar',
/** Armenian */
Hy = 'hy',
/** Assamese */
As = 'as',
/** Azerbaijani */
Az = 'az',
/** Bambara */
Bm = 'bm',
/** Bangla */
Bn = 'bn',
/** Basque */
Eu = 'eu',
/** Belarusian */
Be = 'be',
/** Bosnian */
Bs = 'bs',
/** Breton */
Br = 'br',
/** Bulgarian */
Bg = 'bg',
/** Burmese */
My = 'my',
/** Catalan */
Ca = 'ca',
/** Chechen */
Ce = 'ce',
/** Chinese */
Zh = 'zh',
/** Simplified Chinese */
ZhHans = 'zh_Hans',
/** Traditional Chinese */
ZhHant = 'zh_Hant',
/** Church Slavic */
Cu = 'cu',
/** Cornish */
Kw = 'kw',
/** Corsican */
Co = 'co',
/** Croatian */
Hr = 'hr',
/** Czech */
Cs = 'cs',
/** Danish */
Da = 'da',
/** Dutch */
Nl = 'nl',
/** Flemish */
NlBe = 'nl_BE',
/** Dzongkha */
Dz = 'dz',
/** English */
En = 'en',
/** Australian English */
EnAu = 'en_AU',
/** Canadian English */
EnCa = 'en_CA',
/** British English */
EnGb = 'en_GB',
/** American English */
EnUs = 'en_US',
/** Esperanto */
Eo = 'eo',
/** Estonian */
Et = 'et',
/** Ewe */
Ee = 'ee',
/** Faroese */
Fo = 'fo',
/** Finnish */
Fi = 'fi',
/** French */
Fr = 'fr',
/** Canadian French */
FrCa = 'fr_CA',
/** Swiss French */
FrCh = 'fr_CH',
/** Fulah */
Ff = 'ff',
/** Galician */
Gl = 'gl',
/** Ganda */
Lg = 'lg',
/** Georgian */
Ka = 'ka',
/** German */
De = 'de',
/** Austrian German */
DeAt = 'de_AT',
/** Swiss High German */
DeCh = 'de_CH',
/** Greek */
El = 'el',
/** Gujarati */
Gu = 'gu',
/** Haitian Creole */
Ht = 'ht',
/** Hausa */
Ha = 'ha',
/** Hebrew */
He = 'he',
/** Hindi */
Hi = 'hi',
/** Hungarian */
Hu = 'hu',
/** Icelandic */
Is = 'is',
/** Igbo */
Ig = 'ig',
/** Indonesian */
Id = 'id',
/** Interlingua */
Ia = 'ia',
/** Irish */
Ga = 'ga',
/** Italian */
It = 'it',
/** Japanese */
Ja = 'ja',
/** Javanese */
Jv = 'jv',
/** Kalaallisut */
Kl = 'kl',
/** Kannada */
Kn = 'kn',
/** Kashmiri */
Ks = 'ks',
/** Kazakh */
Kk = 'kk',
/** Khmer */
Km = 'km',
/** Kikuyu */
Ki = 'ki',
/** Kinyarwanda */
Rw = 'rw',
/** Korean */
Ko = 'ko',
/** Kurdish */
Ku = 'ku',
/** Kyrgyz */
Ky = 'ky',
/** Lao */
Lo = 'lo',
/** Latin */
La = 'la',
/** Latvian */
Lv = 'lv',
/** Lingala */
Ln = 'ln',
/** Lithuanian */
Lt = 'lt',
/** Luba-Katanga */
Lu = 'lu',
/** Luxembourgish */
Lb = 'lb',
/** Macedonian */
Mk = 'mk',
/** Malagasy */
Mg = 'mg',
/** Malay */
Ms = 'ms',
/** Malayalam */
Ml = 'ml',
/** Maltese */
Mt = 'mt',
/** Manx */
Gv = 'gv',
/** Maori */
Mi = 'mi',
/** Marathi */
Mr = 'mr',
/** Mongolian */
Mn = 'mn',
/** Nepali */
Ne = 'ne',
/** North Ndebele */
Nd = 'nd',
/** Northern Sami */
Se = 'se',
/** Norwegian Bokmål */
Nb = 'nb',
/** Norwegian Nynorsk */
Nn = 'nn',
/** Nyanja */
Ny = 'ny',
/** Odia */
Or = 'or',
/** Oromo */
Om = 'om',
/** Ossetic */
Os = 'os',
/** Pashto */
Ps = 'ps',
/** Persian */
Fa = 'fa',
/** Dari */
FaAf = 'fa_AF',
/** Polish */
Pl = 'pl',
/** Portuguese */
Pt = 'pt',
/** Brazilian Portuguese */
PtBr = 'pt_BR',
/** European Portuguese */
PtPt = 'pt_PT',
/** Punjabi */
Pa = 'pa',
/** Quechua */
Qu = 'qu',
/** Romanian */
Ro = 'ro',
/** Moldavian */
RoMd = 'ro_MD',
/** Romansh */
Rm = 'rm',
/** Rundi */
Rn = 'rn',
/** Russian */
Ru = 'ru',
/** Samoan */
Sm = 'sm',
/** Sango */
Sg = 'sg',
/** Sanskrit */
Sa = 'sa',
/** Scottish Gaelic */
Gd = 'gd',
/** Serbian */
Sr = 'sr',
/** Shona */
Sn = 'sn',
/** Sichuan Yi */
Ii = 'ii',
/** Sindhi */
Sd = 'sd',
/** Sinhala */
Si = 'si',
/** Slovak */
Sk = 'sk',
/** Slovenian */
Sl = 'sl',
/** Somali */
So = 'so',
/** Southern Sotho */
St = 'st',
/** Spanish */
Es = 'es',
/** European Spanish */
EsEs = 'es_ES',
/** Mexican Spanish */
EsMx = 'es_MX',
/** Sundanese */
Su = 'su',
/** Swahili */
Sw = 'sw',
/** Congo Swahili */
SwCd = 'sw_CD',
/** Swedish */
Sv = 'sv',
/** Tajik */
Tg = 'tg',
/** Tamil */
Ta = 'ta',
/** Tatar */
Tt = 'tt',
/** Telugu */
Te = 'te',
/** Thai */
Th = 'th',
/** Tibetan */
Bo = 'bo',
/** Tigrinya */
Ti = 'ti',
/** Tongan */
To = 'to',
/** Turkish */
Tr = 'tr',
/** Turkmen */
Tk = 'tk',
/** Ukrainian */
Uk = 'uk',
/** Urdu */
Ur = 'ur',
/** Uyghur */
Ug = 'ug',
/** Uzbek */
Uz = 'uz',
/** Vietnamese */
Vi = 'vi',
/** Volapük */
Vo = 'vo',
/** Welsh */
Cy = 'cy',
/** Western Frisian */
Fy = 'fy',
/** Wolof */
Wo = 'wo',
/** Xhosa */
Xh = 'xh',
/** Yiddish */
Yi = 'yi',
/** Yoruba */
Yo = 'yo',
/** Zulu */
Zu = 'zu',
}
export type Order = Node & {
__typename?: 'Order'
id: Scalars['ID']
createdAt: Scalars['DateTime']
updatedAt: Scalars['DateTime']
/**
* The date & time that the Order was placed, i.e. the Customer
* completed the checkout and the Order is no longer "active"
*/
orderPlacedAt?: Maybe<Scalars['DateTime']>
/** A unique code for the Order */
code: Scalars['String']
state: Scalars['String']
/** An order is active as long as the payment process has not been completed */
active: Scalars['Boolean']
customer?: Maybe<Customer>
shippingAddress?: Maybe<OrderAddress>
billingAddress?: Maybe<OrderAddress>
lines: Array<OrderLine>
/**
* Surcharges are arbitrary modifications to the Order total which are neither
* ProductVariants nor discounts resulting from applied Promotions. For example,
* one-off discounts based on customer interaction, or surcharges based on payment
* methods.
*/
surcharges: Array<Surcharge>
discounts: Array<Discount>
/** An array of all coupon codes applied to the Order */
couponCodes: Array<Scalars['String']>
/** Promotions applied to the order. Only gets populated after the payment process has completed. */
promotions: Array<Promotion>
payments?: Maybe<Array<Payment>>
fulfillments?: Maybe<Array<Fulfillment>>
totalQuantity: Scalars['Int']
/**
* The subTotal is the total of all OrderLines in the Order. This figure also includes any Order-level
* discounts which have been prorated (proportionally distributed) amongst the OrderItems.
* To get a total of all OrderLines which does not account for prorated discounts, use the
* sum of `OrderLine.discountedLinePrice` values.
*/
subTotal: Scalars['Int']
/** Same as subTotal, but inclusive of tax */
subTotalWithTax: Scalars['Int']
currencyCode: CurrencyCode
shippingLines: Array<ShippingLine>
shipping: Scalars['Int']
shippingWithTax: Scalars['Int']
/** Equal to subTotal plus shipping */
total: Scalars['Int']
/** The final payable amount. Equal to subTotalWithTax plus shippingWithTax */
totalWithTax: Scalars['Int']
/** A summary of the taxes being applied to this Order */
taxSummary: Array<OrderTaxSummary>
history: HistoryEntryList
customFields?: Maybe<Scalars['JSON']>
}
export type OrderHistoryArgs = {
options?: Maybe<HistoryEntryListOptions>
}
/**
* A summary of the taxes being applied to this order, grouped
* by taxRate.
*/
export type OrderTaxSummary = {
__typename?: 'OrderTaxSummary'
/** A description of this tax */
description: Scalars['String']
/** The taxRate as a percentage */
taxRate: Scalars['Float']
/** The total net price or OrderItems to which this taxRate applies */
taxBase: Scalars['Int']
/** The total tax being applied to the Order at this taxRate */
taxTotal: Scalars['Int']
}
export type OrderAddress = {
__typename?: 'OrderAddress'
fullName?: Maybe<Scalars['String']>
company?: Maybe<Scalars['String']>
streetLine1?: Maybe<Scalars['String']>
streetLine2?: Maybe<Scalars['String']>
city?: Maybe<Scalars['String']>
province?: Maybe<Scalars['String']>
postalCode?: Maybe<Scalars['String']>
country?: Maybe<Scalars['String']>
countryCode?: Maybe<Scalars['String']>
phoneNumber?: Maybe<Scalars['String']>
customFields?: Maybe<Scalars['JSON']>
}
export type OrderList = PaginatedList & {
__typename?: 'OrderList'
items: Array<Order>
totalItems: Scalars['Int']
}
export type ShippingLine = {
__typename?: 'ShippingLine'
shippingMethod: ShippingMethod
price: Scalars['Int']
priceWithTax: Scalars['Int']
discountedPrice: Scalars['Int']
discountedPriceWithTax: Scalars['Int']
discounts: Array<Discount>
}
export type Discount = {
__typename?: 'Discount'
adjustmentSource: Scalars['String']
type: AdjustmentType
description: Scalars['String']
amount: Scalars['Int']
amountWithTax: Scalars['Int']
}
export type OrderItem = Node & {
__typename?: 'OrderItem'
id: Scalars['ID']
createdAt: Scalars['DateTime']
updatedAt: Scalars['DateTime']
cancelled: Scalars['Boolean']
/** The price of a single unit, excluding tax and discounts */
unitPrice: Scalars['Int']
/** The price of a single unit, including tax but excluding discounts */
unitPriceWithTax: Scalars['Int']
/**
* The price of a single unit including discounts, excluding tax.
*
* If Order-level discounts have been applied, this will not be the
* actual taxable unit price (see `proratedUnitPrice`), but is generally the
* correct price to display to customers to avoid confusion
* about the internal handling of distributed Order-level discounts.
*/
discountedUnitPrice: Scalars['Int']
/** The price of a single unit including discounts and tax */
discountedUnitPriceWithTax: Scalars['Int']
/**
* The actual unit price, taking into account both item discounts _and_ prorated (proportially-distributed)
* Order-level discounts. This value is the true economic value of the OrderItem, and is used in tax
* and refund calculations.
*/
proratedUnitPrice: Scalars['Int']
/** The proratedUnitPrice including tax */
proratedUnitPriceWithTax: Scalars['Int']
unitTax: Scalars['Int']
taxRate: Scalars['Float']
adjustments: Array<Adjustment>
taxLines: Array<TaxLine>
fulfillment?: Maybe<Fulfillment>
refundId?: Maybe<Scalars['ID']>
}
export type OrderLine = Node & {
__typename?: 'OrderLine'
id: Scalars['ID']
createdAt: Scalars['DateTime']
updatedAt: Scalars['DateTime']
productVariant: ProductVariant
featuredAsset?: Maybe<Asset>
/** The price of a single unit, excluding tax and discounts */
unitPrice: Scalars['Int']
/** The price of a single unit, including tax but excluding discounts */
unitPriceWithTax: Scalars['Int']
/** Non-zero if the unitPrice has changed since it was initially added to Order */
unitPriceChangeSinceAdded: Scalars['Int']
/** Non-zero if the unitPriceWithTax has changed since it was initially added to Order */
unitPriceWithTaxChangeSinceAdded: Scalars['Int']
/**
* The price of a single unit including discounts, excluding tax.
*
* If Order-level discounts have been applied, this will not be the
* actual taxable unit price (see `proratedUnitPrice`), but is generally the
* correct price to display to customers to avoid confusion
* about the internal handling of distributed Order-level discounts.
*/
discountedUnitPrice: Scalars['Int']
/** The price of a single unit including discounts and tax */
discountedUnitPriceWithTax: Scalars['Int']
/**
* The actual unit price, taking into account both item discounts _and_ prorated (proportially-distributed)
* Order-level discounts. This value is the true economic value of the OrderItem, and is used in tax
* and refund calculations.
*/
proratedUnitPrice: Scalars['Int']
/** The proratedUnitPrice including tax */
proratedUnitPriceWithTax: Scalars['Int']
quantity: Scalars['Int']
items: Array<OrderItem>
taxRate: Scalars['Float']
/** The total price of the line excluding tax and discounts. */
linePrice: Scalars['Int']
/** The total price of the line including tax bit excluding discounts. */
linePriceWithTax: Scalars['Int']
/** The price of the line including discounts, excluding tax */
discountedLinePrice: Scalars['Int']
/** The price of the line including discounts and tax */
discountedLinePriceWithTax: Scalars['Int']
/**
* The actual line price, taking into account both item discounts _and_ prorated (proportially-distributed)
* Order-level discounts. This value is the true economic value of the OrderLine, and is used in tax
* and refund calculations.
*/
proratedLinePrice: Scalars['Int']
/** The proratedLinePrice including tax */
proratedLinePriceWithTax: Scalars['Int']
/** The total tax on this line */
lineTax: Scalars['Int']
discounts: Array<Discount>
taxLines: Array<TaxLine>
order: Order
customFields?: Maybe<Scalars['JSON']>
}
export type Payment = Node & {
__typename?: 'Payment'
id: Scalars['ID']
createdAt: Scalars['DateTime']
updatedAt: Scalars['DateTime']
method: Scalars['String']
amount: Scalars['Int']
state: Scalars['String']
transactionId?: Maybe<Scalars['String']>
errorMessage?: Maybe<Scalars['String']>
refunds: Array<Refund>
metadata?: Maybe<Scalars['JSON']>
}
export type Refund = Node & {
__typename?: 'Refund'
id: Scalars['ID']
createdAt: Scalars['DateTime']
updatedAt: Scalars['DateTime']
items: Scalars['Int']
shipping: Scalars['Int']
adjustment: Scalars['Int']
total: Scalars['Int']
method?: Maybe<Scalars['String']>
state: Scalars['String']
transactionId?: Maybe<Scalars['String']>
reason?: Maybe<Scalars['String']>
orderItems: Array<OrderItem>
paymentId: Scalars['ID']
metadata?: Maybe<Scalars['JSON']>
}
export type Fulfillment = Node & {
__typename?: 'Fulfillment'
id: Scalars['ID']
createdAt: Scalars['DateTime']
updatedAt: Scalars['DateTime']
orderItems: Array<OrderItem>
state: Scalars['String']
method: Scalars['String']
trackingCode?: Maybe<Scalars['String']>
customFields?: Maybe<Scalars['JSON']>
}
export type Surcharge = Node & {
__typename?: 'Surcharge'
id: Scalars['ID']
createdAt: Scalars['DateTime']
updatedAt: Scalars['DateTime']
description: Scalars['String']
sku?: Maybe<Scalars['String']>
taxLines: Array<TaxLine>
price: Scalars['Int']
priceWithTax: Scalars['Int']
taxRate: Scalars['Float']
}
export type ProductOptionGroup = Node & {
__typename?: 'ProductOptionGroup'
id: Scalars['ID']
createdAt: Scalars['DateTime']
updatedAt: Scalars['DateTime']
languageCode: LanguageCode
code: Scalars['String']
name: Scalars['String']
options: Array<ProductOption>
translations: Array<ProductOptionGroupTranslation>
customFields?: Maybe<Scalars['JSON']>
}
export type ProductOptionGroupTranslation = {
__typename?: 'ProductOptionGroupTranslation'
id: Scalars['ID']
createdAt: Scalars['DateTime']
updatedAt: Scalars['DateTime']
languageCode: LanguageCode
name: Scalars['String']
}
export type ProductOption = Node & {
__typename?: 'ProductOption'
id: Scalars['ID']
createdAt: Scalars['DateTime']
updatedAt: Scalars['DateTime']
languageCode: LanguageCode
code: Scalars['String']
name: Scalars['String']
groupId: Scalars['ID']
group: ProductOptionGroup
translations: Array<ProductOptionTranslation>
customFields?: Maybe<Scalars['JSON']>
}
export type ProductOptionTranslation = {
__typename?: 'ProductOptionTranslation'
id: Scalars['ID']
createdAt: Scalars['DateTime']
updatedAt: Scalars['DateTime']
languageCode: LanguageCode
name: Scalars['String']
}
export type SearchReindexResponse = {
__typename?: 'SearchReindexResponse'
success: Scalars['Boolean']
}
export type SearchResponse = {
__typename?: 'SearchResponse'
items: Array<SearchResult>
totalItems: Scalars['Int']
facetValues: Array<FacetValueResult>
}
/**
* Which FacetValues are present in the products returned
* by the search, and in what quantity.
*/
export type FacetValueResult = {
__typename?: 'FacetValueResult'
facetValue: FacetValue
count: Scalars['Int']
}
export type SearchResultAsset = {
__typename?: 'SearchResultAsset'
id: Scalars['ID']
preview: Scalars['String']
focalPoint?: Maybe<Coordinate>
}
export type SearchResult = {
__typename?: 'SearchResult'
sku: Scalars['String']
slug: Scalars['String']
productId: Scalars['ID']
productName: Scalars['String']
productAsset?: Maybe<SearchResultAsset>
productVariantId: Scalars['ID']
productVariantName: Scalars['String']
productVariantAsset?: Maybe<SearchResultAsset>
price: SearchResultPrice
priceWithTax: SearchResultPrice
currencyCode: CurrencyCode
description: Scalars['String']
facetIds: Array<Scalars['ID']>
facetValueIds: Array<Scalars['ID']>
/** An array of ids of the Collections in which this result appears */
collectionIds: Array<Scalars['ID']>
/** A relevence score for the result. Differs between database implementations */
score: Scalars['Float']
}
/** The price of a search result product, either as a range or as a single price */
export type SearchResultPrice = PriceRange | SinglePrice
/** The price value where the result has a single price */
export type SinglePrice = {
__typename?: 'SinglePrice'
value: Scalars['Int']
}
/** The price range where the result has more than one price */
export type PriceRange = {
__typename?: 'PriceRange'
min: Scalars['Int']
max: Scalars['Int']
}
export type Product = Node & {
__typename?: 'Product'
id: Scalars['ID']
createdAt: Scalars['DateTime']
updatedAt: Scalars['DateTime']
languageCode: LanguageCode
name: Scalars['String']
slug: Scalars['String']
description: Scalars['String']
featuredAsset?: Maybe<Asset>
assets: Array<Asset>
variants: Array<ProductVariant>
optionGroups: Array<ProductOptionGroup>
facetValues: Array<FacetValue>
translations: Array<ProductTranslation>
collections: Array<Collection>
customFields?: Maybe<Scalars['JSON']>
}
export type ProductTranslation = {
__typename?: 'ProductTranslation'
id: Scalars['ID']
createdAt: Scalars['DateTime']
updatedAt: Scalars['DateTime']
languageCode: LanguageCode
name: Scalars['String']
slug: Scalars['String']
description: Scalars['String']
}
export type ProductList = PaginatedList & {
__typename?: 'ProductList'
items: Array<Product>
totalItems: Scalars['Int']
}
export type ProductVariant = Node & {
__typename?: 'ProductVariant'
id: Scalars['ID']
product: Product
productId: Scalars['ID']
createdAt: Scalars['DateTime']
updatedAt: Scalars['DateTime']
languageCode: LanguageCode
sku: Scalars['String']
name: Scalars['String']
featuredAsset?: Maybe<Asset>
assets: Array<Asset>
price: Scalars['Int']
currencyCode: CurrencyCode
priceWithTax: Scalars['Int']
stockLevel: Scalars['String']
taxRateApplied: TaxRate
taxCategory: TaxCategory
options: Array<ProductOption>
facetValues: Array<FacetValue>
translations: Array<ProductVariantTranslation>
customFields?: Maybe<ProductVariantCustomFields>
}
export type ProductVariantTranslation = {
__typename?: 'ProductVariantTranslation'
id: Scalars['ID']
createdAt: Scalars['DateTime']
updatedAt: Scalars['DateTime']
languageCode: LanguageCode
name: Scalars['String']
}
export type Promotion = Node & {
__typename?: 'Promotion'
id: Scalars['ID']
createdAt: Scalars['DateTime']
updatedAt: Scalars['DateTime']
startsAt?: Maybe<Scalars['DateTime']>
endsAt?: Maybe<Scalars['DateTime']>
couponCode?: Maybe<Scalars['String']>
perCustomerUsageLimit?: Maybe<Scalars['Int']>
name: Scalars['String']
enabled: Scalars['Boolean']
conditions: Array<ConfigurableOperation>
actions: Array<ConfigurableOperation>
}
export type PromotionList = PaginatedList & {
__typename?: 'PromotionList'
items: Array<Promotion>
totalItems: Scalars['Int']
}
export type Role = Node & {
__typename?: 'Role'
id: Scalars['ID']
createdAt: Scalars['DateTime']
updatedAt: Scalars['DateTime']
code: Scalars['String']
description: Scalars['String']
permissions: Array<Permission>
channels: Array<Channel>
}
export type RoleList = PaginatedList & {
__typename?: 'RoleList'
items: Array<Role>
totalItems: Scalars['Int']
}
export type ShippingMethod = Node & {
__typename?: 'ShippingMethod'
id: Scalars['ID']
createdAt: Scalars['DateTime']
updatedAt: Scalars['DateTime']
code: Scalars['String']
name: Scalars['String']
description: Scalars['String']
fulfillmentHandlerCode: Scalars['String']
checker: ConfigurableOperation
calculator: ConfigurableOperation
translations: Array<ShippingMethodTranslation>
customFields?: Maybe<Scalars['JSON']>
}
export type ShippingMethodTranslation = {
__typename?: 'ShippingMethodTranslation'
id: Scalars['ID']
createdAt: Scalars['DateTime']
updatedAt: Scalars['DateTime']
languageCode: LanguageCode
name: Scalars['String']
description: Scalars['String']
}
export type ShippingMethodList = PaginatedList & {
__typename?: 'ShippingMethodList'
items: Array<ShippingMethod>
totalItems: Scalars['Int']
}
export type Tag = Node & {
__typename?: 'Tag'
id: Scalars['ID']
createdAt: Scalars['DateTime']
updatedAt: Scalars['DateTime']
value: Scalars['String']
}
export type TagList = PaginatedList & {
__typename?: 'TagList'
items: Array<Tag>
totalItems: Scalars['Int']
}
export type TaxCategory = Node & {
__typename?: 'TaxCategory'
id: Scalars['ID']
createdAt: Scalars['DateTime']
updatedAt: Scalars['DateTime']
name: Scalars['String']
isDefault: Scalars['Boolean']
}
export type TaxRate = Node & {
__typename?: 'TaxRate'
id: Scalars['ID']
createdAt: Scalars['DateTime']
updatedAt: Scalars['DateTime']
name: Scalars['String']
enabled: Scalars['Boolean']
value: Scalars['Float']
category: TaxCategory
zone: Zone
customerGroup?: Maybe<CustomerGroup>
}
export type TaxRateList = PaginatedList & {
__typename?: 'TaxRateList'
items: Array<TaxRate>
totalItems: Scalars['Int']
}
export type User = Node & {
__typename?: 'User'
id: Scalars['ID']
createdAt: Scalars['DateTime']
updatedAt: Scalars['DateTime']
identifier: Scalars['String']
verified: Scalars['Boolean']
roles: Array<Role>
lastLogin?: Maybe<Scalars['DateTime']>
authenticationMethods: Array<AuthenticationMethod>
customFields?: Maybe<Scalars['JSON']>
}
export type AuthenticationMethod = Node & {
__typename?: 'AuthenticationMethod'
id: Scalars['ID']
createdAt: Scalars['DateTime']
updatedAt: Scalars['DateTime']
strategy: Scalars['String']
}
export type Zone = Node & {
__typename?: 'Zone'
id: Scalars['ID']
createdAt: Scalars['DateTime']
updatedAt: Scalars['DateTime']
name: Scalars['String']
members: Array<Country>
}
/** Returned when attempting to modify the contents of an Order that is not in the `AddingItems` state. */
export type OrderModificationError = ErrorResult & {
__typename?: 'OrderModificationError'
errorCode: ErrorCode
message: Scalars['String']
}
/** Returned when attempting to set a ShippingMethod for which the Order is not eligible */
export type IneligibleShippingMethodError = ErrorResult & {
__typename?: 'IneligibleShippingMethodError'
errorCode: ErrorCode
message: Scalars['String']
}
/** Returned when attempting to add a Payment to an Order that is not in the `ArrangingPayment` state. */
export type OrderPaymentStateError = ErrorResult & {
__typename?: 'OrderPaymentStateError'
errorCode: ErrorCode
message: Scalars['String']
}
/** Returned when attempting to add a Payment using a PaymentMethod for which the Order is not eligible. */
export type IneligiblePaymentMethodError = ErrorResult & {
__typename?: 'IneligiblePaymentMethodError'
errorCode: ErrorCode
message: Scalars['String']
eligibilityCheckerMessage?: Maybe<Scalars['String']>
}
/** Returned when a Payment fails due to an error. */
export type PaymentFailedError = ErrorResult & {
__typename?: 'PaymentFailedError'
errorCode: ErrorCode
message: Scalars['String']
paymentErrorMessage: Scalars['String']
}
/** Returned when a Payment is declined by the payment provider. */
export type PaymentDeclinedError = ErrorResult & {
__typename?: 'PaymentDeclinedError'
errorCode: ErrorCode
message: Scalars['String']
paymentErrorMessage: Scalars['String']
}
/** Returned if the provided coupon code is invalid */
export type CouponCodeInvalidError = ErrorResult & {
__typename?: 'CouponCodeInvalidError'
errorCode: ErrorCode
message: Scalars['String']
couponCode: Scalars['String']
}
/** Returned if the provided coupon code is invalid */
export type CouponCodeExpiredError = ErrorResult & {
__typename?: 'CouponCodeExpiredError'
errorCode: ErrorCode
message: Scalars['String']
couponCode: Scalars['String']
}
/** Returned if the provided coupon code is invalid */
export type CouponCodeLimitError = ErrorResult & {
__typename?: 'CouponCodeLimitError'
errorCode: ErrorCode
message: Scalars['String']
couponCode: Scalars['String']
limit: Scalars['Int']
}
/** Retured when attemting to set the Customer for an Order when already logged in. */
export type AlreadyLoggedInError = ErrorResult & {
__typename?: 'AlreadyLoggedInError'
errorCode: ErrorCode
message: Scalars['String']
}
/** Retured when attemting to register or verify a customer account without a password, when one is required. */
export type MissingPasswordError = ErrorResult & {
__typename?: 'MissingPasswordError'
errorCode: ErrorCode
message: Scalars['String']
}
/** Retured when attemting to verify a customer account with a password, when a password has already been set. */
export type PasswordAlreadySetError = ErrorResult & {
__typename?: 'PasswordAlreadySetError'
errorCode: ErrorCode
message: Scalars['String']
}
/**
* Retured if the verification token (used to verify a Customer's email address) is either
* invalid or does not match any expected tokens.
*/
export type VerificationTokenInvalidError = ErrorResult & {
__typename?: 'VerificationTokenInvalidError'
errorCode: ErrorCode
message: Scalars['String']
}
/**
* Returned if the verification token (used to verify a Customer's email address) is valid, but has
* expired according to the `verificationTokenDuration` setting in the AuthOptions.
*/
export type VerificationTokenExpiredError = ErrorResult & {
__typename?: 'VerificationTokenExpiredError'
errorCode: ErrorCode
message: Scalars['String']
}
/**
* Retured if the token used to change a Customer's email address is either
* invalid or does not match any expected tokens.
*/
export type IdentifierChangeTokenInvalidError = ErrorResult & {
__typename?: 'IdentifierChangeTokenInvalidError'
errorCode: ErrorCode
message: Scalars['String']
}
/**
* Retured if the token used to change a Customer's email address is valid, but has
* expired according to the `verificationTokenDuration` setting in the AuthOptions.
*/
export type IdentifierChangeTokenExpiredError = ErrorResult & {
__typename?: 'IdentifierChangeTokenExpiredError'
errorCode: ErrorCode
message: Scalars['String']
}
/**
* Retured if the token used to reset a Customer's password is either
* invalid or does not match any expected tokens.
*/
export type PasswordResetTokenInvalidError = ErrorResult & {
__typename?: 'PasswordResetTokenInvalidError'
errorCode: ErrorCode
message: Scalars['String']
}
/**
* Retured if the token used to reset a Customer's password is valid, but has
* expired according to the `verificationTokenDuration` setting in the AuthOptions.
*/
export type PasswordResetTokenExpiredError = ErrorResult & {
__typename?: 'PasswordResetTokenExpiredError'
errorCode: ErrorCode
message: Scalars['String']
}
/**
* Returned if `authOptions.requireVerification` is set to `true` (which is the default)
* and an unverified user attempts to authenticate.
*/
export type NotVerifiedError = ErrorResult & {
__typename?: 'NotVerifiedError'
errorCode: ErrorCode
message: Scalars['String']
}
/**
* Returned when invoking a mutation which depends on there being an active Order on the
* current session.
*/
export type NoActiveOrderError = ErrorResult & {
__typename?: 'NoActiveOrderError'
errorCode: ErrorCode
message: Scalars['String']
}
export type AuthenticationInput = {
native?: Maybe<NativeAuthInput>
}
export type RegisterCustomerInput = {
emailAddress: Scalars['String']
title?: Maybe<Scalars['String']>
firstName?: Maybe<Scalars['String']>
lastName?: Maybe<Scalars['String']>
phoneNumber?: Maybe<Scalars['String']>
password?: Maybe<Scalars['String']>
}
export type UpdateCustomerInput = {
title?: Maybe<Scalars['String']>
firstName?: Maybe<Scalars['String']>
lastName?: Maybe<Scalars['String']>
phoneNumber?: Maybe<Scalars['String']>
customFields?: Maybe<Scalars['JSON']>
}
export type UpdateOrderInput = {
customFields?: Maybe<Scalars['JSON']>
}
/** Passed as input to the `addPaymentToOrder` mutation. */
export type PaymentInput = {
/** This field should correspond to the `code` property of a PaymentMethodHandler. */
method: Scalars['String']
/**
* This field should contain arbitrary data passed to the specified PaymentMethodHandler's `createPayment()` method
* as the "metadata" argument. For example, it could contain an ID for the payment and other
* data generated by the payment provider.
*/
metadata: Scalars['JSON']
}
export type CollectionListOptions = {
skip?: Maybe<Scalars['Int']>
take?: Maybe<Scalars['Int']>
sort?: Maybe<CollectionSortParameter>
filter?: Maybe<CollectionFilterParameter>
}
export type OrderListOptions = {
skip?: Maybe<Scalars['Int']>
take?: Maybe<Scalars['Int']>
sort?: Maybe<OrderSortParameter>
filter?: Maybe<OrderFilterParameter>
}
export type ProductListOptions = {
skip?: Maybe<Scalars['Int']>
take?: Maybe<Scalars['Int']>
sort?: Maybe<ProductSortParameter>
filter?: Maybe<ProductFilterParameter>
}
export type UpdateOrderItemsResult =
| Order
| OrderModificationError
| OrderLimitError
| NegativeQuantityError
| InsufficientStockError
export type RemoveOrderItemsResult = Order | OrderModificationError
export type SetOrderShippingMethodResult =
| Order
| OrderModificationError
| IneligibleShippingMethodError
| NoActiveOrderError
export type ApplyCouponCodeResult =
| Order
| CouponCodeExpiredError
| CouponCodeInvalidError
| CouponCodeLimitError
export type AddPaymentToOrderResult =
| Order
| OrderPaymentStateError
| IneligiblePaymentMethodError
| PaymentFailedError
| PaymentDeclinedError
| OrderStateTransitionError
| NoActiveOrderError
export type TransitionOrderToStateResult = Order | OrderStateTransitionError
export type SetCustomerForOrderResult =
| Order
| AlreadyLoggedInError
| EmailAddressConflictError
| NoActiveOrderError
export type RegisterCustomerAccountResult =
| Success
| MissingPasswordError
| NativeAuthStrategyError
export type RefreshCustomerVerificationResult =
| Success
| NativeAuthStrategyError
export type VerifyCustomerAccountResult =
| CurrentUser
| VerificationTokenInvalidError
| VerificationTokenExpiredError
| MissingPasswordError
| PasswordAlreadySetError
| NativeAuthStrategyError
export type UpdateCustomerPasswordResult =
| Success
| InvalidCredentialsError
| NativeAuthStrategyError
export type RequestUpdateCustomerEmailAddressResult =
| Success
| InvalidCredentialsError
| EmailAddressConflictError
| NativeAuthStrategyError
export type UpdateCustomerEmailAddressResult =
| Success
| IdentifierChangeTokenInvalidError
| IdentifierChangeTokenExpiredError
| NativeAuthStrategyError
export type RequestPasswordResetResult = Success | NativeAuthStrategyError
export type ResetPasswordResult =
| CurrentUser
| PasswordResetTokenInvalidError
| PasswordResetTokenExpiredError
| NativeAuthStrategyError
export type NativeAuthenticationResult =
| CurrentUser
| InvalidCredentialsError
| NotVerifiedError
| NativeAuthStrategyError
export type AuthenticationResult =
| CurrentUser
| InvalidCredentialsError
| NotVerifiedError
export type ActiveOrderResult = Order | NoActiveOrderError
export type CollectionFilterParameter = {
createdAt?: Maybe<DateOperators>
updatedAt?: Maybe<DateOperators>
languageCode?: Maybe<StringOperators>
name?: Maybe<StringOperators>
slug?: Maybe<StringOperators>
position?: Maybe<NumberOperators>
description?: Maybe<StringOperators>
}
export type CollectionSortParameter = {
id?: Maybe<SortOrder>
createdAt?: Maybe<SortOrder>
updatedAt?: Maybe<SortOrder>
name?: Maybe<SortOrder>
slug?: Maybe<SortOrder>
position?: Maybe<SortOrder>
description?: Maybe<SortOrder>
}
export type ProductFilterParameter = {
createdAt?: Maybe<DateOperators>
updatedAt?: Maybe<DateOperators>
languageCode?: Maybe<StringOperators>
name?: Maybe<StringOperators>
slug?: Maybe<StringOperators>
description?: Maybe<StringOperators>
}
export type ProductSortParameter = {
id?: Maybe<SortOrder>
createdAt?: Maybe<SortOrder>
updatedAt?: Maybe<SortOrder>
name?: Maybe<SortOrder>
slug?: Maybe<SortOrder>
description?: Maybe<SortOrder>
}
export type ProductVariantFilterParameter = {
createdAt?: Maybe<DateOperators>
updatedAt?: Maybe<DateOperators>
languageCode?: Maybe<StringOperators>
sku?: Maybe<StringOperators>
name?: Maybe<StringOperators>
price?: Maybe<NumberOperators>
currencyCode?: Maybe<StringOperators>
priceWithTax?: Maybe<NumberOperators>
stockLevel?: Maybe<StringOperators>
discountPrice?: Maybe<NumberOperators>
}
export type ProductVariantSortParameter = {
id?: Maybe<SortOrder>
productId?: Maybe<SortOrder>
createdAt?: Maybe<SortOrder>
updatedAt?: Maybe<SortOrder>
sku?: Maybe<SortOrder>
name?: Maybe<SortOrder>
price?: Maybe<SortOrder>
priceWithTax?: Maybe<SortOrder>
stockLevel?: Maybe<SortOrder>
discountPrice?: Maybe<SortOrder>
}
export type CustomerFilterParameter = {
createdAt?: Maybe<DateOperators>
updatedAt?: Maybe<DateOperators>
title?: Maybe<StringOperators>
firstName?: Maybe<StringOperators>
lastName?: Maybe<StringOperators>
phoneNumber?: Maybe<StringOperators>
emailAddress?: Maybe<StringOperators>
}
export type CustomerSortParameter = {
id?: Maybe<SortOrder>
createdAt?: Maybe<SortOrder>
updatedAt?: Maybe<SortOrder>
title?: Maybe<SortOrder>
firstName?: Maybe<SortOrder>
lastName?: Maybe<SortOrder>
phoneNumber?: Maybe<SortOrder>
emailAddress?: Maybe<SortOrder>
}
export type OrderFilterParameter = {
createdAt?: Maybe<DateOperators>
updatedAt?: Maybe<DateOperators>
orderPlacedAt?: Maybe<DateOperators>
code?: Maybe<StringOperators>
state?: Maybe<StringOperators>
active?: Maybe<BooleanOperators>
totalQuantity?: Maybe<NumberOperators>
subTotal?: Maybe<NumberOperators>
subTotalWithTax?: Maybe<NumberOperators>
currencyCode?: Maybe<StringOperators>
shipping?: Maybe<NumberOperators>
shippingWithTax?: Maybe<NumberOperators>
total?: Maybe<NumberOperators>
totalWithTax?: Maybe<NumberOperators>
}
export type OrderSortParameter = {
id?: Maybe<SortOrder>
createdAt?: Maybe<SortOrder>
updatedAt?: Maybe<SortOrder>
orderPlacedAt?: Maybe<SortOrder>
code?: Maybe<SortOrder>
state?: Maybe<SortOrder>
totalQuantity?: Maybe<SortOrder>
subTotal?: Maybe<SortOrder>
subTotalWithTax?: Maybe<SortOrder>
shipping?: Maybe<SortOrder>
shippingWithTax?: Maybe<SortOrder>
total?: Maybe<SortOrder>
totalWithTax?: Maybe<SortOrder>
}
export type HistoryEntryFilterParameter = {
createdAt?: Maybe<DateOperators>
updatedAt?: Maybe<DateOperators>
type?: Maybe<StringOperators>
}
export type HistoryEntrySortParameter = {
id?: Maybe<SortOrder>
createdAt?: Maybe<SortOrder>
updatedAt?: Maybe<SortOrder>
}
export type ProductVariantCustomFields = {
__typename?: 'ProductVariantCustomFields'
discountPrice?: Maybe<Scalars['Int']>
}
export type NativeAuthInput = {
username: Scalars['String']
password: Scalars['String']
}
export type CartFragment = { __typename?: 'Order' } & Pick<
Order,
| 'id'
| 'code'
| 'createdAt'
| 'totalQuantity'
| 'subTotal'
| 'subTotalWithTax'
| 'total'
| 'totalWithTax'
| 'currencyCode'
> & {
customer?: Maybe<{ __typename?: 'Customer' } & Pick<Customer, 'id'>>
lines: Array<
{ __typename?: 'OrderLine' } & Pick<
OrderLine,
| 'id'
| 'quantity'
| 'linePriceWithTax'
| 'discountedLinePriceWithTax'
| 'unitPriceWithTax'
| 'discountedUnitPriceWithTax'
> & {
featuredAsset?: Maybe<
{ __typename?: 'Asset' } & Pick<Asset, 'id' | 'preview'>
>
discounts: Array<
{ __typename?: 'Discount' } & Pick<
Discount,
'description' | 'amount'
>
>
productVariant: { __typename?: 'ProductVariant' } & Pick<
ProductVariant,
| 'id'
| 'name'
| 'sku'
| 'price'
| 'priceWithTax'
| 'stockLevel'
| 'productId'
> & { product: { __typename?: 'Product' } & Pick<Product, 'slug'> }
}
>
}
export type SearchResultFragment = { __typename?: 'SearchResult' } & Pick<
SearchResult,
'productId' | 'productName' | 'description' | 'slug' | 'sku' | 'currencyCode'
> & {
productAsset?: Maybe<
{ __typename?: 'SearchResultAsset' } & Pick<
SearchResultAsset,
'id' | 'preview'
>
>
priceWithTax:
| ({ __typename?: 'PriceRange' } & Pick<PriceRange, 'min' | 'max'>)
| ({ __typename?: 'SinglePrice' } & Pick<SinglePrice, 'value'>)
}
export type AddItemToOrderMutationVariables = Exact<{
variantId: Scalars['ID']
quantity: Scalars['Int']
}>
export type AddItemToOrderMutation = { __typename?: 'Mutation' } & {
addItemToOrder:
| ({ __typename: 'Order' } & CartFragment)
| ({ __typename: 'OrderModificationError' } & Pick<
OrderModificationError,
'errorCode' | 'message'
>)
| ({ __typename: 'OrderLimitError' } & Pick<
OrderLimitError,
'errorCode' | 'message'
>)
| ({ __typename: 'NegativeQuantityError' } & Pick<
NegativeQuantityError,
'errorCode' | 'message'
>)
| ({ __typename: 'InsufficientStockError' } & Pick<
InsufficientStockError,
'errorCode' | 'message'
>)
}
export type AdjustOrderLineMutationVariables = Exact<{
orderLineId: Scalars['ID']
quantity: Scalars['Int']
}>
export type AdjustOrderLineMutation = { __typename?: 'Mutation' } & {
adjustOrderLine:
| ({ __typename: 'Order' } & CartFragment)
| ({ __typename: 'OrderModificationError' } & Pick<
OrderModificationError,
'errorCode' | 'message'
>)
| ({ __typename: 'OrderLimitError' } & Pick<
OrderLimitError,
'errorCode' | 'message'
>)
| ({ __typename: 'NegativeQuantityError' } & Pick<
NegativeQuantityError,
'errorCode' | 'message'
>)
| ({ __typename: 'InsufficientStockError' } & Pick<
InsufficientStockError,
'errorCode' | 'message'
>)
}
export type LoginMutationVariables = Exact<{
username: Scalars['String']
password: Scalars['String']
}>
export type LoginMutation = { __typename?: 'Mutation' } & {
login:
| ({ __typename: 'CurrentUser' } & Pick<CurrentUser, 'id'>)
| ({ __typename: 'InvalidCredentialsError' } & Pick<
InvalidCredentialsError,
'errorCode' | 'message'
>)
| ({ __typename: 'NotVerifiedError' } & Pick<
NotVerifiedError,
'errorCode' | 'message'
>)
| ({ __typename: 'NativeAuthStrategyError' } & Pick<
NativeAuthStrategyError,
'errorCode' | 'message'
>)
}
export type LogoutMutationVariables = Exact<{ [key: string]: never }>
export type LogoutMutation = { __typename?: 'Mutation' } & {
logout: { __typename?: 'Success' } & Pick<Success, 'success'>
}
export type RemoveOrderLineMutationVariables = Exact<{
orderLineId: Scalars['ID']
}>
export type RemoveOrderLineMutation = { __typename?: 'Mutation' } & {
removeOrderLine:
| ({ __typename: 'Order' } & CartFragment)
| ({ __typename: 'OrderModificationError' } & Pick<
OrderModificationError,
'errorCode' | 'message'
>)
}
export type SignupMutationVariables = Exact<{
input: RegisterCustomerInput
}>
export type SignupMutation = { __typename?: 'Mutation' } & {
registerCustomerAccount:
| ({ __typename: 'Success' } & Pick<Success, 'success'>)
| ({ __typename: 'MissingPasswordError' } & Pick<
MissingPasswordError,
'errorCode' | 'message'
>)
| ({ __typename: 'NativeAuthStrategyError' } & Pick<
NativeAuthStrategyError,
'errorCode' | 'message'
>)
}
export type ActiveCustomerQueryVariables = Exact<{ [key: string]: never }>
export type ActiveCustomerQuery = { __typename?: 'Query' } & {
activeCustomer?: Maybe<
{ __typename?: 'Customer' } & Pick<
Customer,
'id' | 'firstName' | 'lastName' | 'emailAddress'
>
>
}
export type GetAllProductPathsQueryVariables = Exact<{
first?: Maybe<Scalars['Int']>
}>
export type GetAllProductPathsQuery = { __typename?: 'Query' } & {
products: { __typename?: 'ProductList' } & {
items: Array<{ __typename?: 'Product' } & Pick<Product, 'slug'>>
}
}
export type GetAllProductsQueryVariables = Exact<{
input: SearchInput
}>
export type GetAllProductsQuery = { __typename?: 'Query' } & {
search: { __typename?: 'SearchResponse' } & {
items: Array<{ __typename?: 'SearchResult' } & SearchResultFragment>
}
}
export type ActiveOrderQueryVariables = Exact<{ [key: string]: never }>
export type ActiveOrderQuery = { __typename?: 'Query' } & {
activeOrder?: Maybe<{ __typename?: 'Order' } & CartFragment>
}
export type GetCollectionsQueryVariables = Exact<{ [key: string]: never }>
export type GetCollectionsQuery = { __typename?: 'Query' } & {
collections: { __typename?: 'CollectionList' } & {
items: Array<
{ __typename?: 'Collection' } & Pick<
Collection,
'id' | 'name' | 'description' | 'slug'
> & {
productVariants: { __typename?: 'ProductVariantList' } & Pick<
ProductVariantList,
'totalItems'
>
parent?: Maybe<{ __typename?: 'Collection' } & Pick<Collection, 'id'>>
children?: Maybe<
Array<{ __typename?: 'Collection' } & Pick<Collection, 'id'>>
>
}
>
}
}
export type GetProductQueryVariables = Exact<{
slug: Scalars['String']
}>
export type GetProductQuery = { __typename?: 'Query' } & {
product?: Maybe<
{ __typename?: 'Product' } & Pick<
Product,
'id' | 'name' | 'slug' | 'description'
> & {
assets: Array<
{ __typename?: 'Asset' } & Pick<Asset, 'id' | 'preview' | 'name'>
>
variants: Array<
{ __typename?: 'ProductVariant' } & Pick<
ProductVariant,
'id' | 'priceWithTax' | 'currencyCode'
> & {
options: Array<
{ __typename?: 'ProductOption' } & Pick<
ProductOption,
'id' | 'name' | 'code' | 'groupId'
> & {
group: { __typename?: 'ProductOptionGroup' } & Pick<
ProductOptionGroup,
'id'
> & {
options: Array<
{ __typename?: 'ProductOption' } & Pick<
ProductOption,
'name'
>
>
}
}
>
}
>
optionGroups: Array<
{ __typename?: 'ProductOptionGroup' } & Pick<
ProductOptionGroup,
'id' | 'code' | 'name'
> & {
options: Array<
{ __typename?: 'ProductOption' } & Pick<
ProductOption,
'id' | 'name'
>
>
}
>
}
>
}
export type SearchQueryVariables = Exact<{
input: SearchInput
}>
export type SearchQuery = { __typename?: 'Query' } & {
search: { __typename?: 'SearchResponse' } & Pick<
SearchResponse,
'totalItems'
> & { items: Array<{ __typename?: 'SearchResult' } & SearchResultFragment> }
}