@vendure/payments-plugin 2.0.0-next.1 → 2.0.0-next.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (5) hide show
  1. package/package/mollie/graphql/generated-shop-types.d.ts +998 -997
  2. package/package/mollie/graphql/generated-shop-types.js +306 -306
  3. package/package/mollie/graphql/generated-shop-types.js.map +1 -1
  4. package/package/mollie/mollie-shop-schema.js +15 -15
  5. package/package.json +5 -5
package/package/mollie/graphql/generated-shop-types.d.ts CHANGED
@@ -1,4 +1,5 @@
1
1
  export declare type Maybe<T> = T | null;
2
+ export declare type InputMaybe<T> = Maybe<T>;
2
3
  export declare type Exact<T extends {
3
4
  [key: string]: unknown;
4
5
  }> = {
@@ -24,37 +25,37 @@ export declare type Scalars = {
24
25
  /** The `Upload` scalar type represents a file upload. */
25
26
  Upload: any;
26
27
  };
27
- export declare type ActiveOrderResult = Order | NoActiveOrderError;
28
- export declare type AddPaymentToOrderResult = Order | OrderPaymentStateError | IneligiblePaymentMethodError | PaymentFailedError | PaymentDeclinedError | OrderStateTransitionError | NoActiveOrderError;
28
+ export declare type ActiveOrderResult = NoActiveOrderError | Order;
29
+ export declare type AddPaymentToOrderResult = IneligiblePaymentMethodError | NoActiveOrderError | Order | OrderPaymentStateError | OrderStateTransitionError | PaymentDeclinedError | PaymentFailedError;
29
30
  export declare type Address = Node & {
30
31
  __typename?: 'Address';
31
- id: Scalars['ID'];
32
+ city?: Maybe<Scalars['String']>;
33
+ company?: Maybe<Scalars['String']>;
34
+ country: Country;
32
35
  createdAt: Scalars['DateTime'];
33
- updatedAt: Scalars['DateTime'];
36
+ customFields?: Maybe<Scalars['JSON']>;
37
+ defaultBillingAddress?: Maybe<Scalars['Boolean']>;
38
+ defaultShippingAddress?: Maybe<Scalars['Boolean']>;
34
39
  fullName?: Maybe<Scalars['String']>;
35
- company?: Maybe<Scalars['String']>;
40
+ id: Scalars['ID'];
41
+ phoneNumber?: Maybe<Scalars['String']>;
42
+ postalCode?: Maybe<Scalars['String']>;
43
+ province?: Maybe<Scalars['String']>;
36
44
  streetLine1: Scalars['String'];
37
45
  streetLine2?: Maybe<Scalars['String']>;
38
- city?: Maybe<Scalars['String']>;
39
- province?: Maybe<Scalars['String']>;
40
- postalCode?: Maybe<Scalars['String']>;
41
- country: Country;
42
- phoneNumber?: Maybe<Scalars['String']>;
43
- defaultShippingAddress?: Maybe<Scalars['Boolean']>;
44
- defaultBillingAddress?: Maybe<Scalars['Boolean']>;
45
- customFields?: Maybe<Scalars['JSON']>;
46
+ updatedAt: Scalars['DateTime'];
46
47
  };
47
48
  export declare type Adjustment = {
48
49
  __typename?: 'Adjustment';
49
50
  adjustmentSource: Scalars['String'];
50
- type: AdjustmentType;
51
- description: Scalars['String'];
52
51
  amount: Scalars['Int'];
52
+ description: Scalars['String'];
53
+ type: AdjustmentType;
53
54
  };
54
55
  export declare enum AdjustmentType {
55
- PROMOTION = "PROMOTION",
56
56
  DISTRIBUTED_ORDER_PROMOTION = "DISTRIBUTED_ORDER_PROMOTION",
57
- OTHER = "OTHER"
57
+ OTHER = "OTHER",
58
+ PROMOTION = "PROMOTION"
58
59
  }
59
60
  /** Returned when attempting to set the Customer for an Order when already logged in. */
60
61
  export declare type AlreadyLoggedInError = ErrorResult & {
@@ -62,22 +63,22 @@ export declare type AlreadyLoggedInError = ErrorResult & {
62
63
  errorCode: ErrorCode;
63
64
  message: Scalars['String'];
64
65
  };
65
- export declare type ApplyCouponCodeResult = Order | CouponCodeExpiredError | CouponCodeInvalidError | CouponCodeLimitError;
66
+ export declare type ApplyCouponCodeResult = CouponCodeExpiredError | CouponCodeInvalidError | CouponCodeLimitError | Order;
66
67
  export declare type Asset = Node & {
67
68
  __typename?: 'Asset';
68
- id: Scalars['ID'];
69
69
  createdAt: Scalars['DateTime'];
70
- updatedAt: Scalars['DateTime'];
71
- name: Scalars['String'];
72
- type: AssetType;
70
+ customFields?: Maybe<Scalars['JSON']>;
73
71
  fileSize: Scalars['Int'];
74
- mimeType: Scalars['String'];
75
- width: Scalars['Int'];
72
+ focalPoint?: Maybe<Coordinate>;
76
73
  height: Scalars['Int'];
77
- source: Scalars['String'];
74
+ id: Scalars['ID'];
75
+ mimeType: Scalars['String'];
76
+ name: Scalars['String'];
78
77
  preview: Scalars['String'];
79
- focalPoint?: Maybe<Coordinate>;
80
- customFields?: Maybe<Scalars['JSON']>;
78
+ source: Scalars['String'];
79
+ type: AssetType;
80
+ updatedAt: Scalars['DateTime'];
81
+ width: Scalars['Int'];
81
82
  };
82
83
  export declare type AssetList = PaginatedList & {
83
84
  __typename?: 'AssetList';
@@ -85,31 +86,31 @@ export declare type AssetList = PaginatedList & {
85
86
  totalItems: Scalars['Int'];
86
87
  };
87
88
  export declare enum AssetType {
89
+ BINARY = "BINARY",
88
90
  IMAGE = "IMAGE",
89
- VIDEO = "VIDEO",
90
- BINARY = "BINARY"
91
+ VIDEO = "VIDEO"
91
92
  }
92
93
  export declare type AuthenticationInput = {
93
- native?: Maybe<NativeAuthInput>;
94
+ native?: InputMaybe<NativeAuthInput>;
94
95
  };
95
96
  export declare type AuthenticationMethod = Node & {
96
97
  __typename?: 'AuthenticationMethod';
97
- id: Scalars['ID'];
98
98
  createdAt: Scalars['DateTime'];
99
- updatedAt: Scalars['DateTime'];
99
+ id: Scalars['ID'];
100
100
  strategy: Scalars['String'];
101
+ updatedAt: Scalars['DateTime'];
101
102
  };
102
103
  export declare type AuthenticationResult = CurrentUser | InvalidCredentialsError | NotVerifiedError;
103
104
  export declare type BooleanCustomFieldConfig = CustomField & {
104
105
  __typename?: 'BooleanCustomFieldConfig';
105
- name: Scalars['String'];
106
- type: Scalars['String'];
107
- list: Scalars['Boolean'];
108
- label?: Maybe<Array<LocalizedString>>;
109
106
  description?: Maybe<Array<LocalizedString>>;
110
- readonly?: Maybe<Scalars['Boolean']>;
111
107
  internal?: Maybe<Scalars['Boolean']>;
108
+ label?: Maybe<Array<LocalizedString>>;
109
+ list: Scalars['Boolean'];
110
+ name: Scalars['String'];
112
111
  nullable?: Maybe<Scalars['Boolean']>;
112
+ readonly?: Maybe<Scalars['Boolean']>;
113
+ type: Scalars['String'];
113
114
  ui?: Maybe<Scalars['JSON']>;
114
115
  };
115
116
  /** Operators for filtering on a list of Boolean fields */
@@ -118,44 +119,44 @@ export declare type BooleanListOperators = {
118
119
  };
119
120
  /** Operators for filtering on a Boolean field */
120
121
  export declare type BooleanOperators = {
121
- eq?: Maybe<Scalars['Boolean']>;
122
+ eq?: InputMaybe<Scalars['Boolean']>;
122
123
  };
123
124
  export declare type Channel = Node & {
124
125
  __typename?: 'Channel';
125
- id: Scalars['ID'];
126
- createdAt: Scalars['DateTime'];
127
- updatedAt: Scalars['DateTime'];
128
126
  code: Scalars['String'];
129
- token: Scalars['String'];
130
- defaultTaxZone?: Maybe<Zone>;
131
- defaultShippingZone?: Maybe<Zone>;
132
- defaultLanguageCode: LanguageCode;
127
+ createdAt: Scalars['DateTime'];
133
128
  currencyCode: CurrencyCode;
134
- pricesIncludeTax: Scalars['Boolean'];
135
129
  customFields?: Maybe<Scalars['JSON']>;
130
+ defaultLanguageCode: LanguageCode;
131
+ defaultShippingZone?: Maybe<Zone>;
132
+ defaultTaxZone?: Maybe<Zone>;
133
+ id: Scalars['ID'];
134
+ pricesIncludeTax: Scalars['Boolean'];
135
+ token: Scalars['String'];
136
+ updatedAt: Scalars['DateTime'];
136
137
  };
137
138
  export declare type Collection = Node & {
138
139
  __typename?: 'Collection';
139
- id: Scalars['ID'];
140
- createdAt: Scalars['DateTime'];
141
- updatedAt: Scalars['DateTime'];
142
- languageCode?: Maybe<LanguageCode>;
143
- name: Scalars['String'];
144
- slug: Scalars['String'];
140
+ assets: Array<Asset>;
145
141
  breadcrumbs: Array<CollectionBreadcrumb>;
146
- position: Scalars['Int'];
142
+ children?: Maybe<Array<Collection>>;
143
+ createdAt: Scalars['DateTime'];
144
+ customFields?: Maybe<Scalars['JSON']>;
147
145
  description: Scalars['String'];
148
146
  featuredAsset?: Maybe<Asset>;
149
- assets: Array<Asset>;
150
- parent?: Maybe<Collection>;
151
- children?: Maybe<Array<Collection>>;
152
147
  filters: Array<ConfigurableOperation>;
153
- translations: Array<CollectionTranslation>;
148
+ id: Scalars['ID'];
149
+ languageCode?: Maybe<LanguageCode>;
150
+ name: Scalars['String'];
151
+ parent?: Maybe<Collection>;
152
+ position: Scalars['Int'];
154
153
  productVariants: ProductVariantList;
155
- customFields?: Maybe<Scalars['JSON']>;
154
+ slug: Scalars['String'];
155
+ translations: Array<CollectionTranslation>;
156
+ updatedAt: Scalars['DateTime'];
156
157
  };
157
158
  export declare type CollectionProductVariantsArgs = {
158
- options?: Maybe<ProductVariantListOptions>;
159
+ options?: InputMaybe<ProductVariantListOptions>;
159
160
  };
160
161
  export declare type CollectionBreadcrumb = {
161
162
  __typename?: 'CollectionBreadcrumb';
@@ -164,14 +165,14 @@ export declare type CollectionBreadcrumb = {
164
165
  slug: Scalars['String'];
165
166
  };
166
167
  export declare type CollectionFilterParameter = {
167
- id?: Maybe<IdOperators>;
168
- createdAt?: Maybe<DateOperators>;
169
- updatedAt?: Maybe<DateOperators>;
170
- languageCode?: Maybe<StringOperators>;
171
- name?: Maybe<StringOperators>;
172
- slug?: Maybe<StringOperators>;
173
- position?: Maybe<NumberOperators>;
174
- description?: Maybe<StringOperators>;
168
+ createdAt?: InputMaybe<DateOperators>;
169
+ description?: InputMaybe<StringOperators>;
170
+ id?: InputMaybe<IdOperators>;
171
+ languageCode?: InputMaybe<StringOperators>;
172
+ name?: InputMaybe<StringOperators>;
173
+ position?: InputMaybe<NumberOperators>;
174
+ slug?: InputMaybe<StringOperators>;
175
+ updatedAt?: InputMaybe<DateOperators>;
175
176
  };
176
177
  export declare type CollectionList = PaginatedList & {
177
178
  __typename?: 'CollectionList';
@@ -179,16 +180,16 @@ export declare type CollectionList = PaginatedList & {
179
180
  totalItems: Scalars['Int'];
180
181
  };
181
182
  export declare type CollectionListOptions = {
182
- /** Skips the first n results, for use in pagination */
183
- skip?: Maybe<Scalars['Int']>;
184
- /** Takes n results, for use in pagination */
185
- take?: Maybe<Scalars['Int']>;
186
- /** Specifies which properties to sort the results by */
187
- sort?: Maybe<CollectionSortParameter>;
188
183
  /** Allows the results to be filtered */
189
- filter?: Maybe<CollectionFilterParameter>;
184
+ filter?: InputMaybe<CollectionFilterParameter>;
190
185
  /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
191
- filterOperator?: Maybe<LogicalOperator>;
186
+ filterOperator?: InputMaybe<LogicalOperator>;
187
+ /** Skips the first n results, for use in pagination */
188
+ skip?: InputMaybe<Scalars['Int']>;
189
+ /** Specifies which properties to sort the results by */
190
+ sort?: InputMaybe<CollectionSortParameter>;
191
+ /** Takes n results, for use in pagination */
192
+ take?: InputMaybe<Scalars['Int']>;
192
193
  };
193
194
  /**
194
195
  * Which Collections are present in the products returned
@@ -200,23 +201,23 @@ export declare type CollectionResult = {
200
201
  count: Scalars['Int'];
201
202
  };
202
203
  export declare type CollectionSortParameter = {
203
- id?: Maybe<SortOrder>;
204
- createdAt?: Maybe<SortOrder>;
205
- updatedAt?: Maybe<SortOrder>;
206
- name?: Maybe<SortOrder>;
207
- slug?: Maybe<SortOrder>;
208
- position?: Maybe<SortOrder>;
209
- description?: Maybe<SortOrder>;
204
+ createdAt?: InputMaybe<SortOrder>;
205
+ description?: InputMaybe<SortOrder>;
206
+ id?: InputMaybe<SortOrder>;
207
+ name?: InputMaybe<SortOrder>;
208
+ position?: InputMaybe<SortOrder>;
209
+ slug?: InputMaybe<SortOrder>;
210
+ updatedAt?: InputMaybe<SortOrder>;
210
211
  };
211
212
  export declare type CollectionTranslation = {
212
213
  __typename?: 'CollectionTranslation';
213
- id: Scalars['ID'];
214
214
  createdAt: Scalars['DateTime'];
215
- updatedAt: Scalars['DateTime'];
215
+ description: Scalars['String'];
216
+ id: Scalars['ID'];
216
217
  languageCode: LanguageCode;
217
218
  name: Scalars['String'];
218
219
  slug: Scalars['String'];
219
- description: Scalars['String'];
220
+ updatedAt: Scalars['DateTime'];
220
221
  };
221
222
  export declare type ConfigArg = {
222
223
  __typename?: 'ConfigArg';
@@ -225,13 +226,13 @@ export declare type ConfigArg = {
225
226
  };
226
227
  export declare type ConfigArgDefinition = {
227
228
  __typename?: 'ConfigArgDefinition';
228
- name: Scalars['String'];
229
- type: Scalars['String'];
230
- list: Scalars['Boolean'];
231
- required: Scalars['Boolean'];
232
229
  defaultValue?: Maybe<Scalars['JSON']>;
233
- label?: Maybe<Scalars['String']>;
234
230
  description?: Maybe<Scalars['String']>;
231
+ label?: Maybe<Scalars['String']>;
232
+ list: Scalars['Boolean'];
233
+ name: Scalars['String'];
234
+ required: Scalars['Boolean'];
235
+ type: Scalars['String'];
235
236
  ui?: Maybe<Scalars['JSON']>;
236
237
  };
237
238
  export declare type ConfigArgInput = {
@@ -241,18 +242,18 @@ export declare type ConfigArgInput = {
241
242
  };
242
243
  export declare type ConfigurableOperation = {
243
244
  __typename?: 'ConfigurableOperation';
244
- code: Scalars['String'];
245
245
  args: Array<ConfigArg>;
246
+ code: Scalars['String'];
246
247
  };
247
248
  export declare type ConfigurableOperationDefinition = {
248
249
  __typename?: 'ConfigurableOperationDefinition';
249
- code: Scalars['String'];
250
250
  args: Array<ConfigArgDefinition>;
251
+ code: Scalars['String'];
251
252
  description: Scalars['String'];
252
253
  };
253
254
  export declare type ConfigurableOperationInput = {
254
- code: Scalars['String'];
255
255
  arguments: Array<ConfigArgInput>;
256
+ code: Scalars['String'];
256
257
  };
257
258
  export declare type Coordinate = {
258
259
  __typename?: 'Coordinate';
@@ -261,15 +262,15 @@ export declare type Coordinate = {
261
262
  };
262
263
  export declare type Country = Node & {
263
264
  __typename?: 'Country';
264
- id: Scalars['ID'];
265
+ code: Scalars['String'];
265
266
  createdAt: Scalars['DateTime'];
266
- updatedAt: Scalars['DateTime'];
267
+ customFields?: Maybe<Scalars['JSON']>;
268
+ enabled: Scalars['Boolean'];
269
+ id: Scalars['ID'];
267
270
  languageCode: LanguageCode;
268
- code: Scalars['String'];
269
271
  name: Scalars['String'];
270
- enabled: Scalars['Boolean'];
271
272
  translations: Array<CountryTranslation>;
272
- customFields?: Maybe<Scalars['JSON']>;
273
+ updatedAt: Scalars['DateTime'];
273
274
  };
274
275
  export declare type CountryList = PaginatedList & {
275
276
  __typename?: 'CountryList';
@@ -278,55 +279,55 @@ export declare type CountryList = PaginatedList & {
278
279
  };
279
280
  export declare type CountryTranslation = {
280
281
  __typename?: 'CountryTranslation';
281
- id: Scalars['ID'];
282
282
  createdAt: Scalars['DateTime'];
283
- updatedAt: Scalars['DateTime'];
283
+ id: Scalars['ID'];
284
284
  languageCode: LanguageCode;
285
285
  name: Scalars['String'];
286
+ updatedAt: Scalars['DateTime'];
286
287
  };
287
288
  /** Returned if the provided coupon code is invalid */
288
289
  export declare type CouponCodeExpiredError = ErrorResult & {
289
290
  __typename?: 'CouponCodeExpiredError';
291
+ couponCode: Scalars['String'];
290
292
  errorCode: ErrorCode;
291
293
  message: Scalars['String'];
292
- couponCode: Scalars['String'];
293
294
  };
294
295
  /** Returned if the provided coupon code is invalid */
295
296
  export declare type CouponCodeInvalidError = ErrorResult & {
296
297
  __typename?: 'CouponCodeInvalidError';
298
+ couponCode: Scalars['String'];
297
299
  errorCode: ErrorCode;
298
300
  message: Scalars['String'];
299
- couponCode: Scalars['String'];
300
301
  };
301
302
  /** Returned if the provided coupon code is invalid */
302
303
  export declare type CouponCodeLimitError = ErrorResult & {
303
304
  __typename?: 'CouponCodeLimitError';
304
- errorCode: ErrorCode;
305
- message: Scalars['String'];
306
305
  couponCode: Scalars['String'];
306
+ errorCode: ErrorCode;
307
307
  limit: Scalars['Int'];
308
+ message: Scalars['String'];
308
309
  };
309
310
  export declare type CreateAddressInput = {
310
- fullName?: Maybe<Scalars['String']>;
311
- company?: Maybe<Scalars['String']>;
312
- streetLine1: Scalars['String'];
313
- streetLine2?: Maybe<Scalars['String']>;
314
- city?: Maybe<Scalars['String']>;
315
- province?: Maybe<Scalars['String']>;
316
- postalCode?: Maybe<Scalars['String']>;
311
+ city?: InputMaybe<Scalars['String']>;
312
+ company?: InputMaybe<Scalars['String']>;
317
313
  countryCode: Scalars['String'];
318
- phoneNumber?: Maybe<Scalars['String']>;
319
- defaultShippingAddress?: Maybe<Scalars['Boolean']>;
320
- defaultBillingAddress?: Maybe<Scalars['Boolean']>;
321
- customFields?: Maybe<Scalars['JSON']>;
314
+ customFields?: InputMaybe<Scalars['JSON']>;
315
+ defaultBillingAddress?: InputMaybe<Scalars['Boolean']>;
316
+ defaultShippingAddress?: InputMaybe<Scalars['Boolean']>;
317
+ fullName?: InputMaybe<Scalars['String']>;
318
+ phoneNumber?: InputMaybe<Scalars['String']>;
319
+ postalCode?: InputMaybe<Scalars['String']>;
320
+ province?: InputMaybe<Scalars['String']>;
321
+ streetLine1: Scalars['String'];
322
+ streetLine2?: InputMaybe<Scalars['String']>;
322
323
  };
323
324
  export declare type CreateCustomerInput = {
324
- title?: Maybe<Scalars['String']>;
325
+ customFields?: InputMaybe<Scalars['JSON']>;
326
+ emailAddress: Scalars['String'];
325
327
  firstName: Scalars['String'];
326
328
  lastName: Scalars['String'];
327
- phoneNumber?: Maybe<Scalars['String']>;
328
- emailAddress: Scalars['String'];
329
- customFields?: Maybe<Scalars['JSON']>;
329
+ phoneNumber?: InputMaybe<Scalars['String']>;
330
+ title?: InputMaybe<Scalars['String']>;
330
331
  };
331
332
  /**
332
333
  * @description
@@ -652,68 +653,68 @@ export declare enum CurrencyCode {
652
653
  }
653
654
  export declare type CurrentUser = {
654
655
  __typename?: 'CurrentUser';
656
+ channels: Array<CurrentUserChannel>;
655
657
  id: Scalars['ID'];
656
658
  identifier: Scalars['String'];
657
- channels: Array<CurrentUserChannel>;
658
659
  };
659
660
  export declare type CurrentUserChannel = {
660
661
  __typename?: 'CurrentUserChannel';
661
- id: Scalars['ID'];
662
- token: Scalars['String'];
663
662
  code: Scalars['String'];
663
+ id: Scalars['ID'];
664
664
  permissions: Array<Permission>;
665
+ token: Scalars['String'];
665
666
  };
666
667
  export declare type CustomField = {
667
- name: Scalars['String'];
668
- type: Scalars['String'];
669
- list: Scalars['Boolean'];
670
- label?: Maybe<Array<LocalizedString>>;
671
668
  description?: Maybe<Array<LocalizedString>>;
672
- readonly?: Maybe<Scalars['Boolean']>;
673
669
  internal?: Maybe<Scalars['Boolean']>;
670
+ label?: Maybe<Array<LocalizedString>>;
671
+ list: Scalars['Boolean'];
672
+ name: Scalars['String'];
674
673
  nullable?: Maybe<Scalars['Boolean']>;
674
+ readonly?: Maybe<Scalars['Boolean']>;
675
+ type: Scalars['String'];
675
676
  ui?: Maybe<Scalars['JSON']>;
676
677
  };
677
- export declare type CustomFieldConfig = StringCustomFieldConfig | LocaleStringCustomFieldConfig | IntCustomFieldConfig | FloatCustomFieldConfig | BooleanCustomFieldConfig | DateTimeCustomFieldConfig | RelationCustomFieldConfig | TextCustomFieldConfig;
678
+ export declare type CustomFieldConfig = BooleanCustomFieldConfig | DateTimeCustomFieldConfig | FloatCustomFieldConfig | IntCustomFieldConfig | LocaleStringCustomFieldConfig | RelationCustomFieldConfig | StringCustomFieldConfig | TextCustomFieldConfig;
678
679
  export declare type Customer = Node & {
679
680
  __typename?: 'Customer';
680
- id: Scalars['ID'];
681
+ addresses?: Maybe<Array<Address>>;
681
682
  createdAt: Scalars['DateTime'];
682
- updatedAt: Scalars['DateTime'];
683
- title?: Maybe<Scalars['String']>;
683
+ customFields?: Maybe<Scalars['JSON']>;
684
+ emailAddress: Scalars['String'];
684
685
  firstName: Scalars['String'];
686
+ id: Scalars['ID'];
685
687
  lastName: Scalars['String'];
686
- phoneNumber?: Maybe<Scalars['String']>;
687
- emailAddress: Scalars['String'];
688
- addresses?: Maybe<Array<Address>>;
689
688
  orders: OrderList;
689
+ phoneNumber?: Maybe<Scalars['String']>;
690
+ title?: Maybe<Scalars['String']>;
691
+ updatedAt: Scalars['DateTime'];
690
692
  user?: Maybe<User>;
691
- customFields?: Maybe<Scalars['JSON']>;
692
693
  };
693
694
  export declare type CustomerOrdersArgs = {
694
- options?: Maybe<OrderListOptions>;
695
+ options?: InputMaybe<OrderListOptions>;
695
696
  };
696
697
  export declare type CustomerFilterParameter = {
697
- id?: Maybe<IdOperators>;
698
- createdAt?: Maybe<DateOperators>;
699
- updatedAt?: Maybe<DateOperators>;
700
- title?: Maybe<StringOperators>;
701
- firstName?: Maybe<StringOperators>;
702
- lastName?: Maybe<StringOperators>;
703
- phoneNumber?: Maybe<StringOperators>;
704
- emailAddress?: Maybe<StringOperators>;
698
+ createdAt?: InputMaybe<DateOperators>;
699
+ emailAddress?: InputMaybe<StringOperators>;
700
+ firstName?: InputMaybe<StringOperators>;
701
+ id?: InputMaybe<IdOperators>;
702
+ lastName?: InputMaybe<StringOperators>;
703
+ phoneNumber?: InputMaybe<StringOperators>;
704
+ title?: InputMaybe<StringOperators>;
705
+ updatedAt?: InputMaybe<DateOperators>;
705
706
  };
706
707
  export declare type CustomerGroup = Node & {
707
708
  __typename?: 'CustomerGroup';
708
- id: Scalars['ID'];
709
709
  createdAt: Scalars['DateTime'];
710
- updatedAt: Scalars['DateTime'];
711
- name: Scalars['String'];
712
- customers: CustomerList;
713
710
  customFields?: Maybe<Scalars['JSON']>;
711
+ customers: CustomerList;
712
+ id: Scalars['ID'];
713
+ name: Scalars['String'];
714
+ updatedAt: Scalars['DateTime'];
714
715
  };
715
716
  export declare type CustomerGroupCustomersArgs = {
716
- options?: Maybe<CustomerListOptions>;
717
+ options?: InputMaybe<CustomerListOptions>;
717
718
  };
718
719
  export declare type CustomerList = PaginatedList & {
719
720
  __typename?: 'CustomerList';
@@ -721,26 +722,26 @@ export declare type CustomerList = PaginatedList & {
721
722
  totalItems: Scalars['Int'];
722
723
  };
723
724
  export declare type CustomerListOptions = {
724
- /** Skips the first n results, for use in pagination */
725
- skip?: Maybe<Scalars['Int']>;
726
- /** Takes n results, for use in pagination */
727
- take?: Maybe<Scalars['Int']>;
728
- /** Specifies which properties to sort the results by */
729
- sort?: Maybe<CustomerSortParameter>;
730
725
  /** Allows the results to be filtered */
731
- filter?: Maybe<CustomerFilterParameter>;
726
+ filter?: InputMaybe<CustomerFilterParameter>;
732
727
  /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
733
- filterOperator?: Maybe<LogicalOperator>;
728
+ filterOperator?: InputMaybe<LogicalOperator>;
729
+ /** Skips the first n results, for use in pagination */
730
+ skip?: InputMaybe<Scalars['Int']>;
731
+ /** Specifies which properties to sort the results by */
732
+ sort?: InputMaybe<CustomerSortParameter>;
733
+ /** Takes n results, for use in pagination */
734
+ take?: InputMaybe<Scalars['Int']>;
734
735
  };
735
736
  export declare type CustomerSortParameter = {
736
- id?: Maybe<SortOrder>;
737
- createdAt?: Maybe<SortOrder>;
738
- updatedAt?: Maybe<SortOrder>;
739
- title?: Maybe<SortOrder>;
740
- firstName?: Maybe<SortOrder>;
741
- lastName?: Maybe<SortOrder>;
742
- phoneNumber?: Maybe<SortOrder>;
743
- emailAddress?: Maybe<SortOrder>;
737
+ createdAt?: InputMaybe<SortOrder>;
738
+ emailAddress?: InputMaybe<SortOrder>;
739
+ firstName?: InputMaybe<SortOrder>;
740
+ id?: InputMaybe<SortOrder>;
741
+ lastName?: InputMaybe<SortOrder>;
742
+ phoneNumber?: InputMaybe<SortOrder>;
743
+ title?: InputMaybe<SortOrder>;
744
+ updatedAt?: InputMaybe<SortOrder>;
744
745
  };
745
746
  /** Operators for filtering on a list of Date fields */
746
747
  export declare type DateListOperators = {
@@ -748,14 +749,14 @@ export declare type DateListOperators = {
748
749
  };
749
750
  /** Operators for filtering on a DateTime field */
750
751
  export declare type DateOperators = {
751
- eq?: Maybe<Scalars['DateTime']>;
752
- before?: Maybe<Scalars['DateTime']>;
753
- after?: Maybe<Scalars['DateTime']>;
754
- between?: Maybe<DateRange>;
752
+ after?: InputMaybe<Scalars['DateTime']>;
753
+ before?: InputMaybe<Scalars['DateTime']>;
754
+ between?: InputMaybe<DateRange>;
755
+ eq?: InputMaybe<Scalars['DateTime']>;
755
756
  };
756
757
  export declare type DateRange = {
757
- start: Scalars['DateTime'];
758
758
  end: Scalars['DateTime'];
759
+ start: Scalars['DateTime'];
759
760
  };
760
761
  /**
761
762
  * Expects the same validation formats as the `<input type="datetime-local">` HTML element.
@@ -763,23 +764,23 @@ export declare type DateRange = {
763
764
  */
764
765
  export declare type DateTimeCustomFieldConfig = CustomField & {
765
766
  __typename?: 'DateTimeCustomFieldConfig';
766
- name: Scalars['String'];
767
- type: Scalars['String'];
768
- list: Scalars['Boolean'];
769
- label?: Maybe<Array<LocalizedString>>;
770
767
  description?: Maybe<Array<LocalizedString>>;
771
- readonly?: Maybe<Scalars['Boolean']>;
772
768
  internal?: Maybe<Scalars['Boolean']>;
773
- nullable?: Maybe<Scalars['Boolean']>;
774
- min?: Maybe<Scalars['String']>;
769
+ label?: Maybe<Array<LocalizedString>>;
770
+ list: Scalars['Boolean'];
775
771
  max?: Maybe<Scalars['String']>;
772
+ min?: Maybe<Scalars['String']>;
773
+ name: Scalars['String'];
774
+ nullable?: Maybe<Scalars['Boolean']>;
775
+ readonly?: Maybe<Scalars['Boolean']>;
776
776
  step?: Maybe<Scalars['Int']>;
777
+ type: Scalars['String'];
777
778
  ui?: Maybe<Scalars['JSON']>;
778
779
  };
779
780
  export declare type DeletionResponse = {
780
781
  __typename?: 'DeletionResponse';
781
- result: DeletionResult;
782
782
  message?: Maybe<Scalars['String']>;
783
+ result: DeletionResult;
783
784
  };
784
785
  export declare enum DeletionResult {
785
786
  /** The entity was successfully deleted */
@@ -790,10 +791,10 @@ export declare enum DeletionResult {
790
791
  export declare type Discount = {
791
792
  __typename?: 'Discount';
792
793
  adjustmentSource: Scalars['String'];
793
- type: AdjustmentType;
794
- description: Scalars['String'];
795
794
  amount: Scalars['Int'];
796
795
  amountWithTax: Scalars['Int'];
796
+ description: Scalars['String'];
797
+ type: AdjustmentType;
797
798
  };
798
799
  /** Returned when attempting to create a Customer with an email address already registered to an existing User. */
799
800
  export declare type EmailAddressConflictError = ErrorResult & {
@@ -802,35 +803,35 @@ export declare type EmailAddressConflictError = ErrorResult & {
802
803
  message: Scalars['String'];
803
804
  };
804
805
  export declare enum ErrorCode {
805
- UNKNOWN_ERROR = "UNKNOWN_ERROR",
806
- NATIVE_AUTH_STRATEGY_ERROR = "NATIVE_AUTH_STRATEGY_ERROR",
807
- INVALID_CREDENTIALS_ERROR = "INVALID_CREDENTIALS_ERROR",
808
- ORDER_STATE_TRANSITION_ERROR = "ORDER_STATE_TRANSITION_ERROR",
806
+ ALREADY_LOGGED_IN_ERROR = "ALREADY_LOGGED_IN_ERROR",
807
+ COUPON_CODE_EXPIRED_ERROR = "COUPON_CODE_EXPIRED_ERROR",
808
+ COUPON_CODE_INVALID_ERROR = "COUPON_CODE_INVALID_ERROR",
809
+ COUPON_CODE_LIMIT_ERROR = "COUPON_CODE_LIMIT_ERROR",
809
810
  EMAIL_ADDRESS_CONFLICT_ERROR = "EMAIL_ADDRESS_CONFLICT_ERROR",
810
- ORDER_LIMIT_ERROR = "ORDER_LIMIT_ERROR",
811
- NEGATIVE_QUANTITY_ERROR = "NEGATIVE_QUANTITY_ERROR",
811
+ IDENTIFIER_CHANGE_TOKEN_EXPIRED_ERROR = "IDENTIFIER_CHANGE_TOKEN_EXPIRED_ERROR",
812
+ IDENTIFIER_CHANGE_TOKEN_INVALID_ERROR = "IDENTIFIER_CHANGE_TOKEN_INVALID_ERROR",
813
+ INELIGIBLE_PAYMENT_METHOD_ERROR = "INELIGIBLE_PAYMENT_METHOD_ERROR",
814
+ INELIGIBLE_SHIPPING_METHOD_ERROR = "INELIGIBLE_SHIPPING_METHOD_ERROR",
812
815
  INSUFFICIENT_STOCK_ERROR = "INSUFFICIENT_STOCK_ERROR",
816
+ INVALID_CREDENTIALS_ERROR = "INVALID_CREDENTIALS_ERROR",
817
+ MISSING_PASSWORD_ERROR = "MISSING_PASSWORD_ERROR",
818
+ NATIVE_AUTH_STRATEGY_ERROR = "NATIVE_AUTH_STRATEGY_ERROR",
819
+ NEGATIVE_QUANTITY_ERROR = "NEGATIVE_QUANTITY_ERROR",
820
+ NOT_VERIFIED_ERROR = "NOT_VERIFIED_ERROR",
821
+ NO_ACTIVE_ORDER_ERROR = "NO_ACTIVE_ORDER_ERROR",
822
+ ORDER_LIMIT_ERROR = "ORDER_LIMIT_ERROR",
813
823
  ORDER_MODIFICATION_ERROR = "ORDER_MODIFICATION_ERROR",
814
- INELIGIBLE_SHIPPING_METHOD_ERROR = "INELIGIBLE_SHIPPING_METHOD_ERROR",
815
824
  ORDER_PAYMENT_STATE_ERROR = "ORDER_PAYMENT_STATE_ERROR",
816
- INELIGIBLE_PAYMENT_METHOD_ERROR = "INELIGIBLE_PAYMENT_METHOD_ERROR",
817
- PAYMENT_FAILED_ERROR = "PAYMENT_FAILED_ERROR",
818
- PAYMENT_DECLINED_ERROR = "PAYMENT_DECLINED_ERROR",
819
- COUPON_CODE_INVALID_ERROR = "COUPON_CODE_INVALID_ERROR",
820
- COUPON_CODE_EXPIRED_ERROR = "COUPON_CODE_EXPIRED_ERROR",
821
- COUPON_CODE_LIMIT_ERROR = "COUPON_CODE_LIMIT_ERROR",
822
- ALREADY_LOGGED_IN_ERROR = "ALREADY_LOGGED_IN_ERROR",
823
- MISSING_PASSWORD_ERROR = "MISSING_PASSWORD_ERROR",
824
- PASSWORD_VALIDATION_ERROR = "PASSWORD_VALIDATION_ERROR",
825
+ ORDER_STATE_TRANSITION_ERROR = "ORDER_STATE_TRANSITION_ERROR",
825
826
  PASSWORD_ALREADY_SET_ERROR = "PASSWORD_ALREADY_SET_ERROR",
826
- VERIFICATION_TOKEN_INVALID_ERROR = "VERIFICATION_TOKEN_INVALID_ERROR",
827
- VERIFICATION_TOKEN_EXPIRED_ERROR = "VERIFICATION_TOKEN_EXPIRED_ERROR",
828
- IDENTIFIER_CHANGE_TOKEN_INVALID_ERROR = "IDENTIFIER_CHANGE_TOKEN_INVALID_ERROR",
829
- IDENTIFIER_CHANGE_TOKEN_EXPIRED_ERROR = "IDENTIFIER_CHANGE_TOKEN_EXPIRED_ERROR",
830
- PASSWORD_RESET_TOKEN_INVALID_ERROR = "PASSWORD_RESET_TOKEN_INVALID_ERROR",
831
827
  PASSWORD_RESET_TOKEN_EXPIRED_ERROR = "PASSWORD_RESET_TOKEN_EXPIRED_ERROR",
832
- NOT_VERIFIED_ERROR = "NOT_VERIFIED_ERROR",
833
- NO_ACTIVE_ORDER_ERROR = "NO_ACTIVE_ORDER_ERROR"
828
+ PASSWORD_RESET_TOKEN_INVALID_ERROR = "PASSWORD_RESET_TOKEN_INVALID_ERROR",
829
+ PASSWORD_VALIDATION_ERROR = "PASSWORD_VALIDATION_ERROR",
830
+ PAYMENT_DECLINED_ERROR = "PAYMENT_DECLINED_ERROR",
831
+ PAYMENT_FAILED_ERROR = "PAYMENT_FAILED_ERROR",
832
+ UNKNOWN_ERROR = "UNKNOWN_ERROR",
833
+ VERIFICATION_TOKEN_EXPIRED_ERROR = "VERIFICATION_TOKEN_EXPIRED_ERROR",
834
+ VERIFICATION_TOKEN_INVALID_ERROR = "VERIFICATION_TOKEN_INVALID_ERROR"
834
835
  }
835
836
  export declare type ErrorResult = {
836
837
  errorCode: ErrorCode;
@@ -838,23 +839,23 @@ export declare type ErrorResult = {
838
839
  };
839
840
  export declare type Facet = Node & {
840
841
  __typename?: 'Facet';
841
- id: Scalars['ID'];
842
+ code: Scalars['String'];
842
843
  createdAt: Scalars['DateTime'];
843
- updatedAt: Scalars['DateTime'];
844
+ customFields?: Maybe<Scalars['JSON']>;
845
+ id: Scalars['ID'];
844
846
  languageCode: LanguageCode;
845
847
  name: Scalars['String'];
846
- code: Scalars['String'];
847
- values: Array<FacetValue>;
848
848
  translations: Array<FacetTranslation>;
849
- customFields?: Maybe<Scalars['JSON']>;
849
+ updatedAt: Scalars['DateTime'];
850
+ values: Array<FacetValue>;
850
851
  };
851
852
  export declare type FacetFilterParameter = {
852
- id?: Maybe<IdOperators>;
853
- createdAt?: Maybe<DateOperators>;
854
- updatedAt?: Maybe<DateOperators>;
855
- languageCode?: Maybe<StringOperators>;
856
- name?: Maybe<StringOperators>;
857
- code?: Maybe<StringOperators>;
853
+ code?: InputMaybe<StringOperators>;
854
+ createdAt?: InputMaybe<DateOperators>;
855
+ id?: InputMaybe<IdOperators>;
856
+ languageCode?: InputMaybe<StringOperators>;
857
+ name?: InputMaybe<StringOperators>;
858
+ updatedAt?: InputMaybe<DateOperators>;
858
859
  };
859
860
  export declare type FacetList = PaginatedList & {
860
861
  __typename?: 'FacetList';
@@ -862,43 +863,43 @@ export declare type FacetList = PaginatedList & {
862
863
  totalItems: Scalars['Int'];
863
864
  };
864
865
  export declare type FacetListOptions = {
865
- /** Skips the first n results, for use in pagination */
866
- skip?: Maybe<Scalars['Int']>;
867
- /** Takes n results, for use in pagination */
868
- take?: Maybe<Scalars['Int']>;
869
- /** Specifies which properties to sort the results by */
870
- sort?: Maybe<FacetSortParameter>;
871
866
  /** Allows the results to be filtered */
872
- filter?: Maybe<FacetFilterParameter>;
867
+ filter?: InputMaybe<FacetFilterParameter>;
873
868
  /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
874
- filterOperator?: Maybe<LogicalOperator>;
869
+ filterOperator?: InputMaybe<LogicalOperator>;
870
+ /** Skips the first n results, for use in pagination */
871
+ skip?: InputMaybe<Scalars['Int']>;
872
+ /** Specifies which properties to sort the results by */
873
+ sort?: InputMaybe<FacetSortParameter>;
874
+ /** Takes n results, for use in pagination */
875
+ take?: InputMaybe<Scalars['Int']>;
875
876
  };
876
877
  export declare type FacetSortParameter = {
877
- id?: Maybe<SortOrder>;
878
- createdAt?: Maybe<SortOrder>;
879
- updatedAt?: Maybe<SortOrder>;
880
- name?: Maybe<SortOrder>;
881
- code?: Maybe<SortOrder>;
878
+ code?: InputMaybe<SortOrder>;
879
+ createdAt?: InputMaybe<SortOrder>;
880
+ id?: InputMaybe<SortOrder>;
881
+ name?: InputMaybe<SortOrder>;
882
+ updatedAt?: InputMaybe<SortOrder>;
882
883
  };
883
884
  export declare type FacetTranslation = {
884
885
  __typename?: 'FacetTranslation';
885
- id: Scalars['ID'];
886
886
  createdAt: Scalars['DateTime'];
887
- updatedAt: Scalars['DateTime'];
887
+ id: Scalars['ID'];
888
888
  languageCode: LanguageCode;
889
889
  name: Scalars['String'];
890
+ updatedAt: Scalars['DateTime'];
890
891
  };
891
892
  export declare type FacetValue = Node & {
892
893
  __typename?: 'FacetValue';
893
- id: Scalars['ID'];
894
+ code: Scalars['String'];
894
895
  createdAt: Scalars['DateTime'];
895
- updatedAt: Scalars['DateTime'];
896
- languageCode: LanguageCode;
896
+ customFields?: Maybe<Scalars['JSON']>;
897
897
  facet: Facet;
898
+ id: Scalars['ID'];
899
+ languageCode: LanguageCode;
898
900
  name: Scalars['String'];
899
- code: Scalars['String'];
900
901
  translations: Array<FacetValueTranslation>;
901
- customFields?: Maybe<Scalars['JSON']>;
902
+ updatedAt: Scalars['DateTime'];
902
903
  };
903
904
  /**
904
905
  * Used to construct boolean expressions for filtering search results
@@ -909,8 +910,8 @@ export declare type FacetValue = Node & {
909
910
  * * ID=1 AND (ID=2 OR ID=3): `{ facetValueFilters: [{ and: 1 }, { or: [2,3] }] }`
910
911
  */
911
912
  export declare type FacetValueFilterInput = {
912
- and?: Maybe<Scalars['ID']>;
913
- or?: Maybe<Array<Scalars['ID']>>;
913
+ and?: InputMaybe<Scalars['ID']>;
914
+ or?: InputMaybe<Array<Scalars['ID']>>;
914
915
  };
915
916
  /**
916
917
  * Which FacetValues are present in the products returned
@@ -918,61 +919,61 @@ export declare type FacetValueFilterInput = {
918
919
  */
919
920
  export declare type FacetValueResult = {
920
921
  __typename?: 'FacetValueResult';
921
- facetValue: FacetValue;
922
922
  count: Scalars['Int'];
923
+ facetValue: FacetValue;
923
924
  };
924
925
  export declare type FacetValueTranslation = {
925
926
  __typename?: 'FacetValueTranslation';
926
- id: Scalars['ID'];
927
927
  createdAt: Scalars['DateTime'];
928
- updatedAt: Scalars['DateTime'];
928
+ id: Scalars['ID'];
929
929
  languageCode: LanguageCode;
930
930
  name: Scalars['String'];
931
+ updatedAt: Scalars['DateTime'];
931
932
  };
932
933
  export declare type FloatCustomFieldConfig = CustomField & {
933
934
  __typename?: 'FloatCustomFieldConfig';
934
- name: Scalars['String'];
935
- type: Scalars['String'];
936
- list: Scalars['Boolean'];
937
- label?: Maybe<Array<LocalizedString>>;
938
935
  description?: Maybe<Array<LocalizedString>>;
939
- readonly?: Maybe<Scalars['Boolean']>;
940
936
  internal?: Maybe<Scalars['Boolean']>;
941
- nullable?: Maybe<Scalars['Boolean']>;
942
- min?: Maybe<Scalars['Float']>;
937
+ label?: Maybe<Array<LocalizedString>>;
938
+ list: Scalars['Boolean'];
943
939
  max?: Maybe<Scalars['Float']>;
940
+ min?: Maybe<Scalars['Float']>;
941
+ name: Scalars['String'];
942
+ nullable?: Maybe<Scalars['Boolean']>;
943
+ readonly?: Maybe<Scalars['Boolean']>;
944
944
  step?: Maybe<Scalars['Float']>;
945
+ type: Scalars['String'];
945
946
  ui?: Maybe<Scalars['JSON']>;
946
947
  };
947
948
  export declare type Fulfillment = Node & {
948
949
  __typename?: 'Fulfillment';
949
- id: Scalars['ID'];
950
950
  createdAt: Scalars['DateTime'];
951
- updatedAt: Scalars['DateTime'];
951
+ customFields?: Maybe<Scalars['JSON']>;
952
+ id: Scalars['ID'];
953
+ method: Scalars['String'];
952
954
  orderItems: Array<OrderItem>;
953
955
  state: Scalars['String'];
954
- method: Scalars['String'];
955
956
  trackingCode?: Maybe<Scalars['String']>;
956
- customFields?: Maybe<Scalars['JSON']>;
957
+ updatedAt: Scalars['DateTime'];
957
958
  };
958
959
  export declare enum GlobalFlag {
959
- TRUE = "TRUE",
960
960
  FALSE = "FALSE",
961
- INHERIT = "INHERIT"
961
+ INHERIT = "INHERIT",
962
+ TRUE = "TRUE"
962
963
  }
963
964
  export declare type HistoryEntry = Node & {
964
965
  __typename?: 'HistoryEntry';
965
- id: Scalars['ID'];
966
966
  createdAt: Scalars['DateTime'];
967
- updatedAt: Scalars['DateTime'];
968
- type: HistoryEntryType;
969
967
  data: Scalars['JSON'];
968
+ id: Scalars['ID'];
969
+ type: HistoryEntryType;
970
+ updatedAt: Scalars['DateTime'];
970
971
  };
971
972
  export declare type HistoryEntryFilterParameter = {
972
- id?: Maybe<IdOperators>;
973
- createdAt?: Maybe<DateOperators>;
974
- updatedAt?: Maybe<DateOperators>;
975
- type?: Maybe<StringOperators>;
973
+ createdAt?: InputMaybe<DateOperators>;
974
+ id?: InputMaybe<IdOperators>;
975
+ type?: InputMaybe<StringOperators>;
976
+ updatedAt?: InputMaybe<DateOperators>;
976
977
  };
977
978
  export declare type HistoryEntryList = PaginatedList & {
978
979
  __typename?: 'HistoryEntryList';
@@ -980,47 +981,47 @@ export declare type HistoryEntryList = PaginatedList & {
980
981
  totalItems: Scalars['Int'];
981
982
  };
982
983
  export declare type HistoryEntryListOptions = {
983
- /** Skips the first n results, for use in pagination */
984
- skip?: Maybe<Scalars['Int']>;
985
- /** Takes n results, for use in pagination */
986
- take?: Maybe<Scalars['Int']>;
987
- /** Specifies which properties to sort the results by */
988
- sort?: Maybe<HistoryEntrySortParameter>;
989
984
  /** Allows the results to be filtered */
990
- filter?: Maybe<HistoryEntryFilterParameter>;
985
+ filter?: InputMaybe<HistoryEntryFilterParameter>;
991
986
  /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
992
- filterOperator?: Maybe<LogicalOperator>;
987
+ filterOperator?: InputMaybe<LogicalOperator>;
988
+ /** Skips the first n results, for use in pagination */
989
+ skip?: InputMaybe<Scalars['Int']>;
990
+ /** Specifies which properties to sort the results by */
991
+ sort?: InputMaybe<HistoryEntrySortParameter>;
992
+ /** Takes n results, for use in pagination */
993
+ take?: InputMaybe<Scalars['Int']>;
993
994
  };
994
995
  export declare type HistoryEntrySortParameter = {
995
- id?: Maybe<SortOrder>;
996
- createdAt?: Maybe<SortOrder>;
997
- updatedAt?: Maybe<SortOrder>;
996
+ createdAt?: InputMaybe<SortOrder>;
997
+ id?: InputMaybe<SortOrder>;
998
+ updatedAt?: InputMaybe<SortOrder>;
998
999
  };
999
1000
  export declare enum HistoryEntryType {
1000
- CUSTOMER_REGISTERED = "CUSTOMER_REGISTERED",
1001
- CUSTOMER_VERIFIED = "CUSTOMER_VERIFIED",
1002
- CUSTOMER_DETAIL_UPDATED = "CUSTOMER_DETAIL_UPDATED",
1003
1001
  CUSTOMER_ADDED_TO_GROUP = "CUSTOMER_ADDED_TO_GROUP",
1004
- CUSTOMER_REMOVED_FROM_GROUP = "CUSTOMER_REMOVED_FROM_GROUP",
1005
1002
  CUSTOMER_ADDRESS_CREATED = "CUSTOMER_ADDRESS_CREATED",
1006
- CUSTOMER_ADDRESS_UPDATED = "CUSTOMER_ADDRESS_UPDATED",
1007
1003
  CUSTOMER_ADDRESS_DELETED = "CUSTOMER_ADDRESS_DELETED",
1008
- CUSTOMER_PASSWORD_UPDATED = "CUSTOMER_PASSWORD_UPDATED",
1009
- CUSTOMER_PASSWORD_RESET_REQUESTED = "CUSTOMER_PASSWORD_RESET_REQUESTED",
1010
- CUSTOMER_PASSWORD_RESET_VERIFIED = "CUSTOMER_PASSWORD_RESET_VERIFIED",
1004
+ CUSTOMER_ADDRESS_UPDATED = "CUSTOMER_ADDRESS_UPDATED",
1005
+ CUSTOMER_DETAIL_UPDATED = "CUSTOMER_DETAIL_UPDATED",
1011
1006
  CUSTOMER_EMAIL_UPDATE_REQUESTED = "CUSTOMER_EMAIL_UPDATE_REQUESTED",
1012
1007
  CUSTOMER_EMAIL_UPDATE_VERIFIED = "CUSTOMER_EMAIL_UPDATE_VERIFIED",
1013
1008
  CUSTOMER_NOTE = "CUSTOMER_NOTE",
1014
- ORDER_STATE_TRANSITION = "ORDER_STATE_TRANSITION",
1015
- ORDER_PAYMENT_TRANSITION = "ORDER_PAYMENT_TRANSITION",
1016
- ORDER_FULFILLMENT = "ORDER_FULFILLMENT",
1009
+ CUSTOMER_PASSWORD_RESET_REQUESTED = "CUSTOMER_PASSWORD_RESET_REQUESTED",
1010
+ CUSTOMER_PASSWORD_RESET_VERIFIED = "CUSTOMER_PASSWORD_RESET_VERIFIED",
1011
+ CUSTOMER_PASSWORD_UPDATED = "CUSTOMER_PASSWORD_UPDATED",
1012
+ CUSTOMER_REGISTERED = "CUSTOMER_REGISTERED",
1013
+ CUSTOMER_REMOVED_FROM_GROUP = "CUSTOMER_REMOVED_FROM_GROUP",
1014
+ CUSTOMER_VERIFIED = "CUSTOMER_VERIFIED",
1017
1015
  ORDER_CANCELLATION = "ORDER_CANCELLATION",
1018
- ORDER_REFUND_TRANSITION = "ORDER_REFUND_TRANSITION",
1019
- ORDER_FULFILLMENT_TRANSITION = "ORDER_FULFILLMENT_TRANSITION",
1020
- ORDER_NOTE = "ORDER_NOTE",
1021
1016
  ORDER_COUPON_APPLIED = "ORDER_COUPON_APPLIED",
1022
1017
  ORDER_COUPON_REMOVED = "ORDER_COUPON_REMOVED",
1023
- ORDER_MODIFIED = "ORDER_MODIFIED"
1018
+ ORDER_FULFILLMENT = "ORDER_FULFILLMENT",
1019
+ ORDER_FULFILLMENT_TRANSITION = "ORDER_FULFILLMENT_TRANSITION",
1020
+ ORDER_MODIFIED = "ORDER_MODIFIED",
1021
+ ORDER_NOTE = "ORDER_NOTE",
1022
+ ORDER_PAYMENT_TRANSITION = "ORDER_PAYMENT_TRANSITION",
1023
+ ORDER_REFUND_TRANSITION = "ORDER_REFUND_TRANSITION",
1024
+ ORDER_STATE_TRANSITION = "ORDER_STATE_TRANSITION"
1024
1025
  }
1025
1026
  /** Operators for filtering on a list of ID fields */
1026
1027
  export declare type IdListOperators = {
@@ -1028,10 +1029,10 @@ export declare type IdListOperators = {
1028
1029
  };
1029
1030
  /** Operators for filtering on an ID field */
1030
1031
  export declare type IdOperators = {
1031
- eq?: Maybe<Scalars['String']>;
1032
- notEq?: Maybe<Scalars['String']>;
1033
- in?: Maybe<Array<Scalars['String']>>;
1034
- notIn?: Maybe<Array<Scalars['String']>>;
1032
+ eq?: InputMaybe<Scalars['String']>;
1033
+ in?: InputMaybe<Array<Scalars['String']>>;
1034
+ notEq?: InputMaybe<Scalars['String']>;
1035
+ notIn?: InputMaybe<Array<Scalars['String']>>;
1035
1036
  };
1036
1037
  /**
1037
1038
  * Returned if the token used to change a Customer's email address is valid, but has
@@ -1054,9 +1055,9 @@ export declare type IdentifierChangeTokenInvalidError = ErrorResult & {
1054
1055
  /** Returned when attempting to add a Payment using a PaymentMethod for which the Order is not eligible. */
1055
1056
  export declare type IneligiblePaymentMethodError = ErrorResult & {
1056
1057
  __typename?: 'IneligiblePaymentMethodError';
1058
+ eligibilityCheckerMessage?: Maybe<Scalars['String']>;
1057
1059
  errorCode: ErrorCode;
1058
1060
  message: Scalars['String'];
1059
- eligibilityCheckerMessage?: Maybe<Scalars['String']>;
1060
1061
  };
1061
1062
  /** Returned when attempting to set a ShippingMethod for which the Order is not eligible */
1062
1063
  export declare type IneligibleShippingMethodError = ErrorResult & {
@@ -1069,30 +1070,30 @@ export declare type InsufficientStockError = ErrorResult & {
1069
1070
  __typename?: 'InsufficientStockError';
1070
1071
  errorCode: ErrorCode;
1071
1072
  message: Scalars['String'];
1072
- quantityAvailable: Scalars['Int'];
1073
1073
  order: Order;
1074
+ quantityAvailable: Scalars['Int'];
1074
1075
  };
1075
1076
  export declare type IntCustomFieldConfig = CustomField & {
1076
1077
  __typename?: 'IntCustomFieldConfig';
1077
- name: Scalars['String'];
1078
- type: Scalars['String'];
1079
- list: Scalars['Boolean'];
1080
- label?: Maybe<Array<LocalizedString>>;
1081
1078
  description?: Maybe<Array<LocalizedString>>;
1082
- readonly?: Maybe<Scalars['Boolean']>;
1083
1079
  internal?: Maybe<Scalars['Boolean']>;
1084
- nullable?: Maybe<Scalars['Boolean']>;
1085
- min?: Maybe<Scalars['Int']>;
1080
+ label?: Maybe<Array<LocalizedString>>;
1081
+ list: Scalars['Boolean'];
1086
1082
  max?: Maybe<Scalars['Int']>;
1083
+ min?: Maybe<Scalars['Int']>;
1084
+ name: Scalars['String'];
1085
+ nullable?: Maybe<Scalars['Boolean']>;
1086
+ readonly?: Maybe<Scalars['Boolean']>;
1087
1087
  step?: Maybe<Scalars['Int']>;
1088
+ type: Scalars['String'];
1088
1089
  ui?: Maybe<Scalars['JSON']>;
1089
1090
  };
1090
1091
  /** Returned if the user authentication credentials are not valid */
1091
1092
  export declare type InvalidCredentialsError = ErrorResult & {
1092
1093
  __typename?: 'InvalidCredentialsError';
1094
+ authenticationError: Scalars['String'];
1093
1095
  errorCode: ErrorCode;
1094
1096
  message: Scalars['String'];
1095
- authenticationError: Scalars['String'];
1096
1097
  };
1097
1098
  /**
1098
1099
  * @description
@@ -1108,62 +1109,54 @@ export declare enum LanguageCode {
1108
1109
  af = "af",
1109
1110
  /** Akan */
1110
1111
  ak = "ak",
1111
- /** Albanian */
1112
- sq = "sq",
1113
1112
  /** Amharic */
1114
1113
  am = "am",
1115
1114
  /** Arabic */
1116
1115
  ar = "ar",
1117
- /** Armenian */
1118
- hy = "hy",
1119
1116
  /** Assamese */
1120
1117
  as = "as",
1121
1118
  /** Azerbaijani */
1122
1119
  az = "az",
1120
+ /** Belarusian */
1121
+ be = "be",
1122
+ /** Bulgarian */
1123
+ bg = "bg",
1123
1124
  /** Bambara */
1124
1125
  bm = "bm",
1125
1126
  /** Bangla */
1126
1127
  bn = "bn",
1127
- /** Basque */
1128
- eu = "eu",
1129
- /** Belarusian */
1130
- be = "be",
1131
- /** Bosnian */
1132
- bs = "bs",
1128
+ /** Tibetan */
1129
+ bo = "bo",
1133
1130
  /** Breton */
1134
1131
  br = "br",
1135
- /** Bulgarian */
1136
- bg = "bg",
1137
- /** Burmese */
1138
- my = "my",
1132
+ /** Bosnian */
1133
+ bs = "bs",
1139
1134
  /** Catalan */
1140
1135
  ca = "ca",
1141
1136
  /** Chechen */
1142
1137
  ce = "ce",
1143
- /** Chinese */
1144
- zh = "zh",
1145
- /** Simplified Chinese */
1146
- zh_Hans = "zh_Hans",
1147
- /** Traditional Chinese */
1148
- zh_Hant = "zh_Hant",
1149
- /** Church Slavic */
1150
- cu = "cu",
1151
- /** Cornish */
1152
- kw = "kw",
1153
1138
  /** Corsican */
1154
1139
  co = "co",
1155
- /** Croatian */
1156
- hr = "hr",
1157
1140
  /** Czech */
1158
1141
  cs = "cs",
1142
+ /** Church Slavic */
1143
+ cu = "cu",
1144
+ /** Welsh */
1145
+ cy = "cy",
1159
1146
  /** Danish */
1160
1147
  da = "da",
1161
- /** Dutch */
1162
- nl = "nl",
1163
- /** Flemish */
1164
- nl_BE = "nl_BE",
1148
+ /** German */
1149
+ de = "de",
1150
+ /** Austrian German */
1151
+ de_AT = "de_AT",
1152
+ /** Swiss High German */
1153
+ de_CH = "de_CH",
1165
1154
  /** Dzongkha */
1166
1155
  dz = "dz",
1156
+ /** Ewe */
1157
+ ee = "ee",
1158
+ /** Greek */
1159
+ el = "el",
1167
1160
  /** English */
1168
1161
  en = "en",
1169
1162
  /** Australian English */
@@ -1176,238 +1169,240 @@ export declare enum LanguageCode {
1176
1169
  en_US = "en_US",
1177
1170
  /** Esperanto */
1178
1171
  eo = "eo",
1172
+ /** Spanish */
1173
+ es = "es",
1174
+ /** European Spanish */
1175
+ es_ES = "es_ES",
1176
+ /** Mexican Spanish */
1177
+ es_MX = "es_MX",
1179
1178
  /** Estonian */
1180
1179
  et = "et",
1181
- /** Ewe */
1182
- ee = "ee",
1183
- /** Faroese */
1184
- fo = "fo",
1180
+ /** Basque */
1181
+ eu = "eu",
1182
+ /** Persian */
1183
+ fa = "fa",
1184
+ /** Dari */
1185
+ fa_AF = "fa_AF",
1186
+ /** Fulah */
1187
+ ff = "ff",
1185
1188
  /** Finnish */
1186
1189
  fi = "fi",
1190
+ /** Faroese */
1191
+ fo = "fo",
1187
1192
  /** French */
1188
1193
  fr = "fr",
1189
1194
  /** Canadian French */
1190
1195
  fr_CA = "fr_CA",
1191
1196
  /** Swiss French */
1192
1197
  fr_CH = "fr_CH",
1193
- /** Fulah */
1194
- ff = "ff",
1198
+ /** Western Frisian */
1199
+ fy = "fy",
1200
+ /** Irish */
1201
+ ga = "ga",
1202
+ /** Scottish Gaelic */
1203
+ gd = "gd",
1195
1204
  /** Galician */
1196
1205
  gl = "gl",
1197
- /** Ganda */
1198
- lg = "lg",
1199
- /** Georgian */
1200
- ka = "ka",
1201
- /** German */
1202
- de = "de",
1203
- /** Austrian German */
1204
- de_AT = "de_AT",
1205
- /** Swiss High German */
1206
- de_CH = "de_CH",
1207
- /** Greek */
1208
- el = "el",
1209
1206
  /** Gujarati */
1210
1207
  gu = "gu",
1211
- /** Haitian Creole */
1212
- ht = "ht",
1208
+ /** Manx */
1209
+ gv = "gv",
1213
1210
  /** Hausa */
1214
1211
  ha = "ha",
1215
1212
  /** Hebrew */
1216
1213
  he = "he",
1217
1214
  /** Hindi */
1218
1215
  hi = "hi",
1216
+ /** Croatian */
1217
+ hr = "hr",
1218
+ /** Haitian Creole */
1219
+ ht = "ht",
1219
1220
  /** Hungarian */
1220
1221
  hu = "hu",
1221
- /** Icelandic */
1222
- is = "is",
1223
- /** Igbo */
1224
- ig = "ig",
1225
- /** Indonesian */
1226
- id = "id",
1222
+ /** Armenian */
1223
+ hy = "hy",
1227
1224
  /** Interlingua */
1228
1225
  ia = "ia",
1229
- /** Irish */
1230
- ga = "ga",
1226
+ /** Indonesian */
1227
+ id = "id",
1228
+ /** Igbo */
1229
+ ig = "ig",
1230
+ /** Sichuan Yi */
1231
+ ii = "ii",
1232
+ /** Icelandic */
1233
+ is = "is",
1231
1234
  /** Italian */
1232
1235
  it = "it",
1233
1236
  /** Japanese */
1234
1237
  ja = "ja",
1235
1238
  /** Javanese */
1236
1239
  jv = "jv",
1237
- /** Kalaallisut */
1238
- kl = "kl",
1239
- /** Kannada */
1240
- kn = "kn",
1241
- /** Kashmiri */
1242
- ks = "ks",
1240
+ /** Georgian */
1241
+ ka = "ka",
1242
+ /** Kikuyu */
1243
+ ki = "ki",
1243
1244
  /** Kazakh */
1244
1245
  kk = "kk",
1246
+ /** Kalaallisut */
1247
+ kl = "kl",
1245
1248
  /** Khmer */
1246
1249
  km = "km",
1247
- /** Kikuyu */
1248
- ki = "ki",
1249
- /** Kinyarwanda */
1250
- rw = "rw",
1250
+ /** Kannada */
1251
+ kn = "kn",
1251
1252
  /** Korean */
1252
1253
  ko = "ko",
1254
+ /** Kashmiri */
1255
+ ks = "ks",
1253
1256
  /** Kurdish */
1254
1257
  ku = "ku",
1258
+ /** Cornish */
1259
+ kw = "kw",
1255
1260
  /** Kyrgyz */
1256
1261
  ky = "ky",
1257
- /** Lao */
1258
- lo = "lo",
1259
1262
  /** Latin */
1260
1263
  la = "la",
1261
- /** Latvian */
1262
- lv = "lv",
1264
+ /** Luxembourgish */
1265
+ lb = "lb",
1266
+ /** Ganda */
1267
+ lg = "lg",
1263
1268
  /** Lingala */
1264
1269
  ln = "ln",
1270
+ /** Lao */
1271
+ lo = "lo",
1265
1272
  /** Lithuanian */
1266
1273
  lt = "lt",
1267
1274
  /** Luba-Katanga */
1268
1275
  lu = "lu",
1269
- /** Luxembourgish */
1270
- lb = "lb",
1271
- /** Macedonian */
1272
- mk = "mk",
1276
+ /** Latvian */
1277
+ lv = "lv",
1273
1278
  /** Malagasy */
1274
1279
  mg = "mg",
1275
- /** Malay */
1276
- ms = "ms",
1277
- /** Malayalam */
1278
- ml = "ml",
1279
- /** Maltese */
1280
- mt = "mt",
1281
- /** Manx */
1282
- gv = "gv",
1283
1280
  /** Maori */
1284
1281
  mi = "mi",
1285
- /** Marathi */
1286
- mr = "mr",
1282
+ /** Macedonian */
1283
+ mk = "mk",
1284
+ /** Malayalam */
1285
+ ml = "ml",
1287
1286
  /** Mongolian */
1288
1287
  mn = "mn",
1289
- /** Nepali */
1290
- ne = "ne",
1291
- /** North Ndebele */
1292
- nd = "nd",
1293
- /** Northern Sami */
1294
- se = "se",
1288
+ /** Marathi */
1289
+ mr = "mr",
1290
+ /** Malay */
1291
+ ms = "ms",
1292
+ /** Maltese */
1293
+ mt = "mt",
1294
+ /** Burmese */
1295
+ my = "my",
1295
1296
  /** Norwegian Bokmål */
1296
1297
  nb = "nb",
1298
+ /** North Ndebele */
1299
+ nd = "nd",
1300
+ /** Nepali */
1301
+ ne = "ne",
1302
+ /** Dutch */
1303
+ nl = "nl",
1304
+ /** Flemish */
1305
+ nl_BE = "nl_BE",
1297
1306
  /** Norwegian Nynorsk */
1298
1307
  nn = "nn",
1299
1308
  /** Nyanja */
1300
1309
  ny = "ny",
1301
- /** Odia */
1302
- or = "or",
1303
1310
  /** Oromo */
1304
1311
  om = "om",
1312
+ /** Odia */
1313
+ or = "or",
1305
1314
  /** Ossetic */
1306
1315
  os = "os",
1307
- /** Pashto */
1308
- ps = "ps",
1309
- /** Persian */
1310
- fa = "fa",
1311
- /** Dari */
1312
- fa_AF = "fa_AF",
1316
+ /** Punjabi */
1317
+ pa = "pa",
1313
1318
  /** Polish */
1314
1319
  pl = "pl",
1320
+ /** Pashto */
1321
+ ps = "ps",
1315
1322
  /** Portuguese */
1316
1323
  pt = "pt",
1317
1324
  /** Brazilian Portuguese */
1318
1325
  pt_BR = "pt_BR",
1319
1326
  /** European Portuguese */
1320
1327
  pt_PT = "pt_PT",
1321
- /** Punjabi */
1322
- pa = "pa",
1323
1328
  /** Quechua */
1324
1329
  qu = "qu",
1325
- /** Romanian */
1326
- ro = "ro",
1327
- /** Moldavian */
1328
- ro_MD = "ro_MD",
1329
1330
  /** Romansh */
1330
1331
  rm = "rm",
1331
1332
  /** Rundi */
1332
1333
  rn = "rn",
1334
+ /** Romanian */
1335
+ ro = "ro",
1336
+ /** Moldavian */
1337
+ ro_MD = "ro_MD",
1333
1338
  /** Russian */
1334
1339
  ru = "ru",
1335
- /** Samoan */
1336
- sm = "sm",
1337
- /** Sango */
1338
- sg = "sg",
1340
+ /** Kinyarwanda */
1341
+ rw = "rw",
1339
1342
  /** Sanskrit */
1340
1343
  sa = "sa",
1341
- /** Scottish Gaelic */
1342
- gd = "gd",
1343
- /** Serbian */
1344
- sr = "sr",
1345
- /** Shona */
1346
- sn = "sn",
1347
- /** Sichuan Yi */
1348
- ii = "ii",
1349
1344
  /** Sindhi */
1350
1345
  sd = "sd",
1346
+ /** Northern Sami */
1347
+ se = "se",
1348
+ /** Sango */
1349
+ sg = "sg",
1351
1350
  /** Sinhala */
1352
1351
  si = "si",
1353
1352
  /** Slovak */
1354
1353
  sk = "sk",
1355
1354
  /** Slovenian */
1356
1355
  sl = "sl",
1356
+ /** Samoan */
1357
+ sm = "sm",
1358
+ /** Shona */
1359
+ sn = "sn",
1357
1360
  /** Somali */
1358
1361
  so = "so",
1362
+ /** Albanian */
1363
+ sq = "sq",
1364
+ /** Serbian */
1365
+ sr = "sr",
1359
1366
  /** Southern Sotho */
1360
1367
  st = "st",
1361
- /** Spanish */
1362
- es = "es",
1363
- /** European Spanish */
1364
- es_ES = "es_ES",
1365
- /** Mexican Spanish */
1366
- es_MX = "es_MX",
1367
1368
  /** Sundanese */
1368
1369
  su = "su",
1370
+ /** Swedish */
1371
+ sv = "sv",
1369
1372
  /** Swahili */
1370
1373
  sw = "sw",
1371
1374
  /** Congo Swahili */
1372
1375
  sw_CD = "sw_CD",
1373
- /** Swedish */
1374
- sv = "sv",
1375
- /** Tajik */
1376
- tg = "tg",
1377
1376
  /** Tamil */
1378
1377
  ta = "ta",
1379
- /** Tatar */
1380
- tt = "tt",
1381
1378
  /** Telugu */
1382
1379
  te = "te",
1380
+ /** Tajik */
1381
+ tg = "tg",
1383
1382
  /** Thai */
1384
1383
  th = "th",
1385
- /** Tibetan */
1386
- bo = "bo",
1387
1384
  /** Tigrinya */
1388
1385
  ti = "ti",
1386
+ /** Turkmen */
1387
+ tk = "tk",
1389
1388
  /** Tongan */
1390
1389
  to = "to",
1391
1390
  /** Turkish */
1392
1391
  tr = "tr",
1393
- /** Turkmen */
1394
- tk = "tk",
1392
+ /** Tatar */
1393
+ tt = "tt",
1394
+ /** Uyghur */
1395
+ ug = "ug",
1395
1396
  /** Ukrainian */
1396
1397
  uk = "uk",
1397
1398
  /** Urdu */
1398
1399
  ur = "ur",
1399
- /** Uyghur */
1400
- ug = "ug",
1401
1400
  /** Uzbek */
1402
1401
  uz = "uz",
1403
1402
  /** Vietnamese */
1404
1403
  vi = "vi",
1405
1404
  /** Volapük */
1406
1405
  vo = "vo",
1407
- /** Welsh */
1408
- cy = "cy",
1409
- /** Western Frisian */
1410
- fy = "fy",
1411
1406
  /** Wolof */
1412
1407
  wo = "wo",
1413
1408
  /** Xhosa */
@@ -1416,21 +1411,27 @@ export declare enum LanguageCode {
1416
1411
  yi = "yi",
1417
1412
  /** Yoruba */
1418
1413
  yo = "yo",
1414
+ /** Chinese */
1415
+ zh = "zh",
1416
+ /** Simplified Chinese */
1417
+ zh_Hans = "zh_Hans",
1418
+ /** Traditional Chinese */
1419
+ zh_Hant = "zh_Hant",
1419
1420
  /** Zulu */
1420
1421
  zu = "zu"
1421
1422
  }
1422
1423
  export declare type LocaleStringCustomFieldConfig = CustomField & {
1423
1424
  __typename?: 'LocaleStringCustomFieldConfig';
1424
- name: Scalars['String'];
1425
- type: Scalars['String'];
1426
- list: Scalars['Boolean'];
1427
- length?: Maybe<Scalars['Int']>;
1428
- label?: Maybe<Array<LocalizedString>>;
1429
1425
  description?: Maybe<Array<LocalizedString>>;
1430
- readonly?: Maybe<Scalars['Boolean']>;
1431
1426
  internal?: Maybe<Scalars['Boolean']>;
1427
+ label?: Maybe<Array<LocalizedString>>;
1428
+ length?: Maybe<Scalars['Int']>;
1429
+ list: Scalars['Boolean'];
1430
+ name: Scalars['String'];
1432
1431
  nullable?: Maybe<Scalars['Boolean']>;
1433
1432
  pattern?: Maybe<Scalars['String']>;
1433
+ readonly?: Maybe<Scalars['Boolean']>;
1434
+ type: Scalars['String'];
1434
1435
  ui?: Maybe<Scalars['JSON']>;
1435
1436
  };
1436
1437
  export declare type LocalizedString = {
@@ -1565,7 +1566,7 @@ export declare type MutationApplyCouponCodeArgs = {
1565
1566
  };
1566
1567
  export declare type MutationAuthenticateArgs = {
1567
1568
  input: AuthenticationInput;
1568
- rememberMe?: Maybe<Scalars['Boolean']>;
1569
+ rememberMe?: InputMaybe<Scalars['Boolean']>;
1569
1570
  };
1570
1571
  export declare type MutationCreateCustomerAddressArgs = {
1571
1572
  input: CreateAddressInput;
@@ -1577,9 +1578,9 @@ export declare type MutationDeleteCustomerAddressArgs = {
1577
1578
  id: Scalars['ID'];
1578
1579
  };
1579
1580
  export declare type MutationLoginArgs = {
1580
- username: Scalars['String'];
1581
1581
  password: Scalars['String'];
1582
- rememberMe?: Maybe<Scalars['Boolean']>;
1582
+ rememberMe?: InputMaybe<Scalars['Boolean']>;
1583
+ username: Scalars['String'];
1583
1584
  };
1584
1585
  export declare type MutationRefreshCustomerVerificationArgs = {
1585
1586
  emailAddress: Scalars['String'];
@@ -1597,12 +1598,12 @@ export declare type MutationRequestPasswordResetArgs = {
1597
1598
  emailAddress: Scalars['String'];
1598
1599
  };
1599
1600
  export declare type MutationRequestUpdateCustomerEmailAddressArgs = {
1600
- password: Scalars['String'];
1601
1601
  newEmailAddress: Scalars['String'];
1602
+ password: Scalars['String'];
1602
1603
  };
1603
1604
  export declare type MutationResetPasswordArgs = {
1604
- token: Scalars['String'];
1605
1605
  password: Scalars['String'];
1606
+ token: Scalars['String'];
1606
1607
  };
1607
1608
  export declare type MutationSetCustomerForOrderArgs = {
1608
1609
  input: CreateCustomerInput;
@@ -1636,12 +1637,12 @@ export declare type MutationUpdateCustomerPasswordArgs = {
1636
1637
  newPassword: Scalars['String'];
1637
1638
  };
1638
1639
  export declare type MutationVerifyCustomerAccountArgs = {
1640
+ password?: InputMaybe<Scalars['String']>;
1639
1641
  token: Scalars['String'];
1640
- password?: Maybe<Scalars['String']>;
1641
1642
  };
1642
1643
  export declare type NativeAuthInput = {
1643
- username: Scalars['String'];
1644
1644
  password: Scalars['String'];
1645
+ username: Scalars['String'];
1645
1646
  };
1646
1647
  /** Returned when attempting an operation that relies on the NativeAuthStrategy, if that strategy is not configured. */
1647
1648
  export declare type NativeAuthStrategyError = ErrorResult & {
@@ -1649,7 +1650,7 @@ export declare type NativeAuthStrategyError = ErrorResult & {
1649
1650
  errorCode: ErrorCode;
1650
1651
  message: Scalars['String'];
1651
1652
  };
1652
- export declare type NativeAuthenticationResult = CurrentUser | InvalidCredentialsError | NotVerifiedError | NativeAuthStrategyError;
1653
+ export declare type NativeAuthenticationResult = CurrentUser | InvalidCredentialsError | NativeAuthStrategyError | NotVerifiedError;
1653
1654
  /** Returned when attempting to set a negative OrderLine quantity. */
1654
1655
  export declare type NegativeQuantityError = ErrorResult & {
1655
1656
  __typename?: 'NegativeQuantityError';
@@ -1683,51 +1684,48 @@ export declare type NumberListOperators = {
1683
1684
  };
1684
1685
  /** Operators for filtering on a Int or Float field */
1685
1686
  export declare type NumberOperators = {
1686
- eq?: Maybe<Scalars['Float']>;
1687
- lt?: Maybe<Scalars['Float']>;
1688
- lte?: Maybe<Scalars['Float']>;
1689
- gt?: Maybe<Scalars['Float']>;
1690
- gte?: Maybe<Scalars['Float']>;
1691
- between?: Maybe<NumberRange>;
1687
+ between?: InputMaybe<NumberRange>;
1688
+ eq?: InputMaybe<Scalars['Float']>;
1689
+ gt?: InputMaybe<Scalars['Float']>;
1690
+ gte?: InputMaybe<Scalars['Float']>;
1691
+ lt?: InputMaybe<Scalars['Float']>;
1692
+ lte?: InputMaybe<Scalars['Float']>;
1692
1693
  };
1693
1694
  export declare type NumberRange = {
1694
- start: Scalars['Float'];
1695
1695
  end: Scalars['Float'];
1696
+ start: Scalars['Float'];
1696
1697
  };
1697
1698
  export declare type Order = Node & {
1698
1699
  __typename?: 'Order';
1699
- id: Scalars['ID'];
1700
- createdAt: Scalars['DateTime'];
1701
- updatedAt: Scalars['DateTime'];
1702
- /**
1703
- * The date & time that the Order was placed, i.e. the Customer
1704
- * completed the checkout and the Order is no longer "active"
1705
- */
1706
- orderPlacedAt?: Maybe<Scalars['DateTime']>;
1707
- /** A unique code for the Order */
1708
- code: Scalars['String'];
1709
- state: Scalars['String'];
1710
1700
  /** An order is active as long as the payment process has not been completed */
1711
1701
  active: Scalars['Boolean'];
1712
- customer?: Maybe<Customer>;
1713
- shippingAddress?: Maybe<OrderAddress>;
1714
1702
  billingAddress?: Maybe<OrderAddress>;
1703
+ /** A unique code for the Order */
1704
+ code: Scalars['String'];
1705
+ /** An array of all coupon codes applied to the Order */
1706
+ couponCodes: Array<Scalars['String']>;
1707
+ createdAt: Scalars['DateTime'];
1708
+ currencyCode: CurrencyCode;
1709
+ customFields?: Maybe<Scalars['JSON']>;
1710
+ customer?: Maybe<Customer>;
1711
+ discounts: Array<Discount>;
1712
+ fulfillments?: Maybe<Array<Fulfillment>>;
1713
+ history: HistoryEntryList;
1714
+ id: Scalars['ID'];
1715
1715
  lines: Array<OrderLine>;
1716
1716
  /**
1717
- * Surcharges are arbitrary modifications to the Order total which are neither
1718
- * ProductVariants nor discounts resulting from applied Promotions. For example,
1719
- * one-off discounts based on customer interaction, or surcharges based on payment
1720
- * methods.
1717
+ * The date & time that the Order was placed, i.e. the Customer
1718
+ * completed the checkout and the Order is no longer "active"
1721
1719
  */
1722
- surcharges: Array<Surcharge>;
1723
- discounts: Array<Discount>;
1724
- /** An array of all coupon codes applied to the Order */
1725
- couponCodes: Array<Scalars['String']>;
1720
+ orderPlacedAt?: Maybe<Scalars['DateTime']>;
1721
+ payments?: Maybe<Array<Payment>>;
1726
1722
  /** Promotions applied to the order. Only gets populated after the payment process has completed. */
1727
1723
  promotions: Array<Promotion>;
1728
- payments?: Maybe<Array<Payment>>;
1729
- fulfillments?: Maybe<Array<Fulfillment>>;
1730
- totalQuantity: Scalars['Int'];
1724
+ shipping: Scalars['Int'];
1725
+ shippingAddress?: Maybe<OrderAddress>;
1726
+ shippingLines: Array<ShippingLine>;
1727
+ shippingWithTax: Scalars['Int'];
1728
+ state: Scalars['String'];
1731
1729
  /**
1732
1730
  * The subTotal is the total of all OrderLines in the Order. This figure also includes any Order-level
1733
1731
  * discounts which have been prorated (proportionally distributed) amongst the OrderItems.
@@ -1737,63 +1735,61 @@ export declare type Order = Node & {
1737
1735
  subTotal: Scalars['Int'];
1738
1736
  /** Same as subTotal, but inclusive of tax */
1739
1737
  subTotalWithTax: Scalars['Int'];
1740
- currencyCode: CurrencyCode;
1741
- shippingLines: Array<ShippingLine>;
1742
- shipping: Scalars['Int'];
1743
- shippingWithTax: Scalars['Int'];
1738
+ /**
1739
+ * Surcharges are arbitrary modifications to the Order total which are neither
1740
+ * ProductVariants nor discounts resulting from applied Promotions. For example,
1741
+ * one-off discounts based on customer interaction, or surcharges based on payment
1742
+ * methods.
1743
+ */
1744
+ surcharges: Array<Surcharge>;
1745
+ /** A summary of the taxes being applied to this Order */
1746
+ taxSummary: Array<OrderTaxSummary>;
1744
1747
  /** Equal to subTotal plus shipping */
1745
1748
  total: Scalars['Int'];
1749
+ totalQuantity: Scalars['Int'];
1746
1750
  /** The final payable amount. Equal to subTotalWithTax plus shippingWithTax */
1747
1751
  totalWithTax: Scalars['Int'];
1748
- /** A summary of the taxes being applied to this Order */
1749
- taxSummary: Array<OrderTaxSummary>;
1750
- history: HistoryEntryList;
1751
- customFields?: Maybe<Scalars['JSON']>;
1752
+ updatedAt: Scalars['DateTime'];
1752
1753
  };
1753
1754
  export declare type OrderHistoryArgs = {
1754
- options?: Maybe<HistoryEntryListOptions>;
1755
+ options?: InputMaybe<HistoryEntryListOptions>;
1755
1756
  };
1756
1757
  export declare type OrderAddress = {
1757
1758
  __typename?: 'OrderAddress';
1758
- fullName?: Maybe<Scalars['String']>;
1759
- company?: Maybe<Scalars['String']>;
1760
- streetLine1?: Maybe<Scalars['String']>;
1761
- streetLine2?: Maybe<Scalars['String']>;
1762
1759
  city?: Maybe<Scalars['String']>;
1763
- province?: Maybe<Scalars['String']>;
1764
- postalCode?: Maybe<Scalars['String']>;
1760
+ company?: Maybe<Scalars['String']>;
1765
1761
  country?: Maybe<Scalars['String']>;
1766
1762
  countryCode?: Maybe<Scalars['String']>;
1767
- phoneNumber?: Maybe<Scalars['String']>;
1768
1763
  customFields?: Maybe<Scalars['JSON']>;
1769
- };
1770
- export declare type OrderFilterParameter = {
1771
- id?: Maybe<IdOperators>;
1772
- createdAt?: Maybe<DateOperators>;
1773
- updatedAt?: Maybe<DateOperators>;
1774
- orderPlacedAt?: Maybe<DateOperators>;
1775
- code?: Maybe<StringOperators>;
1776
- state?: Maybe<StringOperators>;
1777
- active?: Maybe<BooleanOperators>;
1778
- totalQuantity?: Maybe<NumberOperators>;
1779
- subTotal?: Maybe<NumberOperators>;
1780
- subTotalWithTax?: Maybe<NumberOperators>;
1781
- currencyCode?: Maybe<StringOperators>;
1782
- shipping?: Maybe<NumberOperators>;
1783
- shippingWithTax?: Maybe<NumberOperators>;
1784
- total?: Maybe<NumberOperators>;
1785
- totalWithTax?: Maybe<NumberOperators>;
1786
- };
1787
- export declare type OrderItem = Node & {
1788
- __typename?: 'OrderItem';
1789
- id: Scalars['ID'];
1790
- createdAt: Scalars['DateTime'];
1791
- updatedAt: Scalars['DateTime'];
1764
+ fullName?: Maybe<Scalars['String']>;
1765
+ phoneNumber?: Maybe<Scalars['String']>;
1766
+ postalCode?: Maybe<Scalars['String']>;
1767
+ province?: Maybe<Scalars['String']>;
1768
+ streetLine1?: Maybe<Scalars['String']>;
1769
+ streetLine2?: Maybe<Scalars['String']>;
1770
+ };
1771
+ export declare type OrderFilterParameter = {
1772
+ active?: InputMaybe<BooleanOperators>;
1773
+ code?: InputMaybe<StringOperators>;
1774
+ createdAt?: InputMaybe<DateOperators>;
1775
+ currencyCode?: InputMaybe<StringOperators>;
1776
+ id?: InputMaybe<IdOperators>;
1777
+ orderPlacedAt?: InputMaybe<DateOperators>;
1778
+ shipping?: InputMaybe<NumberOperators>;
1779
+ shippingWithTax?: InputMaybe<NumberOperators>;
1780
+ state?: InputMaybe<StringOperators>;
1781
+ subTotal?: InputMaybe<NumberOperators>;
1782
+ subTotalWithTax?: InputMaybe<NumberOperators>;
1783
+ total?: InputMaybe<NumberOperators>;
1784
+ totalQuantity?: InputMaybe<NumberOperators>;
1785
+ totalWithTax?: InputMaybe<NumberOperators>;
1786
+ updatedAt?: InputMaybe<DateOperators>;
1787
+ };
1788
+ export declare type OrderItem = Node & {
1789
+ __typename?: 'OrderItem';
1790
+ adjustments: Array<Adjustment>;
1792
1791
  cancelled: Scalars['Boolean'];
1793
- /** The price of a single unit, excluding tax and discounts */
1794
- unitPrice: Scalars['Int'];
1795
- /** The price of a single unit, including tax but excluding discounts */
1796
- unitPriceWithTax: Scalars['Int'];
1792
+ createdAt: Scalars['DateTime'];
1797
1793
  /**
1798
1794
  * The price of a single unit including discounts, excluding tax.
1799
1795
  *
@@ -1805,6 +1801,8 @@ export declare type OrderItem = Node & {
1805
1801
  discountedUnitPrice: Scalars['Int'];
1806
1802
  /** The price of a single unit including discounts and tax */
1807
1803
  discountedUnitPriceWithTax: Scalars['Int'];
1804
+ fulfillment?: Maybe<Fulfillment>;
1805
+ id: Scalars['ID'];
1808
1806
  /**
1809
1807
  * The actual unit price, taking into account both item discounts _and_ prorated (proportionally-distributed)
1810
1808
  * Order-level discounts. This value is the true economic value of the OrderItem, and is used in tax
@@ -1813,35 +1811,31 @@ export declare type OrderItem = Node & {
1813
1811
  proratedUnitPrice: Scalars['Int'];
1814
1812
  /** The proratedUnitPrice including tax */
1815
1813
  proratedUnitPriceWithTax: Scalars['Int'];
1816
- unitTax: Scalars['Int'];
1817
- taxRate: Scalars['Float'];
1818
- adjustments: Array<Adjustment>;
1819
- taxLines: Array<TaxLine>;
1820
- fulfillment?: Maybe<Fulfillment>;
1821
1814
  refundId?: Maybe<Scalars['ID']>;
1815
+ taxLines: Array<TaxLine>;
1816
+ taxRate: Scalars['Float'];
1817
+ /** The price of a single unit, excluding tax and discounts */
1818
+ unitPrice: Scalars['Int'];
1819
+ /** The price of a single unit, including tax but excluding discounts */
1820
+ unitPriceWithTax: Scalars['Int'];
1821
+ unitTax: Scalars['Int'];
1822
+ updatedAt: Scalars['DateTime'];
1822
1823
  };
1823
1824
  /** Returned when the maximum order size limit has been reached. */
1824
1825
  export declare type OrderLimitError = ErrorResult & {
1825
1826
  __typename?: 'OrderLimitError';
1826
1827
  errorCode: ErrorCode;
1827
- message: Scalars['String'];
1828
1828
  maxItems: Scalars['Int'];
1829
+ message: Scalars['String'];
1829
1830
  };
1830
1831
  export declare type OrderLine = Node & {
1831
1832
  __typename?: 'OrderLine';
1832
- id: Scalars['ID'];
1833
1833
  createdAt: Scalars['DateTime'];
1834
- updatedAt: Scalars['DateTime'];
1835
- productVariant: ProductVariant;
1836
- featuredAsset?: Maybe<Asset>;
1837
- /** The price of a single unit, excluding tax and discounts */
1838
- unitPrice: Scalars['Int'];
1839
- /** The price of a single unit, including tax but excluding discounts */
1840
- unitPriceWithTax: Scalars['Int'];
1841
- /** Non-zero if the unitPrice has changed since it was initially added to Order */
1842
- unitPriceChangeSinceAdded: Scalars['Int'];
1843
- /** Non-zero if the unitPriceWithTax has changed since it was initially added to Order */
1844
- unitPriceWithTaxChangeSinceAdded: Scalars['Int'];
1834
+ customFields?: Maybe<Scalars['JSON']>;
1835
+ /** The price of the line including discounts, excluding tax */
1836
+ discountedLinePrice: Scalars['Int'];
1837
+ /** The price of the line including discounts and tax */
1838
+ discountedLinePriceWithTax: Scalars['Int'];
1845
1839
  /**
1846
1840
  * The price of a single unit including discounts, excluding tax.
1847
1841
  *
@@ -1853,25 +1847,18 @@ export declare type OrderLine = Node & {
1853
1847
  discountedUnitPrice: Scalars['Int'];
1854
1848
  /** The price of a single unit including discounts and tax */
1855
1849
  discountedUnitPriceWithTax: Scalars['Int'];
1856
- /**
1857
- * The actual unit price, taking into account both item discounts _and_ prorated (proportionally-distributed)
1858
- * Order-level discounts. This value is the true economic value of the OrderItem, and is used in tax
1859
- * and refund calculations.
1860
- */
1861
- proratedUnitPrice: Scalars['Int'];
1862
- /** The proratedUnitPrice including tax */
1863
- proratedUnitPriceWithTax: Scalars['Int'];
1864
- quantity: Scalars['Int'];
1850
+ discounts: Array<Discount>;
1851
+ featuredAsset?: Maybe<Asset>;
1852
+ id: Scalars['ID'];
1865
1853
  items: Array<OrderItem>;
1866
- taxRate: Scalars['Float'];
1867
1854
  /** The total price of the line excluding tax and discounts. */
1868
1855
  linePrice: Scalars['Int'];
1869
1856
  /** The total price of the line including tax but excluding discounts. */
1870
1857
  linePriceWithTax: Scalars['Int'];
1871
- /** The price of the line including discounts, excluding tax */
1872
- discountedLinePrice: Scalars['Int'];
1873
- /** The price of the line including discounts and tax */
1874
- discountedLinePriceWithTax: Scalars['Int'];
1858
+ /** The total tax on this line */
1859
+ lineTax: Scalars['Int'];
1860
+ order: Order;
1861
+ productVariant: ProductVariant;
1875
1862
  /**
1876
1863
  * The actual line price, taking into account both item discounts _and_ prorated (proportionally-distributed)
1877
1864
  * Order-level discounts. This value is the true economic value of the OrderLine, and is used in tax
@@ -1880,12 +1867,26 @@ export declare type OrderLine = Node & {
1880
1867
  proratedLinePrice: Scalars['Int'];
1881
1868
  /** The proratedLinePrice including tax */
1882
1869
  proratedLinePriceWithTax: Scalars['Int'];
1883
- /** The total tax on this line */
1884
- lineTax: Scalars['Int'];
1885
- discounts: Array<Discount>;
1870
+ /**
1871
+ * The actual unit price, taking into account both item discounts _and_ prorated (proportionally-distributed)
1872
+ * Order-level discounts. This value is the true economic value of the OrderItem, and is used in tax
1873
+ * and refund calculations.
1874
+ */
1875
+ proratedUnitPrice: Scalars['Int'];
1876
+ /** The proratedUnitPrice including tax */
1877
+ proratedUnitPriceWithTax: Scalars['Int'];
1878
+ quantity: Scalars['Int'];
1886
1879
  taxLines: Array<TaxLine>;
1887
- order: Order;
1888
- customFields?: Maybe<Scalars['JSON']>;
1880
+ taxRate: Scalars['Float'];
1881
+ /** The price of a single unit, excluding tax and discounts */
1882
+ unitPrice: Scalars['Int'];
1883
+ /** Non-zero if the unitPrice has changed since it was initially added to Order */
1884
+ unitPriceChangeSinceAdded: Scalars['Int'];
1885
+ /** The price of a single unit, including tax but excluding discounts */
1886
+ unitPriceWithTax: Scalars['Int'];
1887
+ /** Non-zero if the unitPriceWithTax has changed since it was initially added to Order */
1888
+ unitPriceWithTaxChangeSinceAdded: Scalars['Int'];
1889
+ updatedAt: Scalars['DateTime'];
1889
1890
  };
1890
1891
  export declare type OrderList = PaginatedList & {
1891
1892
  __typename?: 'OrderList';
@@ -1893,16 +1894,16 @@ export declare type OrderList = PaginatedList & {
1893
1894
  totalItems: Scalars['Int'];
1894
1895
  };
1895
1896
  export declare type OrderListOptions = {
1896
- /** Skips the first n results, for use in pagination */
1897
- skip?: Maybe<Scalars['Int']>;
1898
- /** Takes n results, for use in pagination */
1899
- take?: Maybe<Scalars['Int']>;
1900
- /** Specifies which properties to sort the results by */
1901
- sort?: Maybe<OrderSortParameter>;
1902
1897
  /** Allows the results to be filtered */
1903
- filter?: Maybe<OrderFilterParameter>;
1898
+ filter?: InputMaybe<OrderFilterParameter>;
1904
1899
  /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
1905
- filterOperator?: Maybe<LogicalOperator>;
1900
+ filterOperator?: InputMaybe<LogicalOperator>;
1901
+ /** Skips the first n results, for use in pagination */
1902
+ skip?: InputMaybe<Scalars['Int']>;
1903
+ /** Specifies which properties to sort the results by */
1904
+ sort?: InputMaybe<OrderSortParameter>;
1905
+ /** Takes n results, for use in pagination */
1906
+ take?: InputMaybe<Scalars['Int']>;
1906
1907
  };
1907
1908
  /** Returned when attempting to modify the contents of an Order that is not in the `AddingItems` state. */
1908
1909
  export declare type OrderModificationError = ErrorResult & {
@@ -1917,28 +1918,28 @@ export declare type OrderPaymentStateError = ErrorResult & {
1917
1918
  message: Scalars['String'];
1918
1919
  };
1919
1920
  export declare type OrderSortParameter = {
1920
- id?: Maybe<SortOrder>;
1921
- createdAt?: Maybe<SortOrder>;
1922
- updatedAt?: Maybe<SortOrder>;
1923
- orderPlacedAt?: Maybe<SortOrder>;
1924
- code?: Maybe<SortOrder>;
1925
- state?: Maybe<SortOrder>;
1926
- totalQuantity?: Maybe<SortOrder>;
1927
- subTotal?: Maybe<SortOrder>;
1928
- subTotalWithTax?: Maybe<SortOrder>;
1929
- shipping?: Maybe<SortOrder>;
1930
- shippingWithTax?: Maybe<SortOrder>;
1931
- total?: Maybe<SortOrder>;
1932
- totalWithTax?: Maybe<SortOrder>;
1921
+ code?: InputMaybe<SortOrder>;
1922
+ createdAt?: InputMaybe<SortOrder>;
1923
+ id?: InputMaybe<SortOrder>;
1924
+ orderPlacedAt?: InputMaybe<SortOrder>;
1925
+ shipping?: InputMaybe<SortOrder>;
1926
+ shippingWithTax?: InputMaybe<SortOrder>;
1927
+ state?: InputMaybe<SortOrder>;
1928
+ subTotal?: InputMaybe<SortOrder>;
1929
+ subTotalWithTax?: InputMaybe<SortOrder>;
1930
+ total?: InputMaybe<SortOrder>;
1931
+ totalQuantity?: InputMaybe<SortOrder>;
1932
+ totalWithTax?: InputMaybe<SortOrder>;
1933
+ updatedAt?: InputMaybe<SortOrder>;
1933
1934
  };
1934
1935
  /** Returned if there is an error in transitioning the Order state */
1935
1936
  export declare type OrderStateTransitionError = ErrorResult & {
1936
1937
  __typename?: 'OrderStateTransitionError';
1937
1938
  errorCode: ErrorCode;
1938
- message: Scalars['String'];
1939
- transitionError: Scalars['String'];
1940
1939
  fromState: Scalars['String'];
1940
+ message: Scalars['String'];
1941
1941
  toState: Scalars['String'];
1942
+ transitionError: Scalars['String'];
1942
1943
  };
1943
1944
  /**
1944
1945
  * A summary of the taxes being applied to this order, grouped
@@ -1948,10 +1949,10 @@ export declare type OrderTaxSummary = {
1948
1949
  __typename?: 'OrderTaxSummary';
1949
1950
  /** A description of this tax */
1950
1951
  description: Scalars['String'];
1951
- /** The taxRate as a percentage */
1952
- taxRate: Scalars['Float'];
1953
1952
  /** The total net price or OrderItems to which this taxRate applies */
1954
1953
  taxBase: Scalars['Int'];
1954
+ /** The taxRate as a percentage */
1955
+ taxRate: Scalars['Float'];
1955
1956
  /** The total tax being applied to the Order at this taxRate */
1956
1957
  taxTotal: Scalars['Int'];
1957
1958
  };
@@ -1992,16 +1993,16 @@ export declare type PasswordValidationError = ErrorResult & {
1992
1993
  };
1993
1994
  export declare type Payment = Node & {
1994
1995
  __typename?: 'Payment';
1995
- id: Scalars['ID'];
1996
+ amount: Scalars['Int'];
1996
1997
  createdAt: Scalars['DateTime'];
1997
- updatedAt: Scalars['DateTime'];
1998
+ errorMessage?: Maybe<Scalars['String']>;
1999
+ id: Scalars['ID'];
2000
+ metadata?: Maybe<Scalars['JSON']>;
1998
2001
  method: Scalars['String'];
1999
- amount: Scalars['Int'];
2002
+ refunds: Array<Refund>;
2000
2003
  state: Scalars['String'];
2001
2004
  transactionId?: Maybe<Scalars['String']>;
2002
- errorMessage?: Maybe<Scalars['String']>;
2003
- refunds: Array<Refund>;
2004
- metadata?: Maybe<Scalars['JSON']>;
2005
+ updatedAt: Scalars['DateTime'];
2005
2006
  };
2006
2007
  /** Returned when a Payment is declined by the payment provider. */
2007
2008
  export declare type PaymentDeclinedError = ErrorResult & {
@@ -2019,37 +2020,37 @@ export declare type PaymentFailedError = ErrorResult & {
2019
2020
  };
2020
2021
  /** Passed as input to the `addPaymentToOrder` mutation. */
2021
2022
  export declare type PaymentInput = {
2022
- /** This field should correspond to the `code` property of a PaymentMethod. */
2023
- method: Scalars['String'];
2024
2023
  /**
2025
2024
  * This field should contain arbitrary data passed to the specified PaymentMethodHandler's `createPayment()` method
2026
2025
  * as the "metadata" argument. For example, it could contain an ID for the payment and other
2027
2026
  * data generated by the payment provider.
2028
2027
  */
2029
2028
  metadata: Scalars['JSON'];
2029
+ /** This field should correspond to the `code` property of a PaymentMethod. */
2030
+ method: Scalars['String'];
2030
2031
  };
2031
2032
  export declare type PaymentMethod = Node & {
2032
2033
  __typename?: 'PaymentMethod';
2033
- id: Scalars['ID'];
2034
- createdAt: Scalars['DateTime'];
2035
- updatedAt: Scalars['DateTime'];
2036
- name: Scalars['String'];
2034
+ checker?: Maybe<ConfigurableOperation>;
2037
2035
  code: Scalars['String'];
2036
+ createdAt: Scalars['DateTime'];
2037
+ customFields?: Maybe<Scalars['JSON']>;
2038
2038
  description: Scalars['String'];
2039
2039
  enabled: Scalars['Boolean'];
2040
- checker?: Maybe<ConfigurableOperation>;
2041
2040
  handler: ConfigurableOperation;
2042
- customFields?: Maybe<Scalars['JSON']>;
2041
+ id: Scalars['ID'];
2042
+ name: Scalars['String'];
2043
+ updatedAt: Scalars['DateTime'];
2043
2044
  };
2044
2045
  export declare type PaymentMethodQuote = {
2045
2046
  __typename?: 'PaymentMethodQuote';
2046
- id: Scalars['ID'];
2047
2047
  code: Scalars['String'];
2048
- name: Scalars['String'];
2048
+ customFields?: Maybe<Scalars['JSON']>;
2049
2049
  description: Scalars['String'];
2050
- isEligible: Scalars['Boolean'];
2051
2050
  eligibilityMessage?: Maybe<Scalars['String']>;
2052
- customFields?: Maybe<Scalars['JSON']>;
2051
+ id: Scalars['ID'];
2052
+ isEligible: Scalars['Boolean'];
2053
+ name: Scalars['String'];
2053
2054
  };
2054
2055
  /**
2055
2056
  * @description
@@ -2061,213 +2062,213 @@ export declare type PaymentMethodQuote = {
2061
2062
  export declare enum Permission {
2062
2063
  /** Authenticated means simply that the user is logged in */
2063
2064
  Authenticated = "Authenticated",
2064
- /** SuperAdmin has unrestricted access to all operations */
2065
- SuperAdmin = "SuperAdmin",
2066
- /** Owner means the user owns this entity, e.g. a Customer's own Order */
2067
- Owner = "Owner",
2068
- /** Public means any unauthenticated user may perform the operation */
2069
- Public = "Public",
2070
- /** Grants permission to update GlobalSettings */
2071
- UpdateGlobalSettings = "UpdateGlobalSettings",
2065
+ /** Grants permission to create Administrator */
2066
+ CreateAdministrator = "CreateAdministrator",
2067
+ /** Grants permission to create Asset */
2068
+ CreateAsset = "CreateAsset",
2072
2069
  /** Grants permission to create Products, Facets, Assets, Collections */
2073
2070
  CreateCatalog = "CreateCatalog",
2074
- /** Grants permission to read Products, Facets, Assets, Collections */
2075
- ReadCatalog = "ReadCatalog",
2076
- /** Grants permission to update Products, Facets, Assets, Collections */
2077
- UpdateCatalog = "UpdateCatalog",
2078
- /** Grants permission to delete Products, Facets, Assets, Collections */
2079
- DeleteCatalog = "DeleteCatalog",
2071
+ /** Grants permission to create Channel */
2072
+ CreateChannel = "CreateChannel",
2073
+ /** Grants permission to create Collection */
2074
+ CreateCollection = "CreateCollection",
2075
+ /** Grants permission to create Country */
2076
+ CreateCountry = "CreateCountry",
2077
+ /** Grants permission to create Customer */
2078
+ CreateCustomer = "CreateCustomer",
2079
+ /** Grants permission to create CustomerGroup */
2080
+ CreateCustomerGroup = "CreateCustomerGroup",
2081
+ /** Grants permission to create Facet */
2082
+ CreateFacet = "CreateFacet",
2083
+ /** Grants permission to create Order */
2084
+ CreateOrder = "CreateOrder",
2085
+ /** Grants permission to create PaymentMethod */
2086
+ CreatePaymentMethod = "CreatePaymentMethod",
2087
+ /** Grants permission to create Product */
2088
+ CreateProduct = "CreateProduct",
2089
+ /** Grants permission to create Promotion */
2090
+ CreatePromotion = "CreatePromotion",
2080
2091
  /** Grants permission to create PaymentMethods, ShippingMethods, TaxCategories, TaxRates, Zones, Countries, System & GlobalSettings */
2081
2092
  CreateSettings = "CreateSettings",
2082
- /** Grants permission to read PaymentMethods, ShippingMethods, TaxCategories, TaxRates, Zones, Countries, System & GlobalSettings */
2083
- ReadSettings = "ReadSettings",
2084
- /** Grants permission to update PaymentMethods, ShippingMethods, TaxCategories, TaxRates, Zones, Countries, System & GlobalSettings */
2085
- UpdateSettings = "UpdateSettings",
2086
- /** Grants permission to delete PaymentMethods, ShippingMethods, TaxCategories, TaxRates, Zones, Countries, System & GlobalSettings */
2087
- DeleteSettings = "DeleteSettings",
2088
- /** Grants permission to create Administrator */
2089
- CreateAdministrator = "CreateAdministrator",
2090
- /** Grants permission to read Administrator */
2091
- ReadAdministrator = "ReadAdministrator",
2092
- /** Grants permission to update Administrator */
2093
- UpdateAdministrator = "UpdateAdministrator",
2093
+ /** Grants permission to create ShippingMethod */
2094
+ CreateShippingMethod = "CreateShippingMethod",
2095
+ /** Grants permission to create System */
2096
+ CreateSystem = "CreateSystem",
2097
+ /** Grants permission to create Tag */
2098
+ CreateTag = "CreateTag",
2099
+ /** Grants permission to create TaxCategory */
2100
+ CreateTaxCategory = "CreateTaxCategory",
2101
+ /** Grants permission to create TaxRate */
2102
+ CreateTaxRate = "CreateTaxRate",
2103
+ /** Grants permission to create Zone */
2104
+ CreateZone = "CreateZone",
2094
2105
  /** Grants permission to delete Administrator */
2095
2106
  DeleteAdministrator = "DeleteAdministrator",
2096
- /** Grants permission to create Asset */
2097
- CreateAsset = "CreateAsset",
2098
- /** Grants permission to read Asset */
2099
- ReadAsset = "ReadAsset",
2100
- /** Grants permission to update Asset */
2101
- UpdateAsset = "UpdateAsset",
2102
2107
  /** Grants permission to delete Asset */
2103
2108
  DeleteAsset = "DeleteAsset",
2104
- /** Grants permission to create Channel */
2105
- CreateChannel = "CreateChannel",
2106
- /** Grants permission to read Channel */
2107
- ReadChannel = "ReadChannel",
2108
- /** Grants permission to update Channel */
2109
- UpdateChannel = "UpdateChannel",
2109
+ /** Grants permission to delete Products, Facets, Assets, Collections */
2110
+ DeleteCatalog = "DeleteCatalog",
2110
2111
  /** Grants permission to delete Channel */
2111
2112
  DeleteChannel = "DeleteChannel",
2112
- /** Grants permission to create Collection */
2113
- CreateCollection = "CreateCollection",
2114
- /** Grants permission to read Collection */
2115
- ReadCollection = "ReadCollection",
2116
- /** Grants permission to update Collection */
2117
- UpdateCollection = "UpdateCollection",
2118
2113
  /** Grants permission to delete Collection */
2119
2114
  DeleteCollection = "DeleteCollection",
2120
- /** Grants permission to create Country */
2121
- CreateCountry = "CreateCountry",
2122
- /** Grants permission to read Country */
2123
- ReadCountry = "ReadCountry",
2124
- /** Grants permission to update Country */
2125
- UpdateCountry = "UpdateCountry",
2126
2115
  /** Grants permission to delete Country */
2127
2116
  DeleteCountry = "DeleteCountry",
2128
- /** Grants permission to create Customer */
2129
- CreateCustomer = "CreateCustomer",
2130
- /** Grants permission to read Customer */
2131
- ReadCustomer = "ReadCustomer",
2132
- /** Grants permission to update Customer */
2133
- UpdateCustomer = "UpdateCustomer",
2134
2117
  /** Grants permission to delete Customer */
2135
2118
  DeleteCustomer = "DeleteCustomer",
2136
- /** Grants permission to create CustomerGroup */
2137
- CreateCustomerGroup = "CreateCustomerGroup",
2138
- /** Grants permission to read CustomerGroup */
2139
- ReadCustomerGroup = "ReadCustomerGroup",
2140
- /** Grants permission to update CustomerGroup */
2141
- UpdateCustomerGroup = "UpdateCustomerGroup",
2142
2119
  /** Grants permission to delete CustomerGroup */
2143
2120
  DeleteCustomerGroup = "DeleteCustomerGroup",
2144
- /** Grants permission to create Facet */
2145
- CreateFacet = "CreateFacet",
2146
- /** Grants permission to read Facet */
2147
- ReadFacet = "ReadFacet",
2148
- /** Grants permission to update Facet */
2149
- UpdateFacet = "UpdateFacet",
2150
2121
  /** Grants permission to delete Facet */
2151
2122
  DeleteFacet = "DeleteFacet",
2152
- /** Grants permission to create Order */
2153
- CreateOrder = "CreateOrder",
2154
- /** Grants permission to read Order */
2155
- ReadOrder = "ReadOrder",
2156
- /** Grants permission to update Order */
2157
- UpdateOrder = "UpdateOrder",
2158
2123
  /** Grants permission to delete Order */
2159
2124
  DeleteOrder = "DeleteOrder",
2160
- /** Grants permission to create PaymentMethod */
2161
- CreatePaymentMethod = "CreatePaymentMethod",
2162
- /** Grants permission to read PaymentMethod */
2163
- ReadPaymentMethod = "ReadPaymentMethod",
2164
- /** Grants permission to update PaymentMethod */
2165
- UpdatePaymentMethod = "UpdatePaymentMethod",
2166
2125
  /** Grants permission to delete PaymentMethod */
2167
2126
  DeletePaymentMethod = "DeletePaymentMethod",
2168
- /** Grants permission to create Product */
2169
- CreateProduct = "CreateProduct",
2170
- /** Grants permission to read Product */
2171
- ReadProduct = "ReadProduct",
2172
- /** Grants permission to update Product */
2173
- UpdateProduct = "UpdateProduct",
2174
2127
  /** Grants permission to delete Product */
2175
2128
  DeleteProduct = "DeleteProduct",
2176
- /** Grants permission to create Promotion */
2177
- CreatePromotion = "CreatePromotion",
2178
- /** Grants permission to read Promotion */
2179
- ReadPromotion = "ReadPromotion",
2180
- /** Grants permission to update Promotion */
2181
- UpdatePromotion = "UpdatePromotion",
2182
2129
  /** Grants permission to delete Promotion */
2183
2130
  DeletePromotion = "DeletePromotion",
2184
- /** Grants permission to create ShippingMethod */
2185
- CreateShippingMethod = "CreateShippingMethod",
2186
- /** Grants permission to read ShippingMethod */
2187
- ReadShippingMethod = "ReadShippingMethod",
2188
- /** Grants permission to update ShippingMethod */
2189
- UpdateShippingMethod = "UpdateShippingMethod",
2131
+ /** Grants permission to delete PaymentMethods, ShippingMethods, TaxCategories, TaxRates, Zones, Countries, System & GlobalSettings */
2132
+ DeleteSettings = "DeleteSettings",
2190
2133
  /** Grants permission to delete ShippingMethod */
2191
2134
  DeleteShippingMethod = "DeleteShippingMethod",
2192
- /** Grants permission to create Tag */
2193
- CreateTag = "CreateTag",
2194
- /** Grants permission to read Tag */
2195
- ReadTag = "ReadTag",
2196
- /** Grants permission to update Tag */
2197
- UpdateTag = "UpdateTag",
2135
+ /** Grants permission to delete System */
2136
+ DeleteSystem = "DeleteSystem",
2198
2137
  /** Grants permission to delete Tag */
2199
2138
  DeleteTag = "DeleteTag",
2200
- /** Grants permission to create TaxCategory */
2201
- CreateTaxCategory = "CreateTaxCategory",
2202
- /** Grants permission to read TaxCategory */
2203
- ReadTaxCategory = "ReadTaxCategory",
2204
- /** Grants permission to update TaxCategory */
2205
- UpdateTaxCategory = "UpdateTaxCategory",
2206
2139
  /** Grants permission to delete TaxCategory */
2207
2140
  DeleteTaxCategory = "DeleteTaxCategory",
2208
- /** Grants permission to create TaxRate */
2209
- CreateTaxRate = "CreateTaxRate",
2210
- /** Grants permission to read TaxRate */
2211
- ReadTaxRate = "ReadTaxRate",
2212
- /** Grants permission to update TaxRate */
2213
- UpdateTaxRate = "UpdateTaxRate",
2214
2141
  /** Grants permission to delete TaxRate */
2215
2142
  DeleteTaxRate = "DeleteTaxRate",
2216
- /** Grants permission to create System */
2217
- CreateSystem = "CreateSystem",
2143
+ /** Grants permission to delete Zone */
2144
+ DeleteZone = "DeleteZone",
2145
+ /** Owner means the user owns this entity, e.g. a Customer's own Order */
2146
+ Owner = "Owner",
2147
+ /** Public means any unauthenticated user may perform the operation */
2148
+ Public = "Public",
2149
+ /** Grants permission to read Administrator */
2150
+ ReadAdministrator = "ReadAdministrator",
2151
+ /** Grants permission to read Asset */
2152
+ ReadAsset = "ReadAsset",
2153
+ /** Grants permission to read Products, Facets, Assets, Collections */
2154
+ ReadCatalog = "ReadCatalog",
2155
+ /** Grants permission to read Channel */
2156
+ ReadChannel = "ReadChannel",
2157
+ /** Grants permission to read Collection */
2158
+ ReadCollection = "ReadCollection",
2159
+ /** Grants permission to read Country */
2160
+ ReadCountry = "ReadCountry",
2161
+ /** Grants permission to read Customer */
2162
+ ReadCustomer = "ReadCustomer",
2163
+ /** Grants permission to read CustomerGroup */
2164
+ ReadCustomerGroup = "ReadCustomerGroup",
2165
+ /** Grants permission to read Facet */
2166
+ ReadFacet = "ReadFacet",
2167
+ /** Grants permission to read Order */
2168
+ ReadOrder = "ReadOrder",
2169
+ /** Grants permission to read PaymentMethod */
2170
+ ReadPaymentMethod = "ReadPaymentMethod",
2171
+ /** Grants permission to read Product */
2172
+ ReadProduct = "ReadProduct",
2173
+ /** Grants permission to read Promotion */
2174
+ ReadPromotion = "ReadPromotion",
2175
+ /** Grants permission to read PaymentMethods, ShippingMethods, TaxCategories, TaxRates, Zones, Countries, System & GlobalSettings */
2176
+ ReadSettings = "ReadSettings",
2177
+ /** Grants permission to read ShippingMethod */
2178
+ ReadShippingMethod = "ReadShippingMethod",
2218
2179
  /** Grants permission to read System */
2219
2180
  ReadSystem = "ReadSystem",
2220
- /** Grants permission to update System */
2221
- UpdateSystem = "UpdateSystem",
2222
- /** Grants permission to delete System */
2223
- DeleteSystem = "DeleteSystem",
2224
- /** Grants permission to create Zone */
2225
- CreateZone = "CreateZone",
2181
+ /** Grants permission to read Tag */
2182
+ ReadTag = "ReadTag",
2183
+ /** Grants permission to read TaxCategory */
2184
+ ReadTaxCategory = "ReadTaxCategory",
2185
+ /** Grants permission to read TaxRate */
2186
+ ReadTaxRate = "ReadTaxRate",
2226
2187
  /** Grants permission to read Zone */
2227
2188
  ReadZone = "ReadZone",
2189
+ /** SuperAdmin has unrestricted access to all operations */
2190
+ SuperAdmin = "SuperAdmin",
2191
+ /** Grants permission to update Administrator */
2192
+ UpdateAdministrator = "UpdateAdministrator",
2193
+ /** Grants permission to update Asset */
2194
+ UpdateAsset = "UpdateAsset",
2195
+ /** Grants permission to update Products, Facets, Assets, Collections */
2196
+ UpdateCatalog = "UpdateCatalog",
2197
+ /** Grants permission to update Channel */
2198
+ UpdateChannel = "UpdateChannel",
2199
+ /** Grants permission to update Collection */
2200
+ UpdateCollection = "UpdateCollection",
2201
+ /** Grants permission to update Country */
2202
+ UpdateCountry = "UpdateCountry",
2203
+ /** Grants permission to update Customer */
2204
+ UpdateCustomer = "UpdateCustomer",
2205
+ /** Grants permission to update CustomerGroup */
2206
+ UpdateCustomerGroup = "UpdateCustomerGroup",
2207
+ /** Grants permission to update Facet */
2208
+ UpdateFacet = "UpdateFacet",
2209
+ /** Grants permission to update GlobalSettings */
2210
+ UpdateGlobalSettings = "UpdateGlobalSettings",
2211
+ /** Grants permission to update Order */
2212
+ UpdateOrder = "UpdateOrder",
2213
+ /** Grants permission to update PaymentMethod */
2214
+ UpdatePaymentMethod = "UpdatePaymentMethod",
2215
+ /** Grants permission to update Product */
2216
+ UpdateProduct = "UpdateProduct",
2217
+ /** Grants permission to update Promotion */
2218
+ UpdatePromotion = "UpdatePromotion",
2219
+ /** Grants permission to update PaymentMethods, ShippingMethods, TaxCategories, TaxRates, Zones, Countries, System & GlobalSettings */
2220
+ UpdateSettings = "UpdateSettings",
2221
+ /** Grants permission to update ShippingMethod */
2222
+ UpdateShippingMethod = "UpdateShippingMethod",
2223
+ /** Grants permission to update System */
2224
+ UpdateSystem = "UpdateSystem",
2225
+ /** Grants permission to update Tag */
2226
+ UpdateTag = "UpdateTag",
2227
+ /** Grants permission to update TaxCategory */
2228
+ UpdateTaxCategory = "UpdateTaxCategory",
2229
+ /** Grants permission to update TaxRate */
2230
+ UpdateTaxRate = "UpdateTaxRate",
2228
2231
  /** Grants permission to update Zone */
2229
- UpdateZone = "UpdateZone",
2230
- /** Grants permission to delete Zone */
2231
- DeleteZone = "DeleteZone"
2232
+ UpdateZone = "UpdateZone"
2232
2233
  }
2233
2234
  /** The price range where the result has more than one price */
2234
2235
  export declare type PriceRange = {
2235
2236
  __typename?: 'PriceRange';
2236
- min: Scalars['Int'];
2237
2237
  max: Scalars['Int'];
2238
+ min: Scalars['Int'];
2238
2239
  };
2239
2240
  export declare type Product = Node & {
2240
2241
  __typename?: 'Product';
2241
- id: Scalars['ID'];
2242
+ assets: Array<Asset>;
2243
+ collections: Array<Collection>;
2242
2244
  createdAt: Scalars['DateTime'];
2243
- updatedAt: Scalars['DateTime'];
2245
+ customFields?: Maybe<Scalars['JSON']>;
2246
+ description: Scalars['String'];
2247
+ facetValues: Array<FacetValue>;
2248
+ featuredAsset?: Maybe<Asset>;
2249
+ id: Scalars['ID'];
2244
2250
  languageCode: LanguageCode;
2245
2251
  name: Scalars['String'];
2252
+ optionGroups: Array<ProductOptionGroup>;
2246
2253
  slug: Scalars['String'];
2247
- description: Scalars['String'];
2248
- featuredAsset?: Maybe<Asset>;
2249
- assets: Array<Asset>;
2250
- /** Returns all ProductVariants */
2251
- variants: Array<ProductVariant>;
2254
+ translations: Array<ProductTranslation>;
2255
+ updatedAt: Scalars['DateTime'];
2252
2256
  /** Returns a paginated, sortable, filterable list of ProductVariants */
2253
2257
  variantList: ProductVariantList;
2254
- optionGroups: Array<ProductOptionGroup>;
2255
- facetValues: Array<FacetValue>;
2256
- translations: Array<ProductTranslation>;
2257
- collections: Array<Collection>;
2258
- customFields?: Maybe<Scalars['JSON']>;
2258
+ /** Returns all ProductVariants */
2259
+ variants: Array<ProductVariant>;
2259
2260
  };
2260
2261
  export declare type ProductVariantListArgs = {
2261
- options?: Maybe<ProductVariantListOptions>;
2262
+ options?: InputMaybe<ProductVariantListOptions>;
2262
2263
  };
2263
2264
  export declare type ProductFilterParameter = {
2264
- id?: Maybe<IdOperators>;
2265
- createdAt?: Maybe<DateOperators>;
2266
- updatedAt?: Maybe<DateOperators>;
2267
- languageCode?: Maybe<StringOperators>;
2268
- name?: Maybe<StringOperators>;
2269
- slug?: Maybe<StringOperators>;
2270
- description?: Maybe<StringOperators>;
2265
+ createdAt?: InputMaybe<DateOperators>;
2266
+ description?: InputMaybe<StringOperators>;
2267
+ id?: InputMaybe<IdOperators>;
2268
+ languageCode?: InputMaybe<StringOperators>;
2269
+ name?: InputMaybe<StringOperators>;
2270
+ slug?: InputMaybe<StringOperators>;
2271
+ updatedAt?: InputMaybe<DateOperators>;
2271
2272
  };
2272
2273
  export declare type ProductList = PaginatedList & {
2273
2274
  __typename?: 'ProductList';
@@ -2275,111 +2276,111 @@ export declare type ProductList = PaginatedList & {
2275
2276
  totalItems: Scalars['Int'];
2276
2277
  };
2277
2278
  export declare type ProductListOptions = {
2278
- /** Skips the first n results, for use in pagination */
2279
- skip?: Maybe<Scalars['Int']>;
2280
- /** Takes n results, for use in pagination */
2281
- take?: Maybe<Scalars['Int']>;
2282
- /** Specifies which properties to sort the results by */
2283
- sort?: Maybe<ProductSortParameter>;
2284
2279
  /** Allows the results to be filtered */
2285
- filter?: Maybe<ProductFilterParameter>;
2280
+ filter?: InputMaybe<ProductFilterParameter>;
2286
2281
  /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
2287
- filterOperator?: Maybe<LogicalOperator>;
2282
+ filterOperator?: InputMaybe<LogicalOperator>;
2283
+ /** Skips the first n results, for use in pagination */
2284
+ skip?: InputMaybe<Scalars['Int']>;
2285
+ /** Specifies which properties to sort the results by */
2286
+ sort?: InputMaybe<ProductSortParameter>;
2287
+ /** Takes n results, for use in pagination */
2288
+ take?: InputMaybe<Scalars['Int']>;
2288
2289
  };
2289
2290
  export declare type ProductOption = Node & {
2290
2291
  __typename?: 'ProductOption';
2291
- id: Scalars['ID'];
2292
+ code: Scalars['String'];
2292
2293
  createdAt: Scalars['DateTime'];
2293
- updatedAt: Scalars['DateTime'];
2294
+ customFields?: Maybe<Scalars['JSON']>;
2295
+ group: ProductOptionGroup;
2296
+ groupId: Scalars['ID'];
2297
+ id: Scalars['ID'];
2294
2298
  languageCode: LanguageCode;
2295
- code: Scalars['String'];
2296
2299
  name: Scalars['String'];
2297
- groupId: Scalars['ID'];
2298
- group: ProductOptionGroup;
2299
2300
  translations: Array<ProductOptionTranslation>;
2300
- customFields?: Maybe<Scalars['JSON']>;
2301
+ updatedAt: Scalars['DateTime'];
2301
2302
  };
2302
2303
  export declare type ProductOptionGroup = Node & {
2303
2304
  __typename?: 'ProductOptionGroup';
2304
- id: Scalars['ID'];
2305
+ code: Scalars['String'];
2305
2306
  createdAt: Scalars['DateTime'];
2306
- updatedAt: Scalars['DateTime'];
2307
+ customFields?: Maybe<Scalars['JSON']>;
2308
+ id: Scalars['ID'];
2307
2309
  languageCode: LanguageCode;
2308
- code: Scalars['String'];
2309
2310
  name: Scalars['String'];
2310
2311
  options: Array<ProductOption>;
2311
2312
  translations: Array<ProductOptionGroupTranslation>;
2312
- customFields?: Maybe<Scalars['JSON']>;
2313
+ updatedAt: Scalars['DateTime'];
2313
2314
  };
2314
2315
  export declare type ProductOptionGroupTranslation = {
2315
2316
  __typename?: 'ProductOptionGroupTranslation';
2316
- id: Scalars['ID'];
2317
2317
  createdAt: Scalars['DateTime'];
2318
- updatedAt: Scalars['DateTime'];
2318
+ id: Scalars['ID'];
2319
2319
  languageCode: LanguageCode;
2320
2320
  name: Scalars['String'];
2321
+ updatedAt: Scalars['DateTime'];
2321
2322
  };
2322
2323
  export declare type ProductOptionTranslation = {
2323
2324
  __typename?: 'ProductOptionTranslation';
2324
- id: Scalars['ID'];
2325
2325
  createdAt: Scalars['DateTime'];
2326
- updatedAt: Scalars['DateTime'];
2326
+ id: Scalars['ID'];
2327
2327
  languageCode: LanguageCode;
2328
2328
  name: Scalars['String'];
2329
+ updatedAt: Scalars['DateTime'];
2329
2330
  };
2330
2331
  export declare type ProductSortParameter = {
2331
- id?: Maybe<SortOrder>;
2332
- createdAt?: Maybe<SortOrder>;
2333
- updatedAt?: Maybe<SortOrder>;
2334
- name?: Maybe<SortOrder>;
2335
- slug?: Maybe<SortOrder>;
2336
- description?: Maybe<SortOrder>;
2332
+ createdAt?: InputMaybe<SortOrder>;
2333
+ description?: InputMaybe<SortOrder>;
2334
+ id?: InputMaybe<SortOrder>;
2335
+ name?: InputMaybe<SortOrder>;
2336
+ slug?: InputMaybe<SortOrder>;
2337
+ updatedAt?: InputMaybe<SortOrder>;
2337
2338
  };
2338
2339
  export declare type ProductTranslation = {
2339
2340
  __typename?: 'ProductTranslation';
2340
- id: Scalars['ID'];
2341
2341
  createdAt: Scalars['DateTime'];
2342
- updatedAt: Scalars['DateTime'];
2342
+ description: Scalars['String'];
2343
+ id: Scalars['ID'];
2343
2344
  languageCode: LanguageCode;
2344
2345
  name: Scalars['String'];
2345
2346
  slug: Scalars['String'];
2346
- description: Scalars['String'];
2347
+ updatedAt: Scalars['DateTime'];
2347
2348
  };
2348
2349
  export declare type ProductVariant = Node & {
2349
2350
  __typename?: 'ProductVariant';
2350
- id: Scalars['ID'];
2351
- product: Product;
2352
- productId: Scalars['ID'];
2351
+ assets: Array<Asset>;
2353
2352
  createdAt: Scalars['DateTime'];
2354
- updatedAt: Scalars['DateTime'];
2355
- languageCode: LanguageCode;
2356
- sku: Scalars['String'];
2357
- name: Scalars['String'];
2353
+ currencyCode: CurrencyCode;
2354
+ customFields?: Maybe<Scalars['JSON']>;
2355
+ facetValues: Array<FacetValue>;
2358
2356
  featuredAsset?: Maybe<Asset>;
2359
- assets: Array<Asset>;
2357
+ id: Scalars['ID'];
2358
+ languageCode: LanguageCode;
2359
+ name: Scalars['String'];
2360
+ options: Array<ProductOption>;
2360
2361
  price: Scalars['Int'];
2361
- currencyCode: CurrencyCode;
2362
2362
  priceWithTax: Scalars['Int'];
2363
+ product: Product;
2364
+ productId: Scalars['ID'];
2365
+ sku: Scalars['String'];
2363
2366
  stockLevel: Scalars['String'];
2364
- taxRateApplied: TaxRate;
2365
2367
  taxCategory: TaxCategory;
2366
- options: Array<ProductOption>;
2367
- facetValues: Array<FacetValue>;
2368
+ taxRateApplied: TaxRate;
2368
2369
  translations: Array<ProductVariantTranslation>;
2369
- customFields?: Maybe<Scalars['JSON']>;
2370
+ updatedAt: Scalars['DateTime'];
2370
2371
  };
2371
2372
  export declare type ProductVariantFilterParameter = {
2372
- id?: Maybe<IdOperators>;
2373
- productId?: Maybe<IdOperators>;
2374
- createdAt?: Maybe<DateOperators>;
2375
- updatedAt?: Maybe<DateOperators>;
2376
- languageCode?: Maybe<StringOperators>;
2377
- sku?: Maybe<StringOperators>;
2378
- name?: Maybe<StringOperators>;
2379
- price?: Maybe<NumberOperators>;
2380
- currencyCode?: Maybe<StringOperators>;
2381
- priceWithTax?: Maybe<NumberOperators>;
2382
- stockLevel?: Maybe<StringOperators>;
2373
+ createdAt?: InputMaybe<DateOperators>;
2374
+ currencyCode?: InputMaybe<StringOperators>;
2375
+ id?: InputMaybe<IdOperators>;
2376
+ languageCode?: InputMaybe<StringOperators>;
2377
+ name?: InputMaybe<StringOperators>;
2378
+ price?: InputMaybe<NumberOperators>;
2379
+ priceWithTax?: InputMaybe<NumberOperators>;
2380
+ productId?: InputMaybe<IdOperators>;
2381
+ sku?: InputMaybe<StringOperators>;
2382
+ stockLevel?: InputMaybe<StringOperators>;
2383
+ updatedAt?: InputMaybe<DateOperators>;
2383
2384
  };
2384
2385
  export declare type ProductVariantList = PaginatedList & {
2385
2386
  __typename?: 'ProductVariantList';
@@ -2387,50 +2388,50 @@ export declare type ProductVariantList = PaginatedList & {
2387
2388
  totalItems: Scalars['Int'];
2388
2389
  };
2389
2390
  export declare type ProductVariantListOptions = {
2390
- /** Skips the first n results, for use in pagination */
2391
- skip?: Maybe<Scalars['Int']>;
2392
- /** Takes n results, for use in pagination */
2393
- take?: Maybe<Scalars['Int']>;
2394
- /** Specifies which properties to sort the results by */
2395
- sort?: Maybe<ProductVariantSortParameter>;
2396
2391
  /** Allows the results to be filtered */
2397
- filter?: Maybe<ProductVariantFilterParameter>;
2392
+ filter?: InputMaybe<ProductVariantFilterParameter>;
2398
2393
  /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
2399
- filterOperator?: Maybe<LogicalOperator>;
2394
+ filterOperator?: InputMaybe<LogicalOperator>;
2395
+ /** Skips the first n results, for use in pagination */
2396
+ skip?: InputMaybe<Scalars['Int']>;
2397
+ /** Specifies which properties to sort the results by */
2398
+ sort?: InputMaybe<ProductVariantSortParameter>;
2399
+ /** Takes n results, for use in pagination */
2400
+ take?: InputMaybe<Scalars['Int']>;
2400
2401
  };
2401
2402
  export declare type ProductVariantSortParameter = {
2402
- id?: Maybe<SortOrder>;
2403
- productId?: Maybe<SortOrder>;
2404
- createdAt?: Maybe<SortOrder>;
2405
- updatedAt?: Maybe<SortOrder>;
2406
- sku?: Maybe<SortOrder>;
2407
- name?: Maybe<SortOrder>;
2408
- price?: Maybe<SortOrder>;
2409
- priceWithTax?: Maybe<SortOrder>;
2410
- stockLevel?: Maybe<SortOrder>;
2403
+ createdAt?: InputMaybe<SortOrder>;
2404
+ id?: InputMaybe<SortOrder>;
2405
+ name?: InputMaybe<SortOrder>;
2406
+ price?: InputMaybe<SortOrder>;
2407
+ priceWithTax?: InputMaybe<SortOrder>;
2408
+ productId?: InputMaybe<SortOrder>;
2409
+ sku?: InputMaybe<SortOrder>;
2410
+ stockLevel?: InputMaybe<SortOrder>;
2411
+ updatedAt?: InputMaybe<SortOrder>;
2411
2412
  };
2412
2413
  export declare type ProductVariantTranslation = {
2413
2414
  __typename?: 'ProductVariantTranslation';
2414
- id: Scalars['ID'];
2415
2415
  createdAt: Scalars['DateTime'];
2416
- updatedAt: Scalars['DateTime'];
2416
+ id: Scalars['ID'];
2417
2417
  languageCode: LanguageCode;
2418
2418
  name: Scalars['String'];
2419
+ updatedAt: Scalars['DateTime'];
2419
2420
  };
2420
2421
  export declare type Promotion = Node & {
2421
2422
  __typename?: 'Promotion';
2422
- id: Scalars['ID'];
2423
+ actions: Array<ConfigurableOperation>;
2424
+ conditions: Array<ConfigurableOperation>;
2425
+ couponCode?: Maybe<Scalars['String']>;
2423
2426
  createdAt: Scalars['DateTime'];
2424
- updatedAt: Scalars['DateTime'];
2425
- startsAt?: Maybe<Scalars['DateTime']>;
2427
+ customFields?: Maybe<Scalars['JSON']>;
2428
+ enabled: Scalars['Boolean'];
2426
2429
  endsAt?: Maybe<Scalars['DateTime']>;
2427
- couponCode?: Maybe<Scalars['String']>;
2428
- perCustomerUsageLimit?: Maybe<Scalars['Int']>;
2430
+ id: Scalars['ID'];
2429
2431
  name: Scalars['String'];
2430
- enabled: Scalars['Boolean'];
2431
- conditions: Array<ConfigurableOperation>;
2432
- actions: Array<ConfigurableOperation>;
2433
- customFields?: Maybe<Scalars['JSON']>;
2432
+ perCustomerUsageLimit?: Maybe<Scalars['Int']>;
2433
+ startsAt?: Maybe<Scalars['DateTime']>;
2434
+ updatedAt: Scalars['DateTime'];
2434
2435
  };
2435
2436
  export declare type PromotionList = PaginatedList & {
2436
2437
  __typename?: 'PromotionList';
@@ -2451,18 +2452,18 @@ export declare type Query = {
2451
2452
  activeOrder?: Maybe<Order>;
2452
2453
  /** An array of supported Countries */
2453
2454
  availableCountries: Array<Country>;
2454
- /** A list of Collections available to the shop */
2455
- collections: CollectionList;
2456
2455
  /** Returns a Collection either by its id or slug. If neither 'id' nor 'slug' is specified, an error will result. */
2457
2456
  collection?: Maybe<Collection>;
2458
- /** Returns a list of eligible shipping methods based on the current active Order */
2459
- eligibleShippingMethods: Array<ShippingMethodQuote>;
2457
+ /** A list of Collections available to the shop */
2458
+ collections: CollectionList;
2460
2459
  /** Returns a list of payment methods and their eligibility based on the current active Order */
2461
2460
  eligiblePaymentMethods: Array<PaymentMethodQuote>;
2462
- /** A list of Facets available to the shop */
2463
- facets: FacetList;
2461
+ /** Returns a list of eligible shipping methods based on the current active Order */
2462
+ eligibleShippingMethods: Array<ShippingMethodQuote>;
2464
2463
  /** Returns a Facet by its id */
2465
2464
  facet?: Maybe<Facet>;
2465
+ /** A list of Facets available to the shop */
2466
+ facets: FacetList;
2466
2467
  /** Returns information about the current authenticated User */
2467
2468
  me?: Maybe<CurrentUser>;
2468
2469
  /** Returns the possible next states that the activeOrder can transition to */
@@ -2486,19 +2487,19 @@ export declare type Query = {
2486
2487
  /** Search Products based on the criteria set by the `SearchInput` */
2487
2488
  search: SearchResponse;
2488
2489
  };
2489
- export declare type QueryCollectionsArgs = {
2490
- options?: Maybe<CollectionListOptions>;
2491
- };
2492
2490
  export declare type QueryCollectionArgs = {
2493
- id?: Maybe<Scalars['ID']>;
2494
- slug?: Maybe<Scalars['String']>;
2491
+ id?: InputMaybe<Scalars['ID']>;
2492
+ slug?: InputMaybe<Scalars['String']>;
2495
2493
  };
2496
- export declare type QueryFacetsArgs = {
2497
- options?: Maybe<FacetListOptions>;
2494
+ export declare type QueryCollectionsArgs = {
2495
+ options?: InputMaybe<CollectionListOptions>;
2498
2496
  };
2499
2497
  export declare type QueryFacetArgs = {
2500
2498
  id: Scalars['ID'];
2501
2499
  };
2500
+ export declare type QueryFacetsArgs = {
2501
+ options?: InputMaybe<FacetListOptions>;
2502
+ };
2502
2503
  export declare type QueryOrderArgs = {
2503
2504
  id: Scalars['ID'];
2504
2505
  };
@@ -2506,69 +2507,69 @@ export declare type QueryOrderByCodeArgs = {
2506
2507
  code: Scalars['String'];
2507
2508
  };
2508
2509
  export declare type QueryProductArgs = {
2509
- id?: Maybe<Scalars['ID']>;
2510
- slug?: Maybe<Scalars['String']>;
2510
+ id?: InputMaybe<Scalars['ID']>;
2511
+ slug?: InputMaybe<Scalars['String']>;
2511
2512
  };
2512
2513
  export declare type QueryProductsArgs = {
2513
- options?: Maybe<ProductListOptions>;
2514
+ options?: InputMaybe<ProductListOptions>;
2514
2515
  };
2515
2516
  export declare type QuerySearchArgs = {
2516
2517
  input: SearchInput;
2517
2518
  };
2518
- export declare type RefreshCustomerVerificationResult = Success | NativeAuthStrategyError;
2519
+ export declare type RefreshCustomerVerificationResult = NativeAuthStrategyError | Success;
2519
2520
  export declare type Refund = Node & {
2520
2521
  __typename?: 'Refund';
2521
- id: Scalars['ID'];
2522
+ adjustment: Scalars['Int'];
2522
2523
  createdAt: Scalars['DateTime'];
2523
- updatedAt: Scalars['DateTime'];
2524
+ id: Scalars['ID'];
2524
2525
  items: Scalars['Int'];
2525
- shipping: Scalars['Int'];
2526
- adjustment: Scalars['Int'];
2527
- total: Scalars['Int'];
2526
+ metadata?: Maybe<Scalars['JSON']>;
2528
2527
  method?: Maybe<Scalars['String']>;
2529
- state: Scalars['String'];
2530
- transactionId?: Maybe<Scalars['String']>;
2531
- reason?: Maybe<Scalars['String']>;
2532
2528
  orderItems: Array<OrderItem>;
2533
2529
  paymentId: Scalars['ID'];
2534
- metadata?: Maybe<Scalars['JSON']>;
2530
+ reason?: Maybe<Scalars['String']>;
2531
+ shipping: Scalars['Int'];
2532
+ state: Scalars['String'];
2533
+ total: Scalars['Int'];
2534
+ transactionId?: Maybe<Scalars['String']>;
2535
+ updatedAt: Scalars['DateTime'];
2535
2536
  };
2536
- export declare type RegisterCustomerAccountResult = Success | MissingPasswordError | PasswordValidationError | NativeAuthStrategyError;
2537
+ export declare type RegisterCustomerAccountResult = MissingPasswordError | NativeAuthStrategyError | PasswordValidationError | Success;
2537
2538
  export declare type RegisterCustomerInput = {
2538
2539
  emailAddress: Scalars['String'];
2539
- title?: Maybe<Scalars['String']>;
2540
- firstName?: Maybe<Scalars['String']>;
2541
- lastName?: Maybe<Scalars['String']>;
2542
- phoneNumber?: Maybe<Scalars['String']>;
2543
- password?: Maybe<Scalars['String']>;
2540
+ firstName?: InputMaybe<Scalars['String']>;
2541
+ lastName?: InputMaybe<Scalars['String']>;
2542
+ password?: InputMaybe<Scalars['String']>;
2543
+ phoneNumber?: InputMaybe<Scalars['String']>;
2544
+ title?: InputMaybe<Scalars['String']>;
2544
2545
  };
2545
2546
  export declare type RelationCustomFieldConfig = CustomField & {
2546
2547
  __typename?: 'RelationCustomFieldConfig';
2547
- name: Scalars['String'];
2548
- type: Scalars['String'];
2549
- list: Scalars['Boolean'];
2550
- label?: Maybe<Array<LocalizedString>>;
2551
2548
  description?: Maybe<Array<LocalizedString>>;
2552
- readonly?: Maybe<Scalars['Boolean']>;
2549
+ entity: Scalars['String'];
2553
2550
  internal?: Maybe<Scalars['Boolean']>;
2551
+ label?: Maybe<Array<LocalizedString>>;
2552
+ list: Scalars['Boolean'];
2553
+ name: Scalars['String'];
2554
2554
  nullable?: Maybe<Scalars['Boolean']>;
2555
- entity: Scalars['String'];
2555
+ readonly?: Maybe<Scalars['Boolean']>;
2556
2556
  scalarFields: Array<Scalars['String']>;
2557
+ type: Scalars['String'];
2557
2558
  ui?: Maybe<Scalars['JSON']>;
2558
2559
  };
2559
2560
  export declare type RemoveOrderItemsResult = Order | OrderModificationError;
2560
- export declare type RequestPasswordResetResult = Success | NativeAuthStrategyError;
2561
- export declare type RequestUpdateCustomerEmailAddressResult = Success | InvalidCredentialsError | EmailAddressConflictError | NativeAuthStrategyError;
2562
- export declare type ResetPasswordResult = CurrentUser | PasswordResetTokenInvalidError | PasswordResetTokenExpiredError | PasswordValidationError | NativeAuthStrategyError | NotVerifiedError;
2561
+ export declare type RequestPasswordResetResult = NativeAuthStrategyError | Success;
2562
+ export declare type RequestUpdateCustomerEmailAddressResult = EmailAddressConflictError | InvalidCredentialsError | NativeAuthStrategyError | Success;
2563
+ export declare type ResetPasswordResult = CurrentUser | NativeAuthStrategyError | NotVerifiedError | PasswordResetTokenExpiredError | PasswordResetTokenInvalidError | PasswordValidationError;
2563
2564
  export declare type Role = Node & {
2564
2565
  __typename?: 'Role';
2565
- id: Scalars['ID'];
2566
- createdAt: Scalars['DateTime'];
2567
- updatedAt: Scalars['DateTime'];
2566
+ channels: Array<Channel>;
2568
2567
  code: Scalars['String'];
2568
+ createdAt: Scalars['DateTime'];
2569
2569
  description: Scalars['String'];
2570
+ id: Scalars['ID'];
2570
2571
  permissions: Array<Permission>;
2571
- channels: Array<Channel>;
2572
+ updatedAt: Scalars['DateTime'];
2572
2573
  };
2573
2574
  export declare type RoleList = PaginatedList & {
2574
2575
  __typename?: 'RoleList';
@@ -2576,16 +2577,16 @@ export declare type RoleList = PaginatedList & {
2576
2577
  totalItems: Scalars['Int'];
2577
2578
  };
2578
2579
  export declare type SearchInput = {
2579
- term?: Maybe<Scalars['String']>;
2580
- facetValueIds?: Maybe<Array<Scalars['ID']>>;
2581
- facetValueOperator?: Maybe<LogicalOperator>;
2582
- facetValueFilters?: Maybe<Array<FacetValueFilterInput>>;
2583
- collectionId?: Maybe<Scalars['ID']>;
2584
- collectionSlug?: Maybe<Scalars['String']>;
2585
- groupByProduct?: Maybe<Scalars['Boolean']>;
2586
- take?: Maybe<Scalars['Int']>;
2587
- skip?: Maybe<Scalars['Int']>;
2588
- sort?: Maybe<SearchResultSortParameter>;
2580
+ collectionId?: InputMaybe<Scalars['ID']>;
2581
+ collectionSlug?: InputMaybe<Scalars['String']>;
2582
+ facetValueFilters?: InputMaybe<Array<FacetValueFilterInput>>;
2583
+ facetValueIds?: InputMaybe<Array<Scalars['ID']>>;
2584
+ facetValueOperator?: InputMaybe<LogicalOperator>;
2585
+ groupByProduct?: InputMaybe<Scalars['Boolean']>;
2586
+ skip?: InputMaybe<Scalars['Int']>;
2587
+ sort?: InputMaybe<SearchResultSortParameter>;
2588
+ take?: InputMaybe<Scalars['Int']>;
2589
+ term?: InputMaybe<Scalars['String']>;
2589
2590
  };
2590
2591
  export declare type SearchReindexResponse = {
2591
2592
  __typename?: 'SearchReindexResponse';
@@ -2593,68 +2594,68 @@ export declare type SearchReindexResponse = {
2593
2594
  };
2594
2595
  export declare type SearchResponse = {
2595
2596
  __typename?: 'SearchResponse';
2597
+ collections: Array<CollectionResult>;
2598
+ facetValues: Array<FacetValueResult>;
2596
2599
  items: Array<SearchResult>;
2597
2600
  totalItems: Scalars['Int'];
2598
- facetValues: Array<FacetValueResult>;
2599
- collections: Array<CollectionResult>;
2600
2601
  };
2601
2602
  export declare type SearchResult = {
2602
2603
  __typename?: 'SearchResult';
2603
- sku: Scalars['String'];
2604
- slug: Scalars['String'];
2605
- productId: Scalars['ID'];
2606
- productName: Scalars['String'];
2607
- productAsset?: Maybe<SearchResultAsset>;
2608
- productVariantId: Scalars['ID'];
2609
- productVariantName: Scalars['String'];
2610
- productVariantAsset?: Maybe<SearchResultAsset>;
2611
- price: SearchResultPrice;
2612
- priceWithTax: SearchResultPrice;
2604
+ /** An array of ids of the Collections in which this result appears */
2605
+ collectionIds: Array<Scalars['ID']>;
2613
2606
  currencyCode: CurrencyCode;
2614
2607
  description: Scalars['String'];
2615
2608
  facetIds: Array<Scalars['ID']>;
2616
2609
  facetValueIds: Array<Scalars['ID']>;
2617
- /** An array of ids of the Collections in which this result appears */
2618
- collectionIds: Array<Scalars['ID']>;
2610
+ price: SearchResultPrice;
2611
+ priceWithTax: SearchResultPrice;
2612
+ productAsset?: Maybe<SearchResultAsset>;
2613
+ productId: Scalars['ID'];
2614
+ productName: Scalars['String'];
2615
+ productVariantAsset?: Maybe<SearchResultAsset>;
2616
+ productVariantId: Scalars['ID'];
2617
+ productVariantName: Scalars['String'];
2619
2618
  /** A relevance score for the result. Differs between database implementations */
2620
2619
  score: Scalars['Float'];
2620
+ sku: Scalars['String'];
2621
+ slug: Scalars['String'];
2621
2622
  };
2622
2623
  export declare type SearchResultAsset = {
2623
2624
  __typename?: 'SearchResultAsset';
2625
+ focalPoint?: Maybe<Coordinate>;
2624
2626
  id: Scalars['ID'];
2625
2627
  preview: Scalars['String'];
2626
- focalPoint?: Maybe<Coordinate>;
2627
2628
  };
2628
2629
  /** The price of a search result product, either as a range or as a single price */
2629
2630
  export declare type SearchResultPrice = PriceRange | SinglePrice;
2630
2631
  export declare type SearchResultSortParameter = {
2631
- name?: Maybe<SortOrder>;
2632
- price?: Maybe<SortOrder>;
2632
+ name?: InputMaybe<SortOrder>;
2633
+ price?: InputMaybe<SortOrder>;
2633
2634
  };
2634
- export declare type SetCustomerForOrderResult = Order | AlreadyLoggedInError | EmailAddressConflictError | NoActiveOrderError;
2635
- export declare type SetOrderShippingMethodResult = Order | OrderModificationError | IneligibleShippingMethodError | NoActiveOrderError;
2635
+ export declare type SetCustomerForOrderResult = AlreadyLoggedInError | EmailAddressConflictError | NoActiveOrderError | Order;
2636
+ export declare type SetOrderShippingMethodResult = IneligibleShippingMethodError | NoActiveOrderError | Order | OrderModificationError;
2636
2637
  export declare type ShippingLine = {
2637
2638
  __typename?: 'ShippingLine';
2638
- shippingMethod: ShippingMethod;
2639
- price: Scalars['Int'];
2640
- priceWithTax: Scalars['Int'];
2641
2639
  discountedPrice: Scalars['Int'];
2642
2640
  discountedPriceWithTax: Scalars['Int'];
2643
2641
  discounts: Array<Discount>;
2642
+ price: Scalars['Int'];
2643
+ priceWithTax: Scalars['Int'];
2644
+ shippingMethod: ShippingMethod;
2644
2645
  };
2645
2646
  export declare type ShippingMethod = Node & {
2646
2647
  __typename?: 'ShippingMethod';
2647
- id: Scalars['ID'];
2648
- createdAt: Scalars['DateTime'];
2649
- updatedAt: Scalars['DateTime'];
2648
+ calculator: ConfigurableOperation;
2649
+ checker: ConfigurableOperation;
2650
2650
  code: Scalars['String'];
2651
- name: Scalars['String'];
2651
+ createdAt: Scalars['DateTime'];
2652
+ customFields?: Maybe<Scalars['JSON']>;
2652
2653
  description: Scalars['String'];
2653
2654
  fulfillmentHandlerCode: Scalars['String'];
2654
- checker: ConfigurableOperation;
2655
- calculator: ConfigurableOperation;
2655
+ id: Scalars['ID'];
2656
+ name: Scalars['String'];
2656
2657
  translations: Array<ShippingMethodTranslation>;
2657
- customFields?: Maybe<Scalars['JSON']>;
2658
+ updatedAt: Scalars['DateTime'];
2658
2659
  };
2659
2660
  export declare type ShippingMethodList = PaginatedList & {
2660
2661
  __typename?: 'ShippingMethodList';
@@ -2663,24 +2664,24 @@ export declare type ShippingMethodList = PaginatedList & {
2663
2664
  };
2664
2665
  export declare type ShippingMethodQuote = {
2665
2666
  __typename?: 'ShippingMethodQuote';
2666
- id: Scalars['ID'];
2667
- price: Scalars['Int'];
2668
- priceWithTax: Scalars['Int'];
2669
2667
  code: Scalars['String'];
2670
- name: Scalars['String'];
2668
+ customFields?: Maybe<Scalars['JSON']>;
2671
2669
  description: Scalars['String'];
2670
+ id: Scalars['ID'];
2672
2671
  /** Any optional metadata returned by the ShippingCalculator in the ShippingCalculationResult */
2673
2672
  metadata?: Maybe<Scalars['JSON']>;
2674
- customFields?: Maybe<Scalars['JSON']>;
2673
+ name: Scalars['String'];
2674
+ price: Scalars['Int'];
2675
+ priceWithTax: Scalars['Int'];
2675
2676
  };
2676
2677
  export declare type ShippingMethodTranslation = {
2677
2678
  __typename?: 'ShippingMethodTranslation';
2678
- id: Scalars['ID'];
2679
2679
  createdAt: Scalars['DateTime'];
2680
- updatedAt: Scalars['DateTime'];
2680
+ description: Scalars['String'];
2681
+ id: Scalars['ID'];
2681
2682
  languageCode: LanguageCode;
2682
2683
  name: Scalars['String'];
2683
- description: Scalars['String'];
2684
+ updatedAt: Scalars['DateTime'];
2684
2685
  };
2685
2686
  /** The price value where the result has a single price */
2686
2687
  export declare type SinglePrice = {
@@ -2693,23 +2694,23 @@ export declare enum SortOrder {
2693
2694
  }
2694
2695
  export declare type StringCustomFieldConfig = CustomField & {
2695
2696
  __typename?: 'StringCustomFieldConfig';
2696
- name: Scalars['String'];
2697
- type: Scalars['String'];
2698
- list: Scalars['Boolean'];
2699
- length?: Maybe<Scalars['Int']>;
2700
- label?: Maybe<Array<LocalizedString>>;
2701
2697
  description?: Maybe<Array<LocalizedString>>;
2702
- readonly?: Maybe<Scalars['Boolean']>;
2703
2698
  internal?: Maybe<Scalars['Boolean']>;
2699
+ label?: Maybe<Array<LocalizedString>>;
2700
+ length?: Maybe<Scalars['Int']>;
2701
+ list: Scalars['Boolean'];
2702
+ name: Scalars['String'];
2704
2703
  nullable?: Maybe<Scalars['Boolean']>;
2705
- pattern?: Maybe<Scalars['String']>;
2706
2704
  options?: Maybe<Array<StringFieldOption>>;
2705
+ pattern?: Maybe<Scalars['String']>;
2706
+ readonly?: Maybe<Scalars['Boolean']>;
2707
+ type: Scalars['String'];
2707
2708
  ui?: Maybe<Scalars['JSON']>;
2708
2709
  };
2709
2710
  export declare type StringFieldOption = {
2710
2711
  __typename?: 'StringFieldOption';
2711
- value: Scalars['String'];
2712
2712
  label?: Maybe<Array<LocalizedString>>;
2713
+ value: Scalars['String'];
2713
2714
  };
2714
2715
  /** Operators for filtering on a list of String fields */
2715
2716
  export declare type StringListOperators = {
@@ -2717,13 +2718,13 @@ export declare type StringListOperators = {
2717
2718
  };
2718
2719
  /** Operators for filtering on a String field */
2719
2720
  export declare type StringOperators = {
2720
- eq?: Maybe<Scalars['String']>;
2721
- notEq?: Maybe<Scalars['String']>;
2722
- contains?: Maybe<Scalars['String']>;
2723
- notContains?: Maybe<Scalars['String']>;
2724
- in?: Maybe<Array<Scalars['String']>>;
2725
- notIn?: Maybe<Array<Scalars['String']>>;
2726
- regex?: Maybe<Scalars['String']>;
2721
+ contains?: InputMaybe<Scalars['String']>;
2722
+ eq?: InputMaybe<Scalars['String']>;
2723
+ in?: InputMaybe<Array<Scalars['String']>>;
2724
+ notContains?: InputMaybe<Scalars['String']>;
2725
+ notEq?: InputMaybe<Scalars['String']>;
2726
+ notIn?: InputMaybe<Array<Scalars['String']>>;
2727
+ regex?: InputMaybe<Scalars['String']>;
2727
2728
  };
2728
2729
  /** Indicates that an operation succeeded, where we do not want to return any more specific information. */
2729
2730
  export declare type Success = {
@@ -2732,20 +2733,20 @@ export declare type Success = {
2732
2733
  };
2733
2734
  export declare type Surcharge = Node & {
2734
2735
  __typename?: 'Surcharge';
2735
- id: Scalars['ID'];
2736
2736
  createdAt: Scalars['DateTime'];
2737
- updatedAt: Scalars['DateTime'];
2738
2737
  description: Scalars['String'];
2739
- sku?: Maybe<Scalars['String']>;
2740
- taxLines: Array<TaxLine>;
2738
+ id: Scalars['ID'];
2741
2739
  price: Scalars['Int'];
2742
2740
  priceWithTax: Scalars['Int'];
2741
+ sku?: Maybe<Scalars['String']>;
2742
+ taxLines: Array<TaxLine>;
2743
2743
  taxRate: Scalars['Float'];
2744
+ updatedAt: Scalars['DateTime'];
2744
2745
  };
2745
2746
  export declare type Tag = Node & {
2746
2747
  __typename?: 'Tag';
2747
- id: Scalars['ID'];
2748
2748
  createdAt: Scalars['DateTime'];
2749
+ id: Scalars['ID'];
2749
2750
  updatedAt: Scalars['DateTime'];
2750
2751
  value: Scalars['String'];
2751
2752
  };
@@ -2756,12 +2757,12 @@ export declare type TagList = PaginatedList & {
2756
2757
  };
2757
2758
  export declare type TaxCategory = Node & {
2758
2759
  __typename?: 'TaxCategory';
2759
- id: Scalars['ID'];
2760
2760
  createdAt: Scalars['DateTime'];
2761
- updatedAt: Scalars['DateTime'];
2762
- name: Scalars['String'];
2763
- isDefault: Scalars['Boolean'];
2764
2761
  customFields?: Maybe<Scalars['JSON']>;
2762
+ id: Scalars['ID'];
2763
+ isDefault: Scalars['Boolean'];
2764
+ name: Scalars['String'];
2765
+ updatedAt: Scalars['DateTime'];
2765
2766
  };
2766
2767
  export declare type TaxLine = {
2767
2768
  __typename?: 'TaxLine';
@@ -2770,16 +2771,16 @@ export declare type TaxLine = {
2770
2771
  };
2771
2772
  export declare type TaxRate = Node & {
2772
2773
  __typename?: 'TaxRate';
2773
- id: Scalars['ID'];
2774
+ category: TaxCategory;
2774
2775
  createdAt: Scalars['DateTime'];
2775
- updatedAt: Scalars['DateTime'];
2776
- name: Scalars['String'];
2776
+ customFields?: Maybe<Scalars['JSON']>;
2777
+ customerGroup?: Maybe<CustomerGroup>;
2777
2778
  enabled: Scalars['Boolean'];
2779
+ id: Scalars['ID'];
2780
+ name: Scalars['String'];
2781
+ updatedAt: Scalars['DateTime'];
2778
2782
  value: Scalars['Float'];
2779
- category: TaxCategory;
2780
2783
  zone: Zone;
2781
- customerGroup?: Maybe<CustomerGroup>;
2782
- customFields?: Maybe<Scalars['JSON']>;
2783
2784
  };
2784
2785
  export declare type TaxRateList = PaginatedList & {
2785
2786
  __typename?: 'TaxRateList';
@@ -2788,56 +2789,56 @@ export declare type TaxRateList = PaginatedList & {
2788
2789
  };
2789
2790
  export declare type TextCustomFieldConfig = CustomField & {
2790
2791
  __typename?: 'TextCustomFieldConfig';
2791
- name: Scalars['String'];
2792
- type: Scalars['String'];
2793
- list: Scalars['Boolean'];
2794
- label?: Maybe<Array<LocalizedString>>;
2795
2792
  description?: Maybe<Array<LocalizedString>>;
2796
- readonly?: Maybe<Scalars['Boolean']>;
2797
2793
  internal?: Maybe<Scalars['Boolean']>;
2794
+ label?: Maybe<Array<LocalizedString>>;
2795
+ list: Scalars['Boolean'];
2796
+ name: Scalars['String'];
2798
2797
  nullable?: Maybe<Scalars['Boolean']>;
2798
+ readonly?: Maybe<Scalars['Boolean']>;
2799
+ type: Scalars['String'];
2799
2800
  ui?: Maybe<Scalars['JSON']>;
2800
2801
  };
2801
2802
  export declare type TransitionOrderToStateResult = Order | OrderStateTransitionError;
2802
2803
  export declare type UpdateAddressInput = {
2804
+ city?: InputMaybe<Scalars['String']>;
2805
+ company?: InputMaybe<Scalars['String']>;
2806
+ countryCode?: InputMaybe<Scalars['String']>;
2807
+ customFields?: InputMaybe<Scalars['JSON']>;
2808
+ defaultBillingAddress?: InputMaybe<Scalars['Boolean']>;
2809
+ defaultShippingAddress?: InputMaybe<Scalars['Boolean']>;
2810
+ fullName?: InputMaybe<Scalars['String']>;
2803
2811
  id: Scalars['ID'];
2804
- fullName?: Maybe<Scalars['String']>;
2805
- company?: Maybe<Scalars['String']>;
2806
- streetLine1?: Maybe<Scalars['String']>;
2807
- streetLine2?: Maybe<Scalars['String']>;
2808
- city?: Maybe<Scalars['String']>;
2809
- province?: Maybe<Scalars['String']>;
2810
- postalCode?: Maybe<Scalars['String']>;
2811
- countryCode?: Maybe<Scalars['String']>;
2812
- phoneNumber?: Maybe<Scalars['String']>;
2813
- defaultShippingAddress?: Maybe<Scalars['Boolean']>;
2814
- defaultBillingAddress?: Maybe<Scalars['Boolean']>;
2815
- customFields?: Maybe<Scalars['JSON']>;
2812
+ phoneNumber?: InputMaybe<Scalars['String']>;
2813
+ postalCode?: InputMaybe<Scalars['String']>;
2814
+ province?: InputMaybe<Scalars['String']>;
2815
+ streetLine1?: InputMaybe<Scalars['String']>;
2816
+ streetLine2?: InputMaybe<Scalars['String']>;
2816
2817
  };
2817
- export declare type UpdateCustomerEmailAddressResult = Success | IdentifierChangeTokenInvalidError | IdentifierChangeTokenExpiredError | NativeAuthStrategyError;
2818
+ export declare type UpdateCustomerEmailAddressResult = IdentifierChangeTokenExpiredError | IdentifierChangeTokenInvalidError | NativeAuthStrategyError | Success;
2818
2819
  export declare type UpdateCustomerInput = {
2819
- title?: Maybe<Scalars['String']>;
2820
- firstName?: Maybe<Scalars['String']>;
2821
- lastName?: Maybe<Scalars['String']>;
2822
- phoneNumber?: Maybe<Scalars['String']>;
2823
- customFields?: Maybe<Scalars['JSON']>;
2820
+ customFields?: InputMaybe<Scalars['JSON']>;
2821
+ firstName?: InputMaybe<Scalars['String']>;
2822
+ lastName?: InputMaybe<Scalars['String']>;
2823
+ phoneNumber?: InputMaybe<Scalars['String']>;
2824
+ title?: InputMaybe<Scalars['String']>;
2824
2825
  };
2825
- export declare type UpdateCustomerPasswordResult = Success | InvalidCredentialsError | PasswordValidationError | NativeAuthStrategyError;
2826
+ export declare type UpdateCustomerPasswordResult = InvalidCredentialsError | NativeAuthStrategyError | PasswordValidationError | Success;
2826
2827
  export declare type UpdateOrderInput = {
2827
- customFields?: Maybe<Scalars['JSON']>;
2828
+ customFields?: InputMaybe<Scalars['JSON']>;
2828
2829
  };
2829
- export declare type UpdateOrderItemsResult = Order | OrderModificationError | OrderLimitError | NegativeQuantityError | InsufficientStockError;
2830
+ export declare type UpdateOrderItemsResult = InsufficientStockError | NegativeQuantityError | Order | OrderLimitError | OrderModificationError;
2830
2831
  export declare type User = Node & {
2831
2832
  __typename?: 'User';
2832
- id: Scalars['ID'];
2833
+ authenticationMethods: Array<AuthenticationMethod>;
2833
2834
  createdAt: Scalars['DateTime'];
2834
- updatedAt: Scalars['DateTime'];
2835
+ customFields?: Maybe<Scalars['JSON']>;
2836
+ id: Scalars['ID'];
2835
2837
  identifier: Scalars['String'];
2836
- verified: Scalars['Boolean'];
2837
- roles: Array<Role>;
2838
2838
  lastLogin?: Maybe<Scalars['DateTime']>;
2839
- authenticationMethods: Array<AuthenticationMethod>;
2840
- customFields?: Maybe<Scalars['JSON']>;
2839
+ roles: Array<Role>;
2840
+ updatedAt: Scalars['DateTime'];
2841
+ verified: Scalars['Boolean'];
2841
2842
  };
2842
2843
  /**
2843
2844
  * Returned if the verification token (used to verify a Customer's email address) is valid, but has
@@ -2857,13 +2858,13 @@ export declare type VerificationTokenInvalidError = ErrorResult & {
2857
2858
  errorCode: ErrorCode;
2858
2859
  message: Scalars['String'];
2859
2860
  };
2860
- export declare type VerifyCustomerAccountResult = CurrentUser | VerificationTokenInvalidError | VerificationTokenExpiredError | MissingPasswordError | PasswordValidationError | PasswordAlreadySetError | NativeAuthStrategyError;
2861
+ export declare type VerifyCustomerAccountResult = CurrentUser | MissingPasswordError | NativeAuthStrategyError | PasswordAlreadySetError | PasswordValidationError | VerificationTokenExpiredError | VerificationTokenInvalidError;
2861
2862
  export declare type Zone = Node & {
2862
2863
  __typename?: 'Zone';
2863
- id: Scalars['ID'];
2864
2864
  createdAt: Scalars['DateTime'];
2865
- updatedAt: Scalars['DateTime'];
2866
- name: Scalars['String'];
2867
- members: Array<Country>;
2868
2865
  customFields?: Maybe<Scalars['JSON']>;
2866
+ id: Scalars['ID'];
2867
+ members: Array<Country>;
2868
+ name: Scalars['String'];
2869
+ updatedAt: Scalars['DateTime'];
2869
2870
  };