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