@vendure/payments-plugin 2.1.0-next.0 → 2.1.0-next.2
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/package/braintree/braintree.plugin.js +2 -2
- package/package/braintree/braintree.plugin.js.map +1 -1
- package/package/mollie/graphql/generated-shop-types.d.ts +774 -739
- package/package/mollie/graphql/generated-shop-types.js.map +1 -1
- package/package/stripe/raw-body.middleware.js +2 -2
- package/package/stripe/raw-body.middleware.js.map +1 -1
- package/package/stripe/stripe.plugin.js.map +1 -1
- package/package.json +9 -9
|
@@ -11,48 +11,83 @@ export type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
|
|
|
11
11
|
export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
|
|
12
12
|
[SubKey in K]: Maybe<T[SubKey]>;
|
|
13
13
|
};
|
|
14
|
+
export type MakeEmpty<T extends {
|
|
15
|
+
[key: string]: unknown;
|
|
16
|
+
}, K extends keyof T> = {
|
|
17
|
+
[_ in K]?: never;
|
|
18
|
+
};
|
|
19
|
+
export type Incremental<T> = T | {
|
|
20
|
+
[P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never;
|
|
21
|
+
};
|
|
14
22
|
/** All built-in and custom scalars, mapped to their actual values */
|
|
15
23
|
export type Scalars = {
|
|
16
|
-
ID:
|
|
17
|
-
|
|
18
|
-
|
|
19
|
-
|
|
20
|
-
|
|
24
|
+
ID: {
|
|
25
|
+
input: string;
|
|
26
|
+
output: string;
|
|
27
|
+
};
|
|
28
|
+
String: {
|
|
29
|
+
input: string;
|
|
30
|
+
output: string;
|
|
31
|
+
};
|
|
32
|
+
Boolean: {
|
|
33
|
+
input: boolean;
|
|
34
|
+
output: boolean;
|
|
35
|
+
};
|
|
36
|
+
Int: {
|
|
37
|
+
input: number;
|
|
38
|
+
output: number;
|
|
39
|
+
};
|
|
40
|
+
Float: {
|
|
41
|
+
input: number;
|
|
42
|
+
output: number;
|
|
43
|
+
};
|
|
21
44
|
/** 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. */
|
|
22
|
-
DateTime:
|
|
45
|
+
DateTime: {
|
|
46
|
+
input: any;
|
|
47
|
+
output: any;
|
|
48
|
+
};
|
|
23
49
|
/** The `JSON` scalar type represents JSON values as specified by [ECMA-404](http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf). */
|
|
24
|
-
JSON:
|
|
50
|
+
JSON: {
|
|
51
|
+
input: any;
|
|
52
|
+
output: any;
|
|
53
|
+
};
|
|
25
54
|
/** The `Money` scalar type represents monetary values and supports signed double-precision fractional values as specified by [IEEE 754](https://en.wikipedia.org/wiki/IEEE_floating_point). */
|
|
26
|
-
Money:
|
|
55
|
+
Money: {
|
|
56
|
+
input: number;
|
|
57
|
+
output: number;
|
|
58
|
+
};
|
|
27
59
|
/** The `Upload` scalar type represents a file upload. */
|
|
28
|
-
Upload:
|
|
60
|
+
Upload: {
|
|
61
|
+
input: any;
|
|
62
|
+
output: any;
|
|
63
|
+
};
|
|
29
64
|
};
|
|
30
65
|
export type ActiveOrderResult = NoActiveOrderError | Order;
|
|
31
66
|
export type AddPaymentToOrderResult = IneligiblePaymentMethodError | NoActiveOrderError | Order | OrderPaymentStateError | OrderStateTransitionError | PaymentDeclinedError | PaymentFailedError;
|
|
32
67
|
export type Address = Node & {
|
|
33
68
|
__typename?: 'Address';
|
|
34
|
-
city?: Maybe<Scalars['String']>;
|
|
35
|
-
company?: Maybe<Scalars['String']>;
|
|
69
|
+
city?: Maybe<Scalars['String']['output']>;
|
|
70
|
+
company?: Maybe<Scalars['String']['output']>;
|
|
36
71
|
country: Country;
|
|
37
|
-
createdAt: Scalars['DateTime'];
|
|
38
|
-
customFields?: Maybe<Scalars['JSON']>;
|
|
39
|
-
defaultBillingAddress?: Maybe<Scalars['Boolean']>;
|
|
40
|
-
defaultShippingAddress?: Maybe<Scalars['Boolean']>;
|
|
41
|
-
fullName?: Maybe<Scalars['String']>;
|
|
42
|
-
id: Scalars['ID'];
|
|
43
|
-
phoneNumber?: Maybe<Scalars['String']>;
|
|
44
|
-
postalCode?: Maybe<Scalars['String']>;
|
|
45
|
-
province?: Maybe<Scalars['String']>;
|
|
46
|
-
streetLine1: Scalars['String'];
|
|
47
|
-
streetLine2?: Maybe<Scalars['String']>;
|
|
48
|
-
updatedAt: Scalars['DateTime'];
|
|
72
|
+
createdAt: Scalars['DateTime']['output'];
|
|
73
|
+
customFields?: Maybe<Scalars['JSON']['output']>;
|
|
74
|
+
defaultBillingAddress?: Maybe<Scalars['Boolean']['output']>;
|
|
75
|
+
defaultShippingAddress?: Maybe<Scalars['Boolean']['output']>;
|
|
76
|
+
fullName?: Maybe<Scalars['String']['output']>;
|
|
77
|
+
id: Scalars['ID']['output'];
|
|
78
|
+
phoneNumber?: Maybe<Scalars['String']['output']>;
|
|
79
|
+
postalCode?: Maybe<Scalars['String']['output']>;
|
|
80
|
+
province?: Maybe<Scalars['String']['output']>;
|
|
81
|
+
streetLine1: Scalars['String']['output'];
|
|
82
|
+
streetLine2?: Maybe<Scalars['String']['output']>;
|
|
83
|
+
updatedAt: Scalars['DateTime']['output'];
|
|
49
84
|
};
|
|
50
85
|
export type Adjustment = {
|
|
51
86
|
__typename?: 'Adjustment';
|
|
52
|
-
adjustmentSource: Scalars['String'];
|
|
53
|
-
amount: Scalars['Money'];
|
|
54
|
-
data?: Maybe<Scalars['JSON']>;
|
|
55
|
-
description: Scalars['String'];
|
|
87
|
+
adjustmentSource: Scalars['String']['output'];
|
|
88
|
+
amount: Scalars['Money']['output'];
|
|
89
|
+
data?: Maybe<Scalars['JSON']['output']>;
|
|
90
|
+
description: Scalars['String']['output'];
|
|
56
91
|
type: AdjustmentType;
|
|
57
92
|
};
|
|
58
93
|
export declare enum AdjustmentType {
|
|
@@ -64,30 +99,30 @@ export declare enum AdjustmentType {
|
|
|
64
99
|
export type AlreadyLoggedInError = ErrorResult & {
|
|
65
100
|
__typename?: 'AlreadyLoggedInError';
|
|
66
101
|
errorCode: ErrorCode;
|
|
67
|
-
message: Scalars['String'];
|
|
102
|
+
message: Scalars['String']['output'];
|
|
68
103
|
};
|
|
69
104
|
export type ApplyCouponCodeResult = CouponCodeExpiredError | CouponCodeInvalidError | CouponCodeLimitError | Order;
|
|
70
105
|
export type Asset = Node & {
|
|
71
106
|
__typename?: 'Asset';
|
|
72
|
-
createdAt: Scalars['DateTime'];
|
|
73
|
-
customFields?: Maybe<Scalars['JSON']>;
|
|
74
|
-
fileSize: Scalars['Int'];
|
|
107
|
+
createdAt: Scalars['DateTime']['output'];
|
|
108
|
+
customFields?: Maybe<Scalars['JSON']['output']>;
|
|
109
|
+
fileSize: Scalars['Int']['output'];
|
|
75
110
|
focalPoint?: Maybe<Coordinate>;
|
|
76
|
-
height: Scalars['Int'];
|
|
77
|
-
id: Scalars['ID'];
|
|
78
|
-
mimeType: Scalars['String'];
|
|
79
|
-
name: Scalars['String'];
|
|
80
|
-
preview: Scalars['String'];
|
|
81
|
-
source: Scalars['String'];
|
|
111
|
+
height: Scalars['Int']['output'];
|
|
112
|
+
id: Scalars['ID']['output'];
|
|
113
|
+
mimeType: Scalars['String']['output'];
|
|
114
|
+
name: Scalars['String']['output'];
|
|
115
|
+
preview: Scalars['String']['output'];
|
|
116
|
+
source: Scalars['String']['output'];
|
|
82
117
|
tags: Array<Tag>;
|
|
83
118
|
type: AssetType;
|
|
84
|
-
updatedAt: Scalars['DateTime'];
|
|
85
|
-
width: Scalars['Int'];
|
|
119
|
+
updatedAt: Scalars['DateTime']['output'];
|
|
120
|
+
width: Scalars['Int']['output'];
|
|
86
121
|
};
|
|
87
122
|
export type AssetList = PaginatedList & {
|
|
88
123
|
__typename?: 'AssetList';
|
|
89
124
|
items: Array<Asset>;
|
|
90
|
-
totalItems: Scalars['Int'];
|
|
125
|
+
totalItems: Scalars['Int']['output'];
|
|
91
126
|
};
|
|
92
127
|
export declare enum AssetType {
|
|
93
128
|
BINARY = "BINARY",
|
|
@@ -99,85 +134,85 @@ export type AuthenticationInput = {
|
|
|
99
134
|
};
|
|
100
135
|
export type AuthenticationMethod = Node & {
|
|
101
136
|
__typename?: 'AuthenticationMethod';
|
|
102
|
-
createdAt: Scalars['DateTime'];
|
|
103
|
-
id: Scalars['ID'];
|
|
104
|
-
strategy: Scalars['String'];
|
|
105
|
-
updatedAt: Scalars['DateTime'];
|
|
137
|
+
createdAt: Scalars['DateTime']['output'];
|
|
138
|
+
id: Scalars['ID']['output'];
|
|
139
|
+
strategy: Scalars['String']['output'];
|
|
140
|
+
updatedAt: Scalars['DateTime']['output'];
|
|
106
141
|
};
|
|
107
142
|
export type AuthenticationResult = CurrentUser | InvalidCredentialsError | NotVerifiedError;
|
|
108
143
|
export type BooleanCustomFieldConfig = CustomField & {
|
|
109
144
|
__typename?: 'BooleanCustomFieldConfig';
|
|
110
145
|
description?: Maybe<Array<LocalizedString>>;
|
|
111
|
-
internal?: Maybe<Scalars['Boolean']>;
|
|
146
|
+
internal?: Maybe<Scalars['Boolean']['output']>;
|
|
112
147
|
label?: Maybe<Array<LocalizedString>>;
|
|
113
|
-
list: Scalars['Boolean'];
|
|
114
|
-
name: Scalars['String'];
|
|
115
|
-
nullable?: Maybe<Scalars['Boolean']>;
|
|
116
|
-
readonly?: Maybe<Scalars['Boolean']>;
|
|
117
|
-
type: Scalars['String'];
|
|
118
|
-
ui?: Maybe<Scalars['JSON']>;
|
|
148
|
+
list: Scalars['Boolean']['output'];
|
|
149
|
+
name: Scalars['String']['output'];
|
|
150
|
+
nullable?: Maybe<Scalars['Boolean']['output']>;
|
|
151
|
+
readonly?: Maybe<Scalars['Boolean']['output']>;
|
|
152
|
+
type: Scalars['String']['output'];
|
|
153
|
+
ui?: Maybe<Scalars['JSON']['output']>;
|
|
119
154
|
};
|
|
120
155
|
/** Operators for filtering on a list of Boolean fields */
|
|
121
156
|
export type BooleanListOperators = {
|
|
122
|
-
inList: Scalars['Boolean'];
|
|
157
|
+
inList: Scalars['Boolean']['input'];
|
|
123
158
|
};
|
|
124
159
|
/** Operators for filtering on a Boolean field */
|
|
125
160
|
export type BooleanOperators = {
|
|
126
|
-
eq?: InputMaybe<Scalars['Boolean']>;
|
|
127
|
-
isNull?: InputMaybe<Scalars['Boolean']>;
|
|
161
|
+
eq?: InputMaybe<Scalars['Boolean']['input']>;
|
|
162
|
+
isNull?: InputMaybe<Scalars['Boolean']['input']>;
|
|
128
163
|
};
|
|
129
164
|
export type Channel = Node & {
|
|
130
165
|
__typename?: 'Channel';
|
|
131
166
|
availableCurrencyCodes: Array<CurrencyCode>;
|
|
132
167
|
availableLanguageCodes?: Maybe<Array<LanguageCode>>;
|
|
133
|
-
code: Scalars['String'];
|
|
134
|
-
createdAt: Scalars['DateTime'];
|
|
168
|
+
code: Scalars['String']['output'];
|
|
169
|
+
createdAt: Scalars['DateTime']['output'];
|
|
135
170
|
/** @deprecated Use defaultCurrencyCode instead */
|
|
136
171
|
currencyCode: CurrencyCode;
|
|
137
|
-
customFields?: Maybe<Scalars['JSON']>;
|
|
172
|
+
customFields?: Maybe<Scalars['JSON']['output']>;
|
|
138
173
|
defaultCurrencyCode: CurrencyCode;
|
|
139
174
|
defaultLanguageCode: LanguageCode;
|
|
140
175
|
defaultShippingZone?: Maybe<Zone>;
|
|
141
176
|
defaultTaxZone?: Maybe<Zone>;
|
|
142
|
-
id: Scalars['ID'];
|
|
177
|
+
id: Scalars['ID']['output'];
|
|
143
178
|
/** Not yet used - will be implemented in a future release. */
|
|
144
|
-
outOfStockThreshold?: Maybe<Scalars['Int']>;
|
|
145
|
-
pricesIncludeTax: Scalars['Boolean'];
|
|
179
|
+
outOfStockThreshold?: Maybe<Scalars['Int']['output']>;
|
|
180
|
+
pricesIncludeTax: Scalars['Boolean']['output'];
|
|
146
181
|
seller?: Maybe<Seller>;
|
|
147
|
-
token: Scalars['String'];
|
|
182
|
+
token: Scalars['String']['output'];
|
|
148
183
|
/** Not yet used - will be implemented in a future release. */
|
|
149
|
-
trackInventory?: Maybe<Scalars['Boolean']>;
|
|
150
|
-
updatedAt: Scalars['DateTime'];
|
|
184
|
+
trackInventory?: Maybe<Scalars['Boolean']['output']>;
|
|
185
|
+
updatedAt: Scalars['DateTime']['output'];
|
|
151
186
|
};
|
|
152
187
|
export type Collection = Node & {
|
|
153
188
|
__typename?: 'Collection';
|
|
154
189
|
assets: Array<Asset>;
|
|
155
190
|
breadcrumbs: Array<CollectionBreadcrumb>;
|
|
156
191
|
children?: Maybe<Array<Collection>>;
|
|
157
|
-
createdAt: Scalars['DateTime'];
|
|
158
|
-
customFields?: Maybe<Scalars['JSON']>;
|
|
159
|
-
description: Scalars['String'];
|
|
192
|
+
createdAt: Scalars['DateTime']['output'];
|
|
193
|
+
customFields?: Maybe<Scalars['JSON']['output']>;
|
|
194
|
+
description: Scalars['String']['output'];
|
|
160
195
|
featuredAsset?: Maybe<Asset>;
|
|
161
196
|
filters: Array<ConfigurableOperation>;
|
|
162
|
-
id: Scalars['ID'];
|
|
197
|
+
id: Scalars['ID']['output'];
|
|
163
198
|
languageCode?: Maybe<LanguageCode>;
|
|
164
|
-
name: Scalars['String'];
|
|
199
|
+
name: Scalars['String']['output'];
|
|
165
200
|
parent?: Maybe<Collection>;
|
|
166
|
-
parentId: Scalars['ID'];
|
|
167
|
-
position: Scalars['Int'];
|
|
201
|
+
parentId: Scalars['ID']['output'];
|
|
202
|
+
position: Scalars['Int']['output'];
|
|
168
203
|
productVariants: ProductVariantList;
|
|
169
|
-
slug: Scalars['String'];
|
|
204
|
+
slug: Scalars['String']['output'];
|
|
170
205
|
translations: Array<CollectionTranslation>;
|
|
171
|
-
updatedAt: Scalars['DateTime'];
|
|
206
|
+
updatedAt: Scalars['DateTime']['output'];
|
|
172
207
|
};
|
|
173
208
|
export type CollectionProductVariantsArgs = {
|
|
174
209
|
options?: InputMaybe<ProductVariantListOptions>;
|
|
175
210
|
};
|
|
176
211
|
export type CollectionBreadcrumb = {
|
|
177
212
|
__typename?: 'CollectionBreadcrumb';
|
|
178
|
-
id: Scalars['ID'];
|
|
179
|
-
name: Scalars['String'];
|
|
180
|
-
slug: Scalars['String'];
|
|
213
|
+
id: Scalars['ID']['output'];
|
|
214
|
+
name: Scalars['String']['output'];
|
|
215
|
+
slug: Scalars['String']['output'];
|
|
181
216
|
};
|
|
182
217
|
export type CollectionFilterParameter = {
|
|
183
218
|
createdAt?: InputMaybe<DateOperators>;
|
|
@@ -193,7 +228,7 @@ export type CollectionFilterParameter = {
|
|
|
193
228
|
export type CollectionList = PaginatedList & {
|
|
194
229
|
__typename?: 'CollectionList';
|
|
195
230
|
items: Array<Collection>;
|
|
196
|
-
totalItems: Scalars['Int'];
|
|
231
|
+
totalItems: Scalars['Int']['output'];
|
|
197
232
|
};
|
|
198
233
|
export type CollectionListOptions = {
|
|
199
234
|
/** Allows the results to be filtered */
|
|
@@ -201,12 +236,12 @@ export type CollectionListOptions = {
|
|
|
201
236
|
/** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
|
|
202
237
|
filterOperator?: InputMaybe<LogicalOperator>;
|
|
203
238
|
/** Skips the first n results, for use in pagination */
|
|
204
|
-
skip?: InputMaybe<Scalars['Int']>;
|
|
239
|
+
skip?: InputMaybe<Scalars['Int']['input']>;
|
|
205
240
|
/** Specifies which properties to sort the results by */
|
|
206
241
|
sort?: InputMaybe<CollectionSortParameter>;
|
|
207
242
|
/** Takes n results, for use in pagination */
|
|
208
|
-
take?: InputMaybe<Scalars['Int']>;
|
|
209
|
-
topLevelOnly?: InputMaybe<Scalars['Boolean']>;
|
|
243
|
+
take?: InputMaybe<Scalars['Int']['input']>;
|
|
244
|
+
topLevelOnly?: InputMaybe<Scalars['Boolean']['input']>;
|
|
210
245
|
};
|
|
211
246
|
/**
|
|
212
247
|
* Which Collections are present in the products returned
|
|
@@ -215,7 +250,7 @@ export type CollectionListOptions = {
|
|
|
215
250
|
export type CollectionResult = {
|
|
216
251
|
__typename?: 'CollectionResult';
|
|
217
252
|
collection: Collection;
|
|
218
|
-
count: Scalars['Int'];
|
|
253
|
+
count: Scalars['Int']['output'];
|
|
219
254
|
};
|
|
220
255
|
export type CollectionSortParameter = {
|
|
221
256
|
createdAt?: InputMaybe<SortOrder>;
|
|
@@ -229,118 +264,118 @@ export type CollectionSortParameter = {
|
|
|
229
264
|
};
|
|
230
265
|
export type CollectionTranslation = {
|
|
231
266
|
__typename?: 'CollectionTranslation';
|
|
232
|
-
createdAt: Scalars['DateTime'];
|
|
233
|
-
description: Scalars['String'];
|
|
234
|
-
id: Scalars['ID'];
|
|
267
|
+
createdAt: Scalars['DateTime']['output'];
|
|
268
|
+
description: Scalars['String']['output'];
|
|
269
|
+
id: Scalars['ID']['output'];
|
|
235
270
|
languageCode: LanguageCode;
|
|
236
|
-
name: Scalars['String'];
|
|
237
|
-
slug: Scalars['String'];
|
|
238
|
-
updatedAt: Scalars['DateTime'];
|
|
271
|
+
name: Scalars['String']['output'];
|
|
272
|
+
slug: Scalars['String']['output'];
|
|
273
|
+
updatedAt: Scalars['DateTime']['output'];
|
|
239
274
|
};
|
|
240
275
|
export type ConfigArg = {
|
|
241
276
|
__typename?: 'ConfigArg';
|
|
242
|
-
name: Scalars['String'];
|
|
243
|
-
value: Scalars['String'];
|
|
277
|
+
name: Scalars['String']['output'];
|
|
278
|
+
value: Scalars['String']['output'];
|
|
244
279
|
};
|
|
245
280
|
export type ConfigArgDefinition = {
|
|
246
281
|
__typename?: 'ConfigArgDefinition';
|
|
247
|
-
defaultValue?: Maybe<Scalars['JSON']>;
|
|
248
|
-
description?: Maybe<Scalars['String']>;
|
|
249
|
-
label?: Maybe<Scalars['String']>;
|
|
250
|
-
list: Scalars['Boolean'];
|
|
251
|
-
name: Scalars['String'];
|
|
252
|
-
required: Scalars['Boolean'];
|
|
253
|
-
type: Scalars['String'];
|
|
254
|
-
ui?: Maybe<Scalars['JSON']>;
|
|
282
|
+
defaultValue?: Maybe<Scalars['JSON']['output']>;
|
|
283
|
+
description?: Maybe<Scalars['String']['output']>;
|
|
284
|
+
label?: Maybe<Scalars['String']['output']>;
|
|
285
|
+
list: Scalars['Boolean']['output'];
|
|
286
|
+
name: Scalars['String']['output'];
|
|
287
|
+
required: Scalars['Boolean']['output'];
|
|
288
|
+
type: Scalars['String']['output'];
|
|
289
|
+
ui?: Maybe<Scalars['JSON']['output']>;
|
|
255
290
|
};
|
|
256
291
|
export type ConfigArgInput = {
|
|
257
|
-
name: Scalars['String'];
|
|
292
|
+
name: Scalars['String']['input'];
|
|
258
293
|
/** A JSON stringified representation of the actual value */
|
|
259
|
-
value: Scalars['String'];
|
|
294
|
+
value: Scalars['String']['input'];
|
|
260
295
|
};
|
|
261
296
|
export type ConfigurableOperation = {
|
|
262
297
|
__typename?: 'ConfigurableOperation';
|
|
263
298
|
args: Array<ConfigArg>;
|
|
264
|
-
code: Scalars['String'];
|
|
299
|
+
code: Scalars['String']['output'];
|
|
265
300
|
};
|
|
266
301
|
export type ConfigurableOperationDefinition = {
|
|
267
302
|
__typename?: 'ConfigurableOperationDefinition';
|
|
268
303
|
args: Array<ConfigArgDefinition>;
|
|
269
|
-
code: Scalars['String'];
|
|
270
|
-
description: Scalars['String'];
|
|
304
|
+
code: Scalars['String']['output'];
|
|
305
|
+
description: Scalars['String']['output'];
|
|
271
306
|
};
|
|
272
307
|
export type ConfigurableOperationInput = {
|
|
273
308
|
arguments: Array<ConfigArgInput>;
|
|
274
|
-
code: Scalars['String'];
|
|
309
|
+
code: Scalars['String']['input'];
|
|
275
310
|
};
|
|
276
311
|
export type Coordinate = {
|
|
277
312
|
__typename?: 'Coordinate';
|
|
278
|
-
x: Scalars['Float'];
|
|
279
|
-
y: Scalars['Float'];
|
|
313
|
+
x: Scalars['Float']['output'];
|
|
314
|
+
y: Scalars['Float']['output'];
|
|
280
315
|
};
|
|
281
316
|
export type Country = Node & Region & {
|
|
282
317
|
__typename?: 'Country';
|
|
283
|
-
code: Scalars['String'];
|
|
284
|
-
createdAt: Scalars['DateTime'];
|
|
285
|
-
customFields?: Maybe<Scalars['JSON']>;
|
|
286
|
-
enabled: Scalars['Boolean'];
|
|
287
|
-
id: Scalars['ID'];
|
|
318
|
+
code: Scalars['String']['output'];
|
|
319
|
+
createdAt: Scalars['DateTime']['output'];
|
|
320
|
+
customFields?: Maybe<Scalars['JSON']['output']>;
|
|
321
|
+
enabled: Scalars['Boolean']['output'];
|
|
322
|
+
id: Scalars['ID']['output'];
|
|
288
323
|
languageCode: LanguageCode;
|
|
289
|
-
name: Scalars['String'];
|
|
324
|
+
name: Scalars['String']['output'];
|
|
290
325
|
parent?: Maybe<Region>;
|
|
291
|
-
parentId?: Maybe<Scalars['ID']>;
|
|
326
|
+
parentId?: Maybe<Scalars['ID']['output']>;
|
|
292
327
|
translations: Array<RegionTranslation>;
|
|
293
|
-
type: Scalars['String'];
|
|
294
|
-
updatedAt: Scalars['DateTime'];
|
|
328
|
+
type: Scalars['String']['output'];
|
|
329
|
+
updatedAt: Scalars['DateTime']['output'];
|
|
295
330
|
};
|
|
296
331
|
export type CountryList = PaginatedList & {
|
|
297
332
|
__typename?: 'CountryList';
|
|
298
333
|
items: Array<Country>;
|
|
299
|
-
totalItems: Scalars['Int'];
|
|
334
|
+
totalItems: Scalars['Int']['output'];
|
|
300
335
|
};
|
|
301
336
|
/** Returned if the provided coupon code is invalid */
|
|
302
337
|
export type CouponCodeExpiredError = ErrorResult & {
|
|
303
338
|
__typename?: 'CouponCodeExpiredError';
|
|
304
|
-
couponCode: Scalars['String'];
|
|
339
|
+
couponCode: Scalars['String']['output'];
|
|
305
340
|
errorCode: ErrorCode;
|
|
306
|
-
message: Scalars['String'];
|
|
341
|
+
message: Scalars['String']['output'];
|
|
307
342
|
};
|
|
308
343
|
/** Returned if the provided coupon code is invalid */
|
|
309
344
|
export type CouponCodeInvalidError = ErrorResult & {
|
|
310
345
|
__typename?: 'CouponCodeInvalidError';
|
|
311
|
-
couponCode: Scalars['String'];
|
|
346
|
+
couponCode: Scalars['String']['output'];
|
|
312
347
|
errorCode: ErrorCode;
|
|
313
|
-
message: Scalars['String'];
|
|
348
|
+
message: Scalars['String']['output'];
|
|
314
349
|
};
|
|
315
350
|
/** Returned if the provided coupon code is invalid */
|
|
316
351
|
export type CouponCodeLimitError = ErrorResult & {
|
|
317
352
|
__typename?: 'CouponCodeLimitError';
|
|
318
|
-
couponCode: Scalars['String'];
|
|
353
|
+
couponCode: Scalars['String']['output'];
|
|
319
354
|
errorCode: ErrorCode;
|
|
320
|
-
limit: Scalars['Int'];
|
|
321
|
-
message: Scalars['String'];
|
|
355
|
+
limit: Scalars['Int']['output'];
|
|
356
|
+
message: Scalars['String']['output'];
|
|
322
357
|
};
|
|
323
358
|
export type CreateAddressInput = {
|
|
324
|
-
city?: InputMaybe<Scalars['String']>;
|
|
325
|
-
company?: InputMaybe<Scalars['String']>;
|
|
326
|
-
countryCode: Scalars['String'];
|
|
327
|
-
customFields?: InputMaybe<Scalars['JSON']>;
|
|
328
|
-
defaultBillingAddress?: InputMaybe<Scalars['Boolean']>;
|
|
329
|
-
defaultShippingAddress?: InputMaybe<Scalars['Boolean']>;
|
|
330
|
-
fullName?: InputMaybe<Scalars['String']>;
|
|
331
|
-
phoneNumber?: InputMaybe<Scalars['String']>;
|
|
332
|
-
postalCode?: InputMaybe<Scalars['String']>;
|
|
333
|
-
province?: InputMaybe<Scalars['String']>;
|
|
334
|
-
streetLine1: Scalars['String'];
|
|
335
|
-
streetLine2?: InputMaybe<Scalars['String']>;
|
|
359
|
+
city?: InputMaybe<Scalars['String']['input']>;
|
|
360
|
+
company?: InputMaybe<Scalars['String']['input']>;
|
|
361
|
+
countryCode: Scalars['String']['input'];
|
|
362
|
+
customFields?: InputMaybe<Scalars['JSON']['input']>;
|
|
363
|
+
defaultBillingAddress?: InputMaybe<Scalars['Boolean']['input']>;
|
|
364
|
+
defaultShippingAddress?: InputMaybe<Scalars['Boolean']['input']>;
|
|
365
|
+
fullName?: InputMaybe<Scalars['String']['input']>;
|
|
366
|
+
phoneNumber?: InputMaybe<Scalars['String']['input']>;
|
|
367
|
+
postalCode?: InputMaybe<Scalars['String']['input']>;
|
|
368
|
+
province?: InputMaybe<Scalars['String']['input']>;
|
|
369
|
+
streetLine1: Scalars['String']['input'];
|
|
370
|
+
streetLine2?: InputMaybe<Scalars['String']['input']>;
|
|
336
371
|
};
|
|
337
372
|
export type CreateCustomerInput = {
|
|
338
|
-
customFields?: InputMaybe<Scalars['JSON']>;
|
|
339
|
-
emailAddress: Scalars['String'];
|
|
340
|
-
firstName: Scalars['String'];
|
|
341
|
-
lastName: Scalars['String'];
|
|
342
|
-
phoneNumber?: InputMaybe<Scalars['String']>;
|
|
343
|
-
title?: InputMaybe<Scalars['String']>;
|
|
373
|
+
customFields?: InputMaybe<Scalars['JSON']['input']>;
|
|
374
|
+
emailAddress: Scalars['String']['input'];
|
|
375
|
+
firstName: Scalars['String']['input'];
|
|
376
|
+
lastName: Scalars['String']['input'];
|
|
377
|
+
phoneNumber?: InputMaybe<Scalars['String']['input']>;
|
|
378
|
+
title?: InputMaybe<Scalars['String']['input']>;
|
|
344
379
|
};
|
|
345
380
|
/**
|
|
346
381
|
* @description
|
|
@@ -667,41 +702,41 @@ export declare enum CurrencyCode {
|
|
|
667
702
|
export type CurrentUser = {
|
|
668
703
|
__typename?: 'CurrentUser';
|
|
669
704
|
channels: Array<CurrentUserChannel>;
|
|
670
|
-
id: Scalars['ID'];
|
|
671
|
-
identifier: Scalars['String'];
|
|
705
|
+
id: Scalars['ID']['output'];
|
|
706
|
+
identifier: Scalars['String']['output'];
|
|
672
707
|
};
|
|
673
708
|
export type CurrentUserChannel = {
|
|
674
709
|
__typename?: 'CurrentUserChannel';
|
|
675
|
-
code: Scalars['String'];
|
|
676
|
-
id: Scalars['ID'];
|
|
710
|
+
code: Scalars['String']['output'];
|
|
711
|
+
id: Scalars['ID']['output'];
|
|
677
712
|
permissions: Array<Permission>;
|
|
678
|
-
token: Scalars['String'];
|
|
713
|
+
token: Scalars['String']['output'];
|
|
679
714
|
};
|
|
680
715
|
export type CustomField = {
|
|
681
716
|
description?: Maybe<Array<LocalizedString>>;
|
|
682
|
-
internal?: Maybe<Scalars['Boolean']>;
|
|
717
|
+
internal?: Maybe<Scalars['Boolean']['output']>;
|
|
683
718
|
label?: Maybe<Array<LocalizedString>>;
|
|
684
|
-
list: Scalars['Boolean'];
|
|
685
|
-
name: Scalars['String'];
|
|
686
|
-
nullable?: Maybe<Scalars['Boolean']>;
|
|
687
|
-
readonly?: Maybe<Scalars['Boolean']>;
|
|
688
|
-
type: Scalars['String'];
|
|
689
|
-
ui?: Maybe<Scalars['JSON']>;
|
|
719
|
+
list: Scalars['Boolean']['output'];
|
|
720
|
+
name: Scalars['String']['output'];
|
|
721
|
+
nullable?: Maybe<Scalars['Boolean']['output']>;
|
|
722
|
+
readonly?: Maybe<Scalars['Boolean']['output']>;
|
|
723
|
+
type: Scalars['String']['output'];
|
|
724
|
+
ui?: Maybe<Scalars['JSON']['output']>;
|
|
690
725
|
};
|
|
691
726
|
export type CustomFieldConfig = BooleanCustomFieldConfig | DateTimeCustomFieldConfig | FloatCustomFieldConfig | IntCustomFieldConfig | LocaleStringCustomFieldConfig | LocaleTextCustomFieldConfig | RelationCustomFieldConfig | StringCustomFieldConfig | TextCustomFieldConfig;
|
|
692
727
|
export type Customer = Node & {
|
|
693
728
|
__typename?: 'Customer';
|
|
694
729
|
addresses?: Maybe<Array<Address>>;
|
|
695
|
-
createdAt: Scalars['DateTime'];
|
|
696
|
-
customFields?: Maybe<Scalars['JSON']>;
|
|
697
|
-
emailAddress: Scalars['String'];
|
|
698
|
-
firstName: Scalars['String'];
|
|
699
|
-
id: Scalars['ID'];
|
|
700
|
-
lastName: Scalars['String'];
|
|
730
|
+
createdAt: Scalars['DateTime']['output'];
|
|
731
|
+
customFields?: Maybe<Scalars['JSON']['output']>;
|
|
732
|
+
emailAddress: Scalars['String']['output'];
|
|
733
|
+
firstName: Scalars['String']['output'];
|
|
734
|
+
id: Scalars['ID']['output'];
|
|
735
|
+
lastName: Scalars['String']['output'];
|
|
701
736
|
orders: OrderList;
|
|
702
|
-
phoneNumber?: Maybe<Scalars['String']>;
|
|
703
|
-
title?: Maybe<Scalars['String']>;
|
|
704
|
-
updatedAt: Scalars['DateTime'];
|
|
737
|
+
phoneNumber?: Maybe<Scalars['String']['output']>;
|
|
738
|
+
title?: Maybe<Scalars['String']['output']>;
|
|
739
|
+
updatedAt: Scalars['DateTime']['output'];
|
|
705
740
|
user?: Maybe<User>;
|
|
706
741
|
};
|
|
707
742
|
export type CustomerOrdersArgs = {
|
|
@@ -719,12 +754,12 @@ export type CustomerFilterParameter = {
|
|
|
719
754
|
};
|
|
720
755
|
export type CustomerGroup = Node & {
|
|
721
756
|
__typename?: 'CustomerGroup';
|
|
722
|
-
createdAt: Scalars['DateTime'];
|
|
723
|
-
customFields?: Maybe<Scalars['JSON']>;
|
|
757
|
+
createdAt: Scalars['DateTime']['output'];
|
|
758
|
+
customFields?: Maybe<Scalars['JSON']['output']>;
|
|
724
759
|
customers: CustomerList;
|
|
725
|
-
id: Scalars['ID'];
|
|
726
|
-
name: Scalars['String'];
|
|
727
|
-
updatedAt: Scalars['DateTime'];
|
|
760
|
+
id: Scalars['ID']['output'];
|
|
761
|
+
name: Scalars['String']['output'];
|
|
762
|
+
updatedAt: Scalars['DateTime']['output'];
|
|
728
763
|
};
|
|
729
764
|
export type CustomerGroupCustomersArgs = {
|
|
730
765
|
options?: InputMaybe<CustomerListOptions>;
|
|
@@ -732,7 +767,7 @@ export type CustomerGroupCustomersArgs = {
|
|
|
732
767
|
export type CustomerList = PaginatedList & {
|
|
733
768
|
__typename?: 'CustomerList';
|
|
734
769
|
items: Array<Customer>;
|
|
735
|
-
totalItems: Scalars['Int'];
|
|
770
|
+
totalItems: Scalars['Int']['output'];
|
|
736
771
|
};
|
|
737
772
|
export type CustomerListOptions = {
|
|
738
773
|
/** Allows the results to be filtered */
|
|
@@ -740,11 +775,11 @@ export type CustomerListOptions = {
|
|
|
740
775
|
/** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
|
|
741
776
|
filterOperator?: InputMaybe<LogicalOperator>;
|
|
742
777
|
/** Skips the first n results, for use in pagination */
|
|
743
|
-
skip?: InputMaybe<Scalars['Int']>;
|
|
778
|
+
skip?: InputMaybe<Scalars['Int']['input']>;
|
|
744
779
|
/** Specifies which properties to sort the results by */
|
|
745
780
|
sort?: InputMaybe<CustomerSortParameter>;
|
|
746
781
|
/** Takes n results, for use in pagination */
|
|
747
|
-
take?: InputMaybe<Scalars['Int']>;
|
|
782
|
+
take?: InputMaybe<Scalars['Int']['input']>;
|
|
748
783
|
};
|
|
749
784
|
export type CustomerSortParameter = {
|
|
750
785
|
createdAt?: InputMaybe<SortOrder>;
|
|
@@ -758,19 +793,19 @@ export type CustomerSortParameter = {
|
|
|
758
793
|
};
|
|
759
794
|
/** Operators for filtering on a list of Date fields */
|
|
760
795
|
export type DateListOperators = {
|
|
761
|
-
inList: Scalars['DateTime'];
|
|
796
|
+
inList: Scalars['DateTime']['input'];
|
|
762
797
|
};
|
|
763
798
|
/** Operators for filtering on a DateTime field */
|
|
764
799
|
export type DateOperators = {
|
|
765
|
-
after?: InputMaybe<Scalars['DateTime']>;
|
|
766
|
-
before?: InputMaybe<Scalars['DateTime']>;
|
|
800
|
+
after?: InputMaybe<Scalars['DateTime']['input']>;
|
|
801
|
+
before?: InputMaybe<Scalars['DateTime']['input']>;
|
|
767
802
|
between?: InputMaybe<DateRange>;
|
|
768
|
-
eq?: InputMaybe<Scalars['DateTime']>;
|
|
769
|
-
isNull?: InputMaybe<Scalars['Boolean']>;
|
|
803
|
+
eq?: InputMaybe<Scalars['DateTime']['input']>;
|
|
804
|
+
isNull?: InputMaybe<Scalars['Boolean']['input']>;
|
|
770
805
|
};
|
|
771
806
|
export type DateRange = {
|
|
772
|
-
end: Scalars['DateTime'];
|
|
773
|
-
start: Scalars['DateTime'];
|
|
807
|
+
end: Scalars['DateTime']['input'];
|
|
808
|
+
start: Scalars['DateTime']['input'];
|
|
774
809
|
};
|
|
775
810
|
/**
|
|
776
811
|
* Expects the same validation formats as the `<input type="datetime-local">` HTML element.
|
|
@@ -779,21 +814,21 @@ export type DateRange = {
|
|
|
779
814
|
export type DateTimeCustomFieldConfig = CustomField & {
|
|
780
815
|
__typename?: 'DateTimeCustomFieldConfig';
|
|
781
816
|
description?: Maybe<Array<LocalizedString>>;
|
|
782
|
-
internal?: Maybe<Scalars['Boolean']>;
|
|
817
|
+
internal?: Maybe<Scalars['Boolean']['output']>;
|
|
783
818
|
label?: Maybe<Array<LocalizedString>>;
|
|
784
|
-
list: Scalars['Boolean'];
|
|
785
|
-
max?: Maybe<Scalars['String']>;
|
|
786
|
-
min?: Maybe<Scalars['String']>;
|
|
787
|
-
name: Scalars['String'];
|
|
788
|
-
nullable?: Maybe<Scalars['Boolean']>;
|
|
789
|
-
readonly?: Maybe<Scalars['Boolean']>;
|
|
790
|
-
step?: Maybe<Scalars['Int']>;
|
|
791
|
-
type: Scalars['String'];
|
|
792
|
-
ui?: Maybe<Scalars['JSON']>;
|
|
819
|
+
list: Scalars['Boolean']['output'];
|
|
820
|
+
max?: Maybe<Scalars['String']['output']>;
|
|
821
|
+
min?: Maybe<Scalars['String']['output']>;
|
|
822
|
+
name: Scalars['String']['output'];
|
|
823
|
+
nullable?: Maybe<Scalars['Boolean']['output']>;
|
|
824
|
+
readonly?: Maybe<Scalars['Boolean']['output']>;
|
|
825
|
+
step?: Maybe<Scalars['Int']['output']>;
|
|
826
|
+
type: Scalars['String']['output'];
|
|
827
|
+
ui?: Maybe<Scalars['JSON']['output']>;
|
|
793
828
|
};
|
|
794
829
|
export type DeletionResponse = {
|
|
795
830
|
__typename?: 'DeletionResponse';
|
|
796
|
-
message?: Maybe<Scalars['String']>;
|
|
831
|
+
message?: Maybe<Scalars['String']['output']>;
|
|
797
832
|
result: DeletionResult;
|
|
798
833
|
};
|
|
799
834
|
export declare enum DeletionResult {
|
|
@@ -804,17 +839,17 @@ export declare enum DeletionResult {
|
|
|
804
839
|
}
|
|
805
840
|
export type Discount = {
|
|
806
841
|
__typename?: 'Discount';
|
|
807
|
-
adjustmentSource: Scalars['String'];
|
|
808
|
-
amount: Scalars['Money'];
|
|
809
|
-
amountWithTax: Scalars['Money'];
|
|
810
|
-
description: Scalars['String'];
|
|
842
|
+
adjustmentSource: Scalars['String']['output'];
|
|
843
|
+
amount: Scalars['Money']['output'];
|
|
844
|
+
amountWithTax: Scalars['Money']['output'];
|
|
845
|
+
description: Scalars['String']['output'];
|
|
811
846
|
type: AdjustmentType;
|
|
812
847
|
};
|
|
813
848
|
/** Returned when attempting to create a Customer with an email address already registered to an existing User. */
|
|
814
849
|
export type EmailAddressConflictError = ErrorResult & {
|
|
815
850
|
__typename?: 'EmailAddressConflictError';
|
|
816
851
|
errorCode: ErrorCode;
|
|
817
|
-
message: Scalars['String'];
|
|
852
|
+
message: Scalars['String']['output'];
|
|
818
853
|
};
|
|
819
854
|
export declare enum ErrorCode {
|
|
820
855
|
ALREADY_LOGGED_IN_ERROR = "ALREADY_LOGGED_IN_ERROR",
|
|
@@ -850,18 +885,18 @@ export declare enum ErrorCode {
|
|
|
850
885
|
}
|
|
851
886
|
export type ErrorResult = {
|
|
852
887
|
errorCode: ErrorCode;
|
|
853
|
-
message: Scalars['String'];
|
|
888
|
+
message: Scalars['String']['output'];
|
|
854
889
|
};
|
|
855
890
|
export type Facet = Node & {
|
|
856
891
|
__typename?: 'Facet';
|
|
857
|
-
code: Scalars['String'];
|
|
858
|
-
createdAt: Scalars['DateTime'];
|
|
859
|
-
customFields?: Maybe<Scalars['JSON']>;
|
|
860
|
-
id: Scalars['ID'];
|
|
892
|
+
code: Scalars['String']['output'];
|
|
893
|
+
createdAt: Scalars['DateTime']['output'];
|
|
894
|
+
customFields?: Maybe<Scalars['JSON']['output']>;
|
|
895
|
+
id: Scalars['ID']['output'];
|
|
861
896
|
languageCode: LanguageCode;
|
|
862
|
-
name: Scalars['String'];
|
|
897
|
+
name: Scalars['String']['output'];
|
|
863
898
|
translations: Array<FacetTranslation>;
|
|
864
|
-
updatedAt: Scalars['DateTime'];
|
|
899
|
+
updatedAt: Scalars['DateTime']['output'];
|
|
865
900
|
/** Returns a paginated, sortable, filterable list of the Facet's values. Added in v2.1.0. */
|
|
866
901
|
valueList: FacetValueList;
|
|
867
902
|
values: Array<FacetValue>;
|
|
@@ -880,7 +915,7 @@ export type FacetFilterParameter = {
|
|
|
880
915
|
export type FacetList = PaginatedList & {
|
|
881
916
|
__typename?: 'FacetList';
|
|
882
917
|
items: Array<Facet>;
|
|
883
|
-
totalItems: Scalars['Int'];
|
|
918
|
+
totalItems: Scalars['Int']['output'];
|
|
884
919
|
};
|
|
885
920
|
export type FacetListOptions = {
|
|
886
921
|
/** Allows the results to be filtered */
|
|
@@ -888,11 +923,11 @@ export type FacetListOptions = {
|
|
|
888
923
|
/** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
|
|
889
924
|
filterOperator?: InputMaybe<LogicalOperator>;
|
|
890
925
|
/** Skips the first n results, for use in pagination */
|
|
891
|
-
skip?: InputMaybe<Scalars['Int']>;
|
|
926
|
+
skip?: InputMaybe<Scalars['Int']['input']>;
|
|
892
927
|
/** Specifies which properties to sort the results by */
|
|
893
928
|
sort?: InputMaybe<FacetSortParameter>;
|
|
894
929
|
/** Takes n results, for use in pagination */
|
|
895
|
-
take?: InputMaybe<Scalars['Int']>;
|
|
930
|
+
take?: InputMaybe<Scalars['Int']['input']>;
|
|
896
931
|
};
|
|
897
932
|
export type FacetSortParameter = {
|
|
898
933
|
code?: InputMaybe<SortOrder>;
|
|
@@ -903,24 +938,24 @@ export type FacetSortParameter = {
|
|
|
903
938
|
};
|
|
904
939
|
export type FacetTranslation = {
|
|
905
940
|
__typename?: 'FacetTranslation';
|
|
906
|
-
createdAt: Scalars['DateTime'];
|
|
907
|
-
id: Scalars['ID'];
|
|
941
|
+
createdAt: Scalars['DateTime']['output'];
|
|
942
|
+
id: Scalars['ID']['output'];
|
|
908
943
|
languageCode: LanguageCode;
|
|
909
|
-
name: Scalars['String'];
|
|
910
|
-
updatedAt: Scalars['DateTime'];
|
|
944
|
+
name: Scalars['String']['output'];
|
|
945
|
+
updatedAt: Scalars['DateTime']['output'];
|
|
911
946
|
};
|
|
912
947
|
export type FacetValue = Node & {
|
|
913
948
|
__typename?: 'FacetValue';
|
|
914
|
-
code: Scalars['String'];
|
|
915
|
-
createdAt: Scalars['DateTime'];
|
|
916
|
-
customFields?: Maybe<Scalars['JSON']>;
|
|
949
|
+
code: Scalars['String']['output'];
|
|
950
|
+
createdAt: Scalars['DateTime']['output'];
|
|
951
|
+
customFields?: Maybe<Scalars['JSON']['output']>;
|
|
917
952
|
facet: Facet;
|
|
918
|
-
facetId: Scalars['ID'];
|
|
919
|
-
id: Scalars['ID'];
|
|
953
|
+
facetId: Scalars['ID']['output'];
|
|
954
|
+
id: Scalars['ID']['output'];
|
|
920
955
|
languageCode: LanguageCode;
|
|
921
|
-
name: Scalars['String'];
|
|
956
|
+
name: Scalars['String']['output'];
|
|
922
957
|
translations: Array<FacetValueTranslation>;
|
|
923
|
-
updatedAt: Scalars['DateTime'];
|
|
958
|
+
updatedAt: Scalars['DateTime']['output'];
|
|
924
959
|
};
|
|
925
960
|
/**
|
|
926
961
|
* Used to construct boolean expressions for filtering search results
|
|
@@ -931,8 +966,8 @@ export type FacetValue = Node & {
|
|
|
931
966
|
* * ID=1 AND (ID=2 OR ID=3): `{ facetValueFilters: [{ and: 1 }, { or: [2,3] }] }`
|
|
932
967
|
*/
|
|
933
968
|
export type FacetValueFilterInput = {
|
|
934
|
-
and?: InputMaybe<Scalars['ID']>;
|
|
935
|
-
or?: InputMaybe<Array<Scalars['ID']>>;
|
|
969
|
+
and?: InputMaybe<Scalars['ID']['input']>;
|
|
970
|
+
or?: InputMaybe<Array<Scalars['ID']['input']>>;
|
|
936
971
|
};
|
|
937
972
|
export type FacetValueFilterParameter = {
|
|
938
973
|
code?: InputMaybe<StringOperators>;
|
|
@@ -946,7 +981,7 @@ export type FacetValueFilterParameter = {
|
|
|
946
981
|
export type FacetValueList = PaginatedList & {
|
|
947
982
|
__typename?: 'FacetValueList';
|
|
948
983
|
items: Array<FacetValue>;
|
|
949
|
-
totalItems: Scalars['Int'];
|
|
984
|
+
totalItems: Scalars['Int']['output'];
|
|
950
985
|
};
|
|
951
986
|
export type FacetValueListOptions = {
|
|
952
987
|
/** Allows the results to be filtered */
|
|
@@ -954,11 +989,11 @@ export type FacetValueListOptions = {
|
|
|
954
989
|
/** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
|
|
955
990
|
filterOperator?: InputMaybe<LogicalOperator>;
|
|
956
991
|
/** Skips the first n results, for use in pagination */
|
|
957
|
-
skip?: InputMaybe<Scalars['Int']>;
|
|
992
|
+
skip?: InputMaybe<Scalars['Int']['input']>;
|
|
958
993
|
/** Specifies which properties to sort the results by */
|
|
959
994
|
sort?: InputMaybe<FacetValueSortParameter>;
|
|
960
995
|
/** Takes n results, for use in pagination */
|
|
961
|
-
take?: InputMaybe<Scalars['Int']>;
|
|
996
|
+
take?: InputMaybe<Scalars['Int']['input']>;
|
|
962
997
|
};
|
|
963
998
|
/**
|
|
964
999
|
* Which FacetValues are present in the products returned
|
|
@@ -966,7 +1001,7 @@ export type FacetValueListOptions = {
|
|
|
966
1001
|
*/
|
|
967
1002
|
export type FacetValueResult = {
|
|
968
1003
|
__typename?: 'FacetValueResult';
|
|
969
|
-
count: Scalars['Int'];
|
|
1004
|
+
count: Scalars['Int']['output'];
|
|
970
1005
|
facetValue: FacetValue;
|
|
971
1006
|
};
|
|
972
1007
|
export type FacetValueSortParameter = {
|
|
@@ -979,47 +1014,47 @@ export type FacetValueSortParameter = {
|
|
|
979
1014
|
};
|
|
980
1015
|
export type FacetValueTranslation = {
|
|
981
1016
|
__typename?: 'FacetValueTranslation';
|
|
982
|
-
createdAt: Scalars['DateTime'];
|
|
983
|
-
id: Scalars['ID'];
|
|
1017
|
+
createdAt: Scalars['DateTime']['output'];
|
|
1018
|
+
id: Scalars['ID']['output'];
|
|
984
1019
|
languageCode: LanguageCode;
|
|
985
|
-
name: Scalars['String'];
|
|
986
|
-
updatedAt: Scalars['DateTime'];
|
|
1020
|
+
name: Scalars['String']['output'];
|
|
1021
|
+
updatedAt: Scalars['DateTime']['output'];
|
|
987
1022
|
};
|
|
988
1023
|
export type FloatCustomFieldConfig = CustomField & {
|
|
989
1024
|
__typename?: 'FloatCustomFieldConfig';
|
|
990
1025
|
description?: Maybe<Array<LocalizedString>>;
|
|
991
|
-
internal?: Maybe<Scalars['Boolean']>;
|
|
1026
|
+
internal?: Maybe<Scalars['Boolean']['output']>;
|
|
992
1027
|
label?: Maybe<Array<LocalizedString>>;
|
|
993
|
-
list: Scalars['Boolean'];
|
|
994
|
-
max?: Maybe<Scalars['Float']>;
|
|
995
|
-
min?: Maybe<Scalars['Float']>;
|
|
996
|
-
name: Scalars['String'];
|
|
997
|
-
nullable?: Maybe<Scalars['Boolean']>;
|
|
998
|
-
readonly?: Maybe<Scalars['Boolean']>;
|
|
999
|
-
step?: Maybe<Scalars['Float']>;
|
|
1000
|
-
type: Scalars['String'];
|
|
1001
|
-
ui?: Maybe<Scalars['JSON']>;
|
|
1028
|
+
list: Scalars['Boolean']['output'];
|
|
1029
|
+
max?: Maybe<Scalars['Float']['output']>;
|
|
1030
|
+
min?: Maybe<Scalars['Float']['output']>;
|
|
1031
|
+
name: Scalars['String']['output'];
|
|
1032
|
+
nullable?: Maybe<Scalars['Boolean']['output']>;
|
|
1033
|
+
readonly?: Maybe<Scalars['Boolean']['output']>;
|
|
1034
|
+
step?: Maybe<Scalars['Float']['output']>;
|
|
1035
|
+
type: Scalars['String']['output'];
|
|
1036
|
+
ui?: Maybe<Scalars['JSON']['output']>;
|
|
1002
1037
|
};
|
|
1003
1038
|
export type Fulfillment = Node & {
|
|
1004
1039
|
__typename?: 'Fulfillment';
|
|
1005
|
-
createdAt: Scalars['DateTime'];
|
|
1006
|
-
customFields?: Maybe<Scalars['JSON']>;
|
|
1007
|
-
id: Scalars['ID'];
|
|
1040
|
+
createdAt: Scalars['DateTime']['output'];
|
|
1041
|
+
customFields?: Maybe<Scalars['JSON']['output']>;
|
|
1042
|
+
id: Scalars['ID']['output'];
|
|
1008
1043
|
lines: Array<FulfillmentLine>;
|
|
1009
|
-
method: Scalars['String'];
|
|
1010
|
-
state: Scalars['String'];
|
|
1044
|
+
method: Scalars['String']['output'];
|
|
1045
|
+
state: Scalars['String']['output'];
|
|
1011
1046
|
/** @deprecated Use the `lines` field instead */
|
|
1012
1047
|
summary: Array<FulfillmentLine>;
|
|
1013
|
-
trackingCode?: Maybe<Scalars['String']>;
|
|
1014
|
-
updatedAt: Scalars['DateTime'];
|
|
1048
|
+
trackingCode?: Maybe<Scalars['String']['output']>;
|
|
1049
|
+
updatedAt: Scalars['DateTime']['output'];
|
|
1015
1050
|
};
|
|
1016
1051
|
export type FulfillmentLine = {
|
|
1017
1052
|
__typename?: 'FulfillmentLine';
|
|
1018
1053
|
fulfillment: Fulfillment;
|
|
1019
|
-
fulfillmentId: Scalars['ID'];
|
|
1054
|
+
fulfillmentId: Scalars['ID']['output'];
|
|
1020
1055
|
orderLine: OrderLine;
|
|
1021
|
-
orderLineId: Scalars['ID'];
|
|
1022
|
-
quantity: Scalars['Int'];
|
|
1056
|
+
orderLineId: Scalars['ID']['output'];
|
|
1057
|
+
quantity: Scalars['Int']['output'];
|
|
1023
1058
|
};
|
|
1024
1059
|
export declare enum GlobalFlag {
|
|
1025
1060
|
FALSE = "FALSE",
|
|
@@ -1030,16 +1065,16 @@ export declare enum GlobalFlag {
|
|
|
1030
1065
|
export type GuestCheckoutError = ErrorResult & {
|
|
1031
1066
|
__typename?: 'GuestCheckoutError';
|
|
1032
1067
|
errorCode: ErrorCode;
|
|
1033
|
-
errorDetail: Scalars['String'];
|
|
1034
|
-
message: Scalars['String'];
|
|
1068
|
+
errorDetail: Scalars['String']['output'];
|
|
1069
|
+
message: Scalars['String']['output'];
|
|
1035
1070
|
};
|
|
1036
1071
|
export type HistoryEntry = Node & {
|
|
1037
1072
|
__typename?: 'HistoryEntry';
|
|
1038
|
-
createdAt: Scalars['DateTime'];
|
|
1039
|
-
data: Scalars['JSON'];
|
|
1040
|
-
id: Scalars['ID'];
|
|
1073
|
+
createdAt: Scalars['DateTime']['output'];
|
|
1074
|
+
data: Scalars['JSON']['output'];
|
|
1075
|
+
id: Scalars['ID']['output'];
|
|
1041
1076
|
type: HistoryEntryType;
|
|
1042
|
-
updatedAt: Scalars['DateTime'];
|
|
1077
|
+
updatedAt: Scalars['DateTime']['output'];
|
|
1043
1078
|
};
|
|
1044
1079
|
export type HistoryEntryFilterParameter = {
|
|
1045
1080
|
createdAt?: InputMaybe<DateOperators>;
|
|
@@ -1050,7 +1085,7 @@ export type HistoryEntryFilterParameter = {
|
|
|
1050
1085
|
export type HistoryEntryList = PaginatedList & {
|
|
1051
1086
|
__typename?: 'HistoryEntryList';
|
|
1052
1087
|
items: Array<HistoryEntry>;
|
|
1053
|
-
totalItems: Scalars['Int'];
|
|
1088
|
+
totalItems: Scalars['Int']['output'];
|
|
1054
1089
|
};
|
|
1055
1090
|
export type HistoryEntryListOptions = {
|
|
1056
1091
|
/** Allows the results to be filtered */
|
|
@@ -1058,11 +1093,11 @@ export type HistoryEntryListOptions = {
|
|
|
1058
1093
|
/** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
|
|
1059
1094
|
filterOperator?: InputMaybe<LogicalOperator>;
|
|
1060
1095
|
/** Skips the first n results, for use in pagination */
|
|
1061
|
-
skip?: InputMaybe<Scalars['Int']>;
|
|
1096
|
+
skip?: InputMaybe<Scalars['Int']['input']>;
|
|
1062
1097
|
/** Specifies which properties to sort the results by */
|
|
1063
1098
|
sort?: InputMaybe<HistoryEntrySortParameter>;
|
|
1064
1099
|
/** Takes n results, for use in pagination */
|
|
1065
|
-
take?: InputMaybe<Scalars['Int']>;
|
|
1100
|
+
take?: InputMaybe<Scalars['Int']['input']>;
|
|
1066
1101
|
};
|
|
1067
1102
|
export type HistoryEntrySortParameter = {
|
|
1068
1103
|
createdAt?: InputMaybe<SortOrder>;
|
|
@@ -1097,15 +1132,15 @@ export declare enum HistoryEntryType {
|
|
|
1097
1132
|
}
|
|
1098
1133
|
/** Operators for filtering on a list of ID fields */
|
|
1099
1134
|
export type IdListOperators = {
|
|
1100
|
-
inList: Scalars['ID'];
|
|
1135
|
+
inList: Scalars['ID']['input'];
|
|
1101
1136
|
};
|
|
1102
1137
|
/** Operators for filtering on an ID field */
|
|
1103
1138
|
export type IdOperators = {
|
|
1104
|
-
eq?: InputMaybe<Scalars['String']>;
|
|
1105
|
-
in?: InputMaybe<Array<Scalars['String']>>;
|
|
1106
|
-
isNull?: InputMaybe<Scalars['Boolean']>;
|
|
1107
|
-
notEq?: InputMaybe<Scalars['String']>;
|
|
1108
|
-
notIn?: InputMaybe<Array<Scalars['String']>>;
|
|
1139
|
+
eq?: InputMaybe<Scalars['String']['input']>;
|
|
1140
|
+
in?: InputMaybe<Array<Scalars['String']['input']>>;
|
|
1141
|
+
isNull?: InputMaybe<Scalars['Boolean']['input']>;
|
|
1142
|
+
notEq?: InputMaybe<Scalars['String']['input']>;
|
|
1143
|
+
notIn?: InputMaybe<Array<Scalars['String']['input']>>;
|
|
1109
1144
|
};
|
|
1110
1145
|
/**
|
|
1111
1146
|
* Returned if the token used to change a Customer's email address is valid, but has
|
|
@@ -1114,7 +1149,7 @@ export type IdOperators = {
|
|
|
1114
1149
|
export type IdentifierChangeTokenExpiredError = ErrorResult & {
|
|
1115
1150
|
__typename?: 'IdentifierChangeTokenExpiredError';
|
|
1116
1151
|
errorCode: ErrorCode;
|
|
1117
|
-
message: Scalars['String'];
|
|
1152
|
+
message: Scalars['String']['output'];
|
|
1118
1153
|
};
|
|
1119
1154
|
/**
|
|
1120
1155
|
* Returned if the token used to change a Customer's email address is either
|
|
@@ -1123,50 +1158,50 @@ export type IdentifierChangeTokenExpiredError = ErrorResult & {
|
|
|
1123
1158
|
export type IdentifierChangeTokenInvalidError = ErrorResult & {
|
|
1124
1159
|
__typename?: 'IdentifierChangeTokenInvalidError';
|
|
1125
1160
|
errorCode: ErrorCode;
|
|
1126
|
-
message: Scalars['String'];
|
|
1161
|
+
message: Scalars['String']['output'];
|
|
1127
1162
|
};
|
|
1128
1163
|
/** Returned when attempting to add a Payment using a PaymentMethod for which the Order is not eligible. */
|
|
1129
1164
|
export type IneligiblePaymentMethodError = ErrorResult & {
|
|
1130
1165
|
__typename?: 'IneligiblePaymentMethodError';
|
|
1131
|
-
eligibilityCheckerMessage?: Maybe<Scalars['String']>;
|
|
1166
|
+
eligibilityCheckerMessage?: Maybe<Scalars['String']['output']>;
|
|
1132
1167
|
errorCode: ErrorCode;
|
|
1133
|
-
message: Scalars['String'];
|
|
1168
|
+
message: Scalars['String']['output'];
|
|
1134
1169
|
};
|
|
1135
1170
|
/** Returned when attempting to set a ShippingMethod for which the Order is not eligible */
|
|
1136
1171
|
export type IneligibleShippingMethodError = ErrorResult & {
|
|
1137
1172
|
__typename?: 'IneligibleShippingMethodError';
|
|
1138
1173
|
errorCode: ErrorCode;
|
|
1139
|
-
message: Scalars['String'];
|
|
1174
|
+
message: Scalars['String']['output'];
|
|
1140
1175
|
};
|
|
1141
1176
|
/** Returned when attempting to add more items to the Order than are available */
|
|
1142
1177
|
export type InsufficientStockError = ErrorResult & {
|
|
1143
1178
|
__typename?: 'InsufficientStockError';
|
|
1144
1179
|
errorCode: ErrorCode;
|
|
1145
|
-
message: Scalars['String'];
|
|
1180
|
+
message: Scalars['String']['output'];
|
|
1146
1181
|
order: Order;
|
|
1147
|
-
quantityAvailable: Scalars['Int'];
|
|
1182
|
+
quantityAvailable: Scalars['Int']['output'];
|
|
1148
1183
|
};
|
|
1149
1184
|
export type IntCustomFieldConfig = CustomField & {
|
|
1150
1185
|
__typename?: 'IntCustomFieldConfig';
|
|
1151
1186
|
description?: Maybe<Array<LocalizedString>>;
|
|
1152
|
-
internal?: Maybe<Scalars['Boolean']>;
|
|
1187
|
+
internal?: Maybe<Scalars['Boolean']['output']>;
|
|
1153
1188
|
label?: Maybe<Array<LocalizedString>>;
|
|
1154
|
-
list: Scalars['Boolean'];
|
|
1155
|
-
max?: Maybe<Scalars['Int']>;
|
|
1156
|
-
min?: Maybe<Scalars['Int']>;
|
|
1157
|
-
name: Scalars['String'];
|
|
1158
|
-
nullable?: Maybe<Scalars['Boolean']>;
|
|
1159
|
-
readonly?: Maybe<Scalars['Boolean']>;
|
|
1160
|
-
step?: Maybe<Scalars['Int']>;
|
|
1161
|
-
type: Scalars['String'];
|
|
1162
|
-
ui?: Maybe<Scalars['JSON']>;
|
|
1189
|
+
list: Scalars['Boolean']['output'];
|
|
1190
|
+
max?: Maybe<Scalars['Int']['output']>;
|
|
1191
|
+
min?: Maybe<Scalars['Int']['output']>;
|
|
1192
|
+
name: Scalars['String']['output'];
|
|
1193
|
+
nullable?: Maybe<Scalars['Boolean']['output']>;
|
|
1194
|
+
readonly?: Maybe<Scalars['Boolean']['output']>;
|
|
1195
|
+
step?: Maybe<Scalars['Int']['output']>;
|
|
1196
|
+
type: Scalars['String']['output'];
|
|
1197
|
+
ui?: Maybe<Scalars['JSON']['output']>;
|
|
1163
1198
|
};
|
|
1164
1199
|
/** Returned if the user authentication credentials are not valid */
|
|
1165
1200
|
export type InvalidCredentialsError = ErrorResult & {
|
|
1166
1201
|
__typename?: 'InvalidCredentialsError';
|
|
1167
|
-
authenticationError: Scalars['String'];
|
|
1202
|
+
authenticationError: Scalars['String']['output'];
|
|
1168
1203
|
errorCode: ErrorCode;
|
|
1169
|
-
message: Scalars['String'];
|
|
1204
|
+
message: Scalars['String']['output'];
|
|
1170
1205
|
};
|
|
1171
1206
|
/**
|
|
1172
1207
|
* @description
|
|
@@ -1496,33 +1531,33 @@ export declare enum LanguageCode {
|
|
|
1496
1531
|
export type LocaleStringCustomFieldConfig = CustomField & {
|
|
1497
1532
|
__typename?: 'LocaleStringCustomFieldConfig';
|
|
1498
1533
|
description?: Maybe<Array<LocalizedString>>;
|
|
1499
|
-
internal?: Maybe<Scalars['Boolean']>;
|
|
1534
|
+
internal?: Maybe<Scalars['Boolean']['output']>;
|
|
1500
1535
|
label?: Maybe<Array<LocalizedString>>;
|
|
1501
|
-
length?: Maybe<Scalars['Int']>;
|
|
1502
|
-
list: Scalars['Boolean'];
|
|
1503
|
-
name: Scalars['String'];
|
|
1504
|
-
nullable?: Maybe<Scalars['Boolean']>;
|
|
1505
|
-
pattern?: Maybe<Scalars['String']>;
|
|
1506
|
-
readonly?: Maybe<Scalars['Boolean']>;
|
|
1507
|
-
type: Scalars['String'];
|
|
1508
|
-
ui?: Maybe<Scalars['JSON']>;
|
|
1536
|
+
length?: Maybe<Scalars['Int']['output']>;
|
|
1537
|
+
list: Scalars['Boolean']['output'];
|
|
1538
|
+
name: Scalars['String']['output'];
|
|
1539
|
+
nullable?: Maybe<Scalars['Boolean']['output']>;
|
|
1540
|
+
pattern?: Maybe<Scalars['String']['output']>;
|
|
1541
|
+
readonly?: Maybe<Scalars['Boolean']['output']>;
|
|
1542
|
+
type: Scalars['String']['output'];
|
|
1543
|
+
ui?: Maybe<Scalars['JSON']['output']>;
|
|
1509
1544
|
};
|
|
1510
1545
|
export type LocaleTextCustomFieldConfig = CustomField & {
|
|
1511
1546
|
__typename?: 'LocaleTextCustomFieldConfig';
|
|
1512
1547
|
description?: Maybe<Array<LocalizedString>>;
|
|
1513
|
-
internal?: Maybe<Scalars['Boolean']>;
|
|
1548
|
+
internal?: Maybe<Scalars['Boolean']['output']>;
|
|
1514
1549
|
label?: Maybe<Array<LocalizedString>>;
|
|
1515
|
-
list: Scalars['Boolean'];
|
|
1516
|
-
name: Scalars['String'];
|
|
1517
|
-
nullable?: Maybe<Scalars['Boolean']>;
|
|
1518
|
-
readonly?: Maybe<Scalars['Boolean']>;
|
|
1519
|
-
type: Scalars['String'];
|
|
1520
|
-
ui?: Maybe<Scalars['JSON']>;
|
|
1550
|
+
list: Scalars['Boolean']['output'];
|
|
1551
|
+
name: Scalars['String']['output'];
|
|
1552
|
+
nullable?: Maybe<Scalars['Boolean']['output']>;
|
|
1553
|
+
readonly?: Maybe<Scalars['Boolean']['output']>;
|
|
1554
|
+
type: Scalars['String']['output'];
|
|
1555
|
+
ui?: Maybe<Scalars['JSON']['output']>;
|
|
1521
1556
|
};
|
|
1522
1557
|
export type LocalizedString = {
|
|
1523
1558
|
__typename?: 'LocalizedString';
|
|
1524
1559
|
languageCode: LanguageCode;
|
|
1525
|
-
value: Scalars['String'];
|
|
1560
|
+
value: Scalars['String']['output'];
|
|
1526
1561
|
};
|
|
1527
1562
|
export declare enum LogicalOperator {
|
|
1528
1563
|
AND = "AND",
|
|
@@ -1532,45 +1567,45 @@ export declare enum LogicalOperator {
|
|
|
1532
1567
|
export type MissingPasswordError = ErrorResult & {
|
|
1533
1568
|
__typename?: 'MissingPasswordError';
|
|
1534
1569
|
errorCode: ErrorCode;
|
|
1535
|
-
message: Scalars['String'];
|
|
1570
|
+
message: Scalars['String']['output'];
|
|
1536
1571
|
};
|
|
1537
1572
|
export type MollieAmount = {
|
|
1538
1573
|
__typename?: 'MollieAmount';
|
|
1539
|
-
currency?: Maybe<Scalars['String']>;
|
|
1540
|
-
value?: Maybe<Scalars['String']>;
|
|
1574
|
+
currency?: Maybe<Scalars['String']['output']>;
|
|
1575
|
+
value?: Maybe<Scalars['String']['output']>;
|
|
1541
1576
|
};
|
|
1542
1577
|
export type MolliePaymentIntent = {
|
|
1543
1578
|
__typename?: 'MolliePaymentIntent';
|
|
1544
|
-
url: Scalars['String'];
|
|
1579
|
+
url: Scalars['String']['output'];
|
|
1545
1580
|
};
|
|
1546
1581
|
export type MolliePaymentIntentError = ErrorResult & {
|
|
1547
1582
|
__typename?: 'MolliePaymentIntentError';
|
|
1548
1583
|
errorCode: ErrorCode;
|
|
1549
|
-
message: Scalars['String'];
|
|
1584
|
+
message: Scalars['String']['output'];
|
|
1550
1585
|
};
|
|
1551
1586
|
export type MolliePaymentIntentInput = {
|
|
1552
|
-
molliePaymentMethodCode?: InputMaybe<Scalars['String']>;
|
|
1553
|
-
paymentMethodCode: Scalars['String'];
|
|
1554
|
-
redirectUrl?: InputMaybe<Scalars['String']>;
|
|
1587
|
+
molliePaymentMethodCode?: InputMaybe<Scalars['String']['input']>;
|
|
1588
|
+
paymentMethodCode: Scalars['String']['input'];
|
|
1589
|
+
redirectUrl?: InputMaybe<Scalars['String']['input']>;
|
|
1555
1590
|
};
|
|
1556
1591
|
export type MolliePaymentIntentResult = MolliePaymentIntent | MolliePaymentIntentError;
|
|
1557
1592
|
export type MolliePaymentMethod = {
|
|
1558
1593
|
__typename?: 'MolliePaymentMethod';
|
|
1559
|
-
code: Scalars['String'];
|
|
1560
|
-
description?: Maybe<Scalars['String']>;
|
|
1561
|
-
id: Scalars['ID'];
|
|
1594
|
+
code: Scalars['String']['output'];
|
|
1595
|
+
description?: Maybe<Scalars['String']['output']>;
|
|
1596
|
+
id: Scalars['ID']['output'];
|
|
1562
1597
|
image?: Maybe<MolliePaymentMethodImages>;
|
|
1563
1598
|
maximumAmount?: Maybe<MollieAmount>;
|
|
1564
1599
|
minimumAmount?: Maybe<MollieAmount>;
|
|
1565
1600
|
};
|
|
1566
1601
|
export type MolliePaymentMethodImages = {
|
|
1567
1602
|
__typename?: 'MolliePaymentMethodImages';
|
|
1568
|
-
size1x?: Maybe<Scalars['String']>;
|
|
1569
|
-
size2x?: Maybe<Scalars['String']>;
|
|
1570
|
-
svg?: Maybe<Scalars['String']>;
|
|
1603
|
+
size1x?: Maybe<Scalars['String']['output']>;
|
|
1604
|
+
size2x?: Maybe<Scalars['String']['output']>;
|
|
1605
|
+
svg?: Maybe<Scalars['String']['output']>;
|
|
1571
1606
|
};
|
|
1572
1607
|
export type MolliePaymentMethodsInput = {
|
|
1573
|
-
paymentMethodCode: Scalars['String'];
|
|
1608
|
+
paymentMethodCode: Scalars['String']['input'];
|
|
1574
1609
|
};
|
|
1575
1610
|
export type Mutation = {
|
|
1576
1611
|
__typename?: 'Mutation';
|
|
@@ -1666,22 +1701,22 @@ export type Mutation = {
|
|
|
1666
1701
|
verifyCustomerAccount: VerifyCustomerAccountResult;
|
|
1667
1702
|
};
|
|
1668
1703
|
export type MutationAddItemToOrderArgs = {
|
|
1669
|
-
productVariantId: Scalars['ID'];
|
|
1670
|
-
quantity: Scalars['Int'];
|
|
1704
|
+
productVariantId: Scalars['ID']['input'];
|
|
1705
|
+
quantity: Scalars['Int']['input'];
|
|
1671
1706
|
};
|
|
1672
1707
|
export type MutationAddPaymentToOrderArgs = {
|
|
1673
1708
|
input: PaymentInput;
|
|
1674
1709
|
};
|
|
1675
1710
|
export type MutationAdjustOrderLineArgs = {
|
|
1676
|
-
orderLineId: Scalars['ID'];
|
|
1677
|
-
quantity: Scalars['Int'];
|
|
1711
|
+
orderLineId: Scalars['ID']['input'];
|
|
1712
|
+
quantity: Scalars['Int']['input'];
|
|
1678
1713
|
};
|
|
1679
1714
|
export type MutationApplyCouponCodeArgs = {
|
|
1680
|
-
couponCode: Scalars['String'];
|
|
1715
|
+
couponCode: Scalars['String']['input'];
|
|
1681
1716
|
};
|
|
1682
1717
|
export type MutationAuthenticateArgs = {
|
|
1683
1718
|
input: AuthenticationInput;
|
|
1684
|
-
rememberMe?: InputMaybe<Scalars['Boolean']>;
|
|
1719
|
+
rememberMe?: InputMaybe<Scalars['Boolean']['input']>;
|
|
1685
1720
|
};
|
|
1686
1721
|
export type MutationCreateCustomerAddressArgs = {
|
|
1687
1722
|
input: CreateAddressInput;
|
|
@@ -1690,35 +1725,35 @@ export type MutationCreateMolliePaymentIntentArgs = {
|
|
|
1690
1725
|
input: MolliePaymentIntentInput;
|
|
1691
1726
|
};
|
|
1692
1727
|
export type MutationDeleteCustomerAddressArgs = {
|
|
1693
|
-
id: Scalars['ID'];
|
|
1728
|
+
id: Scalars['ID']['input'];
|
|
1694
1729
|
};
|
|
1695
1730
|
export type MutationLoginArgs = {
|
|
1696
|
-
password: Scalars['String'];
|
|
1697
|
-
rememberMe?: InputMaybe<Scalars['Boolean']>;
|
|
1698
|
-
username: Scalars['String'];
|
|
1731
|
+
password: Scalars['String']['input'];
|
|
1732
|
+
rememberMe?: InputMaybe<Scalars['Boolean']['input']>;
|
|
1733
|
+
username: Scalars['String']['input'];
|
|
1699
1734
|
};
|
|
1700
1735
|
export type MutationRefreshCustomerVerificationArgs = {
|
|
1701
|
-
emailAddress: Scalars['String'];
|
|
1736
|
+
emailAddress: Scalars['String']['input'];
|
|
1702
1737
|
};
|
|
1703
1738
|
export type MutationRegisterCustomerAccountArgs = {
|
|
1704
1739
|
input: RegisterCustomerInput;
|
|
1705
1740
|
};
|
|
1706
1741
|
export type MutationRemoveCouponCodeArgs = {
|
|
1707
|
-
couponCode: Scalars['String'];
|
|
1742
|
+
couponCode: Scalars['String']['input'];
|
|
1708
1743
|
};
|
|
1709
1744
|
export type MutationRemoveOrderLineArgs = {
|
|
1710
|
-
orderLineId: Scalars['ID'];
|
|
1745
|
+
orderLineId: Scalars['ID']['input'];
|
|
1711
1746
|
};
|
|
1712
1747
|
export type MutationRequestPasswordResetArgs = {
|
|
1713
|
-
emailAddress: Scalars['String'];
|
|
1748
|
+
emailAddress: Scalars['String']['input'];
|
|
1714
1749
|
};
|
|
1715
1750
|
export type MutationRequestUpdateCustomerEmailAddressArgs = {
|
|
1716
|
-
newEmailAddress: Scalars['String'];
|
|
1717
|
-
password: Scalars['String'];
|
|
1751
|
+
newEmailAddress: Scalars['String']['input'];
|
|
1752
|
+
password: Scalars['String']['input'];
|
|
1718
1753
|
};
|
|
1719
1754
|
export type MutationResetPasswordArgs = {
|
|
1720
|
-
password: Scalars['String'];
|
|
1721
|
-
token: Scalars['String'];
|
|
1755
|
+
password: Scalars['String']['input'];
|
|
1756
|
+
token: Scalars['String']['input'];
|
|
1722
1757
|
};
|
|
1723
1758
|
export type MutationSetCustomerForOrderArgs = {
|
|
1724
1759
|
input: CreateCustomerInput;
|
|
@@ -1733,10 +1768,10 @@ export type MutationSetOrderShippingAddressArgs = {
|
|
|
1733
1768
|
input: CreateAddressInput;
|
|
1734
1769
|
};
|
|
1735
1770
|
export type MutationSetOrderShippingMethodArgs = {
|
|
1736
|
-
shippingMethodId: Array<Scalars['ID']>;
|
|
1771
|
+
shippingMethodId: Array<Scalars['ID']['input']>;
|
|
1737
1772
|
};
|
|
1738
1773
|
export type MutationTransitionOrderToStateArgs = {
|
|
1739
|
-
state: Scalars['String'];
|
|
1774
|
+
state: Scalars['String']['input'];
|
|
1740
1775
|
};
|
|
1741
1776
|
export type MutationUpdateCustomerArgs = {
|
|
1742
1777
|
input: UpdateCustomerInput;
|
|
@@ -1745,32 +1780,32 @@ export type MutationUpdateCustomerAddressArgs = {
|
|
|
1745
1780
|
input: UpdateAddressInput;
|
|
1746
1781
|
};
|
|
1747
1782
|
export type MutationUpdateCustomerEmailAddressArgs = {
|
|
1748
|
-
token: Scalars['String'];
|
|
1783
|
+
token: Scalars['String']['input'];
|
|
1749
1784
|
};
|
|
1750
1785
|
export type MutationUpdateCustomerPasswordArgs = {
|
|
1751
|
-
currentPassword: Scalars['String'];
|
|
1752
|
-
newPassword: Scalars['String'];
|
|
1786
|
+
currentPassword: Scalars['String']['input'];
|
|
1787
|
+
newPassword: Scalars['String']['input'];
|
|
1753
1788
|
};
|
|
1754
1789
|
export type MutationVerifyCustomerAccountArgs = {
|
|
1755
|
-
password?: InputMaybe<Scalars['String']>;
|
|
1756
|
-
token: Scalars['String'];
|
|
1790
|
+
password?: InputMaybe<Scalars['String']['input']>;
|
|
1791
|
+
token: Scalars['String']['input'];
|
|
1757
1792
|
};
|
|
1758
1793
|
export type NativeAuthInput = {
|
|
1759
|
-
password: Scalars['String'];
|
|
1760
|
-
username: Scalars['String'];
|
|
1794
|
+
password: Scalars['String']['input'];
|
|
1795
|
+
username: Scalars['String']['input'];
|
|
1761
1796
|
};
|
|
1762
1797
|
/** Returned when attempting an operation that relies on the NativeAuthStrategy, if that strategy is not configured. */
|
|
1763
1798
|
export type NativeAuthStrategyError = ErrorResult & {
|
|
1764
1799
|
__typename?: 'NativeAuthStrategyError';
|
|
1765
1800
|
errorCode: ErrorCode;
|
|
1766
|
-
message: Scalars['String'];
|
|
1801
|
+
message: Scalars['String']['output'];
|
|
1767
1802
|
};
|
|
1768
1803
|
export type NativeAuthenticationResult = CurrentUser | InvalidCredentialsError | NativeAuthStrategyError | NotVerifiedError;
|
|
1769
1804
|
/** Returned when attempting to set a negative OrderLine quantity. */
|
|
1770
1805
|
export type NegativeQuantityError = ErrorResult & {
|
|
1771
1806
|
__typename?: 'NegativeQuantityError';
|
|
1772
1807
|
errorCode: ErrorCode;
|
|
1773
|
-
message: Scalars['String'];
|
|
1808
|
+
message: Scalars['String']['output'];
|
|
1774
1809
|
};
|
|
1775
1810
|
/**
|
|
1776
1811
|
* Returned when invoking a mutation which depends on there being an active Order on the
|
|
@@ -1779,10 +1814,10 @@ export type NegativeQuantityError = ErrorResult & {
|
|
|
1779
1814
|
export type NoActiveOrderError = ErrorResult & {
|
|
1780
1815
|
__typename?: 'NoActiveOrderError';
|
|
1781
1816
|
errorCode: ErrorCode;
|
|
1782
|
-
message: Scalars['String'];
|
|
1817
|
+
message: Scalars['String']['output'];
|
|
1783
1818
|
};
|
|
1784
1819
|
export type Node = {
|
|
1785
|
-
id: Scalars['ID'];
|
|
1820
|
+
id: Scalars['ID']['output'];
|
|
1786
1821
|
};
|
|
1787
1822
|
/**
|
|
1788
1823
|
* Returned if `authOptions.requireVerification` is set to `true` (which is the default)
|
|
@@ -1791,66 +1826,66 @@ export type Node = {
|
|
|
1791
1826
|
export type NotVerifiedError = ErrorResult & {
|
|
1792
1827
|
__typename?: 'NotVerifiedError';
|
|
1793
1828
|
errorCode: ErrorCode;
|
|
1794
|
-
message: Scalars['String'];
|
|
1829
|
+
message: Scalars['String']['output'];
|
|
1795
1830
|
};
|
|
1796
1831
|
/** Operators for filtering on a list of Number fields */
|
|
1797
1832
|
export type NumberListOperators = {
|
|
1798
|
-
inList: Scalars['Float'];
|
|
1833
|
+
inList: Scalars['Float']['input'];
|
|
1799
1834
|
};
|
|
1800
1835
|
/** Operators for filtering on a Int or Float field */
|
|
1801
1836
|
export type NumberOperators = {
|
|
1802
1837
|
between?: InputMaybe<NumberRange>;
|
|
1803
|
-
eq?: InputMaybe<Scalars['Float']>;
|
|
1804
|
-
gt?: InputMaybe<Scalars['Float']>;
|
|
1805
|
-
gte?: InputMaybe<Scalars['Float']>;
|
|
1806
|
-
isNull?: InputMaybe<Scalars['Boolean']>;
|
|
1807
|
-
lt?: InputMaybe<Scalars['Float']>;
|
|
1808
|
-
lte?: InputMaybe<Scalars['Float']>;
|
|
1838
|
+
eq?: InputMaybe<Scalars['Float']['input']>;
|
|
1839
|
+
gt?: InputMaybe<Scalars['Float']['input']>;
|
|
1840
|
+
gte?: InputMaybe<Scalars['Float']['input']>;
|
|
1841
|
+
isNull?: InputMaybe<Scalars['Boolean']['input']>;
|
|
1842
|
+
lt?: InputMaybe<Scalars['Float']['input']>;
|
|
1843
|
+
lte?: InputMaybe<Scalars['Float']['input']>;
|
|
1809
1844
|
};
|
|
1810
1845
|
export type NumberRange = {
|
|
1811
|
-
end: Scalars['Float'];
|
|
1812
|
-
start: Scalars['Float'];
|
|
1846
|
+
end: Scalars['Float']['input'];
|
|
1847
|
+
start: Scalars['Float']['input'];
|
|
1813
1848
|
};
|
|
1814
1849
|
export type Order = Node & {
|
|
1815
1850
|
__typename?: 'Order';
|
|
1816
1851
|
/** An order is active as long as the payment process has not been completed */
|
|
1817
|
-
active: Scalars['Boolean'];
|
|
1852
|
+
active: Scalars['Boolean']['output'];
|
|
1818
1853
|
billingAddress?: Maybe<OrderAddress>;
|
|
1819
1854
|
/** A unique code for the Order */
|
|
1820
|
-
code: Scalars['String'];
|
|
1855
|
+
code: Scalars['String']['output'];
|
|
1821
1856
|
/** An array of all coupon codes applied to the Order */
|
|
1822
|
-
couponCodes: Array<Scalars['String']>;
|
|
1823
|
-
createdAt: Scalars['DateTime'];
|
|
1857
|
+
couponCodes: Array<Scalars['String']['output']>;
|
|
1858
|
+
createdAt: Scalars['DateTime']['output'];
|
|
1824
1859
|
currencyCode: CurrencyCode;
|
|
1825
|
-
customFields?: Maybe<Scalars['JSON']>;
|
|
1860
|
+
customFields?: Maybe<Scalars['JSON']['output']>;
|
|
1826
1861
|
customer?: Maybe<Customer>;
|
|
1827
1862
|
discounts: Array<Discount>;
|
|
1828
1863
|
fulfillments?: Maybe<Array<Fulfillment>>;
|
|
1829
1864
|
history: HistoryEntryList;
|
|
1830
|
-
id: Scalars['ID'];
|
|
1865
|
+
id: Scalars['ID']['output'];
|
|
1831
1866
|
lines: Array<OrderLine>;
|
|
1832
1867
|
/**
|
|
1833
1868
|
* The date & time that the Order was placed, i.e. the Customer
|
|
1834
1869
|
* completed the checkout and the Order is no longer "active"
|
|
1835
1870
|
*/
|
|
1836
|
-
orderPlacedAt?: Maybe<Scalars['DateTime']>;
|
|
1871
|
+
orderPlacedAt?: Maybe<Scalars['DateTime']['output']>;
|
|
1837
1872
|
payments?: Maybe<Array<Payment>>;
|
|
1838
1873
|
/** Promotions applied to the order. Only gets populated after the payment process has completed. */
|
|
1839
1874
|
promotions: Array<Promotion>;
|
|
1840
|
-
shipping: Scalars['Money'];
|
|
1875
|
+
shipping: Scalars['Money']['output'];
|
|
1841
1876
|
shippingAddress?: Maybe<OrderAddress>;
|
|
1842
1877
|
shippingLines: Array<ShippingLine>;
|
|
1843
|
-
shippingWithTax: Scalars['Money'];
|
|
1844
|
-
state: Scalars['String'];
|
|
1878
|
+
shippingWithTax: Scalars['Money']['output'];
|
|
1879
|
+
state: Scalars['String']['output'];
|
|
1845
1880
|
/**
|
|
1846
1881
|
* The subTotal is the total of all OrderLines in the Order. This figure also includes any Order-level
|
|
1847
1882
|
* discounts which have been prorated (proportionally distributed) amongst the items of each OrderLine.
|
|
1848
1883
|
* To get a total of all OrderLines which does not account for prorated discounts, use the
|
|
1849
1884
|
* sum of `OrderLine.discountedLinePrice` values.
|
|
1850
1885
|
*/
|
|
1851
|
-
subTotal: Scalars['Money'];
|
|
1886
|
+
subTotal: Scalars['Money']['output'];
|
|
1852
1887
|
/** Same as subTotal, but inclusive of tax */
|
|
1853
|
-
subTotalWithTax: Scalars['Money'];
|
|
1888
|
+
subTotalWithTax: Scalars['Money']['output'];
|
|
1854
1889
|
/**
|
|
1855
1890
|
* Surcharges are arbitrary modifications to the Order total which are neither
|
|
1856
1891
|
* ProductVariants nor discounts resulting from applied Promotions. For example,
|
|
@@ -1861,29 +1896,29 @@ export type Order = Node & {
|
|
|
1861
1896
|
/** A summary of the taxes being applied to this Order */
|
|
1862
1897
|
taxSummary: Array<OrderTaxSummary>;
|
|
1863
1898
|
/** Equal to subTotal plus shipping */
|
|
1864
|
-
total: Scalars['Money'];
|
|
1865
|
-
totalQuantity: Scalars['Int'];
|
|
1899
|
+
total: Scalars['Money']['output'];
|
|
1900
|
+
totalQuantity: Scalars['Int']['output'];
|
|
1866
1901
|
/** The final payable amount. Equal to subTotalWithTax plus shippingWithTax */
|
|
1867
|
-
totalWithTax: Scalars['Money'];
|
|
1902
|
+
totalWithTax: Scalars['Money']['output'];
|
|
1868
1903
|
type: OrderType;
|
|
1869
|
-
updatedAt: Scalars['DateTime'];
|
|
1904
|
+
updatedAt: Scalars['DateTime']['output'];
|
|
1870
1905
|
};
|
|
1871
1906
|
export type OrderHistoryArgs = {
|
|
1872
1907
|
options?: InputMaybe<HistoryEntryListOptions>;
|
|
1873
1908
|
};
|
|
1874
1909
|
export type OrderAddress = {
|
|
1875
1910
|
__typename?: 'OrderAddress';
|
|
1876
|
-
city?: Maybe<Scalars['String']>;
|
|
1877
|
-
company?: Maybe<Scalars['String']>;
|
|
1878
|
-
country?: Maybe<Scalars['String']>;
|
|
1879
|
-
countryCode?: Maybe<Scalars['String']>;
|
|
1880
|
-
customFields?: Maybe<Scalars['JSON']>;
|
|
1881
|
-
fullName?: Maybe<Scalars['String']>;
|
|
1882
|
-
phoneNumber?: Maybe<Scalars['String']>;
|
|
1883
|
-
postalCode?: Maybe<Scalars['String']>;
|
|
1884
|
-
province?: Maybe<Scalars['String']>;
|
|
1885
|
-
streetLine1?: Maybe<Scalars['String']>;
|
|
1886
|
-
streetLine2?: Maybe<Scalars['String']>;
|
|
1911
|
+
city?: Maybe<Scalars['String']['output']>;
|
|
1912
|
+
company?: Maybe<Scalars['String']['output']>;
|
|
1913
|
+
country?: Maybe<Scalars['String']['output']>;
|
|
1914
|
+
countryCode?: Maybe<Scalars['String']['output']>;
|
|
1915
|
+
customFields?: Maybe<Scalars['JSON']['output']>;
|
|
1916
|
+
fullName?: Maybe<Scalars['String']['output']>;
|
|
1917
|
+
phoneNumber?: Maybe<Scalars['String']['output']>;
|
|
1918
|
+
postalCode?: Maybe<Scalars['String']['output']>;
|
|
1919
|
+
province?: Maybe<Scalars['String']['output']>;
|
|
1920
|
+
streetLine1?: Maybe<Scalars['String']['output']>;
|
|
1921
|
+
streetLine2?: Maybe<Scalars['String']['output']>;
|
|
1887
1922
|
};
|
|
1888
1923
|
export type OrderFilterParameter = {
|
|
1889
1924
|
active?: InputMaybe<BooleanOperators>;
|
|
@@ -1907,17 +1942,17 @@ export type OrderFilterParameter = {
|
|
|
1907
1942
|
export type OrderLimitError = ErrorResult & {
|
|
1908
1943
|
__typename?: 'OrderLimitError';
|
|
1909
1944
|
errorCode: ErrorCode;
|
|
1910
|
-
maxItems: Scalars['Int'];
|
|
1911
|
-
message: Scalars['String'];
|
|
1945
|
+
maxItems: Scalars['Int']['output'];
|
|
1946
|
+
message: Scalars['String']['output'];
|
|
1912
1947
|
};
|
|
1913
1948
|
export type OrderLine = Node & {
|
|
1914
1949
|
__typename?: 'OrderLine';
|
|
1915
|
-
createdAt: Scalars['DateTime'];
|
|
1916
|
-
customFields?: Maybe<Scalars['JSON']>;
|
|
1950
|
+
createdAt: Scalars['DateTime']['output'];
|
|
1951
|
+
customFields?: Maybe<Scalars['JSON']['output']>;
|
|
1917
1952
|
/** The price of the line including discounts, excluding tax */
|
|
1918
|
-
discountedLinePrice: Scalars['Money'];
|
|
1953
|
+
discountedLinePrice: Scalars['Money']['output'];
|
|
1919
1954
|
/** The price of the line including discounts and tax */
|
|
1920
|
-
discountedLinePriceWithTax: Scalars['Money'];
|
|
1955
|
+
discountedLinePriceWithTax: Scalars['Money']['output'];
|
|
1921
1956
|
/**
|
|
1922
1957
|
* The price of a single unit including discounts, excluding tax.
|
|
1923
1958
|
*
|
|
@@ -1926,56 +1961,56 @@ export type OrderLine = Node & {
|
|
|
1926
1961
|
* correct price to display to customers to avoid confusion
|
|
1927
1962
|
* about the internal handling of distributed Order-level discounts.
|
|
1928
1963
|
*/
|
|
1929
|
-
discountedUnitPrice: Scalars['Money'];
|
|
1964
|
+
discountedUnitPrice: Scalars['Money']['output'];
|
|
1930
1965
|
/** The price of a single unit including discounts and tax */
|
|
1931
|
-
discountedUnitPriceWithTax: Scalars['Money'];
|
|
1966
|
+
discountedUnitPriceWithTax: Scalars['Money']['output'];
|
|
1932
1967
|
discounts: Array<Discount>;
|
|
1933
1968
|
featuredAsset?: Maybe<Asset>;
|
|
1934
1969
|
fulfillmentLines?: Maybe<Array<FulfillmentLine>>;
|
|
1935
|
-
id: Scalars['ID'];
|
|
1970
|
+
id: Scalars['ID']['output'];
|
|
1936
1971
|
/** The total price of the line excluding tax and discounts. */
|
|
1937
|
-
linePrice: Scalars['Money'];
|
|
1972
|
+
linePrice: Scalars['Money']['output'];
|
|
1938
1973
|
/** The total price of the line including tax but excluding discounts. */
|
|
1939
|
-
linePriceWithTax: Scalars['Money'];
|
|
1974
|
+
linePriceWithTax: Scalars['Money']['output'];
|
|
1940
1975
|
/** The total tax on this line */
|
|
1941
|
-
lineTax: Scalars['Money'];
|
|
1976
|
+
lineTax: Scalars['Money']['output'];
|
|
1942
1977
|
order: Order;
|
|
1943
1978
|
/** The quantity at the time the Order was placed */
|
|
1944
|
-
orderPlacedQuantity: Scalars['Int'];
|
|
1979
|
+
orderPlacedQuantity: Scalars['Int']['output'];
|
|
1945
1980
|
productVariant: ProductVariant;
|
|
1946
1981
|
/**
|
|
1947
1982
|
* The actual line price, taking into account both item discounts _and_ prorated (proportionally-distributed)
|
|
1948
1983
|
* Order-level discounts. This value is the true economic value of the OrderLine, and is used in tax
|
|
1949
1984
|
* and refund calculations.
|
|
1950
1985
|
*/
|
|
1951
|
-
proratedLinePrice: Scalars['Money'];
|
|
1986
|
+
proratedLinePrice: Scalars['Money']['output'];
|
|
1952
1987
|
/** The proratedLinePrice including tax */
|
|
1953
|
-
proratedLinePriceWithTax: Scalars['Money'];
|
|
1988
|
+
proratedLinePriceWithTax: Scalars['Money']['output'];
|
|
1954
1989
|
/**
|
|
1955
1990
|
* The actual unit price, taking into account both item discounts _and_ prorated (proportionally-distributed)
|
|
1956
1991
|
* Order-level discounts. This value is the true economic value of the OrderItem, and is used in tax
|
|
1957
1992
|
* and refund calculations.
|
|
1958
1993
|
*/
|
|
1959
|
-
proratedUnitPrice: Scalars['Money'];
|
|
1994
|
+
proratedUnitPrice: Scalars['Money']['output'];
|
|
1960
1995
|
/** The proratedUnitPrice including tax */
|
|
1961
|
-
proratedUnitPriceWithTax: Scalars['Money'];
|
|
1962
|
-
quantity: Scalars['Int'];
|
|
1996
|
+
proratedUnitPriceWithTax: Scalars['Money']['output'];
|
|
1997
|
+
quantity: Scalars['Int']['output'];
|
|
1963
1998
|
taxLines: Array<TaxLine>;
|
|
1964
|
-
taxRate: Scalars['Float'];
|
|
1999
|
+
taxRate: Scalars['Float']['output'];
|
|
1965
2000
|
/** The price of a single unit, excluding tax and discounts */
|
|
1966
|
-
unitPrice: Scalars['Money'];
|
|
2001
|
+
unitPrice: Scalars['Money']['output'];
|
|
1967
2002
|
/** Non-zero if the unitPrice has changed since it was initially added to Order */
|
|
1968
|
-
unitPriceChangeSinceAdded: Scalars['Money'];
|
|
2003
|
+
unitPriceChangeSinceAdded: Scalars['Money']['output'];
|
|
1969
2004
|
/** The price of a single unit, including tax but excluding discounts */
|
|
1970
|
-
unitPriceWithTax: Scalars['Money'];
|
|
2005
|
+
unitPriceWithTax: Scalars['Money']['output'];
|
|
1971
2006
|
/** Non-zero if the unitPriceWithTax has changed since it was initially added to Order */
|
|
1972
|
-
unitPriceWithTaxChangeSinceAdded: Scalars['Money'];
|
|
1973
|
-
updatedAt: Scalars['DateTime'];
|
|
2007
|
+
unitPriceWithTaxChangeSinceAdded: Scalars['Money']['output'];
|
|
2008
|
+
updatedAt: Scalars['DateTime']['output'];
|
|
1974
2009
|
};
|
|
1975
2010
|
export type OrderList = PaginatedList & {
|
|
1976
2011
|
__typename?: 'OrderList';
|
|
1977
2012
|
items: Array<Order>;
|
|
1978
|
-
totalItems: Scalars['Int'];
|
|
2013
|
+
totalItems: Scalars['Int']['output'];
|
|
1979
2014
|
};
|
|
1980
2015
|
export type OrderListOptions = {
|
|
1981
2016
|
/** Allows the results to be filtered */
|
|
@@ -1983,23 +2018,23 @@ export type OrderListOptions = {
|
|
|
1983
2018
|
/** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
|
|
1984
2019
|
filterOperator?: InputMaybe<LogicalOperator>;
|
|
1985
2020
|
/** Skips the first n results, for use in pagination */
|
|
1986
|
-
skip?: InputMaybe<Scalars['Int']>;
|
|
2021
|
+
skip?: InputMaybe<Scalars['Int']['input']>;
|
|
1987
2022
|
/** Specifies which properties to sort the results by */
|
|
1988
2023
|
sort?: InputMaybe<OrderSortParameter>;
|
|
1989
2024
|
/** Takes n results, for use in pagination */
|
|
1990
|
-
take?: InputMaybe<Scalars['Int']>;
|
|
2025
|
+
take?: InputMaybe<Scalars['Int']['input']>;
|
|
1991
2026
|
};
|
|
1992
2027
|
/** Returned when attempting to modify the contents of an Order that is not in the `AddingItems` state. */
|
|
1993
2028
|
export type OrderModificationError = ErrorResult & {
|
|
1994
2029
|
__typename?: 'OrderModificationError';
|
|
1995
2030
|
errorCode: ErrorCode;
|
|
1996
|
-
message: Scalars['String'];
|
|
2031
|
+
message: Scalars['String']['output'];
|
|
1997
2032
|
};
|
|
1998
2033
|
/** Returned when attempting to add a Payment to an Order that is not in the `ArrangingPayment` state. */
|
|
1999
2034
|
export type OrderPaymentStateError = ErrorResult & {
|
|
2000
2035
|
__typename?: 'OrderPaymentStateError';
|
|
2001
2036
|
errorCode: ErrorCode;
|
|
2002
|
-
message: Scalars['String'];
|
|
2037
|
+
message: Scalars['String']['output'];
|
|
2003
2038
|
};
|
|
2004
2039
|
export type OrderSortParameter = {
|
|
2005
2040
|
code?: InputMaybe<SortOrder>;
|
|
@@ -2020,10 +2055,10 @@ export type OrderSortParameter = {
|
|
|
2020
2055
|
export type OrderStateTransitionError = ErrorResult & {
|
|
2021
2056
|
__typename?: 'OrderStateTransitionError';
|
|
2022
2057
|
errorCode: ErrorCode;
|
|
2023
|
-
fromState: Scalars['String'];
|
|
2024
|
-
message: Scalars['String'];
|
|
2025
|
-
toState: Scalars['String'];
|
|
2026
|
-
transitionError: Scalars['String'];
|
|
2058
|
+
fromState: Scalars['String']['output'];
|
|
2059
|
+
message: Scalars['String']['output'];
|
|
2060
|
+
toState: Scalars['String']['output'];
|
|
2061
|
+
transitionError: Scalars['String']['output'];
|
|
2027
2062
|
};
|
|
2028
2063
|
/**
|
|
2029
2064
|
* A summary of the taxes being applied to this order, grouped
|
|
@@ -2032,13 +2067,13 @@ export type OrderStateTransitionError = ErrorResult & {
|
|
|
2032
2067
|
export type OrderTaxSummary = {
|
|
2033
2068
|
__typename?: 'OrderTaxSummary';
|
|
2034
2069
|
/** A description of this tax */
|
|
2035
|
-
description: Scalars['String'];
|
|
2070
|
+
description: Scalars['String']['output'];
|
|
2036
2071
|
/** The total net price of OrderLines to which this taxRate applies */
|
|
2037
|
-
taxBase: Scalars['Money'];
|
|
2072
|
+
taxBase: Scalars['Money']['output'];
|
|
2038
2073
|
/** The taxRate as a percentage */
|
|
2039
|
-
taxRate: Scalars['Float'];
|
|
2074
|
+
taxRate: Scalars['Float']['output'];
|
|
2040
2075
|
/** The total tax being applied to the Order at this taxRate */
|
|
2041
|
-
taxTotal: Scalars['Money'];
|
|
2076
|
+
taxTotal: Scalars['Money']['output'];
|
|
2042
2077
|
};
|
|
2043
2078
|
export declare enum OrderType {
|
|
2044
2079
|
Aggregate = "Aggregate",
|
|
@@ -2047,13 +2082,13 @@ export declare enum OrderType {
|
|
|
2047
2082
|
}
|
|
2048
2083
|
export type PaginatedList = {
|
|
2049
2084
|
items: Array<Node>;
|
|
2050
|
-
totalItems: Scalars['Int'];
|
|
2085
|
+
totalItems: Scalars['Int']['output'];
|
|
2051
2086
|
};
|
|
2052
2087
|
/** Returned when attempting to verify a customer account with a password, when a password has already been set. */
|
|
2053
2088
|
export type PasswordAlreadySetError = ErrorResult & {
|
|
2054
2089
|
__typename?: 'PasswordAlreadySetError';
|
|
2055
2090
|
errorCode: ErrorCode;
|
|
2056
|
-
message: Scalars['String'];
|
|
2091
|
+
message: Scalars['String']['output'];
|
|
2057
2092
|
};
|
|
2058
2093
|
/**
|
|
2059
2094
|
* Returned if the token used to reset a Customer's password is valid, but has
|
|
@@ -2062,7 +2097,7 @@ export type PasswordAlreadySetError = ErrorResult & {
|
|
|
2062
2097
|
export type PasswordResetTokenExpiredError = ErrorResult & {
|
|
2063
2098
|
__typename?: 'PasswordResetTokenExpiredError';
|
|
2064
2099
|
errorCode: ErrorCode;
|
|
2065
|
-
message: Scalars['String'];
|
|
2100
|
+
message: Scalars['String']['output'];
|
|
2066
2101
|
};
|
|
2067
2102
|
/**
|
|
2068
2103
|
* Returned if the token used to reset a Customer's password is either
|
|
@@ -2071,41 +2106,41 @@ export type PasswordResetTokenExpiredError = ErrorResult & {
|
|
|
2071
2106
|
export type PasswordResetTokenInvalidError = ErrorResult & {
|
|
2072
2107
|
__typename?: 'PasswordResetTokenInvalidError';
|
|
2073
2108
|
errorCode: ErrorCode;
|
|
2074
|
-
message: Scalars['String'];
|
|
2109
|
+
message: Scalars['String']['output'];
|
|
2075
2110
|
};
|
|
2076
2111
|
/** Returned when attempting to register or verify a customer account where the given password fails password validation. */
|
|
2077
2112
|
export type PasswordValidationError = ErrorResult & {
|
|
2078
2113
|
__typename?: 'PasswordValidationError';
|
|
2079
2114
|
errorCode: ErrorCode;
|
|
2080
|
-
message: Scalars['String'];
|
|
2081
|
-
validationErrorMessage: Scalars['String'];
|
|
2115
|
+
message: Scalars['String']['output'];
|
|
2116
|
+
validationErrorMessage: Scalars['String']['output'];
|
|
2082
2117
|
};
|
|
2083
2118
|
export type Payment = Node & {
|
|
2084
2119
|
__typename?: 'Payment';
|
|
2085
|
-
amount: Scalars['Money'];
|
|
2086
|
-
createdAt: Scalars['DateTime'];
|
|
2087
|
-
errorMessage?: Maybe<Scalars['String']>;
|
|
2088
|
-
id: Scalars['ID'];
|
|
2089
|
-
metadata?: Maybe<Scalars['JSON']>;
|
|
2090
|
-
method: Scalars['String'];
|
|
2120
|
+
amount: Scalars['Money']['output'];
|
|
2121
|
+
createdAt: Scalars['DateTime']['output'];
|
|
2122
|
+
errorMessage?: Maybe<Scalars['String']['output']>;
|
|
2123
|
+
id: Scalars['ID']['output'];
|
|
2124
|
+
metadata?: Maybe<Scalars['JSON']['output']>;
|
|
2125
|
+
method: Scalars['String']['output'];
|
|
2091
2126
|
refunds: Array<Refund>;
|
|
2092
|
-
state: Scalars['String'];
|
|
2093
|
-
transactionId?: Maybe<Scalars['String']>;
|
|
2094
|
-
updatedAt: Scalars['DateTime'];
|
|
2127
|
+
state: Scalars['String']['output'];
|
|
2128
|
+
transactionId?: Maybe<Scalars['String']['output']>;
|
|
2129
|
+
updatedAt: Scalars['DateTime']['output'];
|
|
2095
2130
|
};
|
|
2096
2131
|
/** Returned when a Payment is declined by the payment provider. */
|
|
2097
2132
|
export type PaymentDeclinedError = ErrorResult & {
|
|
2098
2133
|
__typename?: 'PaymentDeclinedError';
|
|
2099
2134
|
errorCode: ErrorCode;
|
|
2100
|
-
message: Scalars['String'];
|
|
2101
|
-
paymentErrorMessage: Scalars['String'];
|
|
2135
|
+
message: Scalars['String']['output'];
|
|
2136
|
+
paymentErrorMessage: Scalars['String']['output'];
|
|
2102
2137
|
};
|
|
2103
2138
|
/** Returned when a Payment fails due to an error. */
|
|
2104
2139
|
export type PaymentFailedError = ErrorResult & {
|
|
2105
2140
|
__typename?: 'PaymentFailedError';
|
|
2106
2141
|
errorCode: ErrorCode;
|
|
2107
|
-
message: Scalars['String'];
|
|
2108
|
-
paymentErrorMessage: Scalars['String'];
|
|
2142
|
+
message: Scalars['String']['output'];
|
|
2143
|
+
paymentErrorMessage: Scalars['String']['output'];
|
|
2109
2144
|
};
|
|
2110
2145
|
/** Passed as input to the `addPaymentToOrder` mutation. */
|
|
2111
2146
|
export type PaymentInput = {
|
|
@@ -2114,42 +2149,42 @@ export type PaymentInput = {
|
|
|
2114
2149
|
* as the "metadata" argument. For example, it could contain an ID for the payment and other
|
|
2115
2150
|
* data generated by the payment provider.
|
|
2116
2151
|
*/
|
|
2117
|
-
metadata: Scalars['JSON'];
|
|
2152
|
+
metadata: Scalars['JSON']['input'];
|
|
2118
2153
|
/** This field should correspond to the `code` property of a PaymentMethod. */
|
|
2119
|
-
method: Scalars['String'];
|
|
2154
|
+
method: Scalars['String']['input'];
|
|
2120
2155
|
};
|
|
2121
2156
|
export type PaymentMethod = Node & {
|
|
2122
2157
|
__typename?: 'PaymentMethod';
|
|
2123
2158
|
checker?: Maybe<ConfigurableOperation>;
|
|
2124
|
-
code: Scalars['String'];
|
|
2125
|
-
createdAt: Scalars['DateTime'];
|
|
2126
|
-
customFields?: Maybe<Scalars['JSON']>;
|
|
2127
|
-
description: Scalars['String'];
|
|
2128
|
-
enabled: Scalars['Boolean'];
|
|
2159
|
+
code: Scalars['String']['output'];
|
|
2160
|
+
createdAt: Scalars['DateTime']['output'];
|
|
2161
|
+
customFields?: Maybe<Scalars['JSON']['output']>;
|
|
2162
|
+
description: Scalars['String']['output'];
|
|
2163
|
+
enabled: Scalars['Boolean']['output'];
|
|
2129
2164
|
handler: ConfigurableOperation;
|
|
2130
|
-
id: Scalars['ID'];
|
|
2131
|
-
name: Scalars['String'];
|
|
2165
|
+
id: Scalars['ID']['output'];
|
|
2166
|
+
name: Scalars['String']['output'];
|
|
2132
2167
|
translations: Array<PaymentMethodTranslation>;
|
|
2133
|
-
updatedAt: Scalars['DateTime'];
|
|
2168
|
+
updatedAt: Scalars['DateTime']['output'];
|
|
2134
2169
|
};
|
|
2135
2170
|
export type PaymentMethodQuote = {
|
|
2136
2171
|
__typename?: 'PaymentMethodQuote';
|
|
2137
|
-
code: Scalars['String'];
|
|
2138
|
-
customFields?: Maybe<Scalars['JSON']>;
|
|
2139
|
-
description: Scalars['String'];
|
|
2140
|
-
eligibilityMessage?: Maybe<Scalars['String']>;
|
|
2141
|
-
id: Scalars['ID'];
|
|
2142
|
-
isEligible: Scalars['Boolean'];
|
|
2143
|
-
name: Scalars['String'];
|
|
2172
|
+
code: Scalars['String']['output'];
|
|
2173
|
+
customFields?: Maybe<Scalars['JSON']['output']>;
|
|
2174
|
+
description: Scalars['String']['output'];
|
|
2175
|
+
eligibilityMessage?: Maybe<Scalars['String']['output']>;
|
|
2176
|
+
id: Scalars['ID']['output'];
|
|
2177
|
+
isEligible: Scalars['Boolean']['output'];
|
|
2178
|
+
name: Scalars['String']['output'];
|
|
2144
2179
|
};
|
|
2145
2180
|
export type PaymentMethodTranslation = {
|
|
2146
2181
|
__typename?: 'PaymentMethodTranslation';
|
|
2147
|
-
createdAt: Scalars['DateTime'];
|
|
2148
|
-
description: Scalars['String'];
|
|
2149
|
-
id: Scalars['ID'];
|
|
2182
|
+
createdAt: Scalars['DateTime']['output'];
|
|
2183
|
+
description: Scalars['String']['output'];
|
|
2184
|
+
id: Scalars['ID']['output'];
|
|
2150
2185
|
languageCode: LanguageCode;
|
|
2151
|
-
name: Scalars['String'];
|
|
2152
|
-
updatedAt: Scalars['DateTime'];
|
|
2186
|
+
name: Scalars['String']['output'];
|
|
2187
|
+
updatedAt: Scalars['DateTime']['output'];
|
|
2153
2188
|
};
|
|
2154
2189
|
/**
|
|
2155
2190
|
* @description
|
|
@@ -2374,25 +2409,25 @@ export declare enum Permission {
|
|
|
2374
2409
|
/** The price range where the result has more than one price */
|
|
2375
2410
|
export type PriceRange = {
|
|
2376
2411
|
__typename?: 'PriceRange';
|
|
2377
|
-
max: Scalars['Money'];
|
|
2378
|
-
min: Scalars['Money'];
|
|
2412
|
+
max: Scalars['Money']['output'];
|
|
2413
|
+
min: Scalars['Money']['output'];
|
|
2379
2414
|
};
|
|
2380
2415
|
export type Product = Node & {
|
|
2381
2416
|
__typename?: 'Product';
|
|
2382
2417
|
assets: Array<Asset>;
|
|
2383
2418
|
collections: Array<Collection>;
|
|
2384
|
-
createdAt: Scalars['DateTime'];
|
|
2385
|
-
customFields?: Maybe<Scalars['JSON']>;
|
|
2386
|
-
description: Scalars['String'];
|
|
2419
|
+
createdAt: Scalars['DateTime']['output'];
|
|
2420
|
+
customFields?: Maybe<Scalars['JSON']['output']>;
|
|
2421
|
+
description: Scalars['String']['output'];
|
|
2387
2422
|
facetValues: Array<FacetValue>;
|
|
2388
2423
|
featuredAsset?: Maybe<Asset>;
|
|
2389
|
-
id: Scalars['ID'];
|
|
2424
|
+
id: Scalars['ID']['output'];
|
|
2390
2425
|
languageCode: LanguageCode;
|
|
2391
|
-
name: Scalars['String'];
|
|
2426
|
+
name: Scalars['String']['output'];
|
|
2392
2427
|
optionGroups: Array<ProductOptionGroup>;
|
|
2393
|
-
slug: Scalars['String'];
|
|
2428
|
+
slug: Scalars['String']['output'];
|
|
2394
2429
|
translations: Array<ProductTranslation>;
|
|
2395
|
-
updatedAt: Scalars['DateTime'];
|
|
2430
|
+
updatedAt: Scalars['DateTime']['output'];
|
|
2396
2431
|
/** Returns a paginated, sortable, filterable list of ProductVariants */
|
|
2397
2432
|
variantList: ProductVariantList;
|
|
2398
2433
|
/** Returns all ProductVariants */
|
|
@@ -2413,7 +2448,7 @@ export type ProductFilterParameter = {
|
|
|
2413
2448
|
export type ProductList = PaginatedList & {
|
|
2414
2449
|
__typename?: 'ProductList';
|
|
2415
2450
|
items: Array<Product>;
|
|
2416
|
-
totalItems: Scalars['Int'];
|
|
2451
|
+
totalItems: Scalars['Int']['output'];
|
|
2417
2452
|
};
|
|
2418
2453
|
export type ProductListOptions = {
|
|
2419
2454
|
/** Allows the results to be filtered */
|
|
@@ -2421,52 +2456,52 @@ export type ProductListOptions = {
|
|
|
2421
2456
|
/** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
|
|
2422
2457
|
filterOperator?: InputMaybe<LogicalOperator>;
|
|
2423
2458
|
/** Skips the first n results, for use in pagination */
|
|
2424
|
-
skip?: InputMaybe<Scalars['Int']>;
|
|
2459
|
+
skip?: InputMaybe<Scalars['Int']['input']>;
|
|
2425
2460
|
/** Specifies which properties to sort the results by */
|
|
2426
2461
|
sort?: InputMaybe<ProductSortParameter>;
|
|
2427
2462
|
/** Takes n results, for use in pagination */
|
|
2428
|
-
take?: InputMaybe<Scalars['Int']>;
|
|
2463
|
+
take?: InputMaybe<Scalars['Int']['input']>;
|
|
2429
2464
|
};
|
|
2430
2465
|
export type ProductOption = Node & {
|
|
2431
2466
|
__typename?: 'ProductOption';
|
|
2432
|
-
code: Scalars['String'];
|
|
2433
|
-
createdAt: Scalars['DateTime'];
|
|
2434
|
-
customFields?: Maybe<Scalars['JSON']>;
|
|
2467
|
+
code: Scalars['String']['output'];
|
|
2468
|
+
createdAt: Scalars['DateTime']['output'];
|
|
2469
|
+
customFields?: Maybe<Scalars['JSON']['output']>;
|
|
2435
2470
|
group: ProductOptionGroup;
|
|
2436
|
-
groupId: Scalars['ID'];
|
|
2437
|
-
id: Scalars['ID'];
|
|
2471
|
+
groupId: Scalars['ID']['output'];
|
|
2472
|
+
id: Scalars['ID']['output'];
|
|
2438
2473
|
languageCode: LanguageCode;
|
|
2439
|
-
name: Scalars['String'];
|
|
2474
|
+
name: Scalars['String']['output'];
|
|
2440
2475
|
translations: Array<ProductOptionTranslation>;
|
|
2441
|
-
updatedAt: Scalars['DateTime'];
|
|
2476
|
+
updatedAt: Scalars['DateTime']['output'];
|
|
2442
2477
|
};
|
|
2443
2478
|
export type ProductOptionGroup = Node & {
|
|
2444
2479
|
__typename?: 'ProductOptionGroup';
|
|
2445
|
-
code: Scalars['String'];
|
|
2446
|
-
createdAt: Scalars['DateTime'];
|
|
2447
|
-
customFields?: Maybe<Scalars['JSON']>;
|
|
2448
|
-
id: Scalars['ID'];
|
|
2480
|
+
code: Scalars['String']['output'];
|
|
2481
|
+
createdAt: Scalars['DateTime']['output'];
|
|
2482
|
+
customFields?: Maybe<Scalars['JSON']['output']>;
|
|
2483
|
+
id: Scalars['ID']['output'];
|
|
2449
2484
|
languageCode: LanguageCode;
|
|
2450
|
-
name: Scalars['String'];
|
|
2485
|
+
name: Scalars['String']['output'];
|
|
2451
2486
|
options: Array<ProductOption>;
|
|
2452
2487
|
translations: Array<ProductOptionGroupTranslation>;
|
|
2453
|
-
updatedAt: Scalars['DateTime'];
|
|
2488
|
+
updatedAt: Scalars['DateTime']['output'];
|
|
2454
2489
|
};
|
|
2455
2490
|
export type ProductOptionGroupTranslation = {
|
|
2456
2491
|
__typename?: 'ProductOptionGroupTranslation';
|
|
2457
|
-
createdAt: Scalars['DateTime'];
|
|
2458
|
-
id: Scalars['ID'];
|
|
2492
|
+
createdAt: Scalars['DateTime']['output'];
|
|
2493
|
+
id: Scalars['ID']['output'];
|
|
2459
2494
|
languageCode: LanguageCode;
|
|
2460
|
-
name: Scalars['String'];
|
|
2461
|
-
updatedAt: Scalars['DateTime'];
|
|
2495
|
+
name: Scalars['String']['output'];
|
|
2496
|
+
updatedAt: Scalars['DateTime']['output'];
|
|
2462
2497
|
};
|
|
2463
2498
|
export type ProductOptionTranslation = {
|
|
2464
2499
|
__typename?: 'ProductOptionTranslation';
|
|
2465
|
-
createdAt: Scalars['DateTime'];
|
|
2466
|
-
id: Scalars['ID'];
|
|
2500
|
+
createdAt: Scalars['DateTime']['output'];
|
|
2501
|
+
id: Scalars['ID']['output'];
|
|
2467
2502
|
languageCode: LanguageCode;
|
|
2468
|
-
name: Scalars['String'];
|
|
2469
|
-
updatedAt: Scalars['DateTime'];
|
|
2503
|
+
name: Scalars['String']['output'];
|
|
2504
|
+
updatedAt: Scalars['DateTime']['output'];
|
|
2470
2505
|
};
|
|
2471
2506
|
export type ProductSortParameter = {
|
|
2472
2507
|
createdAt?: InputMaybe<SortOrder>;
|
|
@@ -2478,36 +2513,36 @@ export type ProductSortParameter = {
|
|
|
2478
2513
|
};
|
|
2479
2514
|
export type ProductTranslation = {
|
|
2480
2515
|
__typename?: 'ProductTranslation';
|
|
2481
|
-
createdAt: Scalars['DateTime'];
|
|
2482
|
-
description: Scalars['String'];
|
|
2483
|
-
id: Scalars['ID'];
|
|
2516
|
+
createdAt: Scalars['DateTime']['output'];
|
|
2517
|
+
description: Scalars['String']['output'];
|
|
2518
|
+
id: Scalars['ID']['output'];
|
|
2484
2519
|
languageCode: LanguageCode;
|
|
2485
|
-
name: Scalars['String'];
|
|
2486
|
-
slug: Scalars['String'];
|
|
2487
|
-
updatedAt: Scalars['DateTime'];
|
|
2520
|
+
name: Scalars['String']['output'];
|
|
2521
|
+
slug: Scalars['String']['output'];
|
|
2522
|
+
updatedAt: Scalars['DateTime']['output'];
|
|
2488
2523
|
};
|
|
2489
2524
|
export type ProductVariant = Node & {
|
|
2490
2525
|
__typename?: 'ProductVariant';
|
|
2491
2526
|
assets: Array<Asset>;
|
|
2492
|
-
createdAt: Scalars['DateTime'];
|
|
2527
|
+
createdAt: Scalars['DateTime']['output'];
|
|
2493
2528
|
currencyCode: CurrencyCode;
|
|
2494
|
-
customFields?: Maybe<Scalars['JSON']>;
|
|
2529
|
+
customFields?: Maybe<Scalars['JSON']['output']>;
|
|
2495
2530
|
facetValues: Array<FacetValue>;
|
|
2496
2531
|
featuredAsset?: Maybe<Asset>;
|
|
2497
|
-
id: Scalars['ID'];
|
|
2532
|
+
id: Scalars['ID']['output'];
|
|
2498
2533
|
languageCode: LanguageCode;
|
|
2499
|
-
name: Scalars['String'];
|
|
2534
|
+
name: Scalars['String']['output'];
|
|
2500
2535
|
options: Array<ProductOption>;
|
|
2501
|
-
price: Scalars['Money'];
|
|
2502
|
-
priceWithTax: Scalars['Money'];
|
|
2536
|
+
price: Scalars['Money']['output'];
|
|
2537
|
+
priceWithTax: Scalars['Money']['output'];
|
|
2503
2538
|
product: Product;
|
|
2504
|
-
productId: Scalars['ID'];
|
|
2505
|
-
sku: Scalars['String'];
|
|
2506
|
-
stockLevel: Scalars['String'];
|
|
2539
|
+
productId: Scalars['ID']['output'];
|
|
2540
|
+
sku: Scalars['String']['output'];
|
|
2541
|
+
stockLevel: Scalars['String']['output'];
|
|
2507
2542
|
taxCategory: TaxCategory;
|
|
2508
2543
|
taxRateApplied: TaxRate;
|
|
2509
2544
|
translations: Array<ProductVariantTranslation>;
|
|
2510
|
-
updatedAt: Scalars['DateTime'];
|
|
2545
|
+
updatedAt: Scalars['DateTime']['output'];
|
|
2511
2546
|
};
|
|
2512
2547
|
export type ProductVariantFilterParameter = {
|
|
2513
2548
|
createdAt?: InputMaybe<DateOperators>;
|
|
@@ -2525,7 +2560,7 @@ export type ProductVariantFilterParameter = {
|
|
|
2525
2560
|
export type ProductVariantList = PaginatedList & {
|
|
2526
2561
|
__typename?: 'ProductVariantList';
|
|
2527
2562
|
items: Array<ProductVariant>;
|
|
2528
|
-
totalItems: Scalars['Int'];
|
|
2563
|
+
totalItems: Scalars['Int']['output'];
|
|
2529
2564
|
};
|
|
2530
2565
|
export type ProductVariantListOptions = {
|
|
2531
2566
|
/** Allows the results to be filtered */
|
|
@@ -2533,11 +2568,11 @@ export type ProductVariantListOptions = {
|
|
|
2533
2568
|
/** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
|
|
2534
2569
|
filterOperator?: InputMaybe<LogicalOperator>;
|
|
2535
2570
|
/** Skips the first n results, for use in pagination */
|
|
2536
|
-
skip?: InputMaybe<Scalars['Int']>;
|
|
2571
|
+
skip?: InputMaybe<Scalars['Int']['input']>;
|
|
2537
2572
|
/** Specifies which properties to sort the results by */
|
|
2538
2573
|
sort?: InputMaybe<ProductVariantSortParameter>;
|
|
2539
2574
|
/** Takes n results, for use in pagination */
|
|
2540
|
-
take?: InputMaybe<Scalars['Int']>;
|
|
2575
|
+
take?: InputMaybe<Scalars['Int']['input']>;
|
|
2541
2576
|
};
|
|
2542
2577
|
export type ProductVariantSortParameter = {
|
|
2543
2578
|
createdAt?: InputMaybe<SortOrder>;
|
|
@@ -2552,63 +2587,63 @@ export type ProductVariantSortParameter = {
|
|
|
2552
2587
|
};
|
|
2553
2588
|
export type ProductVariantTranslation = {
|
|
2554
2589
|
__typename?: 'ProductVariantTranslation';
|
|
2555
|
-
createdAt: Scalars['DateTime'];
|
|
2556
|
-
id: Scalars['ID'];
|
|
2590
|
+
createdAt: Scalars['DateTime']['output'];
|
|
2591
|
+
id: Scalars['ID']['output'];
|
|
2557
2592
|
languageCode: LanguageCode;
|
|
2558
|
-
name: Scalars['String'];
|
|
2559
|
-
updatedAt: Scalars['DateTime'];
|
|
2593
|
+
name: Scalars['String']['output'];
|
|
2594
|
+
updatedAt: Scalars['DateTime']['output'];
|
|
2560
2595
|
};
|
|
2561
2596
|
export type Promotion = Node & {
|
|
2562
2597
|
__typename?: 'Promotion';
|
|
2563
2598
|
actions: Array<ConfigurableOperation>;
|
|
2564
2599
|
conditions: Array<ConfigurableOperation>;
|
|
2565
|
-
couponCode?: Maybe<Scalars['String']>;
|
|
2566
|
-
createdAt: Scalars['DateTime'];
|
|
2567
|
-
customFields?: Maybe<Scalars['JSON']>;
|
|
2568
|
-
description: Scalars['String'];
|
|
2569
|
-
enabled: Scalars['Boolean'];
|
|
2570
|
-
endsAt?: Maybe<Scalars['DateTime']>;
|
|
2571
|
-
id: Scalars['ID'];
|
|
2572
|
-
name: Scalars['String'];
|
|
2573
|
-
perCustomerUsageLimit?: Maybe<Scalars['Int']>;
|
|
2574
|
-
startsAt?: Maybe<Scalars['DateTime']>;
|
|
2600
|
+
couponCode?: Maybe<Scalars['String']['output']>;
|
|
2601
|
+
createdAt: Scalars['DateTime']['output'];
|
|
2602
|
+
customFields?: Maybe<Scalars['JSON']['output']>;
|
|
2603
|
+
description: Scalars['String']['output'];
|
|
2604
|
+
enabled: Scalars['Boolean']['output'];
|
|
2605
|
+
endsAt?: Maybe<Scalars['DateTime']['output']>;
|
|
2606
|
+
id: Scalars['ID']['output'];
|
|
2607
|
+
name: Scalars['String']['output'];
|
|
2608
|
+
perCustomerUsageLimit?: Maybe<Scalars['Int']['output']>;
|
|
2609
|
+
startsAt?: Maybe<Scalars['DateTime']['output']>;
|
|
2575
2610
|
translations: Array<PromotionTranslation>;
|
|
2576
|
-
updatedAt: Scalars['DateTime'];
|
|
2577
|
-
usageLimit?: Maybe<Scalars['Int']>;
|
|
2611
|
+
updatedAt: Scalars['DateTime']['output'];
|
|
2612
|
+
usageLimit?: Maybe<Scalars['Int']['output']>;
|
|
2578
2613
|
};
|
|
2579
2614
|
export type PromotionList = PaginatedList & {
|
|
2580
2615
|
__typename?: 'PromotionList';
|
|
2581
2616
|
items: Array<Promotion>;
|
|
2582
|
-
totalItems: Scalars['Int'];
|
|
2617
|
+
totalItems: Scalars['Int']['output'];
|
|
2583
2618
|
};
|
|
2584
2619
|
export type PromotionTranslation = {
|
|
2585
2620
|
__typename?: 'PromotionTranslation';
|
|
2586
|
-
createdAt: Scalars['DateTime'];
|
|
2587
|
-
description: Scalars['String'];
|
|
2588
|
-
id: Scalars['ID'];
|
|
2621
|
+
createdAt: Scalars['DateTime']['output'];
|
|
2622
|
+
description: Scalars['String']['output'];
|
|
2623
|
+
id: Scalars['ID']['output'];
|
|
2589
2624
|
languageCode: LanguageCode;
|
|
2590
|
-
name: Scalars['String'];
|
|
2591
|
-
updatedAt: Scalars['DateTime'];
|
|
2625
|
+
name: Scalars['String']['output'];
|
|
2626
|
+
updatedAt: Scalars['DateTime']['output'];
|
|
2592
2627
|
};
|
|
2593
2628
|
export type Province = Node & Region & {
|
|
2594
2629
|
__typename?: 'Province';
|
|
2595
|
-
code: Scalars['String'];
|
|
2596
|
-
createdAt: Scalars['DateTime'];
|
|
2597
|
-
customFields?: Maybe<Scalars['JSON']>;
|
|
2598
|
-
enabled: Scalars['Boolean'];
|
|
2599
|
-
id: Scalars['ID'];
|
|
2630
|
+
code: Scalars['String']['output'];
|
|
2631
|
+
createdAt: Scalars['DateTime']['output'];
|
|
2632
|
+
customFields?: Maybe<Scalars['JSON']['output']>;
|
|
2633
|
+
enabled: Scalars['Boolean']['output'];
|
|
2634
|
+
id: Scalars['ID']['output'];
|
|
2600
2635
|
languageCode: LanguageCode;
|
|
2601
|
-
name: Scalars['String'];
|
|
2636
|
+
name: Scalars['String']['output'];
|
|
2602
2637
|
parent?: Maybe<Region>;
|
|
2603
|
-
parentId?: Maybe<Scalars['ID']>;
|
|
2638
|
+
parentId?: Maybe<Scalars['ID']['output']>;
|
|
2604
2639
|
translations: Array<RegionTranslation>;
|
|
2605
|
-
type: Scalars['String'];
|
|
2606
|
-
updatedAt: Scalars['DateTime'];
|
|
2640
|
+
type: Scalars['String']['output'];
|
|
2641
|
+
updatedAt: Scalars['DateTime']['output'];
|
|
2607
2642
|
};
|
|
2608
2643
|
export type ProvinceList = PaginatedList & {
|
|
2609
2644
|
__typename?: 'ProvinceList';
|
|
2610
2645
|
items: Array<Province>;
|
|
2611
|
-
totalItems: Scalars['Int'];
|
|
2646
|
+
totalItems: Scalars['Int']['output'];
|
|
2612
2647
|
};
|
|
2613
2648
|
export type Query = {
|
|
2614
2649
|
__typename?: 'Query';
|
|
@@ -2640,7 +2675,7 @@ export type Query = {
|
|
|
2640
2675
|
me?: Maybe<CurrentUser>;
|
|
2641
2676
|
molliePaymentMethods: Array<MolliePaymentMethod>;
|
|
2642
2677
|
/** Returns the possible next states that the activeOrder can transition to */
|
|
2643
|
-
nextOrderStates: Array<Scalars['String']>;
|
|
2678
|
+
nextOrderStates: Array<Scalars['String']['output']>;
|
|
2644
2679
|
/**
|
|
2645
2680
|
* Returns an Order based on the id. Note that in the Shop API, only orders belonging to the
|
|
2646
2681
|
* currently-authenticated User may be queried.
|
|
@@ -2661,14 +2696,14 @@ export type Query = {
|
|
|
2661
2696
|
search: SearchResponse;
|
|
2662
2697
|
};
|
|
2663
2698
|
export type QueryCollectionArgs = {
|
|
2664
|
-
id?: InputMaybe<Scalars['ID']>;
|
|
2665
|
-
slug?: InputMaybe<Scalars['String']>;
|
|
2699
|
+
id?: InputMaybe<Scalars['ID']['input']>;
|
|
2700
|
+
slug?: InputMaybe<Scalars['String']['input']>;
|
|
2666
2701
|
};
|
|
2667
2702
|
export type QueryCollectionsArgs = {
|
|
2668
2703
|
options?: InputMaybe<CollectionListOptions>;
|
|
2669
2704
|
};
|
|
2670
2705
|
export type QueryFacetArgs = {
|
|
2671
|
-
id: Scalars['ID'];
|
|
2706
|
+
id: Scalars['ID']['input'];
|
|
2672
2707
|
};
|
|
2673
2708
|
export type QueryFacetsArgs = {
|
|
2674
2709
|
options?: InputMaybe<FacetListOptions>;
|
|
@@ -2677,14 +2712,14 @@ export type QueryMolliePaymentMethodsArgs = {
|
|
|
2677
2712
|
input: MolliePaymentMethodsInput;
|
|
2678
2713
|
};
|
|
2679
2714
|
export type QueryOrderArgs = {
|
|
2680
|
-
id: Scalars['ID'];
|
|
2715
|
+
id: Scalars['ID']['input'];
|
|
2681
2716
|
};
|
|
2682
2717
|
export type QueryOrderByCodeArgs = {
|
|
2683
|
-
code: Scalars['String'];
|
|
2718
|
+
code: Scalars['String']['input'];
|
|
2684
2719
|
};
|
|
2685
2720
|
export type QueryProductArgs = {
|
|
2686
|
-
id?: InputMaybe<Scalars['ID']>;
|
|
2687
|
-
slug?: InputMaybe<Scalars['String']>;
|
|
2721
|
+
id?: InputMaybe<Scalars['ID']['input']>;
|
|
2722
|
+
slug?: InputMaybe<Scalars['String']['input']>;
|
|
2688
2723
|
};
|
|
2689
2724
|
export type QueryProductsArgs = {
|
|
2690
2725
|
options?: InputMaybe<ProductListOptions>;
|
|
@@ -2695,72 +2730,72 @@ export type QuerySearchArgs = {
|
|
|
2695
2730
|
export type RefreshCustomerVerificationResult = NativeAuthStrategyError | Success;
|
|
2696
2731
|
export type Refund = Node & {
|
|
2697
2732
|
__typename?: 'Refund';
|
|
2698
|
-
adjustment: Scalars['Money'];
|
|
2699
|
-
createdAt: Scalars['DateTime'];
|
|
2700
|
-
id: Scalars['ID'];
|
|
2701
|
-
items: Scalars['Money'];
|
|
2733
|
+
adjustment: Scalars['Money']['output'];
|
|
2734
|
+
createdAt: Scalars['DateTime']['output'];
|
|
2735
|
+
id: Scalars['ID']['output'];
|
|
2736
|
+
items: Scalars['Money']['output'];
|
|
2702
2737
|
lines: Array<RefundLine>;
|
|
2703
|
-
metadata?: Maybe<Scalars['JSON']>;
|
|
2704
|
-
method?: Maybe<Scalars['String']>;
|
|
2705
|
-
paymentId: Scalars['ID'];
|
|
2706
|
-
reason?: Maybe<Scalars['String']>;
|
|
2707
|
-
shipping: Scalars['Money'];
|
|
2708
|
-
state: Scalars['String'];
|
|
2709
|
-
total: Scalars['Money'];
|
|
2710
|
-
transactionId?: Maybe<Scalars['String']>;
|
|
2711
|
-
updatedAt: Scalars['DateTime'];
|
|
2738
|
+
metadata?: Maybe<Scalars['JSON']['output']>;
|
|
2739
|
+
method?: Maybe<Scalars['String']['output']>;
|
|
2740
|
+
paymentId: Scalars['ID']['output'];
|
|
2741
|
+
reason?: Maybe<Scalars['String']['output']>;
|
|
2742
|
+
shipping: Scalars['Money']['output'];
|
|
2743
|
+
state: Scalars['String']['output'];
|
|
2744
|
+
total: Scalars['Money']['output'];
|
|
2745
|
+
transactionId?: Maybe<Scalars['String']['output']>;
|
|
2746
|
+
updatedAt: Scalars['DateTime']['output'];
|
|
2712
2747
|
};
|
|
2713
2748
|
export type RefundLine = {
|
|
2714
2749
|
__typename?: 'RefundLine';
|
|
2715
2750
|
orderLine: OrderLine;
|
|
2716
|
-
orderLineId: Scalars['ID'];
|
|
2717
|
-
quantity: Scalars['Int'];
|
|
2751
|
+
orderLineId: Scalars['ID']['output'];
|
|
2752
|
+
quantity: Scalars['Int']['output'];
|
|
2718
2753
|
refund: Refund;
|
|
2719
|
-
refundId: Scalars['ID'];
|
|
2754
|
+
refundId: Scalars['ID']['output'];
|
|
2720
2755
|
};
|
|
2721
2756
|
export type Region = {
|
|
2722
|
-
code: Scalars['String'];
|
|
2723
|
-
createdAt: Scalars['DateTime'];
|
|
2724
|
-
enabled: Scalars['Boolean'];
|
|
2725
|
-
id: Scalars['ID'];
|
|
2757
|
+
code: Scalars['String']['output'];
|
|
2758
|
+
createdAt: Scalars['DateTime']['output'];
|
|
2759
|
+
enabled: Scalars['Boolean']['output'];
|
|
2760
|
+
id: Scalars['ID']['output'];
|
|
2726
2761
|
languageCode: LanguageCode;
|
|
2727
|
-
name: Scalars['String'];
|
|
2762
|
+
name: Scalars['String']['output'];
|
|
2728
2763
|
parent?: Maybe<Region>;
|
|
2729
|
-
parentId?: Maybe<Scalars['ID']>;
|
|
2764
|
+
parentId?: Maybe<Scalars['ID']['output']>;
|
|
2730
2765
|
translations: Array<RegionTranslation>;
|
|
2731
|
-
type: Scalars['String'];
|
|
2732
|
-
updatedAt: Scalars['DateTime'];
|
|
2766
|
+
type: Scalars['String']['output'];
|
|
2767
|
+
updatedAt: Scalars['DateTime']['output'];
|
|
2733
2768
|
};
|
|
2734
2769
|
export type RegionTranslation = {
|
|
2735
2770
|
__typename?: 'RegionTranslation';
|
|
2736
|
-
createdAt: Scalars['DateTime'];
|
|
2737
|
-
id: Scalars['ID'];
|
|
2771
|
+
createdAt: Scalars['DateTime']['output'];
|
|
2772
|
+
id: Scalars['ID']['output'];
|
|
2738
2773
|
languageCode: LanguageCode;
|
|
2739
|
-
name: Scalars['String'];
|
|
2740
|
-
updatedAt: Scalars['DateTime'];
|
|
2774
|
+
name: Scalars['String']['output'];
|
|
2775
|
+
updatedAt: Scalars['DateTime']['output'];
|
|
2741
2776
|
};
|
|
2742
2777
|
export type RegisterCustomerAccountResult = MissingPasswordError | NativeAuthStrategyError | PasswordValidationError | Success;
|
|
2743
2778
|
export type RegisterCustomerInput = {
|
|
2744
|
-
emailAddress: Scalars['String'];
|
|
2745
|
-
firstName?: InputMaybe<Scalars['String']>;
|
|
2746
|
-
lastName?: InputMaybe<Scalars['String']>;
|
|
2747
|
-
password?: InputMaybe<Scalars['String']>;
|
|
2748
|
-
phoneNumber?: InputMaybe<Scalars['String']>;
|
|
2749
|
-
title?: InputMaybe<Scalars['String']>;
|
|
2779
|
+
emailAddress: Scalars['String']['input'];
|
|
2780
|
+
firstName?: InputMaybe<Scalars['String']['input']>;
|
|
2781
|
+
lastName?: InputMaybe<Scalars['String']['input']>;
|
|
2782
|
+
password?: InputMaybe<Scalars['String']['input']>;
|
|
2783
|
+
phoneNumber?: InputMaybe<Scalars['String']['input']>;
|
|
2784
|
+
title?: InputMaybe<Scalars['String']['input']>;
|
|
2750
2785
|
};
|
|
2751
2786
|
export type RelationCustomFieldConfig = CustomField & {
|
|
2752
2787
|
__typename?: 'RelationCustomFieldConfig';
|
|
2753
2788
|
description?: Maybe<Array<LocalizedString>>;
|
|
2754
|
-
entity: Scalars['String'];
|
|
2755
|
-
internal?: Maybe<Scalars['Boolean']>;
|
|
2789
|
+
entity: Scalars['String']['output'];
|
|
2790
|
+
internal?: Maybe<Scalars['Boolean']['output']>;
|
|
2756
2791
|
label?: Maybe<Array<LocalizedString>>;
|
|
2757
|
-
list: Scalars['Boolean'];
|
|
2758
|
-
name: Scalars['String'];
|
|
2759
|
-
nullable?: Maybe<Scalars['Boolean']>;
|
|
2760
|
-
readonly?: Maybe<Scalars['Boolean']>;
|
|
2761
|
-
scalarFields: Array<Scalars['String']>;
|
|
2762
|
-
type: Scalars['String'];
|
|
2763
|
-
ui?: Maybe<Scalars['JSON']>;
|
|
2792
|
+
list: Scalars['Boolean']['output'];
|
|
2793
|
+
name: Scalars['String']['output'];
|
|
2794
|
+
nullable?: Maybe<Scalars['Boolean']['output']>;
|
|
2795
|
+
readonly?: Maybe<Scalars['Boolean']['output']>;
|
|
2796
|
+
scalarFields: Array<Scalars['String']['output']>;
|
|
2797
|
+
type: Scalars['String']['output'];
|
|
2798
|
+
ui?: Maybe<Scalars['JSON']['output']>;
|
|
2764
2799
|
};
|
|
2765
2800
|
export type RemoveOrderItemsResult = Order | OrderModificationError;
|
|
2766
2801
|
export type RequestPasswordResetResult = NativeAuthStrategyError | Success;
|
|
@@ -2769,69 +2804,69 @@ export type ResetPasswordResult = CurrentUser | NativeAuthStrategyError | NotVer
|
|
|
2769
2804
|
export type Role = Node & {
|
|
2770
2805
|
__typename?: 'Role';
|
|
2771
2806
|
channels: Array<Channel>;
|
|
2772
|
-
code: Scalars['String'];
|
|
2773
|
-
createdAt: Scalars['DateTime'];
|
|
2774
|
-
description: Scalars['String'];
|
|
2775
|
-
id: Scalars['ID'];
|
|
2807
|
+
code: Scalars['String']['output'];
|
|
2808
|
+
createdAt: Scalars['DateTime']['output'];
|
|
2809
|
+
description: Scalars['String']['output'];
|
|
2810
|
+
id: Scalars['ID']['output'];
|
|
2776
2811
|
permissions: Array<Permission>;
|
|
2777
|
-
updatedAt: Scalars['DateTime'];
|
|
2812
|
+
updatedAt: Scalars['DateTime']['output'];
|
|
2778
2813
|
};
|
|
2779
2814
|
export type RoleList = PaginatedList & {
|
|
2780
2815
|
__typename?: 'RoleList';
|
|
2781
2816
|
items: Array<Role>;
|
|
2782
|
-
totalItems: Scalars['Int'];
|
|
2817
|
+
totalItems: Scalars['Int']['output'];
|
|
2783
2818
|
};
|
|
2784
2819
|
export type SearchInput = {
|
|
2785
|
-
collectionId?: InputMaybe<Scalars['ID']>;
|
|
2786
|
-
collectionSlug?: InputMaybe<Scalars['String']>;
|
|
2820
|
+
collectionId?: InputMaybe<Scalars['ID']['input']>;
|
|
2821
|
+
collectionSlug?: InputMaybe<Scalars['String']['input']>;
|
|
2787
2822
|
facetValueFilters?: InputMaybe<Array<FacetValueFilterInput>>;
|
|
2788
2823
|
/** @deprecated Use `facetValueFilters` instead */
|
|
2789
|
-
facetValueIds?: InputMaybe<Array<Scalars['ID']>>;
|
|
2824
|
+
facetValueIds?: InputMaybe<Array<Scalars['ID']['input']>>;
|
|
2790
2825
|
/** @deprecated Use `facetValueFilters` instead */
|
|
2791
2826
|
facetValueOperator?: InputMaybe<LogicalOperator>;
|
|
2792
|
-
groupByProduct?: InputMaybe<Scalars['Boolean']>;
|
|
2793
|
-
skip?: InputMaybe<Scalars['Int']>;
|
|
2827
|
+
groupByProduct?: InputMaybe<Scalars['Boolean']['input']>;
|
|
2828
|
+
skip?: InputMaybe<Scalars['Int']['input']>;
|
|
2794
2829
|
sort?: InputMaybe<SearchResultSortParameter>;
|
|
2795
|
-
take?: InputMaybe<Scalars['Int']>;
|
|
2796
|
-
term?: InputMaybe<Scalars['String']>;
|
|
2830
|
+
take?: InputMaybe<Scalars['Int']['input']>;
|
|
2831
|
+
term?: InputMaybe<Scalars['String']['input']>;
|
|
2797
2832
|
};
|
|
2798
2833
|
export type SearchReindexResponse = {
|
|
2799
2834
|
__typename?: 'SearchReindexResponse';
|
|
2800
|
-
success: Scalars['Boolean'];
|
|
2835
|
+
success: Scalars['Boolean']['output'];
|
|
2801
2836
|
};
|
|
2802
2837
|
export type SearchResponse = {
|
|
2803
2838
|
__typename?: 'SearchResponse';
|
|
2804
2839
|
collections: Array<CollectionResult>;
|
|
2805
2840
|
facetValues: Array<FacetValueResult>;
|
|
2806
2841
|
items: Array<SearchResult>;
|
|
2807
|
-
totalItems: Scalars['Int'];
|
|
2842
|
+
totalItems: Scalars['Int']['output'];
|
|
2808
2843
|
};
|
|
2809
2844
|
export type SearchResult = {
|
|
2810
2845
|
__typename?: 'SearchResult';
|
|
2811
2846
|
/** An array of ids of the Collections in which this result appears */
|
|
2812
|
-
collectionIds: Array<Scalars['ID']>;
|
|
2847
|
+
collectionIds: Array<Scalars['ID']['output']>;
|
|
2813
2848
|
currencyCode: CurrencyCode;
|
|
2814
|
-
description: Scalars['String'];
|
|
2815
|
-
facetIds: Array<Scalars['ID']>;
|
|
2816
|
-
facetValueIds: Array<Scalars['ID']>;
|
|
2849
|
+
description: Scalars['String']['output'];
|
|
2850
|
+
facetIds: Array<Scalars['ID']['output']>;
|
|
2851
|
+
facetValueIds: Array<Scalars['ID']['output']>;
|
|
2817
2852
|
price: SearchResultPrice;
|
|
2818
2853
|
priceWithTax: SearchResultPrice;
|
|
2819
2854
|
productAsset?: Maybe<SearchResultAsset>;
|
|
2820
|
-
productId: Scalars['ID'];
|
|
2821
|
-
productName: Scalars['String'];
|
|
2855
|
+
productId: Scalars['ID']['output'];
|
|
2856
|
+
productName: Scalars['String']['output'];
|
|
2822
2857
|
productVariantAsset?: Maybe<SearchResultAsset>;
|
|
2823
|
-
productVariantId: Scalars['ID'];
|
|
2824
|
-
productVariantName: Scalars['String'];
|
|
2858
|
+
productVariantId: Scalars['ID']['output'];
|
|
2859
|
+
productVariantName: Scalars['String']['output'];
|
|
2825
2860
|
/** A relevance score for the result. Differs between database implementations */
|
|
2826
|
-
score: Scalars['Float'];
|
|
2827
|
-
sku: Scalars['String'];
|
|
2828
|
-
slug: Scalars['String'];
|
|
2861
|
+
score: Scalars['Float']['output'];
|
|
2862
|
+
sku: Scalars['String']['output'];
|
|
2863
|
+
slug: Scalars['String']['output'];
|
|
2829
2864
|
};
|
|
2830
2865
|
export type SearchResultAsset = {
|
|
2831
2866
|
__typename?: 'SearchResultAsset';
|
|
2832
2867
|
focalPoint?: Maybe<Coordinate>;
|
|
2833
|
-
id: Scalars['ID'];
|
|
2834
|
-
preview: Scalars['String'];
|
|
2868
|
+
id: Scalars['ID']['output'];
|
|
2869
|
+
preview: Scalars['String']['output'];
|
|
2835
2870
|
};
|
|
2836
2871
|
/** The price of a search result product, either as a range or as a single price */
|
|
2837
2872
|
export type SearchResultPrice = PriceRange | SinglePrice;
|
|
@@ -2841,69 +2876,69 @@ export type SearchResultSortParameter = {
|
|
|
2841
2876
|
};
|
|
2842
2877
|
export type Seller = Node & {
|
|
2843
2878
|
__typename?: 'Seller';
|
|
2844
|
-
createdAt: Scalars['DateTime'];
|
|
2845
|
-
customFields?: Maybe<Scalars['JSON']>;
|
|
2846
|
-
id: Scalars['ID'];
|
|
2847
|
-
name: Scalars['String'];
|
|
2848
|
-
updatedAt: Scalars['DateTime'];
|
|
2879
|
+
createdAt: Scalars['DateTime']['output'];
|
|
2880
|
+
customFields?: Maybe<Scalars['JSON']['output']>;
|
|
2881
|
+
id: Scalars['ID']['output'];
|
|
2882
|
+
name: Scalars['String']['output'];
|
|
2883
|
+
updatedAt: Scalars['DateTime']['output'];
|
|
2849
2884
|
};
|
|
2850
2885
|
export type SetCustomerForOrderResult = AlreadyLoggedInError | EmailAddressConflictError | GuestCheckoutError | NoActiveOrderError | Order;
|
|
2851
2886
|
export type SetOrderShippingMethodResult = IneligibleShippingMethodError | NoActiveOrderError | Order | OrderModificationError;
|
|
2852
2887
|
export type ShippingLine = {
|
|
2853
2888
|
__typename?: 'ShippingLine';
|
|
2854
|
-
discountedPrice: Scalars['Money'];
|
|
2855
|
-
discountedPriceWithTax: Scalars['Money'];
|
|
2889
|
+
discountedPrice: Scalars['Money']['output'];
|
|
2890
|
+
discountedPriceWithTax: Scalars['Money']['output'];
|
|
2856
2891
|
discounts: Array<Discount>;
|
|
2857
|
-
id: Scalars['ID'];
|
|
2858
|
-
price: Scalars['Money'];
|
|
2859
|
-
priceWithTax: Scalars['Money'];
|
|
2892
|
+
id: Scalars['ID']['output'];
|
|
2893
|
+
price: Scalars['Money']['output'];
|
|
2894
|
+
priceWithTax: Scalars['Money']['output'];
|
|
2860
2895
|
shippingMethod: ShippingMethod;
|
|
2861
2896
|
};
|
|
2862
2897
|
export type ShippingMethod = Node & {
|
|
2863
2898
|
__typename?: 'ShippingMethod';
|
|
2864
2899
|
calculator: ConfigurableOperation;
|
|
2865
2900
|
checker: ConfigurableOperation;
|
|
2866
|
-
code: Scalars['String'];
|
|
2867
|
-
createdAt: Scalars['DateTime'];
|
|
2868
|
-
customFields?: Maybe<Scalars['JSON']>;
|
|
2869
|
-
description: Scalars['String'];
|
|
2870
|
-
fulfillmentHandlerCode: Scalars['String'];
|
|
2871
|
-
id: Scalars['ID'];
|
|
2901
|
+
code: Scalars['String']['output'];
|
|
2902
|
+
createdAt: Scalars['DateTime']['output'];
|
|
2903
|
+
customFields?: Maybe<Scalars['JSON']['output']>;
|
|
2904
|
+
description: Scalars['String']['output'];
|
|
2905
|
+
fulfillmentHandlerCode: Scalars['String']['output'];
|
|
2906
|
+
id: Scalars['ID']['output'];
|
|
2872
2907
|
languageCode: LanguageCode;
|
|
2873
|
-
name: Scalars['String'];
|
|
2908
|
+
name: Scalars['String']['output'];
|
|
2874
2909
|
translations: Array<ShippingMethodTranslation>;
|
|
2875
|
-
updatedAt: Scalars['DateTime'];
|
|
2910
|
+
updatedAt: Scalars['DateTime']['output'];
|
|
2876
2911
|
};
|
|
2877
2912
|
export type ShippingMethodList = PaginatedList & {
|
|
2878
2913
|
__typename?: 'ShippingMethodList';
|
|
2879
2914
|
items: Array<ShippingMethod>;
|
|
2880
|
-
totalItems: Scalars['Int'];
|
|
2915
|
+
totalItems: Scalars['Int']['output'];
|
|
2881
2916
|
};
|
|
2882
2917
|
export type ShippingMethodQuote = {
|
|
2883
2918
|
__typename?: 'ShippingMethodQuote';
|
|
2884
|
-
code: Scalars['String'];
|
|
2885
|
-
customFields?: Maybe<Scalars['JSON']>;
|
|
2886
|
-
description: Scalars['String'];
|
|
2887
|
-
id: Scalars['ID'];
|
|
2919
|
+
code: Scalars['String']['output'];
|
|
2920
|
+
customFields?: Maybe<Scalars['JSON']['output']>;
|
|
2921
|
+
description: Scalars['String']['output'];
|
|
2922
|
+
id: Scalars['ID']['output'];
|
|
2888
2923
|
/** Any optional metadata returned by the ShippingCalculator in the ShippingCalculationResult */
|
|
2889
|
-
metadata?: Maybe<Scalars['JSON']>;
|
|
2890
|
-
name: Scalars['String'];
|
|
2891
|
-
price: Scalars['Money'];
|
|
2892
|
-
priceWithTax: Scalars['Money'];
|
|
2924
|
+
metadata?: Maybe<Scalars['JSON']['output']>;
|
|
2925
|
+
name: Scalars['String']['output'];
|
|
2926
|
+
price: Scalars['Money']['output'];
|
|
2927
|
+
priceWithTax: Scalars['Money']['output'];
|
|
2893
2928
|
};
|
|
2894
2929
|
export type ShippingMethodTranslation = {
|
|
2895
2930
|
__typename?: 'ShippingMethodTranslation';
|
|
2896
|
-
createdAt: Scalars['DateTime'];
|
|
2897
|
-
description: Scalars['String'];
|
|
2898
|
-
id: Scalars['ID'];
|
|
2931
|
+
createdAt: Scalars['DateTime']['output'];
|
|
2932
|
+
description: Scalars['String']['output'];
|
|
2933
|
+
id: Scalars['ID']['output'];
|
|
2899
2934
|
languageCode: LanguageCode;
|
|
2900
|
-
name: Scalars['String'];
|
|
2901
|
-
updatedAt: Scalars['DateTime'];
|
|
2935
|
+
name: Scalars['String']['output'];
|
|
2936
|
+
updatedAt: Scalars['DateTime']['output'];
|
|
2902
2937
|
};
|
|
2903
2938
|
/** The price value where the result has a single price */
|
|
2904
2939
|
export type SinglePrice = {
|
|
2905
2940
|
__typename?: 'SinglePrice';
|
|
2906
|
-
value: Scalars['Money'];
|
|
2941
|
+
value: Scalars['Money']['output'];
|
|
2907
2942
|
};
|
|
2908
2943
|
export declare enum SortOrder {
|
|
2909
2944
|
ASC = "ASC",
|
|
@@ -2912,151 +2947,151 @@ export declare enum SortOrder {
|
|
|
2912
2947
|
export type StringCustomFieldConfig = CustomField & {
|
|
2913
2948
|
__typename?: 'StringCustomFieldConfig';
|
|
2914
2949
|
description?: Maybe<Array<LocalizedString>>;
|
|
2915
|
-
internal?: Maybe<Scalars['Boolean']>;
|
|
2950
|
+
internal?: Maybe<Scalars['Boolean']['output']>;
|
|
2916
2951
|
label?: Maybe<Array<LocalizedString>>;
|
|
2917
|
-
length?: Maybe<Scalars['Int']>;
|
|
2918
|
-
list: Scalars['Boolean'];
|
|
2919
|
-
name: Scalars['String'];
|
|
2920
|
-
nullable?: Maybe<Scalars['Boolean']>;
|
|
2952
|
+
length?: Maybe<Scalars['Int']['output']>;
|
|
2953
|
+
list: Scalars['Boolean']['output'];
|
|
2954
|
+
name: Scalars['String']['output'];
|
|
2955
|
+
nullable?: Maybe<Scalars['Boolean']['output']>;
|
|
2921
2956
|
options?: Maybe<Array<StringFieldOption>>;
|
|
2922
|
-
pattern?: Maybe<Scalars['String']>;
|
|
2923
|
-
readonly?: Maybe<Scalars['Boolean']>;
|
|
2924
|
-
type: Scalars['String'];
|
|
2925
|
-
ui?: Maybe<Scalars['JSON']>;
|
|
2957
|
+
pattern?: Maybe<Scalars['String']['output']>;
|
|
2958
|
+
readonly?: Maybe<Scalars['Boolean']['output']>;
|
|
2959
|
+
type: Scalars['String']['output'];
|
|
2960
|
+
ui?: Maybe<Scalars['JSON']['output']>;
|
|
2926
2961
|
};
|
|
2927
2962
|
export type StringFieldOption = {
|
|
2928
2963
|
__typename?: 'StringFieldOption';
|
|
2929
2964
|
label?: Maybe<Array<LocalizedString>>;
|
|
2930
|
-
value: Scalars['String'];
|
|
2965
|
+
value: Scalars['String']['output'];
|
|
2931
2966
|
};
|
|
2932
2967
|
/** Operators for filtering on a list of String fields */
|
|
2933
2968
|
export type StringListOperators = {
|
|
2934
|
-
inList: Scalars['String'];
|
|
2969
|
+
inList: Scalars['String']['input'];
|
|
2935
2970
|
};
|
|
2936
2971
|
/** Operators for filtering on a String field */
|
|
2937
2972
|
export type StringOperators = {
|
|
2938
|
-
contains?: InputMaybe<Scalars['String']>;
|
|
2939
|
-
eq?: InputMaybe<Scalars['String']>;
|
|
2940
|
-
in?: InputMaybe<Array<Scalars['String']>>;
|
|
2941
|
-
isNull?: InputMaybe<Scalars['Boolean']>;
|
|
2942
|
-
notContains?: InputMaybe<Scalars['String']>;
|
|
2943
|
-
notEq?: InputMaybe<Scalars['String']>;
|
|
2944
|
-
notIn?: InputMaybe<Array<Scalars['String']>>;
|
|
2945
|
-
regex?: InputMaybe<Scalars['String']>;
|
|
2973
|
+
contains?: InputMaybe<Scalars['String']['input']>;
|
|
2974
|
+
eq?: InputMaybe<Scalars['String']['input']>;
|
|
2975
|
+
in?: InputMaybe<Array<Scalars['String']['input']>>;
|
|
2976
|
+
isNull?: InputMaybe<Scalars['Boolean']['input']>;
|
|
2977
|
+
notContains?: InputMaybe<Scalars['String']['input']>;
|
|
2978
|
+
notEq?: InputMaybe<Scalars['String']['input']>;
|
|
2979
|
+
notIn?: InputMaybe<Array<Scalars['String']['input']>>;
|
|
2980
|
+
regex?: InputMaybe<Scalars['String']['input']>;
|
|
2946
2981
|
};
|
|
2947
2982
|
/** Indicates that an operation succeeded, where we do not want to return any more specific information. */
|
|
2948
2983
|
export type Success = {
|
|
2949
2984
|
__typename?: 'Success';
|
|
2950
|
-
success: Scalars['Boolean'];
|
|
2985
|
+
success: Scalars['Boolean']['output'];
|
|
2951
2986
|
};
|
|
2952
2987
|
export type Surcharge = Node & {
|
|
2953
2988
|
__typename?: 'Surcharge';
|
|
2954
|
-
createdAt: Scalars['DateTime'];
|
|
2955
|
-
description: Scalars['String'];
|
|
2956
|
-
id: Scalars['ID'];
|
|
2957
|
-
price: Scalars['Money'];
|
|
2958
|
-
priceWithTax: Scalars['Money'];
|
|
2959
|
-
sku?: Maybe<Scalars['String']>;
|
|
2989
|
+
createdAt: Scalars['DateTime']['output'];
|
|
2990
|
+
description: Scalars['String']['output'];
|
|
2991
|
+
id: Scalars['ID']['output'];
|
|
2992
|
+
price: Scalars['Money']['output'];
|
|
2993
|
+
priceWithTax: Scalars['Money']['output'];
|
|
2994
|
+
sku?: Maybe<Scalars['String']['output']>;
|
|
2960
2995
|
taxLines: Array<TaxLine>;
|
|
2961
|
-
taxRate: Scalars['Float'];
|
|
2962
|
-
updatedAt: Scalars['DateTime'];
|
|
2996
|
+
taxRate: Scalars['Float']['output'];
|
|
2997
|
+
updatedAt: Scalars['DateTime']['output'];
|
|
2963
2998
|
};
|
|
2964
2999
|
export type Tag = Node & {
|
|
2965
3000
|
__typename?: 'Tag';
|
|
2966
|
-
createdAt: Scalars['DateTime'];
|
|
2967
|
-
id: Scalars['ID'];
|
|
2968
|
-
updatedAt: Scalars['DateTime'];
|
|
2969
|
-
value: Scalars['String'];
|
|
3001
|
+
createdAt: Scalars['DateTime']['output'];
|
|
3002
|
+
id: Scalars['ID']['output'];
|
|
3003
|
+
updatedAt: Scalars['DateTime']['output'];
|
|
3004
|
+
value: Scalars['String']['output'];
|
|
2970
3005
|
};
|
|
2971
3006
|
export type TagList = PaginatedList & {
|
|
2972
3007
|
__typename?: 'TagList';
|
|
2973
3008
|
items: Array<Tag>;
|
|
2974
|
-
totalItems: Scalars['Int'];
|
|
3009
|
+
totalItems: Scalars['Int']['output'];
|
|
2975
3010
|
};
|
|
2976
3011
|
export type TaxCategory = Node & {
|
|
2977
3012
|
__typename?: 'TaxCategory';
|
|
2978
|
-
createdAt: Scalars['DateTime'];
|
|
2979
|
-
customFields?: Maybe<Scalars['JSON']>;
|
|
2980
|
-
id: Scalars['ID'];
|
|
2981
|
-
isDefault: Scalars['Boolean'];
|
|
2982
|
-
name: Scalars['String'];
|
|
2983
|
-
updatedAt: Scalars['DateTime'];
|
|
3013
|
+
createdAt: Scalars['DateTime']['output'];
|
|
3014
|
+
customFields?: Maybe<Scalars['JSON']['output']>;
|
|
3015
|
+
id: Scalars['ID']['output'];
|
|
3016
|
+
isDefault: Scalars['Boolean']['output'];
|
|
3017
|
+
name: Scalars['String']['output'];
|
|
3018
|
+
updatedAt: Scalars['DateTime']['output'];
|
|
2984
3019
|
};
|
|
2985
3020
|
export type TaxLine = {
|
|
2986
3021
|
__typename?: 'TaxLine';
|
|
2987
|
-
description: Scalars['String'];
|
|
2988
|
-
taxRate: Scalars['Float'];
|
|
3022
|
+
description: Scalars['String']['output'];
|
|
3023
|
+
taxRate: Scalars['Float']['output'];
|
|
2989
3024
|
};
|
|
2990
3025
|
export type TaxRate = Node & {
|
|
2991
3026
|
__typename?: 'TaxRate';
|
|
2992
3027
|
category: TaxCategory;
|
|
2993
|
-
createdAt: Scalars['DateTime'];
|
|
2994
|
-
customFields?: Maybe<Scalars['JSON']>;
|
|
3028
|
+
createdAt: Scalars['DateTime']['output'];
|
|
3029
|
+
customFields?: Maybe<Scalars['JSON']['output']>;
|
|
2995
3030
|
customerGroup?: Maybe<CustomerGroup>;
|
|
2996
|
-
enabled: Scalars['Boolean'];
|
|
2997
|
-
id: Scalars['ID'];
|
|
2998
|
-
name: Scalars['String'];
|
|
2999
|
-
updatedAt: Scalars['DateTime'];
|
|
3000
|
-
value: Scalars['Float'];
|
|
3031
|
+
enabled: Scalars['Boolean']['output'];
|
|
3032
|
+
id: Scalars['ID']['output'];
|
|
3033
|
+
name: Scalars['String']['output'];
|
|
3034
|
+
updatedAt: Scalars['DateTime']['output'];
|
|
3035
|
+
value: Scalars['Float']['output'];
|
|
3001
3036
|
zone: Zone;
|
|
3002
3037
|
};
|
|
3003
3038
|
export type TaxRateList = PaginatedList & {
|
|
3004
3039
|
__typename?: 'TaxRateList';
|
|
3005
3040
|
items: Array<TaxRate>;
|
|
3006
|
-
totalItems: Scalars['Int'];
|
|
3041
|
+
totalItems: Scalars['Int']['output'];
|
|
3007
3042
|
};
|
|
3008
3043
|
export type TextCustomFieldConfig = CustomField & {
|
|
3009
3044
|
__typename?: 'TextCustomFieldConfig';
|
|
3010
3045
|
description?: Maybe<Array<LocalizedString>>;
|
|
3011
|
-
internal?: Maybe<Scalars['Boolean']>;
|
|
3046
|
+
internal?: Maybe<Scalars['Boolean']['output']>;
|
|
3012
3047
|
label?: Maybe<Array<LocalizedString>>;
|
|
3013
|
-
list: Scalars['Boolean'];
|
|
3014
|
-
name: Scalars['String'];
|
|
3015
|
-
nullable?: Maybe<Scalars['Boolean']>;
|
|
3016
|
-
readonly?: Maybe<Scalars['Boolean']>;
|
|
3017
|
-
type: Scalars['String'];
|
|
3018
|
-
ui?: Maybe<Scalars['JSON']>;
|
|
3048
|
+
list: Scalars['Boolean']['output'];
|
|
3049
|
+
name: Scalars['String']['output'];
|
|
3050
|
+
nullable?: Maybe<Scalars['Boolean']['output']>;
|
|
3051
|
+
readonly?: Maybe<Scalars['Boolean']['output']>;
|
|
3052
|
+
type: Scalars['String']['output'];
|
|
3053
|
+
ui?: Maybe<Scalars['JSON']['output']>;
|
|
3019
3054
|
};
|
|
3020
3055
|
export type TransitionOrderToStateResult = Order | OrderStateTransitionError;
|
|
3021
3056
|
export type UpdateAddressInput = {
|
|
3022
|
-
city?: InputMaybe<Scalars['String']>;
|
|
3023
|
-
company?: InputMaybe<Scalars['String']>;
|
|
3024
|
-
countryCode?: InputMaybe<Scalars['String']>;
|
|
3025
|
-
customFields?: InputMaybe<Scalars['JSON']>;
|
|
3026
|
-
defaultBillingAddress?: InputMaybe<Scalars['Boolean']>;
|
|
3027
|
-
defaultShippingAddress?: InputMaybe<Scalars['Boolean']>;
|
|
3028
|
-
fullName?: InputMaybe<Scalars['String']>;
|
|
3029
|
-
id: Scalars['ID'];
|
|
3030
|
-
phoneNumber?: InputMaybe<Scalars['String']>;
|
|
3031
|
-
postalCode?: InputMaybe<Scalars['String']>;
|
|
3032
|
-
province?: InputMaybe<Scalars['String']>;
|
|
3033
|
-
streetLine1?: InputMaybe<Scalars['String']>;
|
|
3034
|
-
streetLine2?: InputMaybe<Scalars['String']>;
|
|
3057
|
+
city?: InputMaybe<Scalars['String']['input']>;
|
|
3058
|
+
company?: InputMaybe<Scalars['String']['input']>;
|
|
3059
|
+
countryCode?: InputMaybe<Scalars['String']['input']>;
|
|
3060
|
+
customFields?: InputMaybe<Scalars['JSON']['input']>;
|
|
3061
|
+
defaultBillingAddress?: InputMaybe<Scalars['Boolean']['input']>;
|
|
3062
|
+
defaultShippingAddress?: InputMaybe<Scalars['Boolean']['input']>;
|
|
3063
|
+
fullName?: InputMaybe<Scalars['String']['input']>;
|
|
3064
|
+
id: Scalars['ID']['input'];
|
|
3065
|
+
phoneNumber?: InputMaybe<Scalars['String']['input']>;
|
|
3066
|
+
postalCode?: InputMaybe<Scalars['String']['input']>;
|
|
3067
|
+
province?: InputMaybe<Scalars['String']['input']>;
|
|
3068
|
+
streetLine1?: InputMaybe<Scalars['String']['input']>;
|
|
3069
|
+
streetLine2?: InputMaybe<Scalars['String']['input']>;
|
|
3035
3070
|
};
|
|
3036
3071
|
export type UpdateCustomerEmailAddressResult = IdentifierChangeTokenExpiredError | IdentifierChangeTokenInvalidError | NativeAuthStrategyError | Success;
|
|
3037
3072
|
export type UpdateCustomerInput = {
|
|
3038
|
-
customFields?: InputMaybe<Scalars['JSON']>;
|
|
3039
|
-
firstName?: InputMaybe<Scalars['String']>;
|
|
3040
|
-
lastName?: InputMaybe<Scalars['String']>;
|
|
3041
|
-
phoneNumber?: InputMaybe<Scalars['String']>;
|
|
3042
|
-
title?: InputMaybe<Scalars['String']>;
|
|
3073
|
+
customFields?: InputMaybe<Scalars['JSON']['input']>;
|
|
3074
|
+
firstName?: InputMaybe<Scalars['String']['input']>;
|
|
3075
|
+
lastName?: InputMaybe<Scalars['String']['input']>;
|
|
3076
|
+
phoneNumber?: InputMaybe<Scalars['String']['input']>;
|
|
3077
|
+
title?: InputMaybe<Scalars['String']['input']>;
|
|
3043
3078
|
};
|
|
3044
3079
|
export type UpdateCustomerPasswordResult = InvalidCredentialsError | NativeAuthStrategyError | PasswordValidationError | Success;
|
|
3045
3080
|
export type UpdateOrderInput = {
|
|
3046
|
-
customFields?: InputMaybe<Scalars['JSON']>;
|
|
3081
|
+
customFields?: InputMaybe<Scalars['JSON']['input']>;
|
|
3047
3082
|
};
|
|
3048
3083
|
export type UpdateOrderItemsResult = InsufficientStockError | NegativeQuantityError | Order | OrderLimitError | OrderModificationError;
|
|
3049
3084
|
export type User = Node & {
|
|
3050
3085
|
__typename?: 'User';
|
|
3051
3086
|
authenticationMethods: Array<AuthenticationMethod>;
|
|
3052
|
-
createdAt: Scalars['DateTime'];
|
|
3053
|
-
customFields?: Maybe<Scalars['JSON']>;
|
|
3054
|
-
id: Scalars['ID'];
|
|
3055
|
-
identifier: Scalars['String'];
|
|
3056
|
-
lastLogin?: Maybe<Scalars['DateTime']>;
|
|
3087
|
+
createdAt: Scalars['DateTime']['output'];
|
|
3088
|
+
customFields?: Maybe<Scalars['JSON']['output']>;
|
|
3089
|
+
id: Scalars['ID']['output'];
|
|
3090
|
+
identifier: Scalars['String']['output'];
|
|
3091
|
+
lastLogin?: Maybe<Scalars['DateTime']['output']>;
|
|
3057
3092
|
roles: Array<Role>;
|
|
3058
|
-
updatedAt: Scalars['DateTime'];
|
|
3059
|
-
verified: Scalars['Boolean'];
|
|
3093
|
+
updatedAt: Scalars['DateTime']['output'];
|
|
3094
|
+
verified: Scalars['Boolean']['output'];
|
|
3060
3095
|
};
|
|
3061
3096
|
/**
|
|
3062
3097
|
* Returned if the verification token (used to verify a Customer's email address) is valid, but has
|
|
@@ -3065,7 +3100,7 @@ export type User = Node & {
|
|
|
3065
3100
|
export type VerificationTokenExpiredError = ErrorResult & {
|
|
3066
3101
|
__typename?: 'VerificationTokenExpiredError';
|
|
3067
3102
|
errorCode: ErrorCode;
|
|
3068
|
-
message: Scalars['String'];
|
|
3103
|
+
message: Scalars['String']['output'];
|
|
3069
3104
|
};
|
|
3070
3105
|
/**
|
|
3071
3106
|
* Returned if the verification token (used to verify a Customer's email address) is either
|
|
@@ -3074,15 +3109,15 @@ export type VerificationTokenExpiredError = ErrorResult & {
|
|
|
3074
3109
|
export type VerificationTokenInvalidError = ErrorResult & {
|
|
3075
3110
|
__typename?: 'VerificationTokenInvalidError';
|
|
3076
3111
|
errorCode: ErrorCode;
|
|
3077
|
-
message: Scalars['String'];
|
|
3112
|
+
message: Scalars['String']['output'];
|
|
3078
3113
|
};
|
|
3079
3114
|
export type VerifyCustomerAccountResult = CurrentUser | MissingPasswordError | NativeAuthStrategyError | PasswordAlreadySetError | PasswordValidationError | VerificationTokenExpiredError | VerificationTokenInvalidError;
|
|
3080
3115
|
export type Zone = Node & {
|
|
3081
3116
|
__typename?: 'Zone';
|
|
3082
|
-
createdAt: Scalars['DateTime'];
|
|
3083
|
-
customFields?: Maybe<Scalars['JSON']>;
|
|
3084
|
-
id: Scalars['ID'];
|
|
3117
|
+
createdAt: Scalars['DateTime']['output'];
|
|
3118
|
+
customFields?: Maybe<Scalars['JSON']['output']>;
|
|
3119
|
+
id: Scalars['ID']['output'];
|
|
3085
3120
|
members: Array<Region>;
|
|
3086
|
-
name: Scalars['String'];
|
|
3087
|
-
updatedAt: Scalars['DateTime'];
|
|
3121
|
+
name: Scalars['String']['output'];
|
|
3122
|
+
updatedAt: Scalars['DateTime']['output'];
|
|
3088
3123
|
};
|