export type Maybe = T; export type InputMaybe = T; export type Exact = { [K in keyof T]: T[K]; }; export type MakeOptional = Omit & { [SubKey in K]?: Maybe; }; export type MakeMaybe = Omit & { [SubKey in K]: Maybe; }; export type MakeEmpty = { [_ in K]?: never; }; export type Incremental = T | { [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never; }; /** All built-in and custom scalars, mapped to their actual values */ export type Scalars = { ID: { input: string | number; output: string | number; }; 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; }; Money: { input: number; output: number; }; Upload: { input: any; output: any; }; }; export type ActiveOrderResult = NoActiveOrderError | Order; export type AddPaymentToOrderResult = IneligiblePaymentMethodError | NoActiveOrderError | Order | OrderPaymentStateError | OrderStateTransitionError | PaymentDeclinedError | PaymentFailedError; export type Address = Node & { __typename?: 'Address'; city?: Maybe; company?: Maybe; country: Country; createdAt: Scalars['DateTime']['output']; customFields?: Maybe; defaultBillingAddress?: Maybe; defaultShippingAddress?: Maybe; fullName?: Maybe; id: Scalars['ID']['output']; phoneNumber?: Maybe; postalCode?: Maybe; province?: Maybe; streetLine1: Scalars['String']['output']; streetLine2?: Maybe; updatedAt: Scalars['DateTime']['output']; }; export type Adjustment = { __typename?: 'Adjustment'; adjustmentSource: Scalars['String']['output']; amount: Scalars['Money']['output']; data?: Maybe; description: Scalars['String']['output']; type: AdjustmentType; }; export declare enum AdjustmentType { DISTRIBUTED_ORDER_PROMOTION = "DISTRIBUTED_ORDER_PROMOTION", OTHER = "OTHER", PROMOTION = "PROMOTION" } /** Returned when attempting to set the Customer for an Order when already logged in. */ export type AlreadyLoggedInError = ErrorResult & { __typename?: 'AlreadyLoggedInError'; errorCode: ErrorCode; message: Scalars['String']['output']; }; export type ApplyCouponCodeResult = CouponCodeExpiredError | CouponCodeInvalidError | CouponCodeLimitError | Order; export type Asset = Node & { __typename?: 'Asset'; createdAt: Scalars['DateTime']['output']; customFields?: Maybe; fileSize: Scalars['Int']['output']; focalPoint?: Maybe; height: Scalars['Int']['output']; id: Scalars['ID']['output']; mimeType: Scalars['String']['output']; name: Scalars['String']['output']; preview: Scalars['String']['output']; source: Scalars['String']['output']; tags: Array; type: AssetType; updatedAt: Scalars['DateTime']['output']; width: Scalars['Int']['output']; }; export type AssetList = PaginatedList & { __typename?: 'AssetList'; items: Array; totalItems: Scalars['Int']['output']; }; export declare enum AssetType { BINARY = "BINARY", IMAGE = "IMAGE", VIDEO = "VIDEO" } export type AuthenticationInput = { native?: InputMaybe; }; export type AuthenticationMethod = Node & { __typename?: 'AuthenticationMethod'; createdAt: Scalars['DateTime']['output']; id: Scalars['ID']['output']; strategy: Scalars['String']['output']; updatedAt: Scalars['DateTime']['output']; }; export type AuthenticationResult = CurrentUser | InvalidCredentialsError | NotVerifiedError; export type BooleanCustomFieldConfig = CustomField & { __typename?: 'BooleanCustomFieldConfig'; description?: Maybe>; internal?: Maybe; label?: Maybe>; list: Scalars['Boolean']['output']; name: Scalars['String']['output']; nullable?: Maybe; readonly?: Maybe; requiresPermission?: Maybe>; type: Scalars['String']['output']; ui?: Maybe; }; /** Operators for filtering on a list of Boolean fields */ export type BooleanListOperators = { inList: Scalars['Boolean']['input']; }; /** Operators for filtering on a Boolean field */ export type BooleanOperators = { eq?: InputMaybe; isNull?: InputMaybe; }; export type BooleanStructFieldConfig = StructField & { __typename?: 'BooleanStructFieldConfig'; description?: Maybe>; label?: Maybe>; list: Scalars['Boolean']['output']; name: Scalars['String']['output']; type: Scalars['String']['output']; ui?: Maybe; }; export type Channel = Node & { __typename?: 'Channel'; availableCurrencyCodes: Array; availableLanguageCodes?: Maybe>; code: Scalars['String']['output']; createdAt: Scalars['DateTime']['output']; /** @deprecated Use defaultCurrencyCode instead */ currencyCode: CurrencyCode; customFields?: Maybe; defaultCurrencyCode: CurrencyCode; defaultLanguageCode: LanguageCode; defaultShippingZone?: Maybe; defaultTaxZone?: Maybe; id: Scalars['ID']['output']; /** Not yet used - will be implemented in a future release. */ outOfStockThreshold?: Maybe; pricesIncludeTax: Scalars['Boolean']['output']; seller?: Maybe; token: Scalars['String']['output']; /** Not yet used - will be implemented in a future release. */ trackInventory?: Maybe; updatedAt: Scalars['DateTime']['output']; }; export type Collection = Node & { __typename?: 'Collection'; assets: Array; breadcrumbs: Array; children?: Maybe>; createdAt: Scalars['DateTime']['output']; customFields?: Maybe; description: Scalars['String']['output']; featuredAsset?: Maybe; filters: Array; id: Scalars['ID']['output']; languageCode?: Maybe; name: Scalars['String']['output']; parent?: Maybe; parentId: Scalars['ID']['output']; position: Scalars['Int']['output']; productVariants: ProductVariantList; slug: Scalars['String']['output']; translations: Array; updatedAt: Scalars['DateTime']['output']; }; export type CollectionProductVariantsArgs = { options?: InputMaybe; }; export type CollectionBreadcrumb = { __typename?: 'CollectionBreadcrumb'; id: Scalars['ID']['output']; name: Scalars['String']['output']; slug: Scalars['String']['output']; }; export type CollectionFilterParameter = { _and?: InputMaybe>; _or?: InputMaybe>; createdAt?: InputMaybe; description?: InputMaybe; id?: InputMaybe; languageCode?: InputMaybe; name?: InputMaybe; parentId?: InputMaybe; position?: InputMaybe; slug?: InputMaybe; updatedAt?: InputMaybe; }; export type CollectionList = PaginatedList & { __typename?: 'CollectionList'; items: Array; totalItems: Scalars['Int']['output']; }; export type CollectionListOptions = { /** Allows the results to be filtered */ filter?: InputMaybe; /** Specifies whether multiple top-level "filter" fields should be combined with a logical AND or OR operation. Defaults to AND. */ filterOperator?: InputMaybe; /** Skips the first n results, for use in pagination */ skip?: InputMaybe; /** Specifies which properties to sort the results by */ sort?: InputMaybe; /** Takes n results, for use in pagination */ take?: InputMaybe; topLevelOnly?: InputMaybe; }; /** * Which Collections are present in the products returned * by the search, and in what quantity. */ export type CollectionResult = { __typename?: 'CollectionResult'; collection: Collection; count: Scalars['Int']['output']; }; export type CollectionSortParameter = { createdAt?: InputMaybe; description?: InputMaybe; id?: InputMaybe; name?: InputMaybe; parentId?: InputMaybe; position?: InputMaybe; slug?: InputMaybe; updatedAt?: InputMaybe; }; export type CollectionTranslation = { __typename?: 'CollectionTranslation'; createdAt: Scalars['DateTime']['output']; description: Scalars['String']['output']; id: Scalars['ID']['output']; languageCode: LanguageCode; name: Scalars['String']['output']; slug: Scalars['String']['output']; updatedAt: Scalars['DateTime']['output']; }; export type ConfigArg = { __typename?: 'ConfigArg'; name: Scalars['String']['output']; value: Scalars['String']['output']; }; export type ConfigArgDefinition = { __typename?: 'ConfigArgDefinition'; defaultValue?: Maybe; description?: Maybe; label?: Maybe; list: Scalars['Boolean']['output']; name: Scalars['String']['output']; required: Scalars['Boolean']['output']; type: Scalars['String']['output']; ui?: Maybe; }; export type ConfigArgInput = { name: Scalars['String']['input']; /** A JSON stringified representation of the actual value */ value: Scalars['String']['input']; }; export type ConfigurableOperation = { __typename?: 'ConfigurableOperation'; args: Array; code: Scalars['String']['output']; }; export type ConfigurableOperationDefinition = { __typename?: 'ConfigurableOperationDefinition'; args: Array; code: Scalars['String']['output']; description: Scalars['String']['output']; }; export type ConfigurableOperationInput = { arguments: Array; code: Scalars['String']['input']; }; export type Coordinate = { __typename?: 'Coordinate'; x: Scalars['Float']['output']; y: Scalars['Float']['output']; }; /** * A Country of the world which your shop operates in. * * The `code` field is typically a 2-character ISO code such as "GB", "US", "DE" etc. This code is used in certain inputs such as * `UpdateAddressInput` and `CreateAddressInput` to specify the country. */ export type Country = Node & Region & { __typename?: 'Country'; code: Scalars['String']['output']; createdAt: Scalars['DateTime']['output']; customFields?: Maybe; enabled: Scalars['Boolean']['output']; id: Scalars['ID']['output']; languageCode: LanguageCode; name: Scalars['String']['output']; parent?: Maybe; parentId?: Maybe; translations: Array; type: Scalars['String']['output']; updatedAt: Scalars['DateTime']['output']; }; export type CountryList = PaginatedList & { __typename?: 'CountryList'; items: Array; totalItems: Scalars['Int']['output']; }; /** Returned if the provided coupon code is invalid */ export type CouponCodeExpiredError = ErrorResult & { __typename?: 'CouponCodeExpiredError'; couponCode: Scalars['String']['output']; errorCode: ErrorCode; message: Scalars['String']['output']; }; /** Returned if the provided coupon code is invalid */ export type CouponCodeInvalidError = ErrorResult & { __typename?: 'CouponCodeInvalidError'; couponCode: Scalars['String']['output']; errorCode: ErrorCode; message: Scalars['String']['output']; }; /** Returned if the provided coupon code is invalid */ export type CouponCodeLimitError = ErrorResult & { __typename?: 'CouponCodeLimitError'; couponCode: Scalars['String']['output']; errorCode: ErrorCode; limit: Scalars['Int']['output']; message: Scalars['String']['output']; }; /** * Input used to create an Address. * * The countryCode must correspond to a `code` property of a Country that has been defined in the * Vendure server. The `code` property is typically a 2-character ISO code such as "GB", "US", "DE" etc. * If an invalid code is passed, the mutation will fail. */ export type CreateAddressInput = { city?: InputMaybe; company?: InputMaybe; countryCode: Scalars['String']['input']; customFields?: InputMaybe; defaultBillingAddress?: InputMaybe; defaultShippingAddress?: InputMaybe; fullName?: InputMaybe; phoneNumber?: InputMaybe; postalCode?: InputMaybe; province?: InputMaybe; streetLine1: Scalars['String']['input']; streetLine2?: InputMaybe; }; export type CreateCustomerInput = { customFields?: InputMaybe; emailAddress: Scalars['String']['input']; firstName: Scalars['String']['input']; lastName: Scalars['String']['input']; phoneNumber?: InputMaybe; title?: InputMaybe; }; /** * @description * ISO 4217 currency code * * @docsCategory common */ export declare 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 CurrentUser = { __typename?: 'CurrentUser'; channels: Array; id: Scalars['ID']['output']; identifier: Scalars['String']['output']; }; export type CurrentUserChannel = { __typename?: 'CurrentUserChannel'; code: Scalars['String']['output']; id: Scalars['ID']['output']; permissions: Array; token: Scalars['String']['output']; }; export type CustomField = { description?: Maybe>; internal?: Maybe; label?: Maybe>; list: Scalars['Boolean']['output']; name: Scalars['String']['output']; nullable?: Maybe; readonly?: Maybe; requiresPermission?: Maybe>; type: Scalars['String']['output']; ui?: Maybe; }; export type CustomFieldConfig = BooleanCustomFieldConfig | DateTimeCustomFieldConfig | FloatCustomFieldConfig | IntCustomFieldConfig | LocaleStringCustomFieldConfig | LocaleTextCustomFieldConfig | RelationCustomFieldConfig | StringCustomFieldConfig | StructCustomFieldConfig | TextCustomFieldConfig; export type Customer = Node & { __typename?: 'Customer'; addresses?: Maybe>; createdAt: Scalars['DateTime']['output']; customFields?: Maybe; emailAddress: Scalars['String']['output']; firstName: Scalars['String']['output']; id: Scalars['ID']['output']; lastName: Scalars['String']['output']; orders: OrderList; phoneNumber?: Maybe; title?: Maybe; updatedAt: Scalars['DateTime']['output']; user?: Maybe; }; export type CustomerOrdersArgs = { options?: InputMaybe; }; export type CustomerFilterParameter = { _and?: InputMaybe>; _or?: InputMaybe>; createdAt?: InputMaybe; emailAddress?: InputMaybe; firstName?: InputMaybe; id?: InputMaybe; lastName?: InputMaybe; phoneNumber?: InputMaybe; title?: InputMaybe; updatedAt?: InputMaybe; }; export type CustomerGroup = Node & { __typename?: 'CustomerGroup'; createdAt: Scalars['DateTime']['output']; customFields?: Maybe; customers: CustomerList; id: Scalars['ID']['output']; name: Scalars['String']['output']; updatedAt: Scalars['DateTime']['output']; }; export type CustomerGroupCustomersArgs = { options?: InputMaybe; }; export type CustomerList = PaginatedList & { __typename?: 'CustomerList'; items: Array; totalItems: Scalars['Int']['output']; }; export type CustomerListOptions = { /** Allows the results to be filtered */ filter?: InputMaybe; /** Specifies whether multiple top-level "filter" fields should be combined with a logical AND or OR operation. Defaults to AND. */ filterOperator?: InputMaybe; /** Skips the first n results, for use in pagination */ skip?: InputMaybe; /** Specifies which properties to sort the results by */ sort?: InputMaybe; /** Takes n results, for use in pagination */ take?: InputMaybe; }; export type CustomerSortParameter = { createdAt?: InputMaybe; emailAddress?: InputMaybe; firstName?: InputMaybe; id?: InputMaybe; lastName?: InputMaybe; phoneNumber?: InputMaybe; title?: InputMaybe; updatedAt?: InputMaybe; }; /** Operators for filtering on a list of Date fields */ export type DateListOperators = { inList: Scalars['DateTime']['input']; }; /** Operators for filtering on a DateTime field */ export type DateOperators = { after?: InputMaybe; before?: InputMaybe; between?: InputMaybe; eq?: InputMaybe; isNull?: InputMaybe; }; export type DateRange = { end: Scalars['DateTime']['input']; start: Scalars['DateTime']['input']; }; /** * Expects the same validation formats as the `` HTML element. * See https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input/datetime-local#Additional_attributes */ export type DateTimeCustomFieldConfig = CustomField & { __typename?: 'DateTimeCustomFieldConfig'; description?: Maybe>; internal?: Maybe; label?: Maybe>; list: Scalars['Boolean']['output']; max?: Maybe; min?: Maybe; name: Scalars['String']['output']; nullable?: Maybe; readonly?: Maybe; requiresPermission?: Maybe>; step?: Maybe; type: Scalars['String']['output']; ui?: Maybe; }; /** * Expects the same validation formats as the `` HTML element. * See https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input/datetime-local#Additional_attributes */ export type DateTimeStructFieldConfig = StructField & { __typename?: 'DateTimeStructFieldConfig'; description?: Maybe>; label?: Maybe>; list: Scalars['Boolean']['output']; max?: Maybe; min?: Maybe; name: Scalars['String']['output']; step?: Maybe; type: Scalars['String']['output']; ui?: Maybe; }; export type DeletionResponse = { __typename?: 'DeletionResponse'; message?: Maybe; result: DeletionResult; }; export declare enum DeletionResult { /** The entity was successfully deleted */ DELETED = "DELETED", /** Deletion did not take place, reason given in message */ NOT_DELETED = "NOT_DELETED" } export type Discount = { __typename?: 'Discount'; adjustmentSource: Scalars['String']['output']; amount: Scalars['Money']['output']; amountWithTax: Scalars['Money']['output']; description: Scalars['String']['output']; type: AdjustmentType; }; /** Returned when attempting 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']['output']; }; export declare enum ErrorCode { ALREADY_LOGGED_IN_ERROR = "ALREADY_LOGGED_IN_ERROR", COUPON_CODE_EXPIRED_ERROR = "COUPON_CODE_EXPIRED_ERROR", COUPON_CODE_INVALID_ERROR = "COUPON_CODE_INVALID_ERROR", COUPON_CODE_LIMIT_ERROR = "COUPON_CODE_LIMIT_ERROR", EMAIL_ADDRESS_CONFLICT_ERROR = "EMAIL_ADDRESS_CONFLICT_ERROR", GUEST_CHECKOUT_ERROR = "GUEST_CHECKOUT_ERROR", IDENTIFIER_CHANGE_TOKEN_EXPIRED_ERROR = "IDENTIFIER_CHANGE_TOKEN_EXPIRED_ERROR", IDENTIFIER_CHANGE_TOKEN_INVALID_ERROR = "IDENTIFIER_CHANGE_TOKEN_INVALID_ERROR", INELIGIBLE_PAYMENT_METHOD_ERROR = "INELIGIBLE_PAYMENT_METHOD_ERROR", INELIGIBLE_SHIPPING_METHOD_ERROR = "INELIGIBLE_SHIPPING_METHOD_ERROR", INSUFFICIENT_STOCK_ERROR = "INSUFFICIENT_STOCK_ERROR", INVALID_CREDENTIALS_ERROR = "INVALID_CREDENTIALS_ERROR", MISSING_PASSWORD_ERROR = "MISSING_PASSWORD_ERROR", NATIVE_AUTH_STRATEGY_ERROR = "NATIVE_AUTH_STRATEGY_ERROR", NEGATIVE_QUANTITY_ERROR = "NEGATIVE_QUANTITY_ERROR", NOT_VERIFIED_ERROR = "NOT_VERIFIED_ERROR", NO_ACTIVE_ORDER_ERROR = "NO_ACTIVE_ORDER_ERROR", ORDER_INTERCEPTOR_ERROR = "ORDER_INTERCEPTOR_ERROR", ORDER_LIMIT_ERROR = "ORDER_LIMIT_ERROR", ORDER_MODIFICATION_ERROR = "ORDER_MODIFICATION_ERROR", ORDER_PAYMENT_STATE_ERROR = "ORDER_PAYMENT_STATE_ERROR", ORDER_STATE_TRANSITION_ERROR = "ORDER_STATE_TRANSITION_ERROR", PASSWORD_ALREADY_SET_ERROR = "PASSWORD_ALREADY_SET_ERROR", PASSWORD_RESET_TOKEN_EXPIRED_ERROR = "PASSWORD_RESET_TOKEN_EXPIRED_ERROR", PASSWORD_RESET_TOKEN_INVALID_ERROR = "PASSWORD_RESET_TOKEN_INVALID_ERROR", PASSWORD_VALIDATION_ERROR = "PASSWORD_VALIDATION_ERROR", PAYMENT_DECLINED_ERROR = "PAYMENT_DECLINED_ERROR", PAYMENT_FAILED_ERROR = "PAYMENT_FAILED_ERROR", UNKNOWN_ERROR = "UNKNOWN_ERROR", VERIFICATION_TOKEN_EXPIRED_ERROR = "VERIFICATION_TOKEN_EXPIRED_ERROR", VERIFICATION_TOKEN_INVALID_ERROR = "VERIFICATION_TOKEN_INVALID_ERROR" } export type ErrorResult = { errorCode: ErrorCode; message: Scalars['String']['output']; }; export type Facet = Node & { __typename?: 'Facet'; code: Scalars['String']['output']; createdAt: Scalars['DateTime']['output']; customFields?: Maybe; id: Scalars['ID']['output']; languageCode: LanguageCode; name: Scalars['String']['output']; translations: Array; updatedAt: Scalars['DateTime']['output']; /** Returns a paginated, sortable, filterable list of the Facet's values. Added in v2.1.0. */ valueList: FacetValueList; values: Array; }; export type FacetValueListArgs = { options?: InputMaybe; }; export type FacetFilterParameter = { _and?: InputMaybe>; _or?: InputMaybe>; code?: InputMaybe; createdAt?: InputMaybe; id?: InputMaybe; languageCode?: InputMaybe; name?: InputMaybe; updatedAt?: InputMaybe; }; export type FacetList = PaginatedList & { __typename?: 'FacetList'; items: Array; totalItems: Scalars['Int']['output']; }; export type FacetListOptions = { /** Allows the results to be filtered */ filter?: InputMaybe; /** Specifies whether multiple top-level "filter" fields should be combined with a logical AND or OR operation. Defaults to AND. */ filterOperator?: InputMaybe; /** Skips the first n results, for use in pagination */ skip?: InputMaybe; /** Specifies which properties to sort the results by */ sort?: InputMaybe; /** Takes n results, for use in pagination */ take?: InputMaybe; }; export type FacetSortParameter = { code?: InputMaybe; createdAt?: InputMaybe; id?: InputMaybe; name?: InputMaybe; updatedAt?: InputMaybe; }; export type FacetTranslation = { __typename?: 'FacetTranslation'; createdAt: Scalars['DateTime']['output']; id: Scalars['ID']['output']; languageCode: LanguageCode; name: Scalars['String']['output']; updatedAt: Scalars['DateTime']['output']; }; export type FacetValue = Node & { __typename?: 'FacetValue'; code: Scalars['String']['output']; createdAt: Scalars['DateTime']['output']; customFields?: Maybe; facet: Facet; facetId: Scalars['ID']['output']; id: Scalars['ID']['output']; languageCode: LanguageCode; name: Scalars['String']['output']; translations: Array; updatedAt: Scalars['DateTime']['output']; }; /** * 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?: InputMaybe; or?: InputMaybe>; }; export type FacetValueFilterParameter = { _and?: InputMaybe>; _or?: InputMaybe>; code?: InputMaybe; createdAt?: InputMaybe; facetId?: InputMaybe; id?: InputMaybe; languageCode?: InputMaybe; name?: InputMaybe; updatedAt?: InputMaybe; }; export type FacetValueList = PaginatedList & { __typename?: 'FacetValueList'; items: Array; totalItems: Scalars['Int']['output']; }; export type FacetValueListOptions = { /** Allows the results to be filtered */ filter?: InputMaybe; /** Specifies whether multiple top-level "filter" fields should be combined with a logical AND or OR operation. Defaults to AND. */ filterOperator?: InputMaybe; /** Skips the first n results, for use in pagination */ skip?: InputMaybe; /** Specifies which properties to sort the results by */ sort?: InputMaybe; /** Takes n results, for use in pagination */ take?: InputMaybe; }; /** * Which FacetValues are present in the products returned * by the search, and in what quantity. */ export type FacetValueResult = { __typename?: 'FacetValueResult'; count: Scalars['Int']['output']; facetValue: FacetValue; }; export type FacetValueSortParameter = { code?: InputMaybe; createdAt?: InputMaybe; facetId?: InputMaybe; id?: InputMaybe; name?: InputMaybe; updatedAt?: InputMaybe; }; export type FacetValueTranslation = { __typename?: 'FacetValueTranslation'; createdAt: Scalars['DateTime']['output']; id: Scalars['ID']['output']; languageCode: LanguageCode; name: Scalars['String']['output']; updatedAt: Scalars['DateTime']['output']; }; export type FloatCustomFieldConfig = CustomField & { __typename?: 'FloatCustomFieldConfig'; description?: Maybe>; internal?: Maybe; label?: Maybe>; list: Scalars['Boolean']['output']; max?: Maybe; min?: Maybe; name: Scalars['String']['output']; nullable?: Maybe; readonly?: Maybe; requiresPermission?: Maybe>; step?: Maybe; type: Scalars['String']['output']; ui?: Maybe; }; export type FloatStructFieldConfig = StructField & { __typename?: 'FloatStructFieldConfig'; description?: Maybe>; label?: Maybe>; list: Scalars['Boolean']['output']; max?: Maybe; min?: Maybe; name: Scalars['String']['output']; step?: Maybe; type: Scalars['String']['output']; ui?: Maybe; }; export type Fulfillment = Node & { __typename?: 'Fulfillment'; createdAt: Scalars['DateTime']['output']; customFields?: Maybe; id: Scalars['ID']['output']; lines: Array; method: Scalars['String']['output']; state: Scalars['String']['output']; /** @deprecated Use the `lines` field instead */ summary: Array; trackingCode?: Maybe; updatedAt: Scalars['DateTime']['output']; }; export type FulfillmentLine = { __typename?: 'FulfillmentLine'; fulfillment: Fulfillment; fulfillmentId: Scalars['ID']['output']; orderLine: OrderLine; orderLineId: Scalars['ID']['output']; quantity: Scalars['Int']['output']; }; export declare enum GlobalFlag { FALSE = "FALSE", INHERIT = "INHERIT", TRUE = "TRUE" } /** Returned when attempting to set the Customer on a guest checkout when the configured GuestCheckoutStrategy does not allow it. */ export type GuestCheckoutError = ErrorResult & { __typename?: 'GuestCheckoutError'; errorCode: ErrorCode; errorDetail: Scalars['String']['output']; message: Scalars['String']['output']; }; export type HistoryEntry = Node & { __typename?: 'HistoryEntry'; createdAt: Scalars['DateTime']['output']; customFields?: Maybe; data: Scalars['JSON']['output']; id: Scalars['ID']['output']; type: HistoryEntryType; updatedAt: Scalars['DateTime']['output']; }; export type HistoryEntryFilterParameter = { _and?: InputMaybe>; _or?: InputMaybe>; createdAt?: InputMaybe; id?: InputMaybe; type?: InputMaybe; updatedAt?: InputMaybe; }; export type HistoryEntryList = PaginatedList & { __typename?: 'HistoryEntryList'; items: Array; totalItems: Scalars['Int']['output']; }; export type HistoryEntryListOptions = { /** Allows the results to be filtered */ filter?: InputMaybe; /** Specifies whether multiple top-level "filter" fields should be combined with a logical AND or OR operation. Defaults to AND. */ filterOperator?: InputMaybe; /** Skips the first n results, for use in pagination */ skip?: InputMaybe; /** Specifies which properties to sort the results by */ sort?: InputMaybe; /** Takes n results, for use in pagination */ take?: InputMaybe; }; export type HistoryEntrySortParameter = { createdAt?: InputMaybe; id?: InputMaybe; updatedAt?: InputMaybe; }; export declare enum HistoryEntryType { CUSTOMER_ADDED_TO_GROUP = "CUSTOMER_ADDED_TO_GROUP", CUSTOMER_ADDRESS_CREATED = "CUSTOMER_ADDRESS_CREATED", CUSTOMER_ADDRESS_DELETED = "CUSTOMER_ADDRESS_DELETED", CUSTOMER_ADDRESS_UPDATED = "CUSTOMER_ADDRESS_UPDATED", CUSTOMER_DETAIL_UPDATED = "CUSTOMER_DETAIL_UPDATED", CUSTOMER_EMAIL_UPDATE_REQUESTED = "CUSTOMER_EMAIL_UPDATE_REQUESTED", CUSTOMER_EMAIL_UPDATE_VERIFIED = "CUSTOMER_EMAIL_UPDATE_VERIFIED", CUSTOMER_NOTE = "CUSTOMER_NOTE", CUSTOMER_PASSWORD_RESET_REQUESTED = "CUSTOMER_PASSWORD_RESET_REQUESTED", CUSTOMER_PASSWORD_RESET_VERIFIED = "CUSTOMER_PASSWORD_RESET_VERIFIED", CUSTOMER_PASSWORD_UPDATED = "CUSTOMER_PASSWORD_UPDATED", CUSTOMER_REGISTERED = "CUSTOMER_REGISTERED", CUSTOMER_REMOVED_FROM_GROUP = "CUSTOMER_REMOVED_FROM_GROUP", CUSTOMER_VERIFIED = "CUSTOMER_VERIFIED", ORDER_CANCELLATION = "ORDER_CANCELLATION", ORDER_COUPON_APPLIED = "ORDER_COUPON_APPLIED", ORDER_COUPON_REMOVED = "ORDER_COUPON_REMOVED", ORDER_CUSTOMER_UPDATED = "ORDER_CUSTOMER_UPDATED", ORDER_FULFILLMENT = "ORDER_FULFILLMENT", ORDER_FULFILLMENT_TRANSITION = "ORDER_FULFILLMENT_TRANSITION", ORDER_MODIFIED = "ORDER_MODIFIED", ORDER_NOTE = "ORDER_NOTE", ORDER_PAYMENT_TRANSITION = "ORDER_PAYMENT_TRANSITION", ORDER_REFUND_TRANSITION = "ORDER_REFUND_TRANSITION", ORDER_STATE_TRANSITION = "ORDER_STATE_TRANSITION" } /** Operators for filtering on a list of ID fields */ export type IdListOperators = { inList: Scalars['ID']['input']; }; /** Operators for filtering on an ID field */ export type IdOperators = { eq?: InputMaybe; in?: InputMaybe>; isNull?: InputMaybe; notEq?: InputMaybe; notIn?: InputMaybe>; }; /** * Returned 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']['output']; }; /** * Returned 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']['output']; }; /** Returned when attempting to add a Payment using a PaymentMethod for which the Order is not eligible. */ export type IneligiblePaymentMethodError = ErrorResult & { __typename?: 'IneligiblePaymentMethodError'; eligibilityCheckerMessage?: Maybe; errorCode: ErrorCode; message: Scalars['String']['output']; }; /** 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']['output']; }; /** Returned when attempting to add more items to the Order than are available */ export type InsufficientStockError = ErrorResult & { __typename?: 'InsufficientStockError'; errorCode: ErrorCode; message: Scalars['String']['output']; order: Order; quantityAvailable: Scalars['Int']['output']; }; export type IntCustomFieldConfig = CustomField & { __typename?: 'IntCustomFieldConfig'; description?: Maybe>; internal?: Maybe; label?: Maybe>; list: Scalars['Boolean']['output']; max?: Maybe; min?: Maybe; name: Scalars['String']['output']; nullable?: Maybe; readonly?: Maybe; requiresPermission?: Maybe>; step?: Maybe; type: Scalars['String']['output']; ui?: Maybe; }; export type IntStructFieldConfig = StructField & { __typename?: 'IntStructFieldConfig'; description?: Maybe>; label?: Maybe>; list: Scalars['Boolean']['output']; max?: Maybe; min?: Maybe; name: Scalars['String']['output']; step?: Maybe; type: Scalars['String']['output']; ui?: Maybe; }; /** Returned if the user authentication credentials are not valid */ export type InvalidCredentialsError = ErrorResult & { __typename?: 'InvalidCredentialsError'; authenticationError: Scalars['String']['output']; errorCode: ErrorCode; message: Scalars['String']['output']; }; /** * @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 declare enum LanguageCode { /** Afrikaans */ af = "af", /** Akan */ ak = "ak", /** Amharic */ am = "am", /** Arabic */ ar = "ar", /** Assamese */ as = "as", /** Azerbaijani */ az = "az", /** Belarusian */ be = "be", /** Bulgarian */ bg = "bg", /** Bambara */ bm = "bm", /** Bangla */ bn = "bn", /** Tibetan */ bo = "bo", /** Breton */ br = "br", /** Bosnian */ bs = "bs", /** Catalan */ ca = "ca", /** Chechen */ ce = "ce", /** Corsican */ co = "co", /** Czech */ cs = "cs", /** Church Slavic */ cu = "cu", /** Welsh */ cy = "cy", /** Danish */ da = "da", /** German */ de = "de", /** Austrian German */ de_AT = "de_AT", /** Swiss High German */ de_CH = "de_CH", /** Dzongkha */ dz = "dz", /** Ewe */ ee = "ee", /** Greek */ el = "el", /** English */ en = "en", /** Australian English */ en_AU = "en_AU", /** Canadian English */ en_CA = "en_CA", /** British English */ en_GB = "en_GB", /** American English */ en_US = "en_US", /** Esperanto */ eo = "eo", /** Spanish */ es = "es", /** European Spanish */ es_ES = "es_ES", /** Mexican Spanish */ es_MX = "es_MX", /** Estonian */ et = "et", /** Basque */ eu = "eu", /** Persian */ fa = "fa", /** Dari */ fa_AF = "fa_AF", /** Fulah */ ff = "ff", /** Finnish */ fi = "fi", /** Faroese */ fo = "fo", /** French */ fr = "fr", /** Canadian French */ fr_CA = "fr_CA", /** Swiss French */ fr_CH = "fr_CH", /** Western Frisian */ fy = "fy", /** Irish */ ga = "ga", /** Scottish Gaelic */ gd = "gd", /** Galician */ gl = "gl", /** Gujarati */ gu = "gu", /** Manx */ gv = "gv", /** Hausa */ ha = "ha", /** Hebrew */ he = "he", /** Hindi */ hi = "hi", /** Croatian */ hr = "hr", /** Haitian Creole */ ht = "ht", /** Hungarian */ hu = "hu", /** Armenian */ hy = "hy", /** Interlingua */ ia = "ia", /** Indonesian */ id = "id", /** Igbo */ ig = "ig", /** Sichuan Yi */ ii = "ii", /** Icelandic */ is = "is", /** Italian */ it = "it", /** Japanese */ ja = "ja", /** Javanese */ jv = "jv", /** Georgian */ ka = "ka", /** Kikuyu */ ki = "ki", /** Kazakh */ kk = "kk", /** Kalaallisut */ kl = "kl", /** Khmer */ km = "km", /** Kannada */ kn = "kn", /** Korean */ ko = "ko", /** Kashmiri */ ks = "ks", /** Kurdish */ ku = "ku", /** Cornish */ kw = "kw", /** Kyrgyz */ ky = "ky", /** Latin */ la = "la", /** Luxembourgish */ lb = "lb", /** Ganda */ lg = "lg", /** Lingala */ ln = "ln", /** Lao */ lo = "lo", /** Lithuanian */ lt = "lt", /** Luba-Katanga */ lu = "lu", /** Latvian */ lv = "lv", /** Malagasy */ mg = "mg", /** Maori */ mi = "mi", /** Macedonian */ mk = "mk", /** Malayalam */ ml = "ml", /** Mongolian */ mn = "mn", /** Marathi */ mr = "mr", /** Malay */ ms = "ms", /** Maltese */ mt = "mt", /** Burmese */ my = "my", /** Norwegian Bokmål */ nb = "nb", /** North Ndebele */ nd = "nd", /** Nepali */ ne = "ne", /** Dutch */ nl = "nl", /** Flemish */ nl_BE = "nl_BE", /** Norwegian Nynorsk */ nn = "nn", /** Nyanja */ ny = "ny", /** Oromo */ om = "om", /** Odia */ or = "or", /** Ossetic */ os = "os", /** Punjabi */ pa = "pa", /** Polish */ pl = "pl", /** Pashto */ ps = "ps", /** Portuguese */ pt = "pt", /** Brazilian Portuguese */ pt_BR = "pt_BR", /** European Portuguese */ pt_PT = "pt_PT", /** Quechua */ qu = "qu", /** Romansh */ rm = "rm", /** Rundi */ rn = "rn", /** Romanian */ ro = "ro", /** Moldavian */ ro_MD = "ro_MD", /** Russian */ ru = "ru", /** Kinyarwanda */ rw = "rw", /** Sanskrit */ sa = "sa", /** Sindhi */ sd = "sd", /** Northern Sami */ se = "se", /** Sango */ sg = "sg", /** Sinhala */ si = "si", /** Slovak */ sk = "sk", /** Slovenian */ sl = "sl", /** Samoan */ sm = "sm", /** Shona */ sn = "sn", /** Somali */ so = "so", /** Albanian */ sq = "sq", /** Serbian */ sr = "sr", /** Southern Sotho */ st = "st", /** Sundanese */ su = "su", /** Swedish */ sv = "sv", /** Swahili */ sw = "sw", /** Congo Swahili */ sw_CD = "sw_CD", /** Tamil */ ta = "ta", /** Telugu */ te = "te", /** Tajik */ tg = "tg", /** Thai */ th = "th", /** Tigrinya */ ti = "ti", /** Turkmen */ tk = "tk", /** Tongan */ to = "to", /** Turkish */ tr = "tr", /** Tatar */ tt = "tt", /** Uyghur */ ug = "ug", /** Ukrainian */ uk = "uk", /** Urdu */ ur = "ur", /** Uzbek */ uz = "uz", /** Vietnamese */ vi = "vi", /** Volapük */ vo = "vo", /** Wolof */ wo = "wo", /** Xhosa */ xh = "xh", /** Yiddish */ yi = "yi", /** Yoruba */ yo = "yo", /** Chinese */ zh = "zh", /** Simplified Chinese */ zh_Hans = "zh_Hans", /** Traditional Chinese */ zh_Hant = "zh_Hant", /** Zulu */ zu = "zu" } export type LocaleStringCustomFieldConfig = CustomField & { __typename?: 'LocaleStringCustomFieldConfig'; description?: Maybe>; internal?: Maybe; label?: Maybe>; length?: Maybe; list: Scalars['Boolean']['output']; name: Scalars['String']['output']; nullable?: Maybe; pattern?: Maybe; readonly?: Maybe; requiresPermission?: Maybe>; type: Scalars['String']['output']; ui?: Maybe; }; export type LocaleTextCustomFieldConfig = CustomField & { __typename?: 'LocaleTextCustomFieldConfig'; description?: Maybe>; internal?: Maybe; label?: Maybe>; list: Scalars['Boolean']['output']; name: Scalars['String']['output']; nullable?: Maybe; readonly?: Maybe; requiresPermission?: Maybe>; type: Scalars['String']['output']; ui?: Maybe; }; export type LocalizedString = { __typename?: 'LocalizedString'; languageCode: LanguageCode; value: Scalars['String']['output']; }; export declare enum LogicalOperator { AND = "AND", OR = "OR" } /** Returned when attempting 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']['output']; }; 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; /** Add a Payment to the Order */ addPaymentToOrder: AddPaymentToOrderResult; /** 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; /** Authenticates the user using a named authentication strategy */ authenticate: AuthenticationResult; /** Create a new Customer Address */ createCustomerAddress: Address; /** Delete an existing Address */ deleteCustomerAddress: Success; /** * Authenticates the user using the native authentication strategy. This mutation is an alias for authenticate({ native: { ... }}) * * The `rememberMe` option applies when using cookie-based sessions, and if `true` it will set the maxAge of the session cookie * to 1 year. */ login: NativeAuthenticationResult; /** End the current authenticated session */ logout: Success; /** Regenerate and send a verification token for a new Customer registration. Only applicable if `authOptions.requireVerification` is set to true. */ refreshCustomerVerification: RefreshCustomerVerificationResult; /** * 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 chosen 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; /** Remove all OrderLine from the Order */ removeAllOrderLines: RemoveOrderItemsResult; /** Removes the given coupon code from the active Order */ removeCouponCode?: Maybe; /** Remove an OrderLine from the Order */ removeOrderLine: RemoveOrderItemsResult; /** Requests a password reset email to be sent */ requestPasswordReset?: Maybe; /** * 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; /** Resets a Customer's password based on the provided token */ resetPassword: ResetPasswordResult; /** Set the Customer for the Order. Required only if the Customer is not currently logged in */ setCustomerForOrder: SetCustomerForOrderResult; /** Sets the billing address for the active Order */ setOrderBillingAddress: ActiveOrderResult; /** Allows any custom fields to be set for the active Order */ setOrderCustomFields: ActiveOrderResult; /** Sets the shipping address for the active Order */ setOrderShippingAddress: ActiveOrderResult; /** * Sets the shipping method by id, which can be obtained with the `eligibleShippingMethods` query. * An Order can have multiple shipping methods, in which case you can pass an array of ids. In this case, * you should configure a custom ShippingLineAssignmentStrategy in order to know which OrderLines each * shipping method will apply to. */ setOrderShippingMethod: SetOrderShippingMethodResult; /** Transitions an Order to a new state. Valid next states can be found by querying `nextOrderStates` */ transitionOrderToState?: Maybe; /** Unsets the billing address for the active Order. Available since version 3.1.0 */ unsetOrderBillingAddress: ActiveOrderResult; /** Unsets the shipping address for the active Order. Available since version 3.1.0 */ unsetOrderShippingAddress: ActiveOrderResult; /** Update an existing Customer */ updateCustomer: Customer; /** Update an existing Address */ updateCustomerAddress: Address; /** * Confirm the update of the emailAddress with the provided token, which has been generated by the * `requestUpdateCustomerEmailAddress` mutation. */ updateCustomerEmailAddress: UpdateCustomerEmailAddressResult; /** Update the password of the active Customer */ updateCustomerPassword: UpdateCustomerPasswordResult; /** * 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 password _must_ be * provided here. */ verifyCustomerAccount: VerifyCustomerAccountResult; }; export type MutationAddItemToOrderArgs = { productVariantId: Scalars['ID']['input']; quantity: Scalars['Int']['input']; }; export type MutationAddPaymentToOrderArgs = { input: PaymentInput; }; export type MutationAdjustOrderLineArgs = { orderLineId: Scalars['ID']['input']; quantity: Scalars['Int']['input']; }; export type MutationApplyCouponCodeArgs = { couponCode: Scalars['String']['input']; }; export type MutationAuthenticateArgs = { input: AuthenticationInput; rememberMe?: InputMaybe; }; export type MutationCreateCustomerAddressArgs = { input: CreateAddressInput; }; export type MutationDeleteCustomerAddressArgs = { id: Scalars['ID']['input']; }; export type MutationLoginArgs = { password: Scalars['String']['input']; rememberMe?: InputMaybe; username: Scalars['String']['input']; }; export type MutationRefreshCustomerVerificationArgs = { emailAddress: Scalars['String']['input']; }; export type MutationRegisterCustomerAccountArgs = { input: RegisterCustomerInput; }; export type MutationRemoveCouponCodeArgs = { couponCode: Scalars['String']['input']; }; export type MutationRemoveOrderLineArgs = { orderLineId: Scalars['ID']['input']; }; export type MutationRequestPasswordResetArgs = { emailAddress: Scalars['String']['input']; }; export type MutationRequestUpdateCustomerEmailAddressArgs = { newEmailAddress: Scalars['String']['input']; password: Scalars['String']['input']; }; export type MutationResetPasswordArgs = { password: Scalars['String']['input']; token: Scalars['String']['input']; }; export type MutationSetCustomerForOrderArgs = { input: CreateCustomerInput; }; export type MutationSetOrderBillingAddressArgs = { input: CreateAddressInput; }; export type MutationSetOrderCustomFieldsArgs = { input: UpdateOrderInput; }; export type MutationSetOrderShippingAddressArgs = { input: CreateAddressInput; }; export type MutationSetOrderShippingMethodArgs = { shippingMethodId: Array; }; export type MutationTransitionOrderToStateArgs = { state: Scalars['String']['input']; }; export type MutationUpdateCustomerArgs = { input: UpdateCustomerInput; }; export type MutationUpdateCustomerAddressArgs = { input: UpdateAddressInput; }; export type MutationUpdateCustomerEmailAddressArgs = { token: Scalars['String']['input']; }; export type MutationUpdateCustomerPasswordArgs = { currentPassword: Scalars['String']['input']; newPassword: Scalars['String']['input']; }; export type MutationVerifyCustomerAccountArgs = { password?: InputMaybe; token: Scalars['String']['input']; }; export type NativeAuthInput = { password: Scalars['String']['input']; username: Scalars['String']['input']; }; /** Returned 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']['output']; }; export type NativeAuthenticationResult = CurrentUser | InvalidCredentialsError | NativeAuthStrategyError | NotVerifiedError; /** Returned when attempting to set a negative OrderLine quantity. */ export type NegativeQuantityError = ErrorResult & { __typename?: 'NegativeQuantityError'; errorCode: ErrorCode; message: Scalars['String']['output']; }; /** * 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']['output']; }; export type Node = { id: Scalars['ID']['output']; }; /** * 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']['output']; }; /** Operators for filtering on a list of Number fields */ export type NumberListOperators = { inList: Scalars['Float']['input']; }; /** Operators for filtering on a Int or Float field */ export type NumberOperators = { between?: InputMaybe; eq?: InputMaybe; gt?: InputMaybe; gte?: InputMaybe; isNull?: InputMaybe; lt?: InputMaybe; lte?: InputMaybe; }; export type NumberRange = { end: Scalars['Float']['input']; start: Scalars['Float']['input']; }; export type Order = Node & { __typename?: 'Order'; /** An order is active as long as the payment process has not been completed */ active: Scalars['Boolean']['output']; billingAddress?: Maybe; /** A unique code for the Order */ code: Scalars['String']['output']; /** An array of all coupon codes applied to the Order */ couponCodes: Array; createdAt: Scalars['DateTime']['output']; currencyCode: CurrencyCode; customFields?: Maybe; customer?: Maybe; discounts: Array; fulfillments?: Maybe>; history: HistoryEntryList; id: Scalars['ID']['output']; lines: Array; /** * The date & time that the Order was placed, i.e. the Customer * completed the checkout and the Order is no longer "active" */ orderPlacedAt?: Maybe; payments?: Maybe>; /** Promotions applied to the order. Only gets populated after the payment process has completed. */ promotions: Array; shipping: Scalars['Money']['output']; shippingAddress?: Maybe; shippingLines: Array; shippingWithTax: Scalars['Money']['output']; state: Scalars['String']['output']; /** * 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 items of each OrderLine. * To get a total of all OrderLines which does not account for prorated discounts, use the * sum of `OrderLine.discountedLinePrice` values. */ subTotal: Scalars['Money']['output']; /** Same as subTotal, but inclusive of tax */ subTotalWithTax: Scalars['Money']['output']; /** * 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; /** A summary of the taxes being applied to this Order */ taxSummary: Array; /** Equal to subTotal plus shipping */ total: Scalars['Money']['output']; totalQuantity: Scalars['Int']['output']; /** The final payable amount. Equal to subTotalWithTax plus shippingWithTax */ totalWithTax: Scalars['Money']['output']; type: OrderType; updatedAt: Scalars['DateTime']['output']; }; export type OrderHistoryArgs = { options?: InputMaybe; }; export type OrderAddress = { __typename?: 'OrderAddress'; city?: Maybe; company?: Maybe; country?: Maybe; countryCode?: Maybe; customFields?: Maybe; fullName?: Maybe; phoneNumber?: Maybe; postalCode?: Maybe; province?: Maybe; streetLine1?: Maybe; streetLine2?: Maybe; }; export type OrderFilterParameter = { _and?: InputMaybe>; _or?: InputMaybe>; active?: InputMaybe; code?: InputMaybe; createdAt?: InputMaybe; currencyCode?: InputMaybe; id?: InputMaybe; orderPlacedAt?: InputMaybe; shipping?: InputMaybe; shippingWithTax?: InputMaybe; state?: InputMaybe; subTotal?: InputMaybe; subTotalWithTax?: InputMaybe; total?: InputMaybe; totalQuantity?: InputMaybe; totalWithTax?: InputMaybe; type?: InputMaybe; updatedAt?: InputMaybe; }; /** Returned when an order operation is rejected by an OrderInterceptor method. */ export type OrderInterceptorError = ErrorResult & { __typename?: 'OrderInterceptorError'; errorCode: ErrorCode; interceptorError: Scalars['String']['output']; message: Scalars['String']['output']; }; /** Returned when the maximum order size limit has been reached. */ export type OrderLimitError = ErrorResult & { __typename?: 'OrderLimitError'; errorCode: ErrorCode; maxItems: Scalars['Int']['output']; message: Scalars['String']['output']; }; export type OrderLine = Node & { __typename?: 'OrderLine'; createdAt: Scalars['DateTime']['output']; customFields?: Maybe; /** The price of the line including discounts, excluding tax */ discountedLinePrice: Scalars['Money']['output']; /** The price of the line including discounts and tax */ discountedLinePriceWithTax: Scalars['Money']['output']; /** * 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['Money']['output']; /** The price of a single unit including discounts and tax */ discountedUnitPriceWithTax: Scalars['Money']['output']; discounts: Array; featuredAsset?: Maybe; fulfillmentLines?: Maybe>; id: Scalars['ID']['output']; /** The total price of the line excluding tax and discounts. */ linePrice: Scalars['Money']['output']; /** The total price of the line including tax but excluding discounts. */ linePriceWithTax: Scalars['Money']['output']; /** The total tax on this line */ lineTax: Scalars['Money']['output']; order: Order; /** The quantity at the time the Order was placed */ orderPlacedQuantity: Scalars['Int']['output']; productVariant: ProductVariant; /** * The actual line price, taking into account both item discounts _and_ prorated (proportionally-distributed) * Order-level discounts. This value is the true economic value of the OrderLine, and is used in tax * and refund calculations. */ proratedLinePrice: Scalars['Money']['output']; /** The proratedLinePrice including tax */ proratedLinePriceWithTax: Scalars['Money']['output']; /** * The actual unit price, taking into account both item discounts _and_ prorated (proportionally-distributed) * Order-level discounts. This value is the true economic value of the OrderItem, and is used in tax * and refund calculations. */ proratedUnitPrice: Scalars['Money']['output']; /** The proratedUnitPrice including tax */ proratedUnitPriceWithTax: Scalars['Money']['output']; /** The quantity of items purchased */ quantity: Scalars['Int']['output']; taxLines: Array; taxRate: Scalars['Float']['output']; /** The price of a single unit, excluding tax and discounts */ unitPrice: Scalars['Money']['output']; /** Non-zero if the unitPrice has changed since it was initially added to Order */ unitPriceChangeSinceAdded: Scalars['Money']['output']; /** The price of a single unit, including tax but excluding discounts */ unitPriceWithTax: Scalars['Money']['output']; /** Non-zero if the unitPriceWithTax has changed since it was initially added to Order */ unitPriceWithTaxChangeSinceAdded: Scalars['Money']['output']; updatedAt: Scalars['DateTime']['output']; }; export type OrderList = PaginatedList & { __typename?: 'OrderList'; items: Array; totalItems: Scalars['Int']['output']; }; export type OrderListOptions = { /** Allows the results to be filtered */ filter?: InputMaybe; /** Specifies whether multiple top-level "filter" fields should be combined with a logical AND or OR operation. Defaults to AND. */ filterOperator?: InputMaybe; /** Skips the first n results, for use in pagination */ skip?: InputMaybe; /** Specifies which properties to sort the results by */ sort?: InputMaybe; /** Takes n results, for use in pagination */ take?: InputMaybe; }; /** 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']['output']; }; /** 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']['output']; }; export type OrderSortParameter = { code?: InputMaybe; createdAt?: InputMaybe; id?: InputMaybe; orderPlacedAt?: InputMaybe; shipping?: InputMaybe; shippingWithTax?: InputMaybe; state?: InputMaybe; subTotal?: InputMaybe; subTotalWithTax?: InputMaybe; total?: InputMaybe; totalQuantity?: InputMaybe; totalWithTax?: InputMaybe; updatedAt?: InputMaybe; }; /** Returned if there is an error in transitioning the Order state */ export type OrderStateTransitionError = ErrorResult & { __typename?: 'OrderStateTransitionError'; errorCode: ErrorCode; fromState: Scalars['String']['output']; message: Scalars['String']['output']; toState: Scalars['String']['output']; transitionError: Scalars['String']['output']; }; /** * 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']['output']; /** The total net price of OrderLines to which this taxRate applies */ taxBase: Scalars['Money']['output']; /** The taxRate as a percentage */ taxRate: Scalars['Float']['output']; /** The total tax being applied to the Order at this taxRate */ taxTotal: Scalars['Money']['output']; }; export declare enum OrderType { Aggregate = "Aggregate", Regular = "Regular", Seller = "Seller" } export type PaginatedList = { items: Array; totalItems: Scalars['Int']['output']; }; /** Returned when attempting 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']['output']; }; /** * Returned 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']['output']; }; /** * Returned 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']['output']; }; /** Returned when attempting to register or verify a customer account where the given password fails password validation. */ export type PasswordValidationError = ErrorResult & { __typename?: 'PasswordValidationError'; errorCode: ErrorCode; message: Scalars['String']['output']; validationErrorMessage: Scalars['String']['output']; }; export type Payment = Node & { __typename?: 'Payment'; amount: Scalars['Money']['output']; createdAt: Scalars['DateTime']['output']; customFields?: Maybe; errorMessage?: Maybe; id: Scalars['ID']['output']; metadata?: Maybe; method: Scalars['String']['output']; refunds: Array; state: Scalars['String']['output']; transactionId?: Maybe; updatedAt: Scalars['DateTime']['output']; }; /** Returned when a Payment is declined by the payment provider. */ export type PaymentDeclinedError = ErrorResult & { __typename?: 'PaymentDeclinedError'; errorCode: ErrorCode; message: Scalars['String']['output']; paymentErrorMessage: Scalars['String']['output']; }; /** Returned when a Payment fails due to an error. */ export type PaymentFailedError = ErrorResult & { __typename?: 'PaymentFailedError'; errorCode: ErrorCode; message: Scalars['String']['output']; paymentErrorMessage: Scalars['String']['output']; }; /** Passed as input to the `addPaymentToOrder` mutation. */ export type PaymentInput = { /** * 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']['input']; /** This field should correspond to the `code` property of a PaymentMethod. */ method: Scalars['String']['input']; }; export type PaymentMethod = Node & { __typename?: 'PaymentMethod'; checker?: Maybe; code: Scalars['String']['output']; createdAt: Scalars['DateTime']['output']; customFields?: Maybe; description: Scalars['String']['output']; enabled: Scalars['Boolean']['output']; handler: ConfigurableOperation; id: Scalars['ID']['output']; name: Scalars['String']['output']; translations: Array; updatedAt: Scalars['DateTime']['output']; }; export type PaymentMethodQuote = { __typename?: 'PaymentMethodQuote'; code: Scalars['String']['output']; customFields?: Maybe; description: Scalars['String']['output']; eligibilityMessage?: Maybe; id: Scalars['ID']['output']; isEligible: Scalars['Boolean']['output']; name: Scalars['String']['output']; }; export type PaymentMethodTranslation = { __typename?: 'PaymentMethodTranslation'; createdAt: Scalars['DateTime']['output']; description: Scalars['String']['output']; id: Scalars['ID']['output']; languageCode: LanguageCode; name: Scalars['String']['output']; updatedAt: Scalars['DateTime']['output']; }; /** * @description * Permissions for administrators and customers. Used to control access to * GraphQL resolvers via the {@link Allow} decorator. * * ## Understanding Permission.Owner * * `Permission.Owner` is a special permission which is used in some Vendure resolvers to indicate that that resolver should only * be accessible to the "owner" of that resource. * * For example, the Shop API `activeCustomer` query resolver should only return the Customer object for the "owner" of that Customer, i.e. * based on the activeUserId of the current session. As a result, the resolver code looks like this: * * @example * ```TypeScript * \@Query() * \@Allow(Permission.Owner) * async activeCustomer(\@Ctx() ctx: RequestContext): Promise { * const userId = ctx.activeUserId; * if (userId) { * return this.customerService.findOneByUserId(ctx, userId); * } * } * ``` * * Here we can see that the "ownership" must be enforced by custom logic inside the resolver. Since "ownership" cannot be defined generally * nor statically encoded at build-time, any resolvers using `Permission.Owner` **must** include logic to enforce that only the owner * of the resource has access. If not, then it is the equivalent of using `Permission.Public`. * * * @docsCategory common */ export declare enum Permission { /** Authenticated means simply that the user is logged in */ Authenticated = "Authenticated", /** Grants permission to create Administrator */ CreateAdministrator = "CreateAdministrator", /** Grants permission to create Asset */ CreateAsset = "CreateAsset", /** Grants permission to create Products, Facets, Assets, Collections */ CreateCatalog = "CreateCatalog", /** Grants permission to create Channel */ CreateChannel = "CreateChannel", /** Grants permission to create Collection */ CreateCollection = "CreateCollection", /** Grants permission to create Country */ CreateCountry = "CreateCountry", /** Grants permission to create Customer */ CreateCustomer = "CreateCustomer", /** Grants permission to create CustomerGroup */ CreateCustomerGroup = "CreateCustomerGroup", /** Grants permission to create Facet */ CreateFacet = "CreateFacet", /** Grants permission to create Order */ CreateOrder = "CreateOrder", /** Grants permission to create PaymentMethod */ CreatePaymentMethod = "CreatePaymentMethod", /** Grants permission to create Product */ CreateProduct = "CreateProduct", /** Grants permission to create Promotion */ CreatePromotion = "CreatePromotion", /** Grants permission to create Seller */ CreateSeller = "CreateSeller", /** Grants permission to create PaymentMethods, ShippingMethods, TaxCategories, TaxRates, Zones, Countries, System & GlobalSettings */ CreateSettings = "CreateSettings", /** Grants permission to create ShippingMethod */ CreateShippingMethod = "CreateShippingMethod", /** Grants permission to create StockLocation */ CreateStockLocation = "CreateStockLocation", /** Grants permission to create System */ CreateSystem = "CreateSystem", /** Grants permission to create Tag */ CreateTag = "CreateTag", /** Grants permission to create TaxCategory */ CreateTaxCategory = "CreateTaxCategory", /** Grants permission to create TaxRate */ CreateTaxRate = "CreateTaxRate", /** Grants permission to create Zone */ CreateZone = "CreateZone", /** Grants permission to delete Administrator */ DeleteAdministrator = "DeleteAdministrator", /** Grants permission to delete Asset */ DeleteAsset = "DeleteAsset", /** Grants permission to delete Products, Facets, Assets, Collections */ DeleteCatalog = "DeleteCatalog", /** Grants permission to delete Channel */ DeleteChannel = "DeleteChannel", /** Grants permission to delete Collection */ DeleteCollection = "DeleteCollection", /** Grants permission to delete Country */ DeleteCountry = "DeleteCountry", /** Grants permission to delete Customer */ DeleteCustomer = "DeleteCustomer", /** Grants permission to delete CustomerGroup */ DeleteCustomerGroup = "DeleteCustomerGroup", /** Grants permission to delete Facet */ DeleteFacet = "DeleteFacet", /** Grants permission to delete Order */ DeleteOrder = "DeleteOrder", /** Grants permission to delete PaymentMethod */ DeletePaymentMethod = "DeletePaymentMethod", /** Grants permission to delete Product */ DeleteProduct = "DeleteProduct", /** Grants permission to delete Promotion */ DeletePromotion = "DeletePromotion", /** Grants permission to delete Seller */ DeleteSeller = "DeleteSeller", /** Grants permission to delete PaymentMethods, ShippingMethods, TaxCategories, TaxRates, Zones, Countries, System & GlobalSettings */ DeleteSettings = "DeleteSettings", /** Grants permission to delete ShippingMethod */ DeleteShippingMethod = "DeleteShippingMethod", /** Grants permission to delete StockLocation */ DeleteStockLocation = "DeleteStockLocation", /** Grants permission to delete System */ DeleteSystem = "DeleteSystem", /** Grants permission to delete Tag */ DeleteTag = "DeleteTag", /** Grants permission to delete TaxCategory */ DeleteTaxCategory = "DeleteTaxCategory", /** Grants permission to delete TaxRate */ DeleteTaxRate = "DeleteTaxRate", /** Grants permission to delete Zone */ DeleteZone = "DeleteZone", /** 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 read Administrator */ ReadAdministrator = "ReadAdministrator", /** Grants permission to read Asset */ ReadAsset = "ReadAsset", /** Grants permission to read Products, Facets, Assets, Collections */ ReadCatalog = "ReadCatalog", /** Grants permission to read Channel */ ReadChannel = "ReadChannel", /** Grants permission to read Collection */ ReadCollection = "ReadCollection", /** Grants permission to read Country */ ReadCountry = "ReadCountry", /** Grants permission to read Customer */ ReadCustomer = "ReadCustomer", /** Grants permission to read CustomerGroup */ ReadCustomerGroup = "ReadCustomerGroup", /** Grants permission to read Facet */ ReadFacet = "ReadFacet", /** Grants permission to read Order */ ReadOrder = "ReadOrder", /** Grants permission to read PaymentMethod */ ReadPaymentMethod = "ReadPaymentMethod", /** Grants permission to read Product */ ReadProduct = "ReadProduct", /** Grants permission to read Promotion */ ReadPromotion = "ReadPromotion", /** Grants permission to read Seller */ ReadSeller = "ReadSeller", /** Grants permission to read PaymentMethods, ShippingMethods, TaxCategories, TaxRates, Zones, Countries, System & GlobalSettings */ ReadSettings = "ReadSettings", /** Grants permission to read ShippingMethod */ ReadShippingMethod = "ReadShippingMethod", /** Grants permission to read StockLocation */ ReadStockLocation = "ReadStockLocation", /** Grants permission to read System */ ReadSystem = "ReadSystem", /** Grants permission to read Tag */ ReadTag = "ReadTag", /** Grants permission to read TaxCategory */ ReadTaxCategory = "ReadTaxCategory", /** Grants permission to read TaxRate */ ReadTaxRate = "ReadTaxRate", /** Grants permission to read Zone */ ReadZone = "ReadZone", /** SuperAdmin has unrestricted access to all operations */ SuperAdmin = "SuperAdmin", /** Grants permission to update Administrator */ UpdateAdministrator = "UpdateAdministrator", /** Grants permission to update Asset */ UpdateAsset = "UpdateAsset", /** Grants permission to update Products, Facets, Assets, Collections */ UpdateCatalog = "UpdateCatalog", /** Grants permission to update Channel */ UpdateChannel = "UpdateChannel", /** Grants permission to update Collection */ UpdateCollection = "UpdateCollection", /** Grants permission to update Country */ UpdateCountry = "UpdateCountry", /** Grants permission to update Customer */ UpdateCustomer = "UpdateCustomer", /** Grants permission to update CustomerGroup */ UpdateCustomerGroup = "UpdateCustomerGroup", /** Grants permission to update Facet */ UpdateFacet = "UpdateFacet", /** Grants permission to update GlobalSettings */ UpdateGlobalSettings = "UpdateGlobalSettings", /** Grants permission to update Order */ UpdateOrder = "UpdateOrder", /** Grants permission to update PaymentMethod */ UpdatePaymentMethod = "UpdatePaymentMethod", /** Grants permission to update Product */ UpdateProduct = "UpdateProduct", /** Grants permission to update Promotion */ UpdatePromotion = "UpdatePromotion", /** Grants permission to update Seller */ UpdateSeller = "UpdateSeller", /** Grants permission to update PaymentMethods, ShippingMethods, TaxCategories, TaxRates, Zones, Countries, System & GlobalSettings */ UpdateSettings = "UpdateSettings", /** Grants permission to update ShippingMethod */ UpdateShippingMethod = "UpdateShippingMethod", /** Grants permission to update StockLocation */ UpdateStockLocation = "UpdateStockLocation", /** Grants permission to update System */ UpdateSystem = "UpdateSystem", /** Grants permission to update Tag */ UpdateTag = "UpdateTag", /** Grants permission to update TaxCategory */ UpdateTaxCategory = "UpdateTaxCategory", /** Grants permission to update TaxRate */ UpdateTaxRate = "UpdateTaxRate", /** Grants permission to update Zone */ UpdateZone = "UpdateZone" } /** The price range where the result has more than one price */ export type PriceRange = { __typename?: 'PriceRange'; max: Scalars['Money']['output']; min: Scalars['Money']['output']; }; export type Product = Node & { __typename?: 'Product'; assets: Array; collections: Array; createdAt: Scalars['DateTime']['output']; customFields?: Maybe; description: Scalars['String']['output']; enabled: Scalars['Boolean']['output']; facetValues: Array; featuredAsset?: Maybe; id: Scalars['ID']['output']; languageCode: LanguageCode; name: Scalars['String']['output']; optionGroups: Array; slug: Scalars['String']['output']; translations: Array; updatedAt: Scalars['DateTime']['output']; /** Returns a paginated, sortable, filterable list of ProductVariants */ variantList: ProductVariantList; /** Returns all ProductVariants */ variants: Array; }; export type ProductVariantListArgs = { options?: InputMaybe; }; export type ProductFilterParameter = { _and?: InputMaybe>; _or?: InputMaybe>; createdAt?: InputMaybe; description?: InputMaybe; enabled?: InputMaybe