@stigg/node-server-sdk 0.73.0 → 0.74.0

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 (19) hide show
  1. package/dist/api/customerFragments.d.ts +0 -4
  2. package/dist/api/customerFragments.js +2 -209
  3. package/dist/api/entitlements/entitlementsApi.d.ts +2 -1
  4. package/dist/api/entitlements/entitlementsApi.js +3 -9
  5. package/dist/api/entitlements/entitlementsGql.d.ts +1 -2
  6. package/dist/api/entitlements/entitlementsGql.js +15 -19
  7. package/dist/api/generated/types.d.ts +1292 -1604
  8. package/dist/api/generated/types.js +1 -6
  9. package/dist/api/managementApi.d.ts +3 -2
  10. package/dist/api/managementApi.js +4 -20
  11. package/dist/models.d.ts +2 -5
  12. package/dist/models.js +2 -6
  13. package/dist/services/EdgeApiClient.d.ts +2 -1
  14. package/dist/services/EdgeApiClient.js +1 -1
  15. package/dist/utils/ModelMapper.d.ts +2 -1
  16. package/dist/utils/ModelMapper.js +1 -1
  17. package/package.json +2 -1
  18. package/dist/api/packagesFragments.d.ts +0 -1
  19. package/dist/api/packagesFragments.js +0 -85
package/dist/api/generated/types.d.ts CHANGED
@@ -1,5 +1,4 @@
1
1
  export declare type Maybe<T> = T | null;
2
- export declare type InputMaybe<T> = Maybe<T>;
3
2
  export declare type Exact<T extends {
4
3
  [key: string]: unknown;
5
4
  }> = {
@@ -18,8 +17,11 @@ export declare type Scalars = {
18
17
  Boolean: boolean;
19
18
  Int: number;
20
19
  Float: number;
20
+ /** Cursor for paging through collections */
21
21
  ConnectionCursor: any;
22
+ /** A date-time string at UTC, such as 2019-12-03T09:54:33Z, compliant with the date-time format. */
22
23
  DateTime: any;
24
+ /** The `JSON` scalar type represents JSON values as specified by [ECMA-404](http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf). */
23
25
  JSON: any;
24
26
  };
25
27
  /** DenyReason of get access policy */
@@ -42,37 +44,37 @@ export declare type AddCompatibleAddonsToPlanInput = {
42
44
  relationIds: Array<Scalars['String']>;
43
45
  };
44
46
  export declare type AddonCreateInput = {
45
- additionalMetaData?: InputMaybe<Scalars['JSON']>;
46
- billingId?: InputMaybe<Scalars['String']>;
47
- description?: InputMaybe<Scalars['String']>;
47
+ additionalMetaData?: Maybe<Scalars['JSON']>;
48
+ billingId?: Maybe<Scalars['String']>;
49
+ description?: Maybe<Scalars['String']>;
48
50
  displayName: Scalars['String'];
49
- environmentId?: InputMaybe<Scalars['String']>;
50
- hiddenFromWidgets?: InputMaybe<Array<WidgetType>>;
51
+ environmentId?: Maybe<Scalars['String']>;
52
+ hiddenFromWidgets?: Maybe<Array<WidgetType>>;
51
53
  productId: Scalars['String'];
52
- refId?: InputMaybe<Scalars['String']>;
53
- status?: InputMaybe<PackageStatus>;
54
+ refId?: Maybe<Scalars['String']>;
55
+ status?: Maybe<PackageStatus>;
54
56
  };
55
57
  export declare type AddonFilter = {
56
- and?: InputMaybe<Array<AddonFilter>>;
57
- billingId?: InputMaybe<StringFieldComparison>;
58
- createdAt?: InputMaybe<DateFieldComparison>;
59
- description?: InputMaybe<StringFieldComparison>;
60
- displayName?: InputMaybe<StringFieldComparison>;
61
- environmentId?: InputMaybe<StringFieldComparison>;
62
- id?: InputMaybe<StringFieldComparison>;
63
- isLatest?: InputMaybe<BooleanFieldComparison>;
64
- or?: InputMaybe<Array<AddonFilter>>;
65
- pricingType?: InputMaybe<PricingTypeFilterComparison>;
66
- productId?: InputMaybe<StringFieldComparison>;
67
- refId?: InputMaybe<StringFieldComparison>;
68
- status?: InputMaybe<PackageStatusFilterComparison>;
69
- updatedAt?: InputMaybe<DateFieldComparison>;
70
- versionNumber?: InputMaybe<IntFieldComparison>;
58
+ and?: Maybe<Array<AddonFilter>>;
59
+ billingId?: Maybe<StringFieldComparison>;
60
+ createdAt?: Maybe<DateFieldComparison>;
61
+ description?: Maybe<StringFieldComparison>;
62
+ displayName?: Maybe<StringFieldComparison>;
63
+ environmentId?: Maybe<StringFieldComparison>;
64
+ id?: Maybe<StringFieldComparison>;
65
+ isLatest?: Maybe<BooleanFieldComparison>;
66
+ or?: Maybe<Array<AddonFilter>>;
67
+ pricingType?: Maybe<PricingTypeFilterComparison>;
68
+ productId?: Maybe<StringFieldComparison>;
69
+ refId?: Maybe<StringFieldComparison>;
70
+ status?: Maybe<PackageStatusFilterComparison>;
71
+ updatedAt?: Maybe<DateFieldComparison>;
72
+ versionNumber?: Maybe<IntFieldComparison>;
71
73
  };
72
74
  export declare type AddonSort = {
73
75
  direction: SortDirection;
74
76
  field: AddonSortFields;
75
- nulls?: InputMaybe<SortNulls>;
77
+ nulls?: Maybe<SortNulls>;
76
78
  };
77
79
  export declare enum AddonSortFields {
78
80
  BillingId = "billingId",
@@ -90,22 +92,22 @@ export declare enum AddonSortFields {
90
92
  VersionNumber = "versionNumber"
91
93
  }
92
94
  export declare type AddonUpdateInput = {
93
- additionalMetaData?: InputMaybe<Scalars['JSON']>;
94
- billingId?: InputMaybe<Scalars['String']>;
95
- description?: InputMaybe<Scalars['String']>;
95
+ additionalMetaData?: Maybe<Scalars['JSON']>;
96
+ billingId?: Maybe<Scalars['String']>;
97
+ description?: Maybe<Scalars['String']>;
96
98
  displayName: Scalars['String'];
97
- hiddenFromWidgets?: InputMaybe<Array<WidgetType>>;
99
+ hiddenFromWidgets?: Maybe<Array<WidgetType>>;
98
100
  id: Scalars['String'];
99
- status?: InputMaybe<PackageStatus>;
101
+ status?: Maybe<PackageStatus>;
100
102
  };
101
103
  export declare type Address = {
102
- addressLine1?: InputMaybe<Scalars['String']>;
103
- addressLine2?: InputMaybe<Scalars['String']>;
104
- city?: InputMaybe<Scalars['String']>;
105
- country?: InputMaybe<Scalars['String']>;
106
- phoneNumber?: InputMaybe<Scalars['String']>;
107
- postalCode?: InputMaybe<Scalars['String']>;
108
- state?: InputMaybe<Scalars['String']>;
104
+ addressLine1?: Maybe<Scalars['String']>;
105
+ addressLine2?: Maybe<Scalars['String']>;
106
+ city?: Maybe<Scalars['String']>;
107
+ country?: Maybe<Scalars['String']>;
108
+ phoneNumber?: Maybe<Scalars['String']>;
109
+ postalCode?: Maybe<Scalars['String']>;
110
+ state?: Maybe<Scalars['String']>;
109
111
  };
110
112
  /** Alignment */
111
113
  export declare enum Alignment {
@@ -114,14 +116,14 @@ export declare enum Alignment {
114
116
  Right = "RIGHT"
115
117
  }
116
118
  export declare type ApiKeyFilter = {
117
- and?: InputMaybe<Array<ApiKeyFilter>>;
118
- id?: InputMaybe<StringFieldComparison>;
119
- or?: InputMaybe<Array<ApiKeyFilter>>;
119
+ and?: Maybe<Array<ApiKeyFilter>>;
120
+ id?: Maybe<StringFieldComparison>;
121
+ or?: Maybe<Array<ApiKeyFilter>>;
120
122
  };
121
123
  export declare type ApiKeySort = {
122
124
  direction: SortDirection;
123
125
  field: ApiKeySortFields;
124
- nulls?: InputMaybe<SortNulls>;
126
+ nulls?: Maybe<SortNulls>;
125
127
  };
126
128
  export declare enum ApiKeySortFields {
127
129
  Id = "id"
@@ -131,18 +133,18 @@ export declare enum ApiKeyType {
131
133
  Server = "SERVER"
132
134
  }
133
135
  export declare type ArchiveCouponInput = {
134
- environmentId?: InputMaybe<Scalars['String']>;
136
+ environmentId?: Maybe<Scalars['String']>;
135
137
  refId: Scalars['String'];
136
138
  };
137
139
  export declare type ArchivePlanInput = {
138
- environmentId?: InputMaybe<Scalars['String']>;
140
+ environmentId?: Maybe<Scalars['String']>;
139
141
  id: Scalars['String'];
140
142
  };
141
143
  export declare type AttachCustomerPaymentMethodInput = {
142
- customerId?: InputMaybe<Scalars['String']>;
143
- environmentId?: InputMaybe<Scalars['String']>;
144
+ customerId?: Maybe<Scalars['String']>;
145
+ environmentId?: Maybe<Scalars['String']>;
144
146
  paymentMethodId: Scalars['String'];
145
- refId?: InputMaybe<Scalars['String']>;
147
+ refId?: Maybe<Scalars['String']>;
146
148
  vendorIdentifier: VendorIdentifier;
147
149
  };
148
150
  export declare enum BillingAnchor {
@@ -156,20 +158,20 @@ export declare enum BillingModel {
156
158
  UsageBased = "USAGE_BASED"
157
159
  }
158
160
  export declare type BillingModelFilterComparison = {
159
- eq?: InputMaybe<BillingModel>;
160
- gt?: InputMaybe<BillingModel>;
161
- gte?: InputMaybe<BillingModel>;
162
- iLike?: InputMaybe<BillingModel>;
163
- in?: InputMaybe<Array<BillingModel>>;
164
- is?: InputMaybe<Scalars['Boolean']>;
165
- isNot?: InputMaybe<Scalars['Boolean']>;
166
- like?: InputMaybe<BillingModel>;
167
- lt?: InputMaybe<BillingModel>;
168
- lte?: InputMaybe<BillingModel>;
169
- neq?: InputMaybe<BillingModel>;
170
- notILike?: InputMaybe<BillingModel>;
171
- notIn?: InputMaybe<Array<BillingModel>>;
172
- notLike?: InputMaybe<BillingModel>;
161
+ eq?: Maybe<BillingModel>;
162
+ gt?: Maybe<BillingModel>;
163
+ gte?: Maybe<BillingModel>;
164
+ iLike?: Maybe<BillingModel>;
165
+ in?: Maybe<Array<BillingModel>>;
166
+ is?: Maybe<Scalars['Boolean']>;
167
+ isNot?: Maybe<Scalars['Boolean']>;
168
+ like?: Maybe<BillingModel>;
169
+ lt?: Maybe<BillingModel>;
170
+ lte?: Maybe<BillingModel>;
171
+ neq?: Maybe<BillingModel>;
172
+ notILike?: Maybe<BillingModel>;
173
+ notIn?: Maybe<Array<BillingModel>>;
174
+ notLike?: Maybe<BillingModel>;
173
175
  };
174
176
  /** Billing period. */
175
177
  export declare enum BillingPeriod {
@@ -177,24 +179,24 @@ export declare enum BillingPeriod {
177
179
  Monthly = "MONTHLY"
178
180
  }
179
181
  export declare type BillingPeriodFilterComparison = {
180
- eq?: InputMaybe<BillingPeriod>;
181
- gt?: InputMaybe<BillingPeriod>;
182
- gte?: InputMaybe<BillingPeriod>;
183
- iLike?: InputMaybe<BillingPeriod>;
184
- in?: InputMaybe<Array<BillingPeriod>>;
185
- is?: InputMaybe<Scalars['Boolean']>;
186
- isNot?: InputMaybe<Scalars['Boolean']>;
187
- like?: InputMaybe<BillingPeriod>;
188
- lt?: InputMaybe<BillingPeriod>;
189
- lte?: InputMaybe<BillingPeriod>;
190
- neq?: InputMaybe<BillingPeriod>;
191
- notILike?: InputMaybe<BillingPeriod>;
192
- notIn?: InputMaybe<Array<BillingPeriod>>;
193
- notLike?: InputMaybe<BillingPeriod>;
182
+ eq?: Maybe<BillingPeriod>;
183
+ gt?: Maybe<BillingPeriod>;
184
+ gte?: Maybe<BillingPeriod>;
185
+ iLike?: Maybe<BillingPeriod>;
186
+ in?: Maybe<Array<BillingPeriod>>;
187
+ is?: Maybe<Scalars['Boolean']>;
188
+ isNot?: Maybe<Scalars['Boolean']>;
189
+ like?: Maybe<BillingPeriod>;
190
+ lt?: Maybe<BillingPeriod>;
191
+ lte?: Maybe<BillingPeriod>;
192
+ neq?: Maybe<BillingPeriod>;
193
+ notILike?: Maybe<BillingPeriod>;
194
+ notIn?: Maybe<Array<BillingPeriod>>;
195
+ notLike?: Maybe<BillingPeriod>;
194
196
  };
195
197
  export declare type BooleanFieldComparison = {
196
- is?: InputMaybe<Scalars['Boolean']>;
197
- isNot?: InputMaybe<Scalars['Boolean']>;
198
+ is?: Maybe<Scalars['Boolean']>;
199
+ isNot?: Maybe<Scalars['Boolean']>;
198
200
  };
199
201
  export declare enum ChangeType {
200
202
  Added = "ADDED",
@@ -203,48 +205,48 @@ export declare enum ChangeType {
203
205
  Reordered = "REORDERED"
204
206
  }
205
207
  export declare type CheckoutOptions = {
206
- allowPromoCodes?: InputMaybe<Scalars['Boolean']>;
207
- allowTaxIdCollection?: InputMaybe<Scalars['Boolean']>;
208
+ allowPromoCodes?: Maybe<Scalars['Boolean']>;
209
+ allowTaxIdCollection?: Maybe<Scalars['Boolean']>;
208
210
  cancelUrl: Scalars['String'];
209
- collectBillingAddress?: InputMaybe<Scalars['Boolean']>;
210
- referenceId?: InputMaybe<Scalars['String']>;
211
+ collectBillingAddress?: Maybe<Scalars['Boolean']>;
212
+ referenceId?: Maybe<Scalars['String']>;
211
213
  successUrl: Scalars['String'];
212
214
  };
213
215
  export declare type CouponFilter = {
214
- and?: InputMaybe<Array<CouponFilter>>;
215
- billingId?: InputMaybe<StringFieldComparison>;
216
- createdAt?: InputMaybe<DateFieldComparison>;
217
- customers?: InputMaybe<CouponFilterCustomerFilter>;
218
- description?: InputMaybe<StringFieldComparison>;
219
- environmentId?: InputMaybe<StringFieldComparison>;
220
- id?: InputMaybe<StringFieldComparison>;
221
- name?: InputMaybe<StringFieldComparison>;
222
- or?: InputMaybe<Array<CouponFilter>>;
223
- refId?: InputMaybe<StringFieldComparison>;
224
- status?: InputMaybe<CouponStatusFilterComparison>;
225
- type?: InputMaybe<CouponTypeFilterComparison>;
226
- updatedAt?: InputMaybe<DateFieldComparison>;
216
+ and?: Maybe<Array<CouponFilter>>;
217
+ billingId?: Maybe<StringFieldComparison>;
218
+ createdAt?: Maybe<DateFieldComparison>;
219
+ customers?: Maybe<CouponFilterCustomerFilter>;
220
+ description?: Maybe<StringFieldComparison>;
221
+ environmentId?: Maybe<StringFieldComparison>;
222
+ id?: Maybe<StringFieldComparison>;
223
+ name?: Maybe<StringFieldComparison>;
224
+ or?: Maybe<Array<CouponFilter>>;
225
+ refId?: Maybe<StringFieldComparison>;
226
+ status?: Maybe<CouponStatusFilterComparison>;
227
+ type?: Maybe<CouponTypeFilterComparison>;
228
+ updatedAt?: Maybe<DateFieldComparison>;
227
229
  };
228
230
  export declare type CouponFilterCustomerFilter = {
229
- and?: InputMaybe<Array<CouponFilterCustomerFilter>>;
230
- billingId?: InputMaybe<StringFieldComparison>;
231
- createdAt?: InputMaybe<DateFieldComparison>;
232
- crmHubspotCompanyId?: InputMaybe<StringFieldComparison>;
233
- crmHubspotCompanyUrl?: InputMaybe<StringFieldComparison>;
234
- crmId?: InputMaybe<StringFieldComparison>;
235
- customerId?: InputMaybe<StringFieldComparison>;
236
- email?: InputMaybe<StringFieldComparison>;
237
- environmentId?: InputMaybe<StringFieldComparison>;
238
- id?: InputMaybe<StringFieldComparison>;
239
- name?: InputMaybe<StringFieldComparison>;
240
- or?: InputMaybe<Array<CouponFilterCustomerFilter>>;
241
- refId?: InputMaybe<StringFieldComparison>;
242
- updatedAt?: InputMaybe<DateFieldComparison>;
231
+ and?: Maybe<Array<CouponFilterCustomerFilter>>;
232
+ billingId?: Maybe<StringFieldComparison>;
233
+ createdAt?: Maybe<DateFieldComparison>;
234
+ crmHubspotCompanyId?: Maybe<StringFieldComparison>;
235
+ crmHubspotCompanyUrl?: Maybe<StringFieldComparison>;
236
+ crmId?: Maybe<StringFieldComparison>;
237
+ customerId?: Maybe<StringFieldComparison>;
238
+ email?: Maybe<StringFieldComparison>;
239
+ environmentId?: Maybe<StringFieldComparison>;
240
+ id?: Maybe<StringFieldComparison>;
241
+ name?: Maybe<StringFieldComparison>;
242
+ or?: Maybe<Array<CouponFilterCustomerFilter>>;
243
+ refId?: Maybe<StringFieldComparison>;
244
+ updatedAt?: Maybe<DateFieldComparison>;
243
245
  };
244
246
  export declare type CouponSort = {
245
247
  direction: SortDirection;
246
248
  field: CouponSortFields;
247
- nulls?: InputMaybe<SortNulls>;
249
+ nulls?: Maybe<SortNulls>;
248
250
  };
249
251
  export declare enum CouponSortFields {
250
252
  BillingId = "billingId",
@@ -264,20 +266,20 @@ export declare enum CouponStatus {
264
266
  Archived = "ARCHIVED"
265
267
  }
266
268
  export declare type CouponStatusFilterComparison = {
267
- eq?: InputMaybe<CouponStatus>;
268
- gt?: InputMaybe<CouponStatus>;
269
- gte?: InputMaybe<CouponStatus>;
270
- iLike?: InputMaybe<CouponStatus>;
271
- in?: InputMaybe<Array<CouponStatus>>;
272
- is?: InputMaybe<Scalars['Boolean']>;
273
- isNot?: InputMaybe<Scalars['Boolean']>;
274
- like?: InputMaybe<CouponStatus>;
275
- lt?: InputMaybe<CouponStatus>;
276
- lte?: InputMaybe<CouponStatus>;
277
- neq?: InputMaybe<CouponStatus>;
278
- notILike?: InputMaybe<CouponStatus>;
279
- notIn?: InputMaybe<Array<CouponStatus>>;
280
- notLike?: InputMaybe<CouponStatus>;
269
+ eq?: Maybe<CouponStatus>;
270
+ gt?: Maybe<CouponStatus>;
271
+ gte?: Maybe<CouponStatus>;
272
+ iLike?: Maybe<CouponStatus>;
273
+ in?: Maybe<Array<CouponStatus>>;
274
+ is?: Maybe<Scalars['Boolean']>;
275
+ isNot?: Maybe<Scalars['Boolean']>;
276
+ like?: Maybe<CouponStatus>;
277
+ lt?: Maybe<CouponStatus>;
278
+ lte?: Maybe<CouponStatus>;
279
+ neq?: Maybe<CouponStatus>;
280
+ notILike?: Maybe<CouponStatus>;
281
+ notIn?: Maybe<Array<CouponStatus>>;
282
+ notLike?: Maybe<CouponStatus>;
281
283
  };
282
284
  /** The type of the coupon */
283
285
  export declare enum CouponType {
@@ -285,68 +287,68 @@ export declare enum CouponType {
285
287
  Percentage = "PERCENTAGE"
286
288
  }
287
289
  export declare type CouponTypeFilterComparison = {
288
- eq?: InputMaybe<CouponType>;
289
- gt?: InputMaybe<CouponType>;
290
- gte?: InputMaybe<CouponType>;
291
- iLike?: InputMaybe<CouponType>;
292
- in?: InputMaybe<Array<CouponType>>;
293
- is?: InputMaybe<Scalars['Boolean']>;
294
- isNot?: InputMaybe<Scalars['Boolean']>;
295
- like?: InputMaybe<CouponType>;
296
- lt?: InputMaybe<CouponType>;
297
- lte?: InputMaybe<CouponType>;
298
- neq?: InputMaybe<CouponType>;
299
- notILike?: InputMaybe<CouponType>;
300
- notIn?: InputMaybe<Array<CouponType>>;
301
- notLike?: InputMaybe<CouponType>;
290
+ eq?: Maybe<CouponType>;
291
+ gt?: Maybe<CouponType>;
292
+ gte?: Maybe<CouponType>;
293
+ iLike?: Maybe<CouponType>;
294
+ in?: Maybe<Array<CouponType>>;
295
+ is?: Maybe<Scalars['Boolean']>;
296
+ isNot?: Maybe<Scalars['Boolean']>;
297
+ like?: Maybe<CouponType>;
298
+ lt?: Maybe<CouponType>;
299
+ lte?: Maybe<CouponType>;
300
+ neq?: Maybe<CouponType>;
301
+ notILike?: Maybe<CouponType>;
302
+ notIn?: Maybe<Array<CouponType>>;
303
+ notLike?: Maybe<CouponType>;
302
304
  };
303
305
  export declare type CreateCouponInput = {
304
- additionalMetaData?: InputMaybe<Scalars['JSON']>;
305
- description?: InputMaybe<Scalars['String']>;
306
+ additionalMetaData?: Maybe<Scalars['JSON']>;
307
+ description?: Maybe<Scalars['String']>;
306
308
  discountValue: Scalars['Float'];
307
- environmentId?: InputMaybe<Scalars['String']>;
309
+ environmentId?: Maybe<Scalars['String']>;
308
310
  name: Scalars['String'];
309
311
  refId: Scalars['String'];
310
312
  type: CouponType;
311
313
  };
312
314
  export declare type CreateEnvironment = {
313
- createdAt?: InputMaybe<Scalars['DateTime']>;
314
- description?: InputMaybe<Scalars['String']>;
315
- displayName?: InputMaybe<Scalars['String']>;
316
- hardenClientAccessEnabled?: InputMaybe<Scalars['Boolean']>;
317
- id?: InputMaybe<Scalars['String']>;
318
- provisionStatus?: InputMaybe<EnvironmentProvisionStatus>;
319
- slug?: InputMaybe<Scalars['String']>;
315
+ createdAt?: Maybe<Scalars['DateTime']>;
316
+ description?: Maybe<Scalars['String']>;
317
+ displayName?: Maybe<Scalars['String']>;
318
+ hardenClientAccessEnabled?: Maybe<Scalars['Boolean']>;
319
+ id?: Maybe<Scalars['String']>;
320
+ provisionStatus?: Maybe<EnvironmentProvisionStatus>;
321
+ slug?: Maybe<Scalars['String']>;
320
322
  };
321
323
  export declare type CreateEnvironmentOptions = {
322
- createDefaultProduct?: InputMaybe<Scalars['Boolean']>;
324
+ createDefaultProduct?: Maybe<Scalars['Boolean']>;
323
325
  };
324
326
  export declare type CreateExperimentInput = {
325
327
  controlGroupName: Scalars['String'];
326
- description?: InputMaybe<Scalars['String']>;
327
- environmentId?: InputMaybe<Scalars['String']>;
328
+ description?: Maybe<Scalars['String']>;
329
+ environmentId?: Maybe<Scalars['String']>;
328
330
  name: Scalars['String'];
329
331
  productId: Scalars['String'];
330
- productSettings?: InputMaybe<ProductSettingsInput>;
332
+ productSettings?: Maybe<ProductSettingsInput>;
331
333
  variantGroupName: Scalars['String'];
332
334
  variantPercentage: Scalars['Float'];
333
335
  };
334
336
  export declare type CreateHook = {
335
- createdAt?: InputMaybe<Scalars['DateTime']>;
336
- description?: InputMaybe<Scalars['String']>;
337
- endpoint?: InputMaybe<Scalars['String']>;
338
- environmentId?: InputMaybe<Scalars['String']>;
339
- eventLogTypes?: InputMaybe<Array<EventLogType>>;
340
- id?: InputMaybe<Scalars['String']>;
341
- secretKey?: InputMaybe<Scalars['String']>;
342
- status?: InputMaybe<HookStatus>;
337
+ createdAt?: Maybe<Scalars['DateTime']>;
338
+ description?: Maybe<Scalars['String']>;
339
+ endpoint?: Maybe<Scalars['String']>;
340
+ environmentId?: Maybe<Scalars['String']>;
341
+ eventLogTypes?: Maybe<Array<EventLogType>>;
342
+ id?: Maybe<Scalars['String']>;
343
+ secretKey?: Maybe<Scalars['String']>;
344
+ status?: Maybe<HookStatus>;
343
345
  };
344
346
  export declare type CreateIntegrationInput = {
345
347
  environmentId: Scalars['String'];
346
- hubspotCredentials?: InputMaybe<HubspotCredentialsInput>;
347
- stripeCredentials?: InputMaybe<StripeCredentialsInput>;
348
+ hubspotCredentials?: Maybe<HubspotCredentialsInput>;
349
+ stripeCredentials?: Maybe<StripeCredentialsInput>;
348
350
  vendorIdentifier: VendorIdentifier;
349
- zuoraCredentials?: InputMaybe<ZuoraCredentialsInput>;
351
+ zuoraCredentials?: Maybe<ZuoraCredentialsInput>;
350
352
  };
351
353
  export declare type CreateManyPackageEntitlementsInput = {
352
354
  /** Array of records to create */
@@ -358,7 +360,7 @@ export declare type CreateManyPromotionalEntitlementsInput = {
358
360
  };
359
361
  export declare type CreateOneEnvironmentInput = {
360
362
  environment: CreateEnvironment;
361
- options?: InputMaybe<CreateEnvironmentOptions>;
363
+ options?: Maybe<CreateEnvironmentOptions>;
362
364
  };
363
365
  export declare type CreateOneFeatureInput = {
364
366
  /** The record to create */
@@ -389,7 +391,6 @@ export declare enum Currency {
389
391
  Bbd = "BBD",
390
392
  Bdt = "BDT",
391
393
  Bgn = "BGN",
392
- Bhd = "BHD",
393
394
  Bif = "BIF",
394
395
  Bmd = "BMD",
395
396
  Bnd = "BND",
@@ -425,14 +426,12 @@ export declare enum Currency {
425
426
  Inr = "INR",
426
427
  Isk = "ISK",
427
428
  Jmd = "JMD",
428
- Jod = "JOD",
429
429
  Jpy = "JPY",
430
430
  Kes = "KES",
431
431
  Kgs = "KGS",
432
432
  Khr = "KHR",
433
433
  Kmf = "KMF",
434
434
  Krw = "KRW",
435
- Kwd = "KWD",
436
435
  Kyd = "KYD",
437
436
  Kzt = "KZT",
438
437
  Lbp = "LBP",
@@ -457,7 +456,6 @@ export declare enum Currency {
457
456
  Nok = "NOK",
458
457
  Npr = "NPR",
459
458
  Nzd = "NZD",
460
- Omr = "OMR",
461
459
  Pgk = "PGK",
462
460
  Php = "PHP",
463
461
  Pkr = "PKR",
@@ -479,7 +477,6 @@ export declare enum Currency {
479
477
  Szl = "SZL",
480
478
  Thb = "THB",
481
479
  Tjs = "TJS",
482
- Tnd = "TND",
483
480
  Top = "TOP",
484
481
  Try = "TRY",
485
482
  Ttd = "TTD",
@@ -501,98 +498,98 @@ export declare enum Currency {
501
498
  }
502
499
  export declare type CursorPaging = {
503
500
  /** Paginate after opaque cursor */
504
- after?: InputMaybe<Scalars['ConnectionCursor']>;
501
+ after?: Maybe<Scalars['ConnectionCursor']>;
505
502
  /** Paginate before opaque cursor */
506
- before?: InputMaybe<Scalars['ConnectionCursor']>;
503
+ before?: Maybe<Scalars['ConnectionCursor']>;
507
504
  /** Paginate first */
508
- first?: InputMaybe<Scalars['Int']>;
505
+ first?: Maybe<Scalars['Int']>;
509
506
  /** Paginate last */
510
- last?: InputMaybe<Scalars['Int']>;
507
+ last?: Maybe<Scalars['Int']>;
511
508
  };
512
509
  export declare type CustomerBillingInfo = {
513
- billingAddress?: InputMaybe<Address>;
514
- currency?: InputMaybe<Currency>;
515
- invoiceCustomFields?: InputMaybe<Scalars['JSON']>;
516
- language?: InputMaybe<Scalars['String']>;
517
- paymentMethodId?: InputMaybe<Scalars['String']>;
518
- shippingAddress?: InputMaybe<Address>;
519
- taxIds?: InputMaybe<Array<TaxExempt>>;
520
- timezone?: InputMaybe<Scalars['String']>;
510
+ billingAddress?: Maybe<Address>;
511
+ currency?: Maybe<Currency>;
512
+ invoiceCustomFields?: Maybe<Scalars['JSON']>;
513
+ language?: Maybe<Scalars['String']>;
514
+ paymentMethodId?: Maybe<Scalars['String']>;
515
+ shippingAddress?: Maybe<Address>;
516
+ taxIds?: Maybe<Array<TaxExempt>>;
517
+ timezone?: Maybe<Scalars['String']>;
521
518
  };
522
519
  export declare type CustomerFilter = {
523
- and?: InputMaybe<Array<CustomerFilter>>;
524
- billingId?: InputMaybe<StringFieldComparison>;
525
- createdAt?: InputMaybe<DateFieldComparison>;
526
- crmHubspotCompanyId?: InputMaybe<StringFieldComparison>;
527
- crmHubspotCompanyUrl?: InputMaybe<StringFieldComparison>;
528
- crmId?: InputMaybe<StringFieldComparison>;
529
- customerId?: InputMaybe<StringFieldComparison>;
530
- email?: InputMaybe<StringFieldComparison>;
531
- environmentId?: InputMaybe<StringFieldComparison>;
532
- id?: InputMaybe<StringFieldComparison>;
533
- name?: InputMaybe<StringFieldComparison>;
534
- or?: InputMaybe<Array<CustomerFilter>>;
535
- promotionalEntitlements?: InputMaybe<CustomerFilterPromotionalEntitlementFilter>;
536
- refId?: InputMaybe<StringFieldComparison>;
537
- subscriptions?: InputMaybe<CustomerFilterCustomerSubscriptionFilter>;
538
- updatedAt?: InputMaybe<DateFieldComparison>;
520
+ and?: Maybe<Array<CustomerFilter>>;
521
+ billingId?: Maybe<StringFieldComparison>;
522
+ createdAt?: Maybe<DateFieldComparison>;
523
+ crmHubspotCompanyId?: Maybe<StringFieldComparison>;
524
+ crmHubspotCompanyUrl?: Maybe<StringFieldComparison>;
525
+ crmId?: Maybe<StringFieldComparison>;
526
+ customerId?: Maybe<StringFieldComparison>;
527
+ email?: Maybe<StringFieldComparison>;
528
+ environmentId?: Maybe<StringFieldComparison>;
529
+ id?: Maybe<StringFieldComparison>;
530
+ name?: Maybe<StringFieldComparison>;
531
+ or?: Maybe<Array<CustomerFilter>>;
532
+ promotionalEntitlements?: Maybe<CustomerFilterPromotionalEntitlementFilter>;
533
+ refId?: Maybe<StringFieldComparison>;
534
+ subscriptions?: Maybe<CustomerFilterCustomerSubscriptionFilter>;
535
+ updatedAt?: Maybe<DateFieldComparison>;
539
536
  };
540
537
  export declare type CustomerFilterCustomerSubscriptionFilter = {
541
- and?: InputMaybe<Array<CustomerFilterCustomerSubscriptionFilter>>;
542
- billingId?: InputMaybe<StringFieldComparison>;
543
- cancelReason?: InputMaybe<SubscriptionCancelReasonFilterComparison>;
544
- cancellationDate?: InputMaybe<DateFieldComparison>;
545
- createdAt?: InputMaybe<DateFieldComparison>;
546
- crmId?: InputMaybe<StringFieldComparison>;
547
- crmLinkUrl?: InputMaybe<StringFieldComparison>;
548
- effectiveEndDate?: InputMaybe<DateFieldComparison>;
549
- endDate?: InputMaybe<DateFieldComparison>;
550
- environmentId?: InputMaybe<StringFieldComparison>;
551
- id?: InputMaybe<StringFieldComparison>;
552
- oldBillingId?: InputMaybe<StringFieldComparison>;
553
- or?: InputMaybe<Array<CustomerFilterCustomerSubscriptionFilter>>;
554
- pricingType?: InputMaybe<PricingTypeFilterComparison>;
555
- refId?: InputMaybe<StringFieldComparison>;
556
- startDate?: InputMaybe<DateFieldComparison>;
557
- status?: InputMaybe<SubscriptionStatusFilterComparison>;
558
- subscriptionId?: InputMaybe<StringFieldComparison>;
559
- trialEndDate?: InputMaybe<DateFieldComparison>;
538
+ and?: Maybe<Array<CustomerFilterCustomerSubscriptionFilter>>;
539
+ billingId?: Maybe<StringFieldComparison>;
540
+ cancelReason?: Maybe<SubscriptionCancelReasonFilterComparison>;
541
+ cancellationDate?: Maybe<DateFieldComparison>;
542
+ createdAt?: Maybe<DateFieldComparison>;
543
+ crmId?: Maybe<StringFieldComparison>;
544
+ crmLinkUrl?: Maybe<StringFieldComparison>;
545
+ effectiveEndDate?: Maybe<DateFieldComparison>;
546
+ endDate?: Maybe<DateFieldComparison>;
547
+ environmentId?: Maybe<StringFieldComparison>;
548
+ id?: Maybe<StringFieldComparison>;
549
+ oldBillingId?: Maybe<StringFieldComparison>;
550
+ or?: Maybe<Array<CustomerFilterCustomerSubscriptionFilter>>;
551
+ pricingType?: Maybe<PricingTypeFilterComparison>;
552
+ refId?: Maybe<StringFieldComparison>;
553
+ startDate?: Maybe<DateFieldComparison>;
554
+ status?: Maybe<SubscriptionStatusFilterComparison>;
555
+ subscriptionId?: Maybe<StringFieldComparison>;
556
+ trialEndDate?: Maybe<DateFieldComparison>;
560
557
  };
561
558
  export declare type CustomerFilterPromotionalEntitlementFilter = {
562
- and?: InputMaybe<Array<CustomerFilterPromotionalEntitlementFilter>>;
563
- createdAt?: InputMaybe<DateFieldComparison>;
564
- environmentId?: InputMaybe<StringFieldComparison>;
565
- id?: InputMaybe<StringFieldComparison>;
566
- or?: InputMaybe<Array<CustomerFilterPromotionalEntitlementFilter>>;
567
- status?: InputMaybe<PromotionalEntitlementStatusFilterComparison>;
568
- updatedAt?: InputMaybe<DateFieldComparison>;
559
+ and?: Maybe<Array<CustomerFilterPromotionalEntitlementFilter>>;
560
+ createdAt?: Maybe<DateFieldComparison>;
561
+ environmentId?: Maybe<StringFieldComparison>;
562
+ id?: Maybe<StringFieldComparison>;
563
+ or?: Maybe<Array<CustomerFilterPromotionalEntitlementFilter>>;
564
+ status?: Maybe<PromotionalEntitlementStatusFilterComparison>;
565
+ updatedAt?: Maybe<DateFieldComparison>;
569
566
  };
570
567
  export declare type CustomerInput = {
571
- additionalMetaData?: InputMaybe<Scalars['JSON']>;
572
- billingId?: InputMaybe<Scalars['String']>;
573
- billingInformation?: InputMaybe<CustomerBillingInfo>;
574
- couponRefId?: InputMaybe<Scalars['String']>;
575
- createdAt?: InputMaybe<Scalars['DateTime']>;
576
- crmId?: InputMaybe<Scalars['String']>;
577
- customerId?: InputMaybe<Scalars['String']>;
578
- email?: InputMaybe<Scalars['String']>;
579
- environmentId?: InputMaybe<Scalars['String']>;
580
- name?: InputMaybe<Scalars['String']>;
581
- refId?: InputMaybe<Scalars['String']>;
582
- shouldSyncFree?: InputMaybe<Scalars['Boolean']>;
568
+ additionalMetaData?: Maybe<Scalars['JSON']>;
569
+ billingId?: Maybe<Scalars['String']>;
570
+ billingInformation?: Maybe<CustomerBillingInfo>;
571
+ couponRefId?: Maybe<Scalars['String']>;
572
+ createdAt?: Maybe<Scalars['DateTime']>;
573
+ crmId?: Maybe<Scalars['String']>;
574
+ customerId?: Maybe<Scalars['String']>;
575
+ email?: Maybe<Scalars['String']>;
576
+ environmentId?: Maybe<Scalars['String']>;
577
+ name?: Maybe<Scalars['String']>;
578
+ refId?: Maybe<Scalars['String']>;
579
+ shouldSyncFree?: Maybe<Scalars['Boolean']>;
583
580
  };
584
581
  export declare type CustomerPortalColorsPaletteInput = {
585
- backgroundColor?: InputMaybe<Scalars['String']>;
586
- borderColor?: InputMaybe<Scalars['String']>;
587
- currentPlanBackground?: InputMaybe<Scalars['String']>;
588
- iconsColor?: InputMaybe<Scalars['String']>;
589
- paywallBackgroundColor?: InputMaybe<Scalars['String']>;
590
- primary?: InputMaybe<Scalars['String']>;
591
- textColor?: InputMaybe<Scalars['String']>;
582
+ backgroundColor?: Maybe<Scalars['String']>;
583
+ borderColor?: Maybe<Scalars['String']>;
584
+ currentPlanBackground?: Maybe<Scalars['String']>;
585
+ iconsColor?: Maybe<Scalars['String']>;
586
+ paywallBackgroundColor?: Maybe<Scalars['String']>;
587
+ primary?: Maybe<Scalars['String']>;
588
+ textColor?: Maybe<Scalars['String']>;
592
589
  };
593
590
  export declare type CustomerPortalConfigurationInput = {
594
- palette?: InputMaybe<CustomerPortalColorsPaletteInput>;
595
- typography?: InputMaybe<TypographyConfigurationInput>;
591
+ palette?: Maybe<CustomerPortalColorsPaletteInput>;
592
+ typography?: Maybe<TypographyConfigurationInput>;
596
593
  };
597
594
  export declare type CustomerPortalInput = {
598
595
  customerId: Scalars['String'];
@@ -600,7 +597,7 @@ export declare type CustomerPortalInput = {
600
597
  export declare type CustomerSort = {
601
598
  direction: SortDirection;
602
599
  field: CustomerSortFields;
603
- nulls?: InputMaybe<SortNulls>;
600
+ nulls?: Maybe<SortNulls>;
604
601
  };
605
602
  export declare enum CustomerSortFields {
606
603
  BillingId = "billingId",
@@ -617,75 +614,75 @@ export declare enum CustomerSortFields {
617
614
  UpdatedAt = "updatedAt"
618
615
  }
619
616
  export declare type CustomerSubscriptionFilter = {
620
- addons?: InputMaybe<CustomerSubscriptionFilterSubscriptionAddonFilter>;
621
- and?: InputMaybe<Array<CustomerSubscriptionFilter>>;
622
- billingId?: InputMaybe<StringFieldComparison>;
623
- cancelReason?: InputMaybe<SubscriptionCancelReasonFilterComparison>;
624
- cancellationDate?: InputMaybe<DateFieldComparison>;
625
- createdAt?: InputMaybe<DateFieldComparison>;
626
- crmId?: InputMaybe<StringFieldComparison>;
627
- crmLinkUrl?: InputMaybe<StringFieldComparison>;
628
- customer?: InputMaybe<CustomerSubscriptionFilterCustomerFilter>;
629
- effectiveEndDate?: InputMaybe<DateFieldComparison>;
630
- endDate?: InputMaybe<DateFieldComparison>;
631
- environmentId?: InputMaybe<StringFieldComparison>;
632
- id?: InputMaybe<StringFieldComparison>;
633
- oldBillingId?: InputMaybe<StringFieldComparison>;
634
- or?: InputMaybe<Array<CustomerSubscriptionFilter>>;
635
- prices?: InputMaybe<CustomerSubscriptionFilterSubscriptionPriceFilter>;
636
- pricingType?: InputMaybe<PricingTypeFilterComparison>;
637
- refId?: InputMaybe<StringFieldComparison>;
638
- startDate?: InputMaybe<DateFieldComparison>;
639
- status?: InputMaybe<SubscriptionStatusFilterComparison>;
640
- subscriptionEntitlements?: InputMaybe<CustomerSubscriptionFilterSubscriptionEntitlementFilter>;
641
- subscriptionId?: InputMaybe<StringFieldComparison>;
642
- trialEndDate?: InputMaybe<DateFieldComparison>;
617
+ addons?: Maybe<CustomerSubscriptionFilterSubscriptionAddonFilter>;
618
+ and?: Maybe<Array<CustomerSubscriptionFilter>>;
619
+ billingId?: Maybe<StringFieldComparison>;
620
+ cancelReason?: Maybe<SubscriptionCancelReasonFilterComparison>;
621
+ cancellationDate?: Maybe<DateFieldComparison>;
622
+ createdAt?: Maybe<DateFieldComparison>;
623
+ crmId?: Maybe<StringFieldComparison>;
624
+ crmLinkUrl?: Maybe<StringFieldComparison>;
625
+ customer?: Maybe<CustomerSubscriptionFilterCustomerFilter>;
626
+ effectiveEndDate?: Maybe<DateFieldComparison>;
627
+ endDate?: Maybe<DateFieldComparison>;
628
+ environmentId?: Maybe<StringFieldComparison>;
629
+ id?: Maybe<StringFieldComparison>;
630
+ oldBillingId?: Maybe<StringFieldComparison>;
631
+ or?: Maybe<Array<CustomerSubscriptionFilter>>;
632
+ prices?: Maybe<CustomerSubscriptionFilterSubscriptionPriceFilter>;
633
+ pricingType?: Maybe<PricingTypeFilterComparison>;
634
+ refId?: Maybe<StringFieldComparison>;
635
+ startDate?: Maybe<DateFieldComparison>;
636
+ status?: Maybe<SubscriptionStatusFilterComparison>;
637
+ subscriptionEntitlements?: Maybe<CustomerSubscriptionFilterSubscriptionEntitlementFilter>;
638
+ subscriptionId?: Maybe<StringFieldComparison>;
639
+ trialEndDate?: Maybe<DateFieldComparison>;
643
640
  };
644
641
  export declare type CustomerSubscriptionFilterCustomerFilter = {
645
- and?: InputMaybe<Array<CustomerSubscriptionFilterCustomerFilter>>;
646
- billingId?: InputMaybe<StringFieldComparison>;
647
- createdAt?: InputMaybe<DateFieldComparison>;
648
- crmHubspotCompanyId?: InputMaybe<StringFieldComparison>;
649
- crmHubspotCompanyUrl?: InputMaybe<StringFieldComparison>;
650
- crmId?: InputMaybe<StringFieldComparison>;
651
- customerId?: InputMaybe<StringFieldComparison>;
652
- email?: InputMaybe<StringFieldComparison>;
653
- environmentId?: InputMaybe<StringFieldComparison>;
654
- id?: InputMaybe<StringFieldComparison>;
655
- name?: InputMaybe<StringFieldComparison>;
656
- or?: InputMaybe<Array<CustomerSubscriptionFilterCustomerFilter>>;
657
- refId?: InputMaybe<StringFieldComparison>;
658
- updatedAt?: InputMaybe<DateFieldComparison>;
642
+ and?: Maybe<Array<CustomerSubscriptionFilterCustomerFilter>>;
643
+ billingId?: Maybe<StringFieldComparison>;
644
+ createdAt?: Maybe<DateFieldComparison>;
645
+ crmHubspotCompanyId?: Maybe<StringFieldComparison>;
646
+ crmHubspotCompanyUrl?: Maybe<StringFieldComparison>;
647
+ crmId?: Maybe<StringFieldComparison>;
648
+ customerId?: Maybe<StringFieldComparison>;
649
+ email?: Maybe<StringFieldComparison>;
650
+ environmentId?: Maybe<StringFieldComparison>;
651
+ id?: Maybe<StringFieldComparison>;
652
+ name?: Maybe<StringFieldComparison>;
653
+ or?: Maybe<Array<CustomerSubscriptionFilterCustomerFilter>>;
654
+ refId?: Maybe<StringFieldComparison>;
655
+ updatedAt?: Maybe<DateFieldComparison>;
659
656
  };
660
657
  export declare type CustomerSubscriptionFilterSubscriptionAddonFilter = {
661
- and?: InputMaybe<Array<CustomerSubscriptionFilterSubscriptionAddonFilter>>;
662
- createdAt?: InputMaybe<DateFieldComparison>;
663
- id?: InputMaybe<StringFieldComparison>;
664
- or?: InputMaybe<Array<CustomerSubscriptionFilterSubscriptionAddonFilter>>;
665
- quantity?: InputMaybe<NumberFieldComparison>;
666
- updatedAt?: InputMaybe<DateFieldComparison>;
658
+ and?: Maybe<Array<CustomerSubscriptionFilterSubscriptionAddonFilter>>;
659
+ createdAt?: Maybe<DateFieldComparison>;
660
+ id?: Maybe<StringFieldComparison>;
661
+ or?: Maybe<Array<CustomerSubscriptionFilterSubscriptionAddonFilter>>;
662
+ quantity?: Maybe<NumberFieldComparison>;
663
+ updatedAt?: Maybe<DateFieldComparison>;
667
664
  };
668
665
  export declare type CustomerSubscriptionFilterSubscriptionEntitlementFilter = {
669
- and?: InputMaybe<Array<CustomerSubscriptionFilterSubscriptionEntitlementFilter>>;
670
- createdAt?: InputMaybe<DateFieldComparison>;
671
- environmentId?: InputMaybe<StringFieldComparison>;
672
- id?: InputMaybe<StringFieldComparison>;
673
- or?: InputMaybe<Array<CustomerSubscriptionFilterSubscriptionEntitlementFilter>>;
674
- subscriptionId?: InputMaybe<StringFieldComparison>;
675
- updatedAt?: InputMaybe<DateFieldComparison>;
666
+ and?: Maybe<Array<CustomerSubscriptionFilterSubscriptionEntitlementFilter>>;
667
+ createdAt?: Maybe<DateFieldComparison>;
668
+ environmentId?: Maybe<StringFieldComparison>;
669
+ id?: Maybe<StringFieldComparison>;
670
+ or?: Maybe<Array<CustomerSubscriptionFilterSubscriptionEntitlementFilter>>;
671
+ subscriptionId?: Maybe<StringFieldComparison>;
672
+ updatedAt?: Maybe<DateFieldComparison>;
676
673
  };
677
674
  export declare type CustomerSubscriptionFilterSubscriptionPriceFilter = {
678
- and?: InputMaybe<Array<CustomerSubscriptionFilterSubscriptionPriceFilter>>;
679
- createdAt?: InputMaybe<DateFieldComparison>;
680
- id?: InputMaybe<StringFieldComparison>;
681
- or?: InputMaybe<Array<CustomerSubscriptionFilterSubscriptionPriceFilter>>;
682
- updatedAt?: InputMaybe<DateFieldComparison>;
683
- usageLimit?: InputMaybe<NumberFieldComparison>;
675
+ and?: Maybe<Array<CustomerSubscriptionFilterSubscriptionPriceFilter>>;
676
+ createdAt?: Maybe<DateFieldComparison>;
677
+ id?: Maybe<StringFieldComparison>;
678
+ or?: Maybe<Array<CustomerSubscriptionFilterSubscriptionPriceFilter>>;
679
+ updatedAt?: Maybe<DateFieldComparison>;
680
+ usageLimit?: Maybe<NumberFieldComparison>;
684
681
  };
685
682
  export declare type CustomerSubscriptionSort = {
686
683
  direction: SortDirection;
687
684
  field: CustomerSubscriptionSortFields;
688
- nulls?: InputMaybe<SortNulls>;
685
+ nulls?: Maybe<SortNulls>;
689
686
  };
690
687
  export declare enum CustomerSubscriptionSortFields {
691
688
  BillingId = "billingId",
@@ -707,33 +704,33 @@ export declare enum CustomerSubscriptionSortFields {
707
704
  TrialEndDate = "trialEndDate"
708
705
  }
709
706
  export declare type DateFieldComparison = {
710
- between?: InputMaybe<DateFieldComparisonBetween>;
711
- eq?: InputMaybe<Scalars['DateTime']>;
712
- gt?: InputMaybe<Scalars['DateTime']>;
713
- gte?: InputMaybe<Scalars['DateTime']>;
714
- in?: InputMaybe<Array<Scalars['DateTime']>>;
715
- is?: InputMaybe<Scalars['Boolean']>;
716
- isNot?: InputMaybe<Scalars['Boolean']>;
717
- lt?: InputMaybe<Scalars['DateTime']>;
718
- lte?: InputMaybe<Scalars['DateTime']>;
719
- neq?: InputMaybe<Scalars['DateTime']>;
720
- notBetween?: InputMaybe<DateFieldComparisonBetween>;
721
- notIn?: InputMaybe<Array<Scalars['DateTime']>>;
707
+ between?: Maybe<DateFieldComparisonBetween>;
708
+ eq?: Maybe<Scalars['DateTime']>;
709
+ gt?: Maybe<Scalars['DateTime']>;
710
+ gte?: Maybe<Scalars['DateTime']>;
711
+ in?: Maybe<Array<Scalars['DateTime']>>;
712
+ is?: Maybe<Scalars['Boolean']>;
713
+ isNot?: Maybe<Scalars['Boolean']>;
714
+ lt?: Maybe<Scalars['DateTime']>;
715
+ lte?: Maybe<Scalars['DateTime']>;
716
+ neq?: Maybe<Scalars['DateTime']>;
717
+ notBetween?: Maybe<DateFieldComparisonBetween>;
718
+ notIn?: Maybe<Array<Scalars['DateTime']>>;
722
719
  };
723
720
  export declare type DateFieldComparisonBetween = {
724
721
  lower: Scalars['DateTime'];
725
722
  upper: Scalars['DateTime'];
726
723
  };
727
724
  export declare type DefaultTrialConfigInputDto = {
728
- duration?: InputMaybe<Scalars['Float']>;
729
- units?: InputMaybe<TrialPeriodUnits>;
725
+ duration?: Maybe<Scalars['Float']>;
726
+ units?: Maybe<TrialPeriodUnits>;
730
727
  };
731
728
  export declare type DeleteCustomerInput = {
732
- environmentId?: InputMaybe<Scalars['String']>;
729
+ environmentId?: Maybe<Scalars['String']>;
733
730
  id: Scalars['String'];
734
731
  };
735
732
  export declare type DeleteFeatureInput = {
736
- environmentId?: InputMaybe<Scalars['String']>;
733
+ environmentId?: Maybe<Scalars['String']>;
737
734
  id: Scalars['String'];
738
735
  };
739
736
  export declare type DeleteOneAddonInput = {
@@ -775,25 +772,25 @@ export declare type DiscardPackageDraftInput = {
775
772
  export declare type EntitlementCheckRequested = {
776
773
  customerId: Scalars['String'];
777
774
  entitlementCheckResult: EntitlementCheckResult;
778
- environmentId?: InputMaybe<Scalars['String']>;
775
+ environmentId?: Maybe<Scalars['String']>;
779
776
  featureId: Scalars['String'];
780
- requestedUsage?: InputMaybe<Scalars['Float']>;
777
+ requestedUsage?: Maybe<Scalars['Float']>;
781
778
  };
782
779
  export declare type EntitlementCheckResult = {
783
- accessDeniedReason?: InputMaybe<AccessDeniedReason>;
784
- currentUsage?: InputMaybe<Scalars['Float']>;
780
+ accessDeniedReason?: Maybe<AccessDeniedReason>;
781
+ currentUsage?: Maybe<Scalars['Float']>;
785
782
  hasAccess: Scalars['Boolean'];
786
- hasUnlimitedUsage?: InputMaybe<Scalars['Boolean']>;
787
- monthlyResetPeriodConfiguration?: InputMaybe<MonthlyResetPeriodConfigInput>;
788
- nextResetDate?: InputMaybe<Scalars['DateTime']>;
789
- requestedUsage?: InputMaybe<Scalars['Float']>;
790
- resetPeriod?: InputMaybe<EntitlementResetPeriod>;
791
- usageLimit?: InputMaybe<Scalars['Float']>;
792
- weeklyResetPeriodConfiguration?: InputMaybe<WeeklyResetPeriodConfigInput>;
783
+ hasUnlimitedUsage?: Maybe<Scalars['Boolean']>;
784
+ monthlyResetPeriodConfiguration?: Maybe<MonthlyResetPeriodConfigInput>;
785
+ nextResetDate?: Maybe<Scalars['DateTime']>;
786
+ requestedUsage?: Maybe<Scalars['Float']>;
787
+ resetPeriod?: Maybe<EntitlementResetPeriod>;
788
+ usageLimit?: Maybe<Scalars['Float']>;
789
+ weeklyResetPeriodConfiguration?: Maybe<WeeklyResetPeriodConfigInput>;
793
790
  };
794
791
  export declare type EntitlementOptions = {
795
- requestedUsage?: InputMaybe<Scalars['Float']>;
796
- shouldTrack?: InputMaybe<Scalars['Boolean']>;
792
+ requestedUsage?: Maybe<Scalars['Float']>;
793
+ shouldTrack?: Maybe<Scalars['Boolean']>;
797
794
  };
798
795
  /** Entitlement reset period. */
799
796
  export declare enum EntitlementResetPeriod {
@@ -807,12 +804,12 @@ export declare enum EntitySelectionMode {
807
804
  WhiteList = "WHITE_LIST"
808
805
  }
809
806
  export declare type EnvironmentFilter = {
810
- and?: InputMaybe<Array<EnvironmentFilter>>;
811
- createdAt?: InputMaybe<DateFieldComparison>;
812
- displayName?: InputMaybe<StringFieldComparison>;
813
- id?: InputMaybe<StringFieldComparison>;
814
- or?: InputMaybe<Array<EnvironmentFilter>>;
815
- slug?: InputMaybe<StringFieldComparison>;
807
+ and?: Maybe<Array<EnvironmentFilter>>;
808
+ createdAt?: Maybe<DateFieldComparison>;
809
+ displayName?: Maybe<StringFieldComparison>;
810
+ id?: Maybe<StringFieldComparison>;
811
+ or?: Maybe<Array<EnvironmentFilter>>;
812
+ slug?: Maybe<StringFieldComparison>;
816
813
  };
817
814
  /** EnvironmentProvisionStatus. */
818
815
  export declare enum EnvironmentProvisionStatus {
@@ -824,7 +821,7 @@ export declare enum EnvironmentProvisionStatus {
824
821
  export declare type EnvironmentSort = {
825
822
  direction: SortDirection;
826
823
  field: EnvironmentSortFields;
827
- nulls?: InputMaybe<SortNulls>;
824
+ nulls?: Maybe<SortNulls>;
828
825
  };
829
826
  export declare enum EnvironmentSortFields {
830
827
  CreatedAt = "createdAt",
@@ -920,22 +917,22 @@ export declare enum ErrorCode {
920
917
  UnsupportedVendorIdentifier = "UnsupportedVendorIdentifier"
921
918
  }
922
919
  export declare type EstimateSubscriptionInput = {
923
- addons?: InputMaybe<Array<SubscriptionAddonInput>>;
924
- billingInformation?: InputMaybe<SubscriptionBillingInfo>;
925
- billingPeriod?: InputMaybe<BillingPeriod>;
920
+ addons?: Maybe<Array<SubscriptionAddonInput>>;
921
+ billingInformation?: Maybe<SubscriptionBillingInfo>;
922
+ billingPeriod?: Maybe<BillingPeriod>;
926
923
  customerId: Scalars['String'];
927
- environmentId?: InputMaybe<Scalars['String']>;
924
+ environmentId?: Maybe<Scalars['String']>;
928
925
  planId: Scalars['String'];
929
- priceUnitAmount?: InputMaybe<Scalars['Float']>;
930
- promotionCode?: InputMaybe<Scalars['String']>;
931
- startDate?: InputMaybe<Scalars['DateTime']>;
926
+ priceUnitAmount?: Maybe<Scalars['Float']>;
927
+ promotionCode?: Maybe<Scalars['String']>;
928
+ startDate?: Maybe<Scalars['DateTime']>;
932
929
  };
933
930
  export declare type EstimateSubscriptionUpdateInput = {
934
- addons?: InputMaybe<Array<SubscriptionAddonInput>>;
935
- environmentId?: InputMaybe<Scalars['String']>;
936
- promotionCode?: InputMaybe<Scalars['String']>;
931
+ addons?: Maybe<Array<SubscriptionAddonInput>>;
932
+ environmentId?: Maybe<Scalars['String']>;
933
+ promotionCode?: Maybe<Scalars['String']>;
937
934
  subscriptionId: Scalars['String'];
938
- unitQuantity?: InputMaybe<Scalars['Float']>;
935
+ unitQuantity?: Maybe<Scalars['Float']>;
939
936
  };
940
937
  /** EventLogType */
941
938
  export declare enum EventLogType {
@@ -987,37 +984,37 @@ export declare enum EventLogType {
987
984
  WidgetConfigurationUpdated = "WIDGET_CONFIGURATION_UPDATED"
988
985
  }
989
986
  export declare type ExperimentFilter = {
990
- and?: InputMaybe<Array<ExperimentFilter>>;
991
- createdAt?: InputMaybe<DateFieldComparison>;
992
- customers?: InputMaybe<ExperimentFilterCustomerFilter>;
993
- environmentId?: InputMaybe<StringFieldComparison>;
994
- id?: InputMaybe<StringFieldComparison>;
995
- name?: InputMaybe<StringFieldComparison>;
996
- or?: InputMaybe<Array<ExperimentFilter>>;
997
- productId?: InputMaybe<StringFieldComparison>;
998
- refId?: InputMaybe<StringFieldComparison>;
999
- status?: InputMaybe<ExperimentStatusFilterComparison>;
987
+ and?: Maybe<Array<ExperimentFilter>>;
988
+ createdAt?: Maybe<DateFieldComparison>;
989
+ customers?: Maybe<ExperimentFilterCustomerFilter>;
990
+ environmentId?: Maybe<StringFieldComparison>;
991
+ id?: Maybe<StringFieldComparison>;
992
+ name?: Maybe<StringFieldComparison>;
993
+ or?: Maybe<Array<ExperimentFilter>>;
994
+ productId?: Maybe<StringFieldComparison>;
995
+ refId?: Maybe<StringFieldComparison>;
996
+ status?: Maybe<ExperimentStatusFilterComparison>;
1000
997
  };
1001
998
  export declare type ExperimentFilterCustomerFilter = {
1002
- and?: InputMaybe<Array<ExperimentFilterCustomerFilter>>;
1003
- billingId?: InputMaybe<StringFieldComparison>;
1004
- createdAt?: InputMaybe<DateFieldComparison>;
1005
- crmHubspotCompanyId?: InputMaybe<StringFieldComparison>;
1006
- crmHubspotCompanyUrl?: InputMaybe<StringFieldComparison>;
1007
- crmId?: InputMaybe<StringFieldComparison>;
1008
- customerId?: InputMaybe<StringFieldComparison>;
1009
- email?: InputMaybe<StringFieldComparison>;
1010
- environmentId?: InputMaybe<StringFieldComparison>;
1011
- id?: InputMaybe<StringFieldComparison>;
1012
- name?: InputMaybe<StringFieldComparison>;
1013
- or?: InputMaybe<Array<ExperimentFilterCustomerFilter>>;
1014
- refId?: InputMaybe<StringFieldComparison>;
1015
- updatedAt?: InputMaybe<DateFieldComparison>;
999
+ and?: Maybe<Array<ExperimentFilterCustomerFilter>>;
1000
+ billingId?: Maybe<StringFieldComparison>;
1001
+ createdAt?: Maybe<DateFieldComparison>;
1002
+ crmHubspotCompanyId?: Maybe<StringFieldComparison>;
1003
+ crmHubspotCompanyUrl?: Maybe<StringFieldComparison>;
1004
+ crmId?: Maybe<StringFieldComparison>;
1005
+ customerId?: Maybe<StringFieldComparison>;
1006
+ email?: Maybe<StringFieldComparison>;
1007
+ environmentId?: Maybe<StringFieldComparison>;
1008
+ id?: Maybe<StringFieldComparison>;
1009
+ name?: Maybe<StringFieldComparison>;
1010
+ or?: Maybe<Array<ExperimentFilterCustomerFilter>>;
1011
+ refId?: Maybe<StringFieldComparison>;
1012
+ updatedAt?: Maybe<DateFieldComparison>;
1016
1013
  };
1017
1014
  export declare type ExperimentSort = {
1018
1015
  direction: SortDirection;
1019
1016
  field: ExperimentSortFields;
1020
- nulls?: InputMaybe<SortNulls>;
1017
+ nulls?: Maybe<SortNulls>;
1021
1018
  };
1022
1019
  export declare enum ExperimentSortFields {
1023
1020
  CreatedAt = "createdAt",
@@ -1029,7 +1026,7 @@ export declare enum ExperimentSortFields {
1029
1026
  Status = "status"
1030
1027
  }
1031
1028
  export declare type ExperimentStatsQuery = {
1032
- environmentId?: InputMaybe<Scalars['String']>;
1029
+ environmentId?: Maybe<Scalars['String']>;
1033
1030
  experimentRefId: Scalars['String'];
1034
1031
  };
1035
1032
  /** The status of the EXPERIMENT */
@@ -1039,51 +1036,51 @@ export declare enum ExperimentStatus {
1039
1036
  InProgress = "IN_PROGRESS"
1040
1037
  }
1041
1038
  export declare type ExperimentStatusFilterComparison = {
1042
- eq?: InputMaybe<ExperimentStatus>;
1043
- gt?: InputMaybe<ExperimentStatus>;
1044
- gte?: InputMaybe<ExperimentStatus>;
1045
- iLike?: InputMaybe<ExperimentStatus>;
1046
- in?: InputMaybe<Array<ExperimentStatus>>;
1047
- is?: InputMaybe<Scalars['Boolean']>;
1048
- isNot?: InputMaybe<Scalars['Boolean']>;
1049
- like?: InputMaybe<ExperimentStatus>;
1050
- lt?: InputMaybe<ExperimentStatus>;
1051
- lte?: InputMaybe<ExperimentStatus>;
1052
- neq?: InputMaybe<ExperimentStatus>;
1053
- notILike?: InputMaybe<ExperimentStatus>;
1054
- notIn?: InputMaybe<Array<ExperimentStatus>>;
1055
- notLike?: InputMaybe<ExperimentStatus>;
1039
+ eq?: Maybe<ExperimentStatus>;
1040
+ gt?: Maybe<ExperimentStatus>;
1041
+ gte?: Maybe<ExperimentStatus>;
1042
+ iLike?: Maybe<ExperimentStatus>;
1043
+ in?: Maybe<Array<ExperimentStatus>>;
1044
+ is?: Maybe<Scalars['Boolean']>;
1045
+ isNot?: Maybe<Scalars['Boolean']>;
1046
+ like?: Maybe<ExperimentStatus>;
1047
+ lt?: Maybe<ExperimentStatus>;
1048
+ lte?: Maybe<ExperimentStatus>;
1049
+ neq?: Maybe<ExperimentStatus>;
1050
+ notILike?: Maybe<ExperimentStatus>;
1051
+ notIn?: Maybe<Array<ExperimentStatus>>;
1052
+ notLike?: Maybe<ExperimentStatus>;
1056
1053
  };
1057
1054
  export declare type FeatureFilter = {
1058
- and?: InputMaybe<Array<FeatureFilter>>;
1059
- createdAt?: InputMaybe<DateFieldComparison>;
1060
- description?: InputMaybe<StringFieldComparison>;
1061
- displayName?: InputMaybe<StringFieldComparison>;
1062
- environmentId?: InputMaybe<StringFieldComparison>;
1063
- featureStatus?: InputMaybe<FeatureStatusFilterComparison>;
1064
- featureType?: InputMaybe<FeatureTypeFilterComparison>;
1065
- id?: InputMaybe<StringFieldComparison>;
1066
- meterType?: InputMaybe<MeterTypeFilterComparison>;
1067
- or?: InputMaybe<Array<FeatureFilter>>;
1068
- refId?: InputMaybe<StringFieldComparison>;
1069
- updatedAt?: InputMaybe<DateFieldComparison>;
1055
+ and?: Maybe<Array<FeatureFilter>>;
1056
+ createdAt?: Maybe<DateFieldComparison>;
1057
+ description?: Maybe<StringFieldComparison>;
1058
+ displayName?: Maybe<StringFieldComparison>;
1059
+ environmentId?: Maybe<StringFieldComparison>;
1060
+ featureStatus?: Maybe<FeatureStatusFilterComparison>;
1061
+ featureType?: Maybe<FeatureTypeFilterComparison>;
1062
+ id?: Maybe<StringFieldComparison>;
1063
+ meterType?: Maybe<MeterTypeFilterComparison>;
1064
+ or?: Maybe<Array<FeatureFilter>>;
1065
+ refId?: Maybe<StringFieldComparison>;
1066
+ updatedAt?: Maybe<DateFieldComparison>;
1070
1067
  };
1071
1068
  export declare type FeatureInput = {
1072
- additionalMetaData?: InputMaybe<Scalars['JSON']>;
1073
- description?: InputMaybe<Scalars['String']>;
1069
+ additionalMetaData?: Maybe<Scalars['JSON']>;
1070
+ description?: Maybe<Scalars['String']>;
1074
1071
  displayName: Scalars['String'];
1075
1072
  environmentId: Scalars['String'];
1076
- featureStatus?: InputMaybe<FeatureStatus>;
1073
+ featureStatus?: Maybe<FeatureStatus>;
1077
1074
  featureType: FeatureType;
1078
- featureUnits?: InputMaybe<Scalars['String']>;
1079
- featureUnitsPlural?: InputMaybe<Scalars['String']>;
1080
- meterType?: InputMaybe<MeterType>;
1075
+ featureUnits?: Maybe<Scalars['String']>;
1076
+ featureUnitsPlural?: Maybe<Scalars['String']>;
1077
+ meterType?: Maybe<MeterType>;
1081
1078
  refId: Scalars['String'];
1082
1079
  };
1083
1080
  export declare type FeatureSort = {
1084
1081
  direction: SortDirection;
1085
1082
  field: FeatureSortFields;
1086
- nulls?: InputMaybe<SortNulls>;
1083
+ nulls?: Maybe<SortNulls>;
1087
1084
  };
1088
1085
  export declare enum FeatureSortFields {
1089
1086
  CreatedAt = "createdAt",
@@ -1104,20 +1101,20 @@ export declare enum FeatureStatus {
1104
1101
  Suspended = "SUSPENDED"
1105
1102
  }
1106
1103
  export declare type FeatureStatusFilterComparison = {
1107
- eq?: InputMaybe<FeatureStatus>;
1108
- gt?: InputMaybe<FeatureStatus>;
1109
- gte?: InputMaybe<FeatureStatus>;
1110
- iLike?: InputMaybe<FeatureStatus>;
1111
- in?: InputMaybe<Array<FeatureStatus>>;
1112
- is?: InputMaybe<Scalars['Boolean']>;
1113
- isNot?: InputMaybe<Scalars['Boolean']>;
1114
- like?: InputMaybe<FeatureStatus>;
1115
- lt?: InputMaybe<FeatureStatus>;
1116
- lte?: InputMaybe<FeatureStatus>;
1117
- neq?: InputMaybe<FeatureStatus>;
1118
- notILike?: InputMaybe<FeatureStatus>;
1119
- notIn?: InputMaybe<Array<FeatureStatus>>;
1120
- notLike?: InputMaybe<FeatureStatus>;
1104
+ eq?: Maybe<FeatureStatus>;
1105
+ gt?: Maybe<FeatureStatus>;
1106
+ gte?: Maybe<FeatureStatus>;
1107
+ iLike?: Maybe<FeatureStatus>;
1108
+ in?: Maybe<Array<FeatureStatus>>;
1109
+ is?: Maybe<Scalars['Boolean']>;
1110
+ isNot?: Maybe<Scalars['Boolean']>;
1111
+ like?: Maybe<FeatureStatus>;
1112
+ lt?: Maybe<FeatureStatus>;
1113
+ lte?: Maybe<FeatureStatus>;
1114
+ neq?: Maybe<FeatureStatus>;
1115
+ notILike?: Maybe<FeatureStatus>;
1116
+ notIn?: Maybe<Array<FeatureStatus>>;
1117
+ notLike?: Maybe<FeatureStatus>;
1121
1118
  };
1122
1119
  /** The type of the feature */
1123
1120
  export declare enum FeatureType {
@@ -1125,34 +1122,34 @@ export declare enum FeatureType {
1125
1122
  Number = "NUMBER"
1126
1123
  }
1127
1124
  export declare type FeatureTypeFilterComparison = {
1128
- eq?: InputMaybe<FeatureType>;
1129
- gt?: InputMaybe<FeatureType>;
1130
- gte?: InputMaybe<FeatureType>;
1131
- iLike?: InputMaybe<FeatureType>;
1132
- in?: InputMaybe<Array<FeatureType>>;
1133
- is?: InputMaybe<Scalars['Boolean']>;
1134
- isNot?: InputMaybe<Scalars['Boolean']>;
1135
- like?: InputMaybe<FeatureType>;
1136
- lt?: InputMaybe<FeatureType>;
1137
- lte?: InputMaybe<FeatureType>;
1138
- neq?: InputMaybe<FeatureType>;
1139
- notILike?: InputMaybe<FeatureType>;
1140
- notIn?: InputMaybe<Array<FeatureType>>;
1141
- notLike?: InputMaybe<FeatureType>;
1125
+ eq?: Maybe<FeatureType>;
1126
+ gt?: Maybe<FeatureType>;
1127
+ gte?: Maybe<FeatureType>;
1128
+ iLike?: Maybe<FeatureType>;
1129
+ in?: Maybe<Array<FeatureType>>;
1130
+ is?: Maybe<Scalars['Boolean']>;
1131
+ isNot?: Maybe<Scalars['Boolean']>;
1132
+ like?: Maybe<FeatureType>;
1133
+ lt?: Maybe<FeatureType>;
1134
+ lte?: Maybe<FeatureType>;
1135
+ neq?: Maybe<FeatureType>;
1136
+ notILike?: Maybe<FeatureType>;
1137
+ notIn?: Maybe<Array<FeatureType>>;
1138
+ notLike?: Maybe<FeatureType>;
1142
1139
  };
1143
1140
  export declare type FetchEntitlementQuery = {
1144
1141
  customerId: Scalars['String'];
1145
- environmentId?: InputMaybe<Scalars['String']>;
1142
+ environmentId?: Maybe<Scalars['String']>;
1146
1143
  featureId: Scalars['String'];
1147
- options?: InputMaybe<EntitlementOptions>;
1144
+ options?: Maybe<EntitlementOptions>;
1148
1145
  };
1149
1146
  export declare type FetchEntitlementsQuery = {
1150
1147
  customerId: Scalars['String'];
1151
- environmentId?: InputMaybe<Scalars['String']>;
1148
+ environmentId?: Maybe<Scalars['String']>;
1152
1149
  };
1153
1150
  export declare type FontVariantInput = {
1154
- fontSize?: InputMaybe<Scalars['Float']>;
1155
- fontWeight?: InputMaybe<FontWeight>;
1151
+ fontSize?: Maybe<Scalars['Float']>;
1152
+ fontWeight?: Maybe<FontWeight>;
1156
1153
  };
1157
1154
  /** Font weight */
1158
1155
  export declare enum FontWeight {
@@ -1161,35 +1158,35 @@ export declare enum FontWeight {
1161
1158
  }
1162
1159
  export declare type GetCustomerByRefIdInput = {
1163
1160
  customerId: Scalars['String'];
1164
- environmentId?: InputMaybe<Scalars['String']>;
1161
+ environmentId?: Maybe<Scalars['String']>;
1165
1162
  };
1166
1163
  export declare type GetPackageByRefIdInput = {
1167
1164
  environmentId: Scalars['String'];
1168
1165
  refId: Scalars['String'];
1169
- versionNumber?: InputMaybe<Scalars['Float']>;
1166
+ versionNumber?: Maybe<Scalars['Float']>;
1170
1167
  };
1171
1168
  export declare type GetPaywallInput = {
1172
- context?: InputMaybe<WidgetType>;
1173
- customerId?: InputMaybe<Scalars['String']>;
1174
- environmentId?: InputMaybe<Scalars['String']>;
1175
- productId?: InputMaybe<Scalars['String']>;
1169
+ context?: Maybe<WidgetType>;
1170
+ customerId?: Maybe<Scalars['String']>;
1171
+ environmentId?: Maybe<Scalars['String']>;
1172
+ productId?: Maybe<Scalars['String']>;
1176
1173
  };
1177
1174
  export declare type GetWidgetConfigurationInput = {
1178
- environmentId?: InputMaybe<Scalars['String']>;
1175
+ environmentId?: Maybe<Scalars['String']>;
1179
1176
  };
1180
1177
  export declare type HookFilter = {
1181
- and?: InputMaybe<Array<HookFilter>>;
1182
- createdAt?: InputMaybe<DateFieldComparison>;
1183
- endpoint?: InputMaybe<StringFieldComparison>;
1184
- environmentId?: InputMaybe<StringFieldComparison>;
1185
- id?: InputMaybe<StringFieldComparison>;
1186
- or?: InputMaybe<Array<HookFilter>>;
1187
- status?: InputMaybe<HookStatusFilterComparison>;
1178
+ and?: Maybe<Array<HookFilter>>;
1179
+ createdAt?: Maybe<DateFieldComparison>;
1180
+ endpoint?: Maybe<StringFieldComparison>;
1181
+ environmentId?: Maybe<StringFieldComparison>;
1182
+ id?: Maybe<StringFieldComparison>;
1183
+ or?: Maybe<Array<HookFilter>>;
1184
+ status?: Maybe<HookStatusFilterComparison>;
1188
1185
  };
1189
1186
  export declare type HookSort = {
1190
1187
  direction: SortDirection;
1191
1188
  field: HookSortFields;
1192
- nulls?: InputMaybe<SortNulls>;
1189
+ nulls?: Maybe<SortNulls>;
1193
1190
  };
1194
1191
  export declare enum HookSortFields {
1195
1192
  CreatedAt = "createdAt",
@@ -1204,67 +1201,67 @@ export declare enum HookStatus {
1204
1201
  Inactive = "INACTIVE"
1205
1202
  }
1206
1203
  export declare type HookStatusFilterComparison = {
1207
- eq?: InputMaybe<HookStatus>;
1208
- gt?: InputMaybe<HookStatus>;
1209
- gte?: InputMaybe<HookStatus>;
1210
- iLike?: InputMaybe<HookStatus>;
1211
- in?: InputMaybe<Array<HookStatus>>;
1212
- is?: InputMaybe<Scalars['Boolean']>;
1213
- isNot?: InputMaybe<Scalars['Boolean']>;
1214
- like?: InputMaybe<HookStatus>;
1215
- lt?: InputMaybe<HookStatus>;
1216
- lte?: InputMaybe<HookStatus>;
1217
- neq?: InputMaybe<HookStatus>;
1218
- notILike?: InputMaybe<HookStatus>;
1219
- notIn?: InputMaybe<Array<HookStatus>>;
1220
- notLike?: InputMaybe<HookStatus>;
1204
+ eq?: Maybe<HookStatus>;
1205
+ gt?: Maybe<HookStatus>;
1206
+ gte?: Maybe<HookStatus>;
1207
+ iLike?: Maybe<HookStatus>;
1208
+ in?: Maybe<Array<HookStatus>>;
1209
+ is?: Maybe<Scalars['Boolean']>;
1210
+ isNot?: Maybe<Scalars['Boolean']>;
1211
+ like?: Maybe<HookStatus>;
1212
+ lt?: Maybe<HookStatus>;
1213
+ lte?: Maybe<HookStatus>;
1214
+ neq?: Maybe<HookStatus>;
1215
+ notILike?: Maybe<HookStatus>;
1216
+ notIn?: Maybe<Array<HookStatus>>;
1217
+ notLike?: Maybe<HookStatus>;
1221
1218
  };
1222
1219
  export declare type HubspotCredentialsInput = {
1223
1220
  authorizationCode: Scalars['String'];
1224
- refreshToken?: InputMaybe<Scalars['String']>;
1221
+ refreshToken?: Maybe<Scalars['String']>;
1225
1222
  };
1226
1223
  export declare type ImportCustomerInput = {
1227
- additionalMetaData?: InputMaybe<Scalars['JSON']>;
1224
+ additionalMetaData?: Maybe<Scalars['JSON']>;
1228
1225
  billingId: Scalars['String'];
1229
- customerId?: InputMaybe<Scalars['String']>;
1230
- email?: InputMaybe<Scalars['String']>;
1231
- environmentId?: InputMaybe<Scalars['String']>;
1232
- name?: InputMaybe<Scalars['String']>;
1233
- refId?: InputMaybe<Scalars['String']>;
1226
+ customerId?: Maybe<Scalars['String']>;
1227
+ email?: Maybe<Scalars['String']>;
1228
+ environmentId?: Maybe<Scalars['String']>;
1229
+ name?: Maybe<Scalars['String']>;
1230
+ refId?: Maybe<Scalars['String']>;
1234
1231
  };
1235
1232
  export declare type ImportIntegrationCatalogInput = {
1236
- billingModel?: InputMaybe<BillingModel>;
1233
+ billingModel?: Maybe<BillingModel>;
1237
1234
  entitySelectionMode: EntitySelectionMode;
1238
1235
  environmentId: Scalars['String'];
1239
- featureUnitName?: InputMaybe<Scalars['String']>;
1240
- featureUnitPluralName?: InputMaybe<Scalars['String']>;
1241
- plansSelectionBlacklist?: InputMaybe<Array<Scalars['String']>>;
1242
- plansSelectionWhitelist?: InputMaybe<Array<Scalars['String']>>;
1236
+ featureUnitName?: Maybe<Scalars['String']>;
1237
+ featureUnitPluralName?: Maybe<Scalars['String']>;
1238
+ plansSelectionBlacklist?: Maybe<Array<Scalars['String']>>;
1239
+ plansSelectionWhitelist?: Maybe<Array<Scalars['String']>>;
1243
1240
  productId: Scalars['String'];
1244
1241
  selectedAddonBillingIds: Array<Scalars['String']>;
1245
1242
  vendorIdentifier: VendorIdentifier;
1246
1243
  };
1247
1244
  export declare type ImportIntegrationCustomersInput = {
1248
- customersSelectionBlacklist?: InputMaybe<Array<Scalars['String']>>;
1249
- customersSelectionWhitelist?: InputMaybe<Array<Scalars['String']>>;
1245
+ customersSelectionBlacklist?: Maybe<Array<Scalars['String']>>;
1246
+ customersSelectionWhitelist?: Maybe<Array<Scalars['String']>>;
1250
1247
  entitySelectionMode: EntitySelectionMode;
1251
1248
  environmentId: Scalars['String'];
1252
1249
  productId: Scalars['String'];
1253
1250
  vendorIdentifier: VendorIdentifier;
1254
1251
  };
1255
1252
  export declare type ImportIntegrationTaskFilter = {
1256
- and?: InputMaybe<Array<ImportIntegrationTaskFilter>>;
1257
- createdAt?: InputMaybe<DateFieldComparison>;
1258
- environmentId?: InputMaybe<StringFieldComparison>;
1259
- id?: InputMaybe<StringFieldComparison>;
1260
- or?: InputMaybe<Array<ImportIntegrationTaskFilter>>;
1261
- status?: InputMaybe<TaskStatusFilterComparison>;
1262
- taskType?: InputMaybe<TaskTypeFilterComparison>;
1253
+ and?: Maybe<Array<ImportIntegrationTaskFilter>>;
1254
+ createdAt?: Maybe<DateFieldComparison>;
1255
+ environmentId?: Maybe<StringFieldComparison>;
1256
+ id?: Maybe<StringFieldComparison>;
1257
+ or?: Maybe<Array<ImportIntegrationTaskFilter>>;
1258
+ status?: Maybe<TaskStatusFilterComparison>;
1259
+ taskType?: Maybe<TaskTypeFilterComparison>;
1263
1260
  };
1264
1261
  export declare type ImportIntegrationTaskSort = {
1265
1262
  direction: SortDirection;
1266
1263
  field: ImportIntegrationTaskSortFields;
1267
- nulls?: InputMaybe<SortNulls>;
1264
+ nulls?: Maybe<SortNulls>;
1268
1265
  };
1269
1266
  export declare enum ImportIntegrationTaskSortFields {
1270
1267
  CreatedAt = "createdAt",
@@ -1275,50 +1272,50 @@ export declare enum ImportIntegrationTaskSortFields {
1275
1272
  }
1276
1273
  export declare type InitAddStripeCustomerPaymentMethodInput = {
1277
1274
  customerRefId: Scalars['String'];
1278
- environmentId?: InputMaybe<Scalars['String']>;
1275
+ environmentId?: Maybe<Scalars['String']>;
1279
1276
  };
1280
1277
  export declare type InitiateCheckoutInput = {
1281
- addons?: InputMaybe<Array<SubscriptionAddonInput>>;
1282
- allowPromoCodes?: InputMaybe<Scalars['Boolean']>;
1283
- allowTaxIdCollection?: InputMaybe<Scalars['Boolean']>;
1278
+ addons?: Maybe<Array<SubscriptionAddonInput>>;
1279
+ allowPromoCodes?: Maybe<Scalars['Boolean']>;
1280
+ allowTaxIdCollection?: Maybe<Scalars['Boolean']>;
1284
1281
  billingPeriod: BillingPeriod;
1285
1282
  cancelUrl: Scalars['String'];
1286
- collectBillingAddress?: InputMaybe<Scalars['Boolean']>;
1283
+ collectBillingAddress?: Maybe<Scalars['Boolean']>;
1287
1284
  customerId: Scalars['String'];
1288
1285
  planId: Scalars['String'];
1289
1286
  successUrl: Scalars['String'];
1290
- unitQuantity?: InputMaybe<Scalars['Int']>;
1287
+ unitQuantity?: Maybe<Scalars['Int']>;
1291
1288
  };
1292
1289
  export declare type IntFieldComparison = {
1293
- between?: InputMaybe<IntFieldComparisonBetween>;
1294
- eq?: InputMaybe<Scalars['Int']>;
1295
- gt?: InputMaybe<Scalars['Int']>;
1296
- gte?: InputMaybe<Scalars['Int']>;
1297
- in?: InputMaybe<Array<Scalars['Int']>>;
1298
- is?: InputMaybe<Scalars['Boolean']>;
1299
- isNot?: InputMaybe<Scalars['Boolean']>;
1300
- lt?: InputMaybe<Scalars['Int']>;
1301
- lte?: InputMaybe<Scalars['Int']>;
1302
- neq?: InputMaybe<Scalars['Int']>;
1303
- notBetween?: InputMaybe<IntFieldComparisonBetween>;
1304
- notIn?: InputMaybe<Array<Scalars['Int']>>;
1290
+ between?: Maybe<IntFieldComparisonBetween>;
1291
+ eq?: Maybe<Scalars['Int']>;
1292
+ gt?: Maybe<Scalars['Int']>;
1293
+ gte?: Maybe<Scalars['Int']>;
1294
+ in?: Maybe<Array<Scalars['Int']>>;
1295
+ is?: Maybe<Scalars['Boolean']>;
1296
+ isNot?: Maybe<Scalars['Boolean']>;
1297
+ lt?: Maybe<Scalars['Int']>;
1298
+ lte?: Maybe<Scalars['Int']>;
1299
+ neq?: Maybe<Scalars['Int']>;
1300
+ notBetween?: Maybe<IntFieldComparisonBetween>;
1301
+ notIn?: Maybe<Array<Scalars['Int']>>;
1305
1302
  };
1306
1303
  export declare type IntFieldComparisonBetween = {
1307
1304
  lower: Scalars['Int'];
1308
1305
  upper: Scalars['Int'];
1309
1306
  };
1310
1307
  export declare type IntegrationFilter = {
1311
- and?: InputMaybe<Array<IntegrationFilter>>;
1312
- createdAt?: InputMaybe<DateFieldComparison>;
1313
- environmentId?: InputMaybe<StringFieldComparison>;
1314
- id?: InputMaybe<StringFieldComparison>;
1315
- or?: InputMaybe<Array<IntegrationFilter>>;
1316
- vendorIdentifier?: InputMaybe<VendorIdentifierFilterComparison>;
1308
+ and?: Maybe<Array<IntegrationFilter>>;
1309
+ createdAt?: Maybe<DateFieldComparison>;
1310
+ environmentId?: Maybe<StringFieldComparison>;
1311
+ id?: Maybe<StringFieldComparison>;
1312
+ or?: Maybe<Array<IntegrationFilter>>;
1313
+ vendorIdentifier?: Maybe<VendorIdentifierFilterComparison>;
1317
1314
  };
1318
1315
  export declare type IntegrationSort = {
1319
1316
  direction: SortDirection;
1320
1317
  field: IntegrationSortFields;
1321
- nulls?: InputMaybe<SortNulls>;
1318
+ nulls?: Maybe<SortNulls>;
1322
1319
  };
1323
1320
  export declare enum IntegrationSortFields {
1324
1321
  CreatedAt = "createdAt",
@@ -1327,15 +1324,15 @@ export declare enum IntegrationSortFields {
1327
1324
  VendorIdentifier = "vendorIdentifier"
1328
1325
  }
1329
1326
  export declare type MemberFilter = {
1330
- and?: InputMaybe<Array<MemberFilter>>;
1331
- createdAt?: InputMaybe<DateFieldComparison>;
1332
- id?: InputMaybe<StringFieldComparison>;
1333
- or?: InputMaybe<Array<MemberFilter>>;
1327
+ and?: Maybe<Array<MemberFilter>>;
1328
+ createdAt?: Maybe<DateFieldComparison>;
1329
+ id?: Maybe<StringFieldComparison>;
1330
+ or?: Maybe<Array<MemberFilter>>;
1334
1331
  };
1335
1332
  export declare type MemberSort = {
1336
1333
  direction: SortDirection;
1337
1334
  field: MemberSortFields;
1338
- nulls?: InputMaybe<SortNulls>;
1335
+ nulls?: Maybe<SortNulls>;
1339
1336
  };
1340
1337
  export declare enum MemberSortFields {
1341
1338
  CreatedAt = "createdAt",
@@ -1353,24 +1350,24 @@ export declare enum MeterType {
1353
1350
  None = "None"
1354
1351
  }
1355
1352
  export declare type MeterTypeFilterComparison = {
1356
- eq?: InputMaybe<MeterType>;
1357
- gt?: InputMaybe<MeterType>;
1358
- gte?: InputMaybe<MeterType>;
1359
- iLike?: InputMaybe<MeterType>;
1360
- in?: InputMaybe<Array<MeterType>>;
1361
- is?: InputMaybe<Scalars['Boolean']>;
1362
- isNot?: InputMaybe<Scalars['Boolean']>;
1363
- like?: InputMaybe<MeterType>;
1364
- lt?: InputMaybe<MeterType>;
1365
- lte?: InputMaybe<MeterType>;
1366
- neq?: InputMaybe<MeterType>;
1367
- notILike?: InputMaybe<MeterType>;
1368
- notIn?: InputMaybe<Array<MeterType>>;
1369
- notLike?: InputMaybe<MeterType>;
1353
+ eq?: Maybe<MeterType>;
1354
+ gt?: Maybe<MeterType>;
1355
+ gte?: Maybe<MeterType>;
1356
+ iLike?: Maybe<MeterType>;
1357
+ in?: Maybe<Array<MeterType>>;
1358
+ is?: Maybe<Scalars['Boolean']>;
1359
+ isNot?: Maybe<Scalars['Boolean']>;
1360
+ like?: Maybe<MeterType>;
1361
+ lt?: Maybe<MeterType>;
1362
+ lte?: Maybe<MeterType>;
1363
+ neq?: Maybe<MeterType>;
1364
+ notILike?: Maybe<MeterType>;
1365
+ notIn?: Maybe<Array<MeterType>>;
1366
+ notLike?: Maybe<MeterType>;
1370
1367
  };
1371
1368
  export declare type MoneyInputDto = {
1372
1369
  amount: Scalars['Float'];
1373
- currency?: InputMaybe<Currency>;
1370
+ currency?: Maybe<Currency>;
1374
1371
  };
1375
1372
  /** Montly reset period according to configuration */
1376
1373
  export declare enum MonthlyAccordingTo {
@@ -1381,44 +1378,44 @@ export declare type MonthlyResetPeriodConfigInput = {
1381
1378
  accordingTo: MonthlyAccordingTo;
1382
1379
  };
1383
1380
  export declare type NumberFieldComparison = {
1384
- between?: InputMaybe<NumberFieldComparisonBetween>;
1385
- eq?: InputMaybe<Scalars['Float']>;
1386
- gt?: InputMaybe<Scalars['Float']>;
1387
- gte?: InputMaybe<Scalars['Float']>;
1388
- in?: InputMaybe<Array<Scalars['Float']>>;
1389
- is?: InputMaybe<Scalars['Boolean']>;
1390
- isNot?: InputMaybe<Scalars['Boolean']>;
1391
- lt?: InputMaybe<Scalars['Float']>;
1392
- lte?: InputMaybe<Scalars['Float']>;
1393
- neq?: InputMaybe<Scalars['Float']>;
1394
- notBetween?: InputMaybe<NumberFieldComparisonBetween>;
1395
- notIn?: InputMaybe<Array<Scalars['Float']>>;
1381
+ between?: Maybe<NumberFieldComparisonBetween>;
1382
+ eq?: Maybe<Scalars['Float']>;
1383
+ gt?: Maybe<Scalars['Float']>;
1384
+ gte?: Maybe<Scalars['Float']>;
1385
+ in?: Maybe<Array<Scalars['Float']>>;
1386
+ is?: Maybe<Scalars['Boolean']>;
1387
+ isNot?: Maybe<Scalars['Boolean']>;
1388
+ lt?: Maybe<Scalars['Float']>;
1389
+ lte?: Maybe<Scalars['Float']>;
1390
+ neq?: Maybe<Scalars['Float']>;
1391
+ notBetween?: Maybe<NumberFieldComparisonBetween>;
1392
+ notIn?: Maybe<Array<Scalars['Float']>>;
1396
1393
  };
1397
1394
  export declare type NumberFieldComparisonBetween = {
1398
1395
  lower: Scalars['Float'];
1399
1396
  upper: Scalars['Float'];
1400
1397
  };
1401
1398
  export declare type PackageDtoFilter = {
1402
- and?: InputMaybe<Array<PackageDtoFilter>>;
1403
- billingId?: InputMaybe<StringFieldComparison>;
1404
- createdAt?: InputMaybe<DateFieldComparison>;
1405
- description?: InputMaybe<StringFieldComparison>;
1406
- displayName?: InputMaybe<StringFieldComparison>;
1407
- environmentId?: InputMaybe<StringFieldComparison>;
1408
- id?: InputMaybe<StringFieldComparison>;
1409
- isLatest?: InputMaybe<BooleanFieldComparison>;
1410
- or?: InputMaybe<Array<PackageDtoFilter>>;
1411
- pricingType?: InputMaybe<PricingTypeFilterComparison>;
1412
- productId?: InputMaybe<StringFieldComparison>;
1413
- refId?: InputMaybe<StringFieldComparison>;
1414
- status?: InputMaybe<PackageStatusFilterComparison>;
1415
- updatedAt?: InputMaybe<DateFieldComparison>;
1416
- versionNumber?: InputMaybe<IntFieldComparison>;
1399
+ and?: Maybe<Array<PackageDtoFilter>>;
1400
+ billingId?: Maybe<StringFieldComparison>;
1401
+ createdAt?: Maybe<DateFieldComparison>;
1402
+ description?: Maybe<StringFieldComparison>;
1403
+ displayName?: Maybe<StringFieldComparison>;
1404
+ environmentId?: Maybe<StringFieldComparison>;
1405
+ id?: Maybe<StringFieldComparison>;
1406
+ isLatest?: Maybe<BooleanFieldComparison>;
1407
+ or?: Maybe<Array<PackageDtoFilter>>;
1408
+ pricingType?: Maybe<PricingTypeFilterComparison>;
1409
+ productId?: Maybe<StringFieldComparison>;
1410
+ refId?: Maybe<StringFieldComparison>;
1411
+ status?: Maybe<PackageStatusFilterComparison>;
1412
+ updatedAt?: Maybe<DateFieldComparison>;
1413
+ versionNumber?: Maybe<IntFieldComparison>;
1417
1414
  };
1418
1415
  export declare type PackageDtoSort = {
1419
1416
  direction: SortDirection;
1420
1417
  field: PackageDtoSortFields;
1421
- nulls?: InputMaybe<SortNulls>;
1418
+ nulls?: Maybe<SortNulls>;
1422
1419
  };
1423
1420
  export declare enum PackageDtoSortFields {
1424
1421
  BillingId = "billingId",
@@ -1436,66 +1433,66 @@ export declare enum PackageDtoSortFields {
1436
1433
  VersionNumber = "versionNumber"
1437
1434
  }
1438
1435
  export declare type PackageEntitlementFilter = {
1439
- and?: InputMaybe<Array<PackageEntitlementFilter>>;
1440
- createdAt?: InputMaybe<DateFieldComparison>;
1441
- environmentId?: InputMaybe<StringFieldComparison>;
1442
- feature?: InputMaybe<PackageEntitlementFilterFeatureFilter>;
1443
- id?: InputMaybe<StringFieldComparison>;
1444
- or?: InputMaybe<Array<PackageEntitlementFilter>>;
1445
- package?: InputMaybe<PackageEntitlementFilterPackageDtoFilter>;
1446
- packageId?: InputMaybe<StringFieldComparison>;
1447
- updatedAt?: InputMaybe<DateFieldComparison>;
1436
+ and?: Maybe<Array<PackageEntitlementFilter>>;
1437
+ createdAt?: Maybe<DateFieldComparison>;
1438
+ environmentId?: Maybe<StringFieldComparison>;
1439
+ feature?: Maybe<PackageEntitlementFilterFeatureFilter>;
1440
+ id?: Maybe<StringFieldComparison>;
1441
+ or?: Maybe<Array<PackageEntitlementFilter>>;
1442
+ package?: Maybe<PackageEntitlementFilterPackageDtoFilter>;
1443
+ packageId?: Maybe<StringFieldComparison>;
1444
+ updatedAt?: Maybe<DateFieldComparison>;
1448
1445
  };
1449
1446
  export declare type PackageEntitlementFilterFeatureFilter = {
1450
- and?: InputMaybe<Array<PackageEntitlementFilterFeatureFilter>>;
1451
- createdAt?: InputMaybe<DateFieldComparison>;
1452
- description?: InputMaybe<StringFieldComparison>;
1453
- displayName?: InputMaybe<StringFieldComparison>;
1454
- environmentId?: InputMaybe<StringFieldComparison>;
1455
- featureStatus?: InputMaybe<FeatureStatusFilterComparison>;
1456
- featureType?: InputMaybe<FeatureTypeFilterComparison>;
1457
- id?: InputMaybe<StringFieldComparison>;
1458
- meterType?: InputMaybe<MeterTypeFilterComparison>;
1459
- or?: InputMaybe<Array<PackageEntitlementFilterFeatureFilter>>;
1460
- refId?: InputMaybe<StringFieldComparison>;
1461
- updatedAt?: InputMaybe<DateFieldComparison>;
1447
+ and?: Maybe<Array<PackageEntitlementFilterFeatureFilter>>;
1448
+ createdAt?: Maybe<DateFieldComparison>;
1449
+ description?: Maybe<StringFieldComparison>;
1450
+ displayName?: Maybe<StringFieldComparison>;
1451
+ environmentId?: Maybe<StringFieldComparison>;
1452
+ featureStatus?: Maybe<FeatureStatusFilterComparison>;
1453
+ featureType?: Maybe<FeatureTypeFilterComparison>;
1454
+ id?: Maybe<StringFieldComparison>;
1455
+ meterType?: Maybe<MeterTypeFilterComparison>;
1456
+ or?: Maybe<Array<PackageEntitlementFilterFeatureFilter>>;
1457
+ refId?: Maybe<StringFieldComparison>;
1458
+ updatedAt?: Maybe<DateFieldComparison>;
1462
1459
  };
1463
1460
  export declare type PackageEntitlementFilterPackageDtoFilter = {
1464
- and?: InputMaybe<Array<PackageEntitlementFilterPackageDtoFilter>>;
1465
- billingId?: InputMaybe<StringFieldComparison>;
1466
- createdAt?: InputMaybe<DateFieldComparison>;
1467
- description?: InputMaybe<StringFieldComparison>;
1468
- displayName?: InputMaybe<StringFieldComparison>;
1469
- environmentId?: InputMaybe<StringFieldComparison>;
1470
- id?: InputMaybe<StringFieldComparison>;
1471
- isLatest?: InputMaybe<BooleanFieldComparison>;
1472
- or?: InputMaybe<Array<PackageEntitlementFilterPackageDtoFilter>>;
1473
- pricingType?: InputMaybe<PricingTypeFilterComparison>;
1474
- productId?: InputMaybe<StringFieldComparison>;
1475
- refId?: InputMaybe<StringFieldComparison>;
1476
- status?: InputMaybe<PackageStatusFilterComparison>;
1477
- updatedAt?: InputMaybe<DateFieldComparison>;
1478
- versionNumber?: InputMaybe<IntFieldComparison>;
1461
+ and?: Maybe<Array<PackageEntitlementFilterPackageDtoFilter>>;
1462
+ billingId?: Maybe<StringFieldComparison>;
1463
+ createdAt?: Maybe<DateFieldComparison>;
1464
+ description?: Maybe<StringFieldComparison>;
1465
+ displayName?: Maybe<StringFieldComparison>;
1466
+ environmentId?: Maybe<StringFieldComparison>;
1467
+ id?: Maybe<StringFieldComparison>;
1468
+ isLatest?: Maybe<BooleanFieldComparison>;
1469
+ or?: Maybe<Array<PackageEntitlementFilterPackageDtoFilter>>;
1470
+ pricingType?: Maybe<PricingTypeFilterComparison>;
1471
+ productId?: Maybe<StringFieldComparison>;
1472
+ refId?: Maybe<StringFieldComparison>;
1473
+ status?: Maybe<PackageStatusFilterComparison>;
1474
+ updatedAt?: Maybe<DateFieldComparison>;
1475
+ versionNumber?: Maybe<IntFieldComparison>;
1479
1476
  };
1480
1477
  export declare type PackageEntitlementInput = {
1481
- description?: InputMaybe<Scalars['String']>;
1482
- displayNameOverride?: InputMaybe<Scalars['String']>;
1478
+ description?: Maybe<Scalars['String']>;
1479
+ displayNameOverride?: Maybe<Scalars['String']>;
1483
1480
  environmentId: Scalars['String'];
1484
1481
  featureId: Scalars['String'];
1485
- hasUnlimitedUsage?: InputMaybe<Scalars['Boolean']>;
1486
- hiddenFromWidgets?: InputMaybe<Array<WidgetType>>;
1487
- isCustom?: InputMaybe<Scalars['Boolean']>;
1488
- monthlyResetPeriodConfiguration?: InputMaybe<MonthlyResetPeriodConfigInput>;
1489
- order?: InputMaybe<Scalars['Float']>;
1482
+ hasUnlimitedUsage?: Maybe<Scalars['Boolean']>;
1483
+ hiddenFromWidgets?: Maybe<Array<WidgetType>>;
1484
+ isCustom?: Maybe<Scalars['Boolean']>;
1485
+ monthlyResetPeriodConfiguration?: Maybe<MonthlyResetPeriodConfigInput>;
1486
+ order?: Maybe<Scalars['Float']>;
1490
1487
  packageId: Scalars['String'];
1491
- resetPeriod?: InputMaybe<EntitlementResetPeriod>;
1492
- usageLimit?: InputMaybe<Scalars['Float']>;
1493
- weeklyResetPeriodConfiguration?: InputMaybe<WeeklyResetPeriodConfigInput>;
1488
+ resetPeriod?: Maybe<EntitlementResetPeriod>;
1489
+ usageLimit?: Maybe<Scalars['Float']>;
1490
+ weeklyResetPeriodConfiguration?: Maybe<WeeklyResetPeriodConfigInput>;
1494
1491
  };
1495
1492
  export declare type PackageEntitlementSort = {
1496
1493
  direction: SortDirection;
1497
1494
  field: PackageEntitlementSortFields;
1498
- nulls?: InputMaybe<SortNulls>;
1495
+ nulls?: Maybe<SortNulls>;
1499
1496
  };
1500
1497
  export declare enum PackageEntitlementSortFields {
1501
1498
  CreatedAt = "createdAt",
@@ -1505,21 +1502,21 @@ export declare enum PackageEntitlementSortFields {
1505
1502
  UpdatedAt = "updatedAt"
1506
1503
  }
1507
1504
  export declare type PackageEntitlementUpdateInput = {
1508
- description?: InputMaybe<Scalars['String']>;
1509
- displayNameOverride?: InputMaybe<Scalars['String']>;
1510
- hasUnlimitedUsage?: InputMaybe<Scalars['Boolean']>;
1511
- hiddenFromWidgets?: InputMaybe<Array<WidgetType>>;
1512
- isCustom?: InputMaybe<Scalars['Boolean']>;
1513
- monthlyResetPeriodConfiguration?: InputMaybe<MonthlyResetPeriodConfigInput>;
1514
- order?: InputMaybe<Scalars['Float']>;
1515
- resetPeriod?: InputMaybe<EntitlementResetPeriod>;
1516
- usageLimit?: InputMaybe<Scalars['Float']>;
1517
- weeklyResetPeriodConfiguration?: InputMaybe<WeeklyResetPeriodConfigInput>;
1505
+ description?: Maybe<Scalars['String']>;
1506
+ displayNameOverride?: Maybe<Scalars['String']>;
1507
+ hasUnlimitedUsage?: Maybe<Scalars['Boolean']>;
1508
+ hiddenFromWidgets?: Maybe<Array<WidgetType>>;
1509
+ isCustom?: Maybe<Scalars['Boolean']>;
1510
+ monthlyResetPeriodConfiguration?: Maybe<MonthlyResetPeriodConfigInput>;
1511
+ order?: Maybe<Scalars['Float']>;
1512
+ resetPeriod?: Maybe<EntitlementResetPeriod>;
1513
+ usageLimit?: Maybe<Scalars['Float']>;
1514
+ weeklyResetPeriodConfiguration?: Maybe<WeeklyResetPeriodConfigInput>;
1518
1515
  };
1519
1516
  export declare type PackagePricingInput = {
1520
1517
  environmentId: Scalars['String'];
1521
1518
  packageId: Scalars['String'];
1522
- pricingModel?: InputMaybe<PricingModelCreateInput>;
1519
+ pricingModel?: Maybe<PricingModelCreateInput>;
1523
1520
  pricingType: PricingType;
1524
1521
  };
1525
1522
  export declare type PackagePublishInput = {
@@ -1533,20 +1530,20 @@ export declare enum PackageStatus {
1533
1530
  Published = "PUBLISHED"
1534
1531
  }
1535
1532
  export declare type PackageStatusFilterComparison = {
1536
- eq?: InputMaybe<PackageStatus>;
1537
- gt?: InputMaybe<PackageStatus>;
1538
- gte?: InputMaybe<PackageStatus>;
1539
- iLike?: InputMaybe<PackageStatus>;
1540
- in?: InputMaybe<Array<PackageStatus>>;
1541
- is?: InputMaybe<Scalars['Boolean']>;
1542
- isNot?: InputMaybe<Scalars['Boolean']>;
1543
- like?: InputMaybe<PackageStatus>;
1544
- lt?: InputMaybe<PackageStatus>;
1545
- lte?: InputMaybe<PackageStatus>;
1546
- neq?: InputMaybe<PackageStatus>;
1547
- notILike?: InputMaybe<PackageStatus>;
1548
- notIn?: InputMaybe<Array<PackageStatus>>;
1549
- notLike?: InputMaybe<PackageStatus>;
1533
+ eq?: Maybe<PackageStatus>;
1534
+ gt?: Maybe<PackageStatus>;
1535
+ gte?: Maybe<PackageStatus>;
1536
+ iLike?: Maybe<PackageStatus>;
1537
+ in?: Maybe<Array<PackageStatus>>;
1538
+ is?: Maybe<Scalars['Boolean']>;
1539
+ isNot?: Maybe<Scalars['Boolean']>;
1540
+ like?: Maybe<PackageStatus>;
1541
+ lt?: Maybe<PackageStatus>;
1542
+ lte?: Maybe<PackageStatus>;
1543
+ neq?: Maybe<PackageStatus>;
1544
+ notILike?: Maybe<PackageStatus>;
1545
+ notIn?: Maybe<Array<PackageStatus>>;
1546
+ notLike?: Maybe<PackageStatus>;
1550
1547
  };
1551
1548
  /** Type of a payment method */
1552
1549
  export declare enum PaymentMethodType {
@@ -1554,87 +1551,87 @@ export declare enum PaymentMethodType {
1554
1551
  Card = "CARD"
1555
1552
  }
1556
1553
  export declare type PaywallColorsPaletteInput = {
1557
- backgroundColor?: InputMaybe<Scalars['String']>;
1558
- borderColor?: InputMaybe<Scalars['String']>;
1559
- currentPlanBackground?: InputMaybe<Scalars['String']>;
1560
- primary?: InputMaybe<Scalars['String']>;
1561
- textColor?: InputMaybe<Scalars['String']>;
1554
+ backgroundColor?: Maybe<Scalars['String']>;
1555
+ borderColor?: Maybe<Scalars['String']>;
1556
+ currentPlanBackground?: Maybe<Scalars['String']>;
1557
+ primary?: Maybe<Scalars['String']>;
1558
+ textColor?: Maybe<Scalars['String']>;
1562
1559
  };
1563
1560
  export declare type PaywallConfigurationInput = {
1564
- layout?: InputMaybe<PaywallLayoutConfigurationInput>;
1565
- palette?: InputMaybe<PaywallColorsPaletteInput>;
1566
- typography?: InputMaybe<TypographyConfigurationInput>;
1561
+ layout?: Maybe<PaywallLayoutConfigurationInput>;
1562
+ palette?: Maybe<PaywallColorsPaletteInput>;
1563
+ typography?: Maybe<TypographyConfigurationInput>;
1567
1564
  };
1568
1565
  export declare type PaywallLayoutConfigurationInput = {
1569
- alignment?: InputMaybe<Alignment>;
1570
- planMargin?: InputMaybe<Scalars['Float']>;
1571
- planPadding?: InputMaybe<Scalars['Float']>;
1572
- planWidth?: InputMaybe<Scalars['Float']>;
1566
+ alignment?: Maybe<Alignment>;
1567
+ planMargin?: Maybe<Scalars['Float']>;
1568
+ planPadding?: Maybe<Scalars['Float']>;
1569
+ planWidth?: Maybe<Scalars['Float']>;
1573
1570
  };
1574
1571
  export declare type PlanCreateInput = {
1575
- additionalMetaData?: InputMaybe<Scalars['JSON']>;
1576
- billingId?: InputMaybe<Scalars['String']>;
1577
- description?: InputMaybe<Scalars['String']>;
1572
+ additionalMetaData?: Maybe<Scalars['JSON']>;
1573
+ billingId?: Maybe<Scalars['String']>;
1574
+ description?: Maybe<Scalars['String']>;
1578
1575
  displayName: Scalars['String'];
1579
- environmentId?: InputMaybe<Scalars['String']>;
1580
- hiddenFromWidgets?: InputMaybe<Array<WidgetType>>;
1581
- parentPlanId?: InputMaybe<Scalars['String']>;
1576
+ environmentId?: Maybe<Scalars['String']>;
1577
+ hiddenFromWidgets?: Maybe<Array<WidgetType>>;
1578
+ parentPlanId?: Maybe<Scalars['String']>;
1582
1579
  productId: Scalars['String'];
1583
- refId?: InputMaybe<Scalars['String']>;
1584
- status?: InputMaybe<PackageStatus>;
1580
+ refId?: Maybe<Scalars['String']>;
1581
+ status?: Maybe<PackageStatus>;
1585
1582
  };
1586
1583
  export declare type PlanFilter = {
1587
- and?: InputMaybe<Array<PlanFilter>>;
1588
- billingId?: InputMaybe<StringFieldComparison>;
1589
- compatibleAddons?: InputMaybe<PlanFilterAddonFilter>;
1590
- createdAt?: InputMaybe<DateFieldComparison>;
1591
- description?: InputMaybe<StringFieldComparison>;
1592
- displayName?: InputMaybe<StringFieldComparison>;
1593
- environmentId?: InputMaybe<StringFieldComparison>;
1594
- id?: InputMaybe<StringFieldComparison>;
1595
- isLatest?: InputMaybe<BooleanFieldComparison>;
1596
- or?: InputMaybe<Array<PlanFilter>>;
1597
- pricingType?: InputMaybe<PricingTypeFilterComparison>;
1598
- product?: InputMaybe<PlanFilterProductFilter>;
1599
- productId?: InputMaybe<StringFieldComparison>;
1600
- refId?: InputMaybe<StringFieldComparison>;
1601
- status?: InputMaybe<PackageStatusFilterComparison>;
1602
- updatedAt?: InputMaybe<DateFieldComparison>;
1603
- versionNumber?: InputMaybe<IntFieldComparison>;
1584
+ and?: Maybe<Array<PlanFilter>>;
1585
+ billingId?: Maybe<StringFieldComparison>;
1586
+ compatibleAddons?: Maybe<PlanFilterAddonFilter>;
1587
+ createdAt?: Maybe<DateFieldComparison>;
1588
+ description?: Maybe<StringFieldComparison>;
1589
+ displayName?: Maybe<StringFieldComparison>;
1590
+ environmentId?: Maybe<StringFieldComparison>;
1591
+ id?: Maybe<StringFieldComparison>;
1592
+ isLatest?: Maybe<BooleanFieldComparison>;
1593
+ or?: Maybe<Array<PlanFilter>>;
1594
+ pricingType?: Maybe<PricingTypeFilterComparison>;
1595
+ product?: Maybe<PlanFilterProductFilter>;
1596
+ productId?: Maybe<StringFieldComparison>;
1597
+ refId?: Maybe<StringFieldComparison>;
1598
+ status?: Maybe<PackageStatusFilterComparison>;
1599
+ updatedAt?: Maybe<DateFieldComparison>;
1600
+ versionNumber?: Maybe<IntFieldComparison>;
1604
1601
  };
1605
1602
  export declare type PlanFilterAddonFilter = {
1606
- and?: InputMaybe<Array<PlanFilterAddonFilter>>;
1607
- billingId?: InputMaybe<StringFieldComparison>;
1608
- createdAt?: InputMaybe<DateFieldComparison>;
1609
- description?: InputMaybe<StringFieldComparison>;
1610
- displayName?: InputMaybe<StringFieldComparison>;
1611
- environmentId?: InputMaybe<StringFieldComparison>;
1612
- id?: InputMaybe<StringFieldComparison>;
1613
- isLatest?: InputMaybe<BooleanFieldComparison>;
1614
- or?: InputMaybe<Array<PlanFilterAddonFilter>>;
1615
- pricingType?: InputMaybe<PricingTypeFilterComparison>;
1616
- productId?: InputMaybe<StringFieldComparison>;
1617
- refId?: InputMaybe<StringFieldComparison>;
1618
- status?: InputMaybe<PackageStatusFilterComparison>;
1619
- updatedAt?: InputMaybe<DateFieldComparison>;
1620
- versionNumber?: InputMaybe<IntFieldComparison>;
1603
+ and?: Maybe<Array<PlanFilterAddonFilter>>;
1604
+ billingId?: Maybe<StringFieldComparison>;
1605
+ createdAt?: Maybe<DateFieldComparison>;
1606
+ description?: Maybe<StringFieldComparison>;
1607
+ displayName?: Maybe<StringFieldComparison>;
1608
+ environmentId?: Maybe<StringFieldComparison>;
1609
+ id?: Maybe<StringFieldComparison>;
1610
+ isLatest?: Maybe<BooleanFieldComparison>;
1611
+ or?: Maybe<Array<PlanFilterAddonFilter>>;
1612
+ pricingType?: Maybe<PricingTypeFilterComparison>;
1613
+ productId?: Maybe<StringFieldComparison>;
1614
+ refId?: Maybe<StringFieldComparison>;
1615
+ status?: Maybe<PackageStatusFilterComparison>;
1616
+ updatedAt?: Maybe<DateFieldComparison>;
1617
+ versionNumber?: Maybe<IntFieldComparison>;
1621
1618
  };
1622
1619
  export declare type PlanFilterProductFilter = {
1623
- and?: InputMaybe<Array<PlanFilterProductFilter>>;
1624
- createdAt?: InputMaybe<DateFieldComparison>;
1625
- description?: InputMaybe<StringFieldComparison>;
1626
- displayName?: InputMaybe<StringFieldComparison>;
1627
- environmentId?: InputMaybe<StringFieldComparison>;
1628
- id?: InputMaybe<StringFieldComparison>;
1629
- isDefaultProduct?: InputMaybe<BooleanFieldComparison>;
1630
- or?: InputMaybe<Array<PlanFilterProductFilter>>;
1631
- refId?: InputMaybe<StringFieldComparison>;
1632
- updatedAt?: InputMaybe<DateFieldComparison>;
1620
+ and?: Maybe<Array<PlanFilterProductFilter>>;
1621
+ createdAt?: Maybe<DateFieldComparison>;
1622
+ description?: Maybe<StringFieldComparison>;
1623
+ displayName?: Maybe<StringFieldComparison>;
1624
+ environmentId?: Maybe<StringFieldComparison>;
1625
+ id?: Maybe<StringFieldComparison>;
1626
+ isDefaultProduct?: Maybe<BooleanFieldComparison>;
1627
+ or?: Maybe<Array<PlanFilterProductFilter>>;
1628
+ refId?: Maybe<StringFieldComparison>;
1629
+ updatedAt?: Maybe<DateFieldComparison>;
1633
1630
  };
1634
1631
  export declare type PlanSort = {
1635
1632
  direction: SortDirection;
1636
1633
  field: PlanSortFields;
1637
- nulls?: InputMaybe<SortNulls>;
1634
+ nulls?: Maybe<SortNulls>;
1638
1635
  };
1639
1636
  export declare enum PlanSortFields {
1640
1637
  BillingId = "billingId",
@@ -1652,52 +1649,52 @@ export declare enum PlanSortFields {
1652
1649
  VersionNumber = "versionNumber"
1653
1650
  }
1654
1651
  export declare type PlanUpdateInput = {
1655
- additionalMetaData?: InputMaybe<Scalars['JSON']>;
1656
- billingId?: InputMaybe<Scalars['String']>;
1657
- defaultTrialConfig?: InputMaybe<DefaultTrialConfigInputDto>;
1658
- description?: InputMaybe<Scalars['String']>;
1659
- displayName?: InputMaybe<Scalars['String']>;
1660
- hiddenFromWidgets?: InputMaybe<Array<WidgetType>>;
1652
+ additionalMetaData?: Maybe<Scalars['JSON']>;
1653
+ billingId?: Maybe<Scalars['String']>;
1654
+ defaultTrialConfig?: Maybe<DefaultTrialConfigInputDto>;
1655
+ description?: Maybe<Scalars['String']>;
1656
+ displayName?: Maybe<Scalars['String']>;
1657
+ hiddenFromWidgets?: Maybe<Array<WidgetType>>;
1661
1658
  id: Scalars['String'];
1662
- parentPlanId?: InputMaybe<Scalars['String']>;
1663
- status?: InputMaybe<PackageStatus>;
1659
+ parentPlanId?: Maybe<Scalars['String']>;
1660
+ status?: Maybe<PackageStatus>;
1664
1661
  };
1665
1662
  export declare type PriceFilter = {
1666
- and?: InputMaybe<Array<PriceFilter>>;
1667
- billingId?: InputMaybe<StringFieldComparison>;
1668
- billingModel?: InputMaybe<BillingModelFilterComparison>;
1669
- billingPeriod?: InputMaybe<BillingPeriodFilterComparison>;
1670
- createdAt?: InputMaybe<DateFieldComparison>;
1671
- id?: InputMaybe<StringFieldComparison>;
1672
- or?: InputMaybe<Array<PriceFilter>>;
1673
- package?: InputMaybe<PriceFilterPackageDtoFilter>;
1663
+ and?: Maybe<Array<PriceFilter>>;
1664
+ billingId?: Maybe<StringFieldComparison>;
1665
+ billingModel?: Maybe<BillingModelFilterComparison>;
1666
+ billingPeriod?: Maybe<BillingPeriodFilterComparison>;
1667
+ createdAt?: Maybe<DateFieldComparison>;
1668
+ id?: Maybe<StringFieldComparison>;
1669
+ or?: Maybe<Array<PriceFilter>>;
1670
+ package?: Maybe<PriceFilterPackageDtoFilter>;
1674
1671
  };
1675
1672
  export declare type PriceFilterPackageDtoFilter = {
1676
- and?: InputMaybe<Array<PriceFilterPackageDtoFilter>>;
1677
- billingId?: InputMaybe<StringFieldComparison>;
1678
- createdAt?: InputMaybe<DateFieldComparison>;
1679
- description?: InputMaybe<StringFieldComparison>;
1680
- displayName?: InputMaybe<StringFieldComparison>;
1681
- environmentId?: InputMaybe<StringFieldComparison>;
1682
- id?: InputMaybe<StringFieldComparison>;
1683
- isLatest?: InputMaybe<BooleanFieldComparison>;
1684
- or?: InputMaybe<Array<PriceFilterPackageDtoFilter>>;
1685
- pricingType?: InputMaybe<PricingTypeFilterComparison>;
1686
- productId?: InputMaybe<StringFieldComparison>;
1687
- refId?: InputMaybe<StringFieldComparison>;
1688
- status?: InputMaybe<PackageStatusFilterComparison>;
1689
- updatedAt?: InputMaybe<DateFieldComparison>;
1690
- versionNumber?: InputMaybe<IntFieldComparison>;
1673
+ and?: Maybe<Array<PriceFilterPackageDtoFilter>>;
1674
+ billingId?: Maybe<StringFieldComparison>;
1675
+ createdAt?: Maybe<DateFieldComparison>;
1676
+ description?: Maybe<StringFieldComparison>;
1677
+ displayName?: Maybe<StringFieldComparison>;
1678
+ environmentId?: Maybe<StringFieldComparison>;
1679
+ id?: Maybe<StringFieldComparison>;
1680
+ isLatest?: Maybe<BooleanFieldComparison>;
1681
+ or?: Maybe<Array<PriceFilterPackageDtoFilter>>;
1682
+ pricingType?: Maybe<PricingTypeFilterComparison>;
1683
+ productId?: Maybe<StringFieldComparison>;
1684
+ refId?: Maybe<StringFieldComparison>;
1685
+ status?: Maybe<PackageStatusFilterComparison>;
1686
+ updatedAt?: Maybe<DateFieldComparison>;
1687
+ versionNumber?: Maybe<IntFieldComparison>;
1691
1688
  };
1692
1689
  export declare type PricePeriodInput = {
1693
- billingCountryCode?: InputMaybe<Scalars['String']>;
1690
+ billingCountryCode?: Maybe<Scalars['String']>;
1694
1691
  billingPeriod: BillingPeriod;
1695
1692
  price: MoneyInputDto;
1696
1693
  };
1697
1694
  export declare type PriceSort = {
1698
1695
  direction: SortDirection;
1699
1696
  field: PriceSortFields;
1700
- nulls?: InputMaybe<SortNulls>;
1697
+ nulls?: Maybe<SortNulls>;
1701
1698
  };
1702
1699
  export declare enum PriceSortFields {
1703
1700
  BillingId = "billingId",
@@ -1708,9 +1705,9 @@ export declare enum PriceSortFields {
1708
1705
  }
1709
1706
  export declare type PricingModelCreateInput = {
1710
1707
  billingModel: BillingModel;
1711
- featureId?: InputMaybe<Scalars['String']>;
1712
- maxUnitQuantity?: InputMaybe<Scalars['Float']>;
1713
- minUnitQuantity?: InputMaybe<Scalars['Float']>;
1708
+ featureId?: Maybe<Scalars['String']>;
1709
+ maxUnitQuantity?: Maybe<Scalars['Float']>;
1710
+ minUnitQuantity?: Maybe<Scalars['Float']>;
1714
1711
  pricePeriods: Array<PricePeriodInput>;
1715
1712
  };
1716
1713
  /** Package pricing type. */
@@ -1720,52 +1717,52 @@ export declare enum PricingType {
1720
1717
  Paid = "PAID"
1721
1718
  }
1722
1719
  export declare type PricingTypeFilterComparison = {
1723
- eq?: InputMaybe<PricingType>;
1724
- gt?: InputMaybe<PricingType>;
1725
- gte?: InputMaybe<PricingType>;
1726
- iLike?: InputMaybe<PricingType>;
1727
- in?: InputMaybe<Array<PricingType>>;
1728
- is?: InputMaybe<Scalars['Boolean']>;
1729
- isNot?: InputMaybe<Scalars['Boolean']>;
1730
- like?: InputMaybe<PricingType>;
1731
- lt?: InputMaybe<PricingType>;
1732
- lte?: InputMaybe<PricingType>;
1733
- neq?: InputMaybe<PricingType>;
1734
- notILike?: InputMaybe<PricingType>;
1735
- notIn?: InputMaybe<Array<PricingType>>;
1736
- notLike?: InputMaybe<PricingType>;
1720
+ eq?: Maybe<PricingType>;
1721
+ gt?: Maybe<PricingType>;
1722
+ gte?: Maybe<PricingType>;
1723
+ iLike?: Maybe<PricingType>;
1724
+ in?: Maybe<Array<PricingType>>;
1725
+ is?: Maybe<Scalars['Boolean']>;
1726
+ isNot?: Maybe<Scalars['Boolean']>;
1727
+ like?: Maybe<PricingType>;
1728
+ lt?: Maybe<PricingType>;
1729
+ lte?: Maybe<PricingType>;
1730
+ neq?: Maybe<PricingType>;
1731
+ notILike?: Maybe<PricingType>;
1732
+ notIn?: Maybe<Array<PricingType>>;
1733
+ notLike?: Maybe<PricingType>;
1737
1734
  };
1738
1735
  export declare type ProductCreateInput = {
1739
- additionalMetaData?: InputMaybe<Scalars['JSON']>;
1740
- description?: InputMaybe<Scalars['String']>;
1741
- displayName?: InputMaybe<Scalars['String']>;
1736
+ additionalMetaData?: Maybe<Scalars['JSON']>;
1737
+ description?: Maybe<Scalars['String']>;
1738
+ displayName?: Maybe<Scalars['String']>;
1742
1739
  environmentId: Scalars['String'];
1743
1740
  refId: Scalars['String'];
1744
1741
  };
1745
1742
  export declare type ProductFilter = {
1746
- and?: InputMaybe<Array<ProductFilter>>;
1747
- createdAt?: InputMaybe<DateFieldComparison>;
1748
- description?: InputMaybe<StringFieldComparison>;
1749
- displayName?: InputMaybe<StringFieldComparison>;
1750
- environmentId?: InputMaybe<StringFieldComparison>;
1751
- id?: InputMaybe<StringFieldComparison>;
1752
- isDefaultProduct?: InputMaybe<BooleanFieldComparison>;
1753
- or?: InputMaybe<Array<ProductFilter>>;
1754
- refId?: InputMaybe<StringFieldComparison>;
1755
- updatedAt?: InputMaybe<DateFieldComparison>;
1743
+ and?: Maybe<Array<ProductFilter>>;
1744
+ createdAt?: Maybe<DateFieldComparison>;
1745
+ description?: Maybe<StringFieldComparison>;
1746
+ displayName?: Maybe<StringFieldComparison>;
1747
+ environmentId?: Maybe<StringFieldComparison>;
1748
+ id?: Maybe<StringFieldComparison>;
1749
+ isDefaultProduct?: Maybe<BooleanFieldComparison>;
1750
+ or?: Maybe<Array<ProductFilter>>;
1751
+ refId?: Maybe<StringFieldComparison>;
1752
+ updatedAt?: Maybe<DateFieldComparison>;
1756
1753
  };
1757
1754
  export declare type ProductSettingsInput = {
1758
- downgradeAtEndOfBillingPeriod?: InputMaybe<Scalars['String']>;
1759
- downgradePlanId?: InputMaybe<Scalars['String']>;
1755
+ downgradeAtEndOfBillingPeriod?: Maybe<Scalars['String']>;
1756
+ downgradePlanId?: Maybe<Scalars['String']>;
1760
1757
  subscriptionCancellationTime: SubscriptionCancellationTime;
1761
1758
  subscriptionEndSetup: SubscriptionEndSetup;
1762
- subscriptionStartPlanId?: InputMaybe<Scalars['String']>;
1759
+ subscriptionStartPlanId?: Maybe<Scalars['String']>;
1763
1760
  subscriptionStartSetup: SubscriptionStartSetup;
1764
1761
  };
1765
1762
  export declare type ProductSort = {
1766
1763
  direction: SortDirection;
1767
1764
  field: ProductSortFields;
1768
- nulls?: InputMaybe<SortNulls>;
1765
+ nulls?: Maybe<SortNulls>;
1769
1766
  };
1770
1767
  export declare enum ProductSortFields {
1771
1768
  CreatedAt = "createdAt",
@@ -1778,33 +1775,33 @@ export declare enum ProductSortFields {
1778
1775
  UpdatedAt = "updatedAt"
1779
1776
  }
1780
1777
  export declare type ProductUpdateInput = {
1781
- additionalMetaData?: InputMaybe<Scalars['JSON']>;
1782
- description?: InputMaybe<Scalars['String']>;
1783
- displayName?: InputMaybe<Scalars['String']>;
1784
- productSettings?: InputMaybe<ProductSettingsInput>;
1778
+ additionalMetaData?: Maybe<Scalars['JSON']>;
1779
+ description?: Maybe<Scalars['String']>;
1780
+ displayName?: Maybe<Scalars['String']>;
1781
+ productSettings?: Maybe<ProductSettingsInput>;
1785
1782
  };
1786
1783
  export declare type PromotionalEntitlementFilter = {
1787
- and?: InputMaybe<Array<PromotionalEntitlementFilter>>;
1788
- createdAt?: InputMaybe<DateFieldComparison>;
1789
- environmentId?: InputMaybe<StringFieldComparison>;
1790
- id?: InputMaybe<StringFieldComparison>;
1791
- or?: InputMaybe<Array<PromotionalEntitlementFilter>>;
1792
- status?: InputMaybe<PromotionalEntitlementStatusFilterComparison>;
1793
- updatedAt?: InputMaybe<DateFieldComparison>;
1784
+ and?: Maybe<Array<PromotionalEntitlementFilter>>;
1785
+ createdAt?: Maybe<DateFieldComparison>;
1786
+ environmentId?: Maybe<StringFieldComparison>;
1787
+ id?: Maybe<StringFieldComparison>;
1788
+ or?: Maybe<Array<PromotionalEntitlementFilter>>;
1789
+ status?: Maybe<PromotionalEntitlementStatusFilterComparison>;
1790
+ updatedAt?: Maybe<DateFieldComparison>;
1794
1791
  };
1795
1792
  export declare type PromotionalEntitlementInput = {
1796
1793
  customerId: Scalars['String'];
1797
- description?: InputMaybe<Scalars['String']>;
1798
- endDate?: InputMaybe<Scalars['DateTime']>;
1794
+ description?: Maybe<Scalars['String']>;
1795
+ endDate?: Maybe<Scalars['DateTime']>;
1799
1796
  environmentId: Scalars['String'];
1800
1797
  featureId: Scalars['String'];
1801
- hasUnlimitedUsage?: InputMaybe<Scalars['Boolean']>;
1798
+ hasUnlimitedUsage?: Maybe<Scalars['Boolean']>;
1802
1799
  isVisible: Scalars['Boolean'];
1803
- monthlyResetPeriodConfiguration?: InputMaybe<MonthlyResetPeriodConfigInput>;
1800
+ monthlyResetPeriodConfiguration?: Maybe<MonthlyResetPeriodConfigInput>;
1804
1801
  period: PromotionalEntitlementPeriod;
1805
- resetPeriod?: InputMaybe<EntitlementResetPeriod>;
1806
- usageLimit?: InputMaybe<Scalars['Float']>;
1807
- weeklyResetPeriodConfiguration?: InputMaybe<WeeklyResetPeriodConfigInput>;
1802
+ resetPeriod?: Maybe<EntitlementResetPeriod>;
1803
+ usageLimit?: Maybe<Scalars['Float']>;
1804
+ weeklyResetPeriodConfiguration?: Maybe<WeeklyResetPeriodConfigInput>;
1808
1805
  };
1809
1806
  /** Promotional entitlement duration */
1810
1807
  export declare enum PromotionalEntitlementPeriod {
@@ -1818,7 +1815,7 @@ export declare enum PromotionalEntitlementPeriod {
1818
1815
  export declare type PromotionalEntitlementSort = {
1819
1816
  direction: SortDirection;
1820
1817
  field: PromotionalEntitlementSortFields;
1821
- nulls?: InputMaybe<SortNulls>;
1818
+ nulls?: Maybe<SortNulls>;
1822
1819
  };
1823
1820
  export declare enum PromotionalEntitlementSortFields {
1824
1821
  CreatedAt = "createdAt",
@@ -1834,96 +1831,96 @@ export declare enum PromotionalEntitlementStatus {
1834
1831
  Paused = "Paused"
1835
1832
  }
1836
1833
  export declare type PromotionalEntitlementStatusFilterComparison = {
1837
- eq?: InputMaybe<PromotionalEntitlementStatus>;
1838
- gt?: InputMaybe<PromotionalEntitlementStatus>;
1839
- gte?: InputMaybe<PromotionalEntitlementStatus>;
1840
- iLike?: InputMaybe<PromotionalEntitlementStatus>;
1841
- in?: InputMaybe<Array<PromotionalEntitlementStatus>>;
1842
- is?: InputMaybe<Scalars['Boolean']>;
1843
- isNot?: InputMaybe<Scalars['Boolean']>;
1844
- like?: InputMaybe<PromotionalEntitlementStatus>;
1845
- lt?: InputMaybe<PromotionalEntitlementStatus>;
1846
- lte?: InputMaybe<PromotionalEntitlementStatus>;
1847
- neq?: InputMaybe<PromotionalEntitlementStatus>;
1848
- notILike?: InputMaybe<PromotionalEntitlementStatus>;
1849
- notIn?: InputMaybe<Array<PromotionalEntitlementStatus>>;
1850
- notLike?: InputMaybe<PromotionalEntitlementStatus>;
1834
+ eq?: Maybe<PromotionalEntitlementStatus>;
1835
+ gt?: Maybe<PromotionalEntitlementStatus>;
1836
+ gte?: Maybe<PromotionalEntitlementStatus>;
1837
+ iLike?: Maybe<PromotionalEntitlementStatus>;
1838
+ in?: Maybe<Array<PromotionalEntitlementStatus>>;
1839
+ is?: Maybe<Scalars['Boolean']>;
1840
+ isNot?: Maybe<Scalars['Boolean']>;
1841
+ like?: Maybe<PromotionalEntitlementStatus>;
1842
+ lt?: Maybe<PromotionalEntitlementStatus>;
1843
+ lte?: Maybe<PromotionalEntitlementStatus>;
1844
+ neq?: Maybe<PromotionalEntitlementStatus>;
1845
+ notILike?: Maybe<PromotionalEntitlementStatus>;
1846
+ notIn?: Maybe<Array<PromotionalEntitlementStatus>>;
1847
+ notLike?: Maybe<PromotionalEntitlementStatus>;
1851
1848
  };
1852
1849
  export declare type PromotionalEntitlementUpdateInput = {
1853
- description?: InputMaybe<Scalars['String']>;
1854
- endDate?: InputMaybe<Scalars['DateTime']>;
1855
- hasUnlimitedUsage?: InputMaybe<Scalars['Boolean']>;
1850
+ description?: Maybe<Scalars['String']>;
1851
+ endDate?: Maybe<Scalars['DateTime']>;
1852
+ hasUnlimitedUsage?: Maybe<Scalars['Boolean']>;
1856
1853
  isVisible: Scalars['Boolean'];
1857
- monthlyResetPeriodConfiguration?: InputMaybe<MonthlyResetPeriodConfigInput>;
1854
+ monthlyResetPeriodConfiguration?: Maybe<MonthlyResetPeriodConfigInput>;
1858
1855
  period: PromotionalEntitlementPeriod;
1859
- resetPeriod?: InputMaybe<EntitlementResetPeriod>;
1860
- usageLimit?: InputMaybe<Scalars['Float']>;
1861
- weeklyResetPeriodConfiguration?: InputMaybe<WeeklyResetPeriodConfigInput>;
1856
+ resetPeriod?: Maybe<EntitlementResetPeriod>;
1857
+ usageLimit?: Maybe<Scalars['Float']>;
1858
+ weeklyResetPeriodConfiguration?: Maybe<WeeklyResetPeriodConfigInput>;
1862
1859
  };
1863
1860
  export declare enum ProrationBehavior {
1864
1861
  CreateProrations = "CREATE_PRORATIONS",
1865
1862
  InvoiceImmediately = "INVOICE_IMMEDIATELY"
1866
1863
  }
1867
1864
  export declare type ProvisionCustomerInput = {
1868
- additionalMetaData?: InputMaybe<Scalars['JSON']>;
1869
- billingId?: InputMaybe<Scalars['String']>;
1870
- billingInformation?: InputMaybe<CustomerBillingInfo>;
1871
- couponRefId?: InputMaybe<Scalars['String']>;
1872
- createdAt?: InputMaybe<Scalars['DateTime']>;
1873
- crmId?: InputMaybe<Scalars['String']>;
1874
- customerId?: InputMaybe<Scalars['String']>;
1875
- email?: InputMaybe<Scalars['String']>;
1876
- environmentId?: InputMaybe<Scalars['String']>;
1877
- excludeFromExperiment?: InputMaybe<Scalars['Boolean']>;
1878
- name?: InputMaybe<Scalars['String']>;
1879
- refId?: InputMaybe<Scalars['String']>;
1880
- shouldSyncFree?: InputMaybe<Scalars['Boolean']>;
1881
- subscriptionParams?: InputMaybe<ProvisionCustomerSubscriptionInput>;
1865
+ additionalMetaData?: Maybe<Scalars['JSON']>;
1866
+ billingId?: Maybe<Scalars['String']>;
1867
+ billingInformation?: Maybe<CustomerBillingInfo>;
1868
+ couponRefId?: Maybe<Scalars['String']>;
1869
+ createdAt?: Maybe<Scalars['DateTime']>;
1870
+ crmId?: Maybe<Scalars['String']>;
1871
+ customerId?: Maybe<Scalars['String']>;
1872
+ email?: Maybe<Scalars['String']>;
1873
+ environmentId?: Maybe<Scalars['String']>;
1874
+ excludeFromExperiment?: Maybe<Scalars['Boolean']>;
1875
+ name?: Maybe<Scalars['String']>;
1876
+ refId?: Maybe<Scalars['String']>;
1877
+ shouldSyncFree?: Maybe<Scalars['Boolean']>;
1878
+ subscriptionParams?: Maybe<ProvisionCustomerSubscriptionInput>;
1882
1879
  };
1883
1880
  export declare type ProvisionCustomerSubscriptionInput = {
1884
- additionalMetaData?: InputMaybe<Scalars['JSON']>;
1885
- addons?: InputMaybe<Array<SubscriptionAddonInput>>;
1886
- awaitPaymentConfirmation?: InputMaybe<Scalars['Boolean']>;
1887
- billingInformation?: InputMaybe<SubscriptionBillingInfo>;
1888
- billingPeriod?: InputMaybe<BillingPeriod>;
1881
+ additionalMetaData?: Maybe<Scalars['JSON']>;
1882
+ addons?: Maybe<Array<SubscriptionAddonInput>>;
1883
+ awaitPaymentConfirmation?: Maybe<Scalars['Boolean']>;
1884
+ billingInformation?: Maybe<SubscriptionBillingInfo>;
1885
+ billingPeriod?: Maybe<BillingPeriod>;
1889
1886
  planId: Scalars['String'];
1890
- priceUnitAmount?: InputMaybe<Scalars['Float']>;
1891
- promotionCode?: InputMaybe<Scalars['String']>;
1892
- refId?: InputMaybe<Scalars['String']>;
1893
- startDate?: InputMaybe<Scalars['DateTime']>;
1894
- subscriptionId?: InputMaybe<Scalars['String']>;
1887
+ priceUnitAmount?: Maybe<Scalars['Float']>;
1888
+ promotionCode?: Maybe<Scalars['String']>;
1889
+ refId?: Maybe<Scalars['String']>;
1890
+ startDate?: Maybe<Scalars['DateTime']>;
1891
+ subscriptionId?: Maybe<Scalars['String']>;
1895
1892
  };
1896
1893
  export declare type ProvisionSubscription = {
1897
- additionalMetaData?: InputMaybe<Scalars['JSON']>;
1898
- addons?: InputMaybe<Array<SubscriptionAddonInput>>;
1899
- awaitPaymentConfirmation?: InputMaybe<Scalars['Boolean']>;
1900
- billingInformation?: InputMaybe<SubscriptionBillingInfo>;
1901
- billingPeriod?: InputMaybe<BillingPeriod>;
1902
- checkoutOptions?: InputMaybe<CheckoutOptions>;
1894
+ additionalMetaData?: Maybe<Scalars['JSON']>;
1895
+ addons?: Maybe<Array<SubscriptionAddonInput>>;
1896
+ awaitPaymentConfirmation?: Maybe<Scalars['Boolean']>;
1897
+ billingInformation?: Maybe<SubscriptionBillingInfo>;
1898
+ billingPeriod?: Maybe<BillingPeriod>;
1899
+ checkoutOptions?: Maybe<CheckoutOptions>;
1903
1900
  customerId: Scalars['String'];
1904
1901
  planId: Scalars['String'];
1905
- priceUnitAmount?: InputMaybe<Scalars['Float']>;
1906
- promotionCode?: InputMaybe<Scalars['String']>;
1907
- refId?: InputMaybe<Scalars['String']>;
1908
- skipTrial?: InputMaybe<Scalars['Boolean']>;
1909
- startDate?: InputMaybe<Scalars['DateTime']>;
1910
- subscriptionId?: InputMaybe<Scalars['String']>;
1902
+ priceUnitAmount?: Maybe<Scalars['Float']>;
1903
+ promotionCode?: Maybe<Scalars['String']>;
1904
+ refId?: Maybe<Scalars['String']>;
1905
+ skipTrial?: Maybe<Scalars['Boolean']>;
1906
+ startDate?: Maybe<Scalars['DateTime']>;
1907
+ subscriptionId?: Maybe<Scalars['String']>;
1911
1908
  };
1912
1909
  export declare type ProvisionSubscriptionInput = {
1913
- additionalMetaData?: InputMaybe<Scalars['JSON']>;
1914
- addons?: InputMaybe<Array<SubscriptionAddonInput>>;
1915
- awaitPaymentConfirmation?: InputMaybe<Scalars['Boolean']>;
1916
- billingInformation?: InputMaybe<SubscriptionBillingInfo>;
1917
- billingPeriod?: InputMaybe<BillingPeriod>;
1918
- checkoutOptions?: InputMaybe<CheckoutOptions>;
1910
+ additionalMetaData?: Maybe<Scalars['JSON']>;
1911
+ addons?: Maybe<Array<SubscriptionAddonInput>>;
1912
+ awaitPaymentConfirmation?: Maybe<Scalars['Boolean']>;
1913
+ billingInformation?: Maybe<SubscriptionBillingInfo>;
1914
+ billingPeriod?: Maybe<BillingPeriod>;
1915
+ checkoutOptions?: Maybe<CheckoutOptions>;
1919
1916
  customerId: Scalars['String'];
1920
1917
  planId: Scalars['String'];
1921
- priceUnitAmount?: InputMaybe<Scalars['Float']>;
1922
- promotionCode?: InputMaybe<Scalars['String']>;
1923
- refId?: InputMaybe<Scalars['String']>;
1924
- skipTrial?: InputMaybe<Scalars['Boolean']>;
1925
- startDate?: InputMaybe<Scalars['DateTime']>;
1926
- subscriptionId?: InputMaybe<Scalars['String']>;
1918
+ priceUnitAmount?: Maybe<Scalars['Float']>;
1919
+ promotionCode?: Maybe<Scalars['String']>;
1920
+ refId?: Maybe<Scalars['String']>;
1921
+ skipTrial?: Maybe<Scalars['Boolean']>;
1922
+ startDate?: Maybe<Scalars['DateTime']>;
1923
+ subscriptionId?: Maybe<Scalars['String']>;
1927
1924
  };
1928
1925
  /** Provision subscription status */
1929
1926
  export declare enum ProvisionSubscriptionStatus {
@@ -2026,114 +2023,114 @@ export declare enum SourceType {
2026
2023
  NodeServerSdk = "NODE_SERVER_SDK"
2027
2024
  }
2028
2025
  export declare type StartExperimentInput = {
2029
- environmentId?: InputMaybe<Scalars['String']>;
2026
+ environmentId?: Maybe<Scalars['String']>;
2030
2027
  refId: Scalars['String'];
2031
2028
  };
2032
2029
  export declare type StopExperimentInput = {
2033
- environmentId?: InputMaybe<Scalars['String']>;
2030
+ environmentId?: Maybe<Scalars['String']>;
2034
2031
  refId: Scalars['String'];
2035
2032
  };
2036
2033
  export declare type StringFieldComparison = {
2037
- eq?: InputMaybe<Scalars['String']>;
2038
- gt?: InputMaybe<Scalars['String']>;
2039
- gte?: InputMaybe<Scalars['String']>;
2040
- iLike?: InputMaybe<Scalars['String']>;
2041
- in?: InputMaybe<Array<Scalars['String']>>;
2042
- is?: InputMaybe<Scalars['Boolean']>;
2043
- isNot?: InputMaybe<Scalars['Boolean']>;
2044
- like?: InputMaybe<Scalars['String']>;
2045
- lt?: InputMaybe<Scalars['String']>;
2046
- lte?: InputMaybe<Scalars['String']>;
2047
- neq?: InputMaybe<Scalars['String']>;
2048
- notILike?: InputMaybe<Scalars['String']>;
2049
- notIn?: InputMaybe<Array<Scalars['String']>>;
2050
- notLike?: InputMaybe<Scalars['String']>;
2034
+ eq?: Maybe<Scalars['String']>;
2035
+ gt?: Maybe<Scalars['String']>;
2036
+ gte?: Maybe<Scalars['String']>;
2037
+ iLike?: Maybe<Scalars['String']>;
2038
+ in?: Maybe<Array<Scalars['String']>>;
2039
+ is?: Maybe<Scalars['Boolean']>;
2040
+ isNot?: Maybe<Scalars['Boolean']>;
2041
+ like?: Maybe<Scalars['String']>;
2042
+ lt?: Maybe<Scalars['String']>;
2043
+ lte?: Maybe<Scalars['String']>;
2044
+ neq?: Maybe<Scalars['String']>;
2045
+ notILike?: Maybe<Scalars['String']>;
2046
+ notIn?: Maybe<Array<Scalars['String']>>;
2047
+ notLike?: Maybe<Scalars['String']>;
2051
2048
  };
2052
2049
  export declare type StripeCredentialsInput = {
2053
- accountId?: InputMaybe<Scalars['String']>;
2050
+ accountId?: Maybe<Scalars['String']>;
2054
2051
  authorizationCode: Scalars['String'];
2055
2052
  isTestMode: Scalars['Boolean'];
2056
2053
  };
2057
2054
  export declare type StripeCustomerSearchInput = {
2058
- customerName?: InputMaybe<Scalars['String']>;
2055
+ customerName?: Maybe<Scalars['String']>;
2059
2056
  environmentId: Scalars['String'];
2060
- nextPage?: InputMaybe<Scalars['String']>;
2057
+ nextPage?: Maybe<Scalars['String']>;
2061
2058
  };
2062
2059
  export declare type StripeProductSearchInput = {
2063
2060
  environmentId: Scalars['String'];
2064
- nextPage?: InputMaybe<Scalars['String']>;
2065
- productName?: InputMaybe<Scalars['String']>;
2061
+ nextPage?: Maybe<Scalars['String']>;
2062
+ productName?: Maybe<Scalars['String']>;
2066
2063
  };
2067
2064
  export declare type StripeSubscriptionSearchInput = {
2068
2065
  environmentId: Scalars['String'];
2069
- nextPage?: InputMaybe<Scalars['String']>;
2066
+ nextPage?: Maybe<Scalars['String']>;
2070
2067
  };
2071
2068
  export declare type SubscriptionAddonFilter = {
2072
- addon?: InputMaybe<SubscriptionAddonFilterAddonFilter>;
2073
- and?: InputMaybe<Array<SubscriptionAddonFilter>>;
2074
- createdAt?: InputMaybe<DateFieldComparison>;
2075
- id?: InputMaybe<StringFieldComparison>;
2076
- or?: InputMaybe<Array<SubscriptionAddonFilter>>;
2077
- price?: InputMaybe<SubscriptionAddonFilterPriceFilter>;
2078
- quantity?: InputMaybe<NumberFieldComparison>;
2079
- subscription?: InputMaybe<SubscriptionAddonFilterCustomerSubscriptionFilter>;
2080
- updatedAt?: InputMaybe<DateFieldComparison>;
2069
+ addon?: Maybe<SubscriptionAddonFilterAddonFilter>;
2070
+ and?: Maybe<Array<SubscriptionAddonFilter>>;
2071
+ createdAt?: Maybe<DateFieldComparison>;
2072
+ id?: Maybe<StringFieldComparison>;
2073
+ or?: Maybe<Array<SubscriptionAddonFilter>>;
2074
+ price?: Maybe<SubscriptionAddonFilterPriceFilter>;
2075
+ quantity?: Maybe<NumberFieldComparison>;
2076
+ subscription?: Maybe<SubscriptionAddonFilterCustomerSubscriptionFilter>;
2077
+ updatedAt?: Maybe<DateFieldComparison>;
2081
2078
  };
2082
2079
  export declare type SubscriptionAddonFilterAddonFilter = {
2083
- and?: InputMaybe<Array<SubscriptionAddonFilterAddonFilter>>;
2084
- billingId?: InputMaybe<StringFieldComparison>;
2085
- createdAt?: InputMaybe<DateFieldComparison>;
2086
- description?: InputMaybe<StringFieldComparison>;
2087
- displayName?: InputMaybe<StringFieldComparison>;
2088
- environmentId?: InputMaybe<StringFieldComparison>;
2089
- id?: InputMaybe<StringFieldComparison>;
2090
- isLatest?: InputMaybe<BooleanFieldComparison>;
2091
- or?: InputMaybe<Array<SubscriptionAddonFilterAddonFilter>>;
2092
- pricingType?: InputMaybe<PricingTypeFilterComparison>;
2093
- productId?: InputMaybe<StringFieldComparison>;
2094
- refId?: InputMaybe<StringFieldComparison>;
2095
- status?: InputMaybe<PackageStatusFilterComparison>;
2096
- updatedAt?: InputMaybe<DateFieldComparison>;
2097
- versionNumber?: InputMaybe<IntFieldComparison>;
2080
+ and?: Maybe<Array<SubscriptionAddonFilterAddonFilter>>;
2081
+ billingId?: Maybe<StringFieldComparison>;
2082
+ createdAt?: Maybe<DateFieldComparison>;
2083
+ description?: Maybe<StringFieldComparison>;
2084
+ displayName?: Maybe<StringFieldComparison>;
2085
+ environmentId?: Maybe<StringFieldComparison>;
2086
+ id?: Maybe<StringFieldComparison>;
2087
+ isLatest?: Maybe<BooleanFieldComparison>;
2088
+ or?: Maybe<Array<SubscriptionAddonFilterAddonFilter>>;
2089
+ pricingType?: Maybe<PricingTypeFilterComparison>;
2090
+ productId?: Maybe<StringFieldComparison>;
2091
+ refId?: Maybe<StringFieldComparison>;
2092
+ status?: Maybe<PackageStatusFilterComparison>;
2093
+ updatedAt?: Maybe<DateFieldComparison>;
2094
+ versionNumber?: Maybe<IntFieldComparison>;
2098
2095
  };
2099
2096
  export declare type SubscriptionAddonFilterCustomerSubscriptionFilter = {
2100
- and?: InputMaybe<Array<SubscriptionAddonFilterCustomerSubscriptionFilter>>;
2101
- billingId?: InputMaybe<StringFieldComparison>;
2102
- cancelReason?: InputMaybe<SubscriptionCancelReasonFilterComparison>;
2103
- cancellationDate?: InputMaybe<DateFieldComparison>;
2104
- createdAt?: InputMaybe<DateFieldComparison>;
2105
- crmId?: InputMaybe<StringFieldComparison>;
2106
- crmLinkUrl?: InputMaybe<StringFieldComparison>;
2107
- effectiveEndDate?: InputMaybe<DateFieldComparison>;
2108
- endDate?: InputMaybe<DateFieldComparison>;
2109
- environmentId?: InputMaybe<StringFieldComparison>;
2110
- id?: InputMaybe<StringFieldComparison>;
2111
- oldBillingId?: InputMaybe<StringFieldComparison>;
2112
- or?: InputMaybe<Array<SubscriptionAddonFilterCustomerSubscriptionFilter>>;
2113
- pricingType?: InputMaybe<PricingTypeFilterComparison>;
2114
- refId?: InputMaybe<StringFieldComparison>;
2115
- startDate?: InputMaybe<DateFieldComparison>;
2116
- status?: InputMaybe<SubscriptionStatusFilterComparison>;
2117
- subscriptionId?: InputMaybe<StringFieldComparison>;
2118
- trialEndDate?: InputMaybe<DateFieldComparison>;
2097
+ and?: Maybe<Array<SubscriptionAddonFilterCustomerSubscriptionFilter>>;
2098
+ billingId?: Maybe<StringFieldComparison>;
2099
+ cancelReason?: Maybe<SubscriptionCancelReasonFilterComparison>;
2100
+ cancellationDate?: Maybe<DateFieldComparison>;
2101
+ createdAt?: Maybe<DateFieldComparison>;
2102
+ crmId?: Maybe<StringFieldComparison>;
2103
+ crmLinkUrl?: Maybe<StringFieldComparison>;
2104
+ effectiveEndDate?: Maybe<DateFieldComparison>;
2105
+ endDate?: Maybe<DateFieldComparison>;
2106
+ environmentId?: Maybe<StringFieldComparison>;
2107
+ id?: Maybe<StringFieldComparison>;
2108
+ oldBillingId?: Maybe<StringFieldComparison>;
2109
+ or?: Maybe<Array<SubscriptionAddonFilterCustomerSubscriptionFilter>>;
2110
+ pricingType?: Maybe<PricingTypeFilterComparison>;
2111
+ refId?: Maybe<StringFieldComparison>;
2112
+ startDate?: Maybe<DateFieldComparison>;
2113
+ status?: Maybe<SubscriptionStatusFilterComparison>;
2114
+ subscriptionId?: Maybe<StringFieldComparison>;
2115
+ trialEndDate?: Maybe<DateFieldComparison>;
2119
2116
  };
2120
2117
  export declare type SubscriptionAddonFilterPriceFilter = {
2121
- and?: InputMaybe<Array<SubscriptionAddonFilterPriceFilter>>;
2122
- billingId?: InputMaybe<StringFieldComparison>;
2123
- billingModel?: InputMaybe<BillingModelFilterComparison>;
2124
- billingPeriod?: InputMaybe<BillingPeriodFilterComparison>;
2125
- createdAt?: InputMaybe<DateFieldComparison>;
2126
- id?: InputMaybe<StringFieldComparison>;
2127
- or?: InputMaybe<Array<SubscriptionAddonFilterPriceFilter>>;
2118
+ and?: Maybe<Array<SubscriptionAddonFilterPriceFilter>>;
2119
+ billingId?: Maybe<StringFieldComparison>;
2120
+ billingModel?: Maybe<BillingModelFilterComparison>;
2121
+ billingPeriod?: Maybe<BillingPeriodFilterComparison>;
2122
+ createdAt?: Maybe<DateFieldComparison>;
2123
+ id?: Maybe<StringFieldComparison>;
2124
+ or?: Maybe<Array<SubscriptionAddonFilterPriceFilter>>;
2128
2125
  };
2129
2126
  export declare type SubscriptionAddonInput = {
2130
2127
  addonId: Scalars['String'];
2131
- quantity?: InputMaybe<Scalars['Int']>;
2128
+ quantity?: Maybe<Scalars['Int']>;
2132
2129
  };
2133
2130
  export declare type SubscriptionAddonSort = {
2134
2131
  direction: SortDirection;
2135
2132
  field: SubscriptionAddonSortFields;
2136
- nulls?: InputMaybe<SortNulls>;
2133
+ nulls?: Maybe<SortNulls>;
2137
2134
  };
2138
2135
  export declare enum SubscriptionAddonSortFields {
2139
2136
  CreatedAt = "createdAt",
@@ -2142,7 +2139,7 @@ export declare enum SubscriptionAddonSortFields {
2142
2139
  UpdatedAt = "updatedAt"
2143
2140
  }
2144
2141
  export declare type SubscriptionBillingInfo = {
2145
- taxRateIds?: InputMaybe<Array<Scalars['String']>>;
2142
+ taxRateIds?: Maybe<Array<Scalars['String']>>;
2146
2143
  };
2147
2144
  /** Subscription cancellation status */
2148
2145
  export declare enum SubscriptionCancelReason {
@@ -2157,25 +2154,25 @@ export declare enum SubscriptionCancelReason {
2157
2154
  UpgradeOrDowngrade = "UpgradeOrDowngrade"
2158
2155
  }
2159
2156
  export declare type SubscriptionCancelReasonFilterComparison = {
2160
- eq?: InputMaybe<SubscriptionCancelReason>;
2161
- gt?: InputMaybe<SubscriptionCancelReason>;
2162
- gte?: InputMaybe<SubscriptionCancelReason>;
2163
- iLike?: InputMaybe<SubscriptionCancelReason>;
2164
- in?: InputMaybe<Array<SubscriptionCancelReason>>;
2165
- is?: InputMaybe<Scalars['Boolean']>;
2166
- isNot?: InputMaybe<Scalars['Boolean']>;
2167
- like?: InputMaybe<SubscriptionCancelReason>;
2168
- lt?: InputMaybe<SubscriptionCancelReason>;
2169
- lte?: InputMaybe<SubscriptionCancelReason>;
2170
- neq?: InputMaybe<SubscriptionCancelReason>;
2171
- notILike?: InputMaybe<SubscriptionCancelReason>;
2172
- notIn?: InputMaybe<Array<SubscriptionCancelReason>>;
2173
- notLike?: InputMaybe<SubscriptionCancelReason>;
2157
+ eq?: Maybe<SubscriptionCancelReason>;
2158
+ gt?: Maybe<SubscriptionCancelReason>;
2159
+ gte?: Maybe<SubscriptionCancelReason>;
2160
+ iLike?: Maybe<SubscriptionCancelReason>;
2161
+ in?: Maybe<Array<SubscriptionCancelReason>>;
2162
+ is?: Maybe<Scalars['Boolean']>;
2163
+ isNot?: Maybe<Scalars['Boolean']>;
2164
+ like?: Maybe<SubscriptionCancelReason>;
2165
+ lt?: Maybe<SubscriptionCancelReason>;
2166
+ lte?: Maybe<SubscriptionCancelReason>;
2167
+ neq?: Maybe<SubscriptionCancelReason>;
2168
+ notILike?: Maybe<SubscriptionCancelReason>;
2169
+ notIn?: Maybe<Array<SubscriptionCancelReason>>;
2170
+ notLike?: Maybe<SubscriptionCancelReason>;
2174
2171
  };
2175
2172
  export declare type SubscriptionCancellationInput = {
2176
- endDate?: InputMaybe<Scalars['DateTime']>;
2177
- environmentId?: InputMaybe<Scalars['String']>;
2178
- subscriptionCancellationTime?: InputMaybe<SubscriptionCancellationTime>;
2173
+ endDate?: Maybe<Scalars['DateTime']>;
2174
+ environmentId?: Maybe<Scalars['String']>;
2175
+ subscriptionCancellationTime?: Maybe<SubscriptionCancellationTime>;
2179
2176
  subscriptionRefId: Scalars['String'];
2180
2177
  };
2181
2178
  export declare enum SubscriptionCancellationTime {
@@ -2195,64 +2192,64 @@ export declare enum SubscriptionEndSetup {
2195
2192
  DowngradeToFree = "DOWNGRADE_TO_FREE"
2196
2193
  }
2197
2194
  export declare type SubscriptionEntitlementFilter = {
2198
- and?: InputMaybe<Array<SubscriptionEntitlementFilter>>;
2199
- createdAt?: InputMaybe<DateFieldComparison>;
2200
- environmentId?: InputMaybe<StringFieldComparison>;
2201
- feature?: InputMaybe<SubscriptionEntitlementFilterFeatureFilter>;
2202
- id?: InputMaybe<StringFieldComparison>;
2203
- or?: InputMaybe<Array<SubscriptionEntitlementFilter>>;
2204
- subscription?: InputMaybe<SubscriptionEntitlementFilterCustomerSubscriptionFilter>;
2205
- subscriptionId?: InputMaybe<StringFieldComparison>;
2206
- updatedAt?: InputMaybe<DateFieldComparison>;
2195
+ and?: Maybe<Array<SubscriptionEntitlementFilter>>;
2196
+ createdAt?: Maybe<DateFieldComparison>;
2197
+ environmentId?: Maybe<StringFieldComparison>;
2198
+ feature?: Maybe<SubscriptionEntitlementFilterFeatureFilter>;
2199
+ id?: Maybe<StringFieldComparison>;
2200
+ or?: Maybe<Array<SubscriptionEntitlementFilter>>;
2201
+ subscription?: Maybe<SubscriptionEntitlementFilterCustomerSubscriptionFilter>;
2202
+ subscriptionId?: Maybe<StringFieldComparison>;
2203
+ updatedAt?: Maybe<DateFieldComparison>;
2207
2204
  };
2208
2205
  export declare type SubscriptionEntitlementFilterCustomerSubscriptionFilter = {
2209
- and?: InputMaybe<Array<SubscriptionEntitlementFilterCustomerSubscriptionFilter>>;
2210
- billingId?: InputMaybe<StringFieldComparison>;
2211
- cancelReason?: InputMaybe<SubscriptionCancelReasonFilterComparison>;
2212
- cancellationDate?: InputMaybe<DateFieldComparison>;
2213
- createdAt?: InputMaybe<DateFieldComparison>;
2214
- crmId?: InputMaybe<StringFieldComparison>;
2215
- crmLinkUrl?: InputMaybe<StringFieldComparison>;
2216
- effectiveEndDate?: InputMaybe<DateFieldComparison>;
2217
- endDate?: InputMaybe<DateFieldComparison>;
2218
- environmentId?: InputMaybe<StringFieldComparison>;
2219
- id?: InputMaybe<StringFieldComparison>;
2220
- oldBillingId?: InputMaybe<StringFieldComparison>;
2221
- or?: InputMaybe<Array<SubscriptionEntitlementFilterCustomerSubscriptionFilter>>;
2222
- pricingType?: InputMaybe<PricingTypeFilterComparison>;
2223
- refId?: InputMaybe<StringFieldComparison>;
2224
- startDate?: InputMaybe<DateFieldComparison>;
2225
- status?: InputMaybe<SubscriptionStatusFilterComparison>;
2226
- subscriptionId?: InputMaybe<StringFieldComparison>;
2227
- trialEndDate?: InputMaybe<DateFieldComparison>;
2206
+ and?: Maybe<Array<SubscriptionEntitlementFilterCustomerSubscriptionFilter>>;
2207
+ billingId?: Maybe<StringFieldComparison>;
2208
+ cancelReason?: Maybe<SubscriptionCancelReasonFilterComparison>;
2209
+ cancellationDate?: Maybe<DateFieldComparison>;
2210
+ createdAt?: Maybe<DateFieldComparison>;
2211
+ crmId?: Maybe<StringFieldComparison>;
2212
+ crmLinkUrl?: Maybe<StringFieldComparison>;
2213
+ effectiveEndDate?: Maybe<DateFieldComparison>;
2214
+ endDate?: Maybe<DateFieldComparison>;
2215
+ environmentId?: Maybe<StringFieldComparison>;
2216
+ id?: Maybe<StringFieldComparison>;
2217
+ oldBillingId?: Maybe<StringFieldComparison>;
2218
+ or?: Maybe<Array<SubscriptionEntitlementFilterCustomerSubscriptionFilter>>;
2219
+ pricingType?: Maybe<PricingTypeFilterComparison>;
2220
+ refId?: Maybe<StringFieldComparison>;
2221
+ startDate?: Maybe<DateFieldComparison>;
2222
+ status?: Maybe<SubscriptionStatusFilterComparison>;
2223
+ subscriptionId?: Maybe<StringFieldComparison>;
2224
+ trialEndDate?: Maybe<DateFieldComparison>;
2228
2225
  };
2229
2226
  export declare type SubscriptionEntitlementFilterFeatureFilter = {
2230
- and?: InputMaybe<Array<SubscriptionEntitlementFilterFeatureFilter>>;
2231
- createdAt?: InputMaybe<DateFieldComparison>;
2232
- description?: InputMaybe<StringFieldComparison>;
2233
- displayName?: InputMaybe<StringFieldComparison>;
2234
- environmentId?: InputMaybe<StringFieldComparison>;
2235
- featureStatus?: InputMaybe<FeatureStatusFilterComparison>;
2236
- featureType?: InputMaybe<FeatureTypeFilterComparison>;
2237
- id?: InputMaybe<StringFieldComparison>;
2238
- meterType?: InputMaybe<MeterTypeFilterComparison>;
2239
- or?: InputMaybe<Array<SubscriptionEntitlementFilterFeatureFilter>>;
2240
- refId?: InputMaybe<StringFieldComparison>;
2241
- updatedAt?: InputMaybe<DateFieldComparison>;
2227
+ and?: Maybe<Array<SubscriptionEntitlementFilterFeatureFilter>>;
2228
+ createdAt?: Maybe<DateFieldComparison>;
2229
+ description?: Maybe<StringFieldComparison>;
2230
+ displayName?: Maybe<StringFieldComparison>;
2231
+ environmentId?: Maybe<StringFieldComparison>;
2232
+ featureStatus?: Maybe<FeatureStatusFilterComparison>;
2233
+ featureType?: Maybe<FeatureTypeFilterComparison>;
2234
+ id?: Maybe<StringFieldComparison>;
2235
+ meterType?: Maybe<MeterTypeFilterComparison>;
2236
+ or?: Maybe<Array<SubscriptionEntitlementFilterFeatureFilter>>;
2237
+ refId?: Maybe<StringFieldComparison>;
2238
+ updatedAt?: Maybe<DateFieldComparison>;
2242
2239
  };
2243
2240
  export declare type SubscriptionEntitlementInput = {
2244
- description?: InputMaybe<Scalars['String']>;
2241
+ description?: Maybe<Scalars['String']>;
2245
2242
  featureId: Scalars['String'];
2246
- hasUnlimitedUsage?: InputMaybe<Scalars['Boolean']>;
2247
- monthlyResetPeriodConfiguration?: InputMaybe<MonthlyResetPeriodConfigInput>;
2248
- resetPeriod?: InputMaybe<EntitlementResetPeriod>;
2249
- usageLimit?: InputMaybe<Scalars['Float']>;
2250
- weeklyResetPeriodConfiguration?: InputMaybe<WeeklyResetPeriodConfigInput>;
2243
+ hasUnlimitedUsage?: Maybe<Scalars['Boolean']>;
2244
+ monthlyResetPeriodConfiguration?: Maybe<MonthlyResetPeriodConfigInput>;
2245
+ resetPeriod?: Maybe<EntitlementResetPeriod>;
2246
+ usageLimit?: Maybe<Scalars['Float']>;
2247
+ weeklyResetPeriodConfiguration?: Maybe<WeeklyResetPeriodConfigInput>;
2251
2248
  };
2252
2249
  export declare type SubscriptionEntitlementSort = {
2253
2250
  direction: SortDirection;
2254
2251
  field: SubscriptionEntitlementSortFields;
2255
- nulls?: InputMaybe<SortNulls>;
2252
+ nulls?: Maybe<SortNulls>;
2256
2253
  };
2257
2254
  export declare enum SubscriptionEntitlementSortFields {
2258
2255
  CreatedAt = "createdAt",
@@ -2262,44 +2259,44 @@ export declare enum SubscriptionEntitlementSortFields {
2262
2259
  UpdatedAt = "updatedAt"
2263
2260
  }
2264
2261
  export declare type SubscriptionInput = {
2265
- additionalMetaData?: InputMaybe<Scalars['JSON']>;
2266
- addons?: InputMaybe<Array<SubscriptionAddonInput>>;
2267
- awaitPaymentConfirmation?: InputMaybe<Scalars['Boolean']>;
2268
- billingId?: InputMaybe<Scalars['String']>;
2269
- billingInformation?: InputMaybe<SubscriptionBillingInfo>;
2270
- billingPeriod?: InputMaybe<BillingPeriod>;
2271
- crmId?: InputMaybe<Scalars['String']>;
2262
+ additionalMetaData?: Maybe<Scalars['JSON']>;
2263
+ addons?: Maybe<Array<SubscriptionAddonInput>>;
2264
+ awaitPaymentConfirmation?: Maybe<Scalars['Boolean']>;
2265
+ billingId?: Maybe<Scalars['String']>;
2266
+ billingInformation?: Maybe<SubscriptionBillingInfo>;
2267
+ billingPeriod?: Maybe<BillingPeriod>;
2268
+ crmId?: Maybe<Scalars['String']>;
2272
2269
  customerId: Scalars['String'];
2273
- endDate?: InputMaybe<Scalars['DateTime']>;
2274
- environmentId?: InputMaybe<Scalars['String']>;
2275
- isCustomPriceSubscription?: InputMaybe<Scalars['Boolean']>;
2276
- isOverridingTrialConfig?: InputMaybe<Scalars['Boolean']>;
2277
- isTrial?: InputMaybe<Scalars['Boolean']>;
2270
+ endDate?: Maybe<Scalars['DateTime']>;
2271
+ environmentId?: Maybe<Scalars['String']>;
2272
+ isCustomPriceSubscription?: Maybe<Scalars['Boolean']>;
2273
+ isOverridingTrialConfig?: Maybe<Scalars['Boolean']>;
2274
+ isTrial?: Maybe<Scalars['Boolean']>;
2278
2275
  planId: Scalars['String'];
2279
- priceUnitAmount?: InputMaybe<Scalars['Float']>;
2280
- promotionCode?: InputMaybe<Scalars['String']>;
2281
- refId?: InputMaybe<Scalars['String']>;
2282
- startDate?: InputMaybe<Scalars['DateTime']>;
2283
- subscriptionEntitlements?: InputMaybe<Array<SubscriptionEntitlementInput>>;
2284
- subscriptionId?: InputMaybe<Scalars['String']>;
2276
+ priceUnitAmount?: Maybe<Scalars['Float']>;
2277
+ promotionCode?: Maybe<Scalars['String']>;
2278
+ refId?: Maybe<Scalars['String']>;
2279
+ startDate?: Maybe<Scalars['DateTime']>;
2280
+ subscriptionEntitlements?: Maybe<Array<SubscriptionEntitlementInput>>;
2281
+ subscriptionId?: Maybe<Scalars['String']>;
2285
2282
  };
2286
2283
  export declare type SubscriptionMigrationInput = {
2287
- environmentId?: InputMaybe<Scalars['String']>;
2284
+ environmentId?: Maybe<Scalars['String']>;
2288
2285
  subscriptionId: Scalars['String'];
2289
2286
  };
2290
2287
  export declare type SubscriptionMigrationTaskFilter = {
2291
- and?: InputMaybe<Array<SubscriptionMigrationTaskFilter>>;
2292
- createdAt?: InputMaybe<DateFieldComparison>;
2293
- environmentId?: InputMaybe<StringFieldComparison>;
2294
- id?: InputMaybe<StringFieldComparison>;
2295
- or?: InputMaybe<Array<SubscriptionMigrationTaskFilter>>;
2296
- status?: InputMaybe<TaskStatusFilterComparison>;
2297
- taskType?: InputMaybe<TaskTypeFilterComparison>;
2288
+ and?: Maybe<Array<SubscriptionMigrationTaskFilter>>;
2289
+ createdAt?: Maybe<DateFieldComparison>;
2290
+ environmentId?: Maybe<StringFieldComparison>;
2291
+ id?: Maybe<StringFieldComparison>;
2292
+ or?: Maybe<Array<SubscriptionMigrationTaskFilter>>;
2293
+ status?: Maybe<TaskStatusFilterComparison>;
2294
+ taskType?: Maybe<TaskTypeFilterComparison>;
2298
2295
  };
2299
2296
  export declare type SubscriptionMigrationTaskSort = {
2300
2297
  direction: SortDirection;
2301
2298
  field: SubscriptionMigrationTaskSortFields;
2302
- nulls?: InputMaybe<SortNulls>;
2299
+ nulls?: Maybe<SortNulls>;
2303
2300
  };
2304
2301
  export declare enum SubscriptionMigrationTaskSortFields {
2305
2302
  CreatedAt = "createdAt",
@@ -2309,49 +2306,49 @@ export declare enum SubscriptionMigrationTaskSortFields {
2309
2306
  TaskType = "taskType"
2310
2307
  }
2311
2308
  export declare type SubscriptionPriceFilter = {
2312
- and?: InputMaybe<Array<SubscriptionPriceFilter>>;
2313
- createdAt?: InputMaybe<DateFieldComparison>;
2314
- id?: InputMaybe<StringFieldComparison>;
2315
- or?: InputMaybe<Array<SubscriptionPriceFilter>>;
2316
- price?: InputMaybe<SubscriptionPriceFilterPriceFilter>;
2317
- subscription?: InputMaybe<SubscriptionPriceFilterCustomerSubscriptionFilter>;
2318
- updatedAt?: InputMaybe<DateFieldComparison>;
2319
- usageLimit?: InputMaybe<NumberFieldComparison>;
2309
+ and?: Maybe<Array<SubscriptionPriceFilter>>;
2310
+ createdAt?: Maybe<DateFieldComparison>;
2311
+ id?: Maybe<StringFieldComparison>;
2312
+ or?: Maybe<Array<SubscriptionPriceFilter>>;
2313
+ price?: Maybe<SubscriptionPriceFilterPriceFilter>;
2314
+ subscription?: Maybe<SubscriptionPriceFilterCustomerSubscriptionFilter>;
2315
+ updatedAt?: Maybe<DateFieldComparison>;
2316
+ usageLimit?: Maybe<NumberFieldComparison>;
2320
2317
  };
2321
2318
  export declare type SubscriptionPriceFilterCustomerSubscriptionFilter = {
2322
- and?: InputMaybe<Array<SubscriptionPriceFilterCustomerSubscriptionFilter>>;
2323
- billingId?: InputMaybe<StringFieldComparison>;
2324
- cancelReason?: InputMaybe<SubscriptionCancelReasonFilterComparison>;
2325
- cancellationDate?: InputMaybe<DateFieldComparison>;
2326
- createdAt?: InputMaybe<DateFieldComparison>;
2327
- crmId?: InputMaybe<StringFieldComparison>;
2328
- crmLinkUrl?: InputMaybe<StringFieldComparison>;
2329
- effectiveEndDate?: InputMaybe<DateFieldComparison>;
2330
- endDate?: InputMaybe<DateFieldComparison>;
2331
- environmentId?: InputMaybe<StringFieldComparison>;
2332
- id?: InputMaybe<StringFieldComparison>;
2333
- oldBillingId?: InputMaybe<StringFieldComparison>;
2334
- or?: InputMaybe<Array<SubscriptionPriceFilterCustomerSubscriptionFilter>>;
2335
- pricingType?: InputMaybe<PricingTypeFilterComparison>;
2336
- refId?: InputMaybe<StringFieldComparison>;
2337
- startDate?: InputMaybe<DateFieldComparison>;
2338
- status?: InputMaybe<SubscriptionStatusFilterComparison>;
2339
- subscriptionId?: InputMaybe<StringFieldComparison>;
2340
- trialEndDate?: InputMaybe<DateFieldComparison>;
2319
+ and?: Maybe<Array<SubscriptionPriceFilterCustomerSubscriptionFilter>>;
2320
+ billingId?: Maybe<StringFieldComparison>;
2321
+ cancelReason?: Maybe<SubscriptionCancelReasonFilterComparison>;
2322
+ cancellationDate?: Maybe<DateFieldComparison>;
2323
+ createdAt?: Maybe<DateFieldComparison>;
2324
+ crmId?: Maybe<StringFieldComparison>;
2325
+ crmLinkUrl?: Maybe<StringFieldComparison>;
2326
+ effectiveEndDate?: Maybe<DateFieldComparison>;
2327
+ endDate?: Maybe<DateFieldComparison>;
2328
+ environmentId?: Maybe<StringFieldComparison>;
2329
+ id?: Maybe<StringFieldComparison>;
2330
+ oldBillingId?: Maybe<StringFieldComparison>;
2331
+ or?: Maybe<Array<SubscriptionPriceFilterCustomerSubscriptionFilter>>;
2332
+ pricingType?: Maybe<PricingTypeFilterComparison>;
2333
+ refId?: Maybe<StringFieldComparison>;
2334
+ startDate?: Maybe<DateFieldComparison>;
2335
+ status?: Maybe<SubscriptionStatusFilterComparison>;
2336
+ subscriptionId?: Maybe<StringFieldComparison>;
2337
+ trialEndDate?: Maybe<DateFieldComparison>;
2341
2338
  };
2342
2339
  export declare type SubscriptionPriceFilterPriceFilter = {
2343
- and?: InputMaybe<Array<SubscriptionPriceFilterPriceFilter>>;
2344
- billingId?: InputMaybe<StringFieldComparison>;
2345
- billingModel?: InputMaybe<BillingModelFilterComparison>;
2346
- billingPeriod?: InputMaybe<BillingPeriodFilterComparison>;
2347
- createdAt?: InputMaybe<DateFieldComparison>;
2348
- id?: InputMaybe<StringFieldComparison>;
2349
- or?: InputMaybe<Array<SubscriptionPriceFilterPriceFilter>>;
2340
+ and?: Maybe<Array<SubscriptionPriceFilterPriceFilter>>;
2341
+ billingId?: Maybe<StringFieldComparison>;
2342
+ billingModel?: Maybe<BillingModelFilterComparison>;
2343
+ billingPeriod?: Maybe<BillingPeriodFilterComparison>;
2344
+ createdAt?: Maybe<DateFieldComparison>;
2345
+ id?: Maybe<StringFieldComparison>;
2346
+ or?: Maybe<Array<SubscriptionPriceFilterPriceFilter>>;
2350
2347
  };
2351
2348
  export declare type SubscriptionPriceSort = {
2352
2349
  direction: SortDirection;
2353
2350
  field: SubscriptionPriceSortFields;
2354
- nulls?: InputMaybe<SortNulls>;
2351
+ nulls?: Maybe<SortNulls>;
2355
2352
  };
2356
2353
  export declare enum SubscriptionPriceSortFields {
2357
2354
  CreatedAt = "createdAt",
@@ -2387,23 +2384,23 @@ export declare enum SubscriptionStatus {
2387
2384
  PaymentPending = "PAYMENT_PENDING"
2388
2385
  }
2389
2386
  export declare type SubscriptionStatusFilterComparison = {
2390
- eq?: InputMaybe<SubscriptionStatus>;
2391
- gt?: InputMaybe<SubscriptionStatus>;
2392
- gte?: InputMaybe<SubscriptionStatus>;
2393
- iLike?: InputMaybe<SubscriptionStatus>;
2394
- in?: InputMaybe<Array<SubscriptionStatus>>;
2395
- is?: InputMaybe<Scalars['Boolean']>;
2396
- isNot?: InputMaybe<Scalars['Boolean']>;
2397
- like?: InputMaybe<SubscriptionStatus>;
2398
- lt?: InputMaybe<SubscriptionStatus>;
2399
- lte?: InputMaybe<SubscriptionStatus>;
2400
- neq?: InputMaybe<SubscriptionStatus>;
2401
- notILike?: InputMaybe<SubscriptionStatus>;
2402
- notIn?: InputMaybe<Array<SubscriptionStatus>>;
2403
- notLike?: InputMaybe<SubscriptionStatus>;
2387
+ eq?: Maybe<SubscriptionStatus>;
2388
+ gt?: Maybe<SubscriptionStatus>;
2389
+ gte?: Maybe<SubscriptionStatus>;
2390
+ iLike?: Maybe<SubscriptionStatus>;
2391
+ in?: Maybe<Array<SubscriptionStatus>>;
2392
+ is?: Maybe<Scalars['Boolean']>;
2393
+ isNot?: Maybe<Scalars['Boolean']>;
2394
+ like?: Maybe<SubscriptionStatus>;
2395
+ lt?: Maybe<SubscriptionStatus>;
2396
+ lte?: Maybe<SubscriptionStatus>;
2397
+ neq?: Maybe<SubscriptionStatus>;
2398
+ notILike?: Maybe<SubscriptionStatus>;
2399
+ notIn?: Maybe<Array<SubscriptionStatus>>;
2400
+ notLike?: Maybe<SubscriptionStatus>;
2404
2401
  };
2405
2402
  export declare type SubscriptionUpdateScheduleCancellationInput = {
2406
- environmentId?: InputMaybe<Scalars['String']>;
2403
+ environmentId?: Maybe<Scalars['String']>;
2407
2404
  subscriptionId: Scalars['String'];
2408
2405
  };
2409
2406
  /** Status of the integration sync */
@@ -2421,20 +2418,20 @@ export declare enum TaskStatus {
2421
2418
  Pending = "PENDING"
2422
2419
  }
2423
2420
  export declare type TaskStatusFilterComparison = {
2424
- eq?: InputMaybe<TaskStatus>;
2425
- gt?: InputMaybe<TaskStatus>;
2426
- gte?: InputMaybe<TaskStatus>;
2427
- iLike?: InputMaybe<TaskStatus>;
2428
- in?: InputMaybe<Array<TaskStatus>>;
2429
- is?: InputMaybe<Scalars['Boolean']>;
2430
- isNot?: InputMaybe<Scalars['Boolean']>;
2431
- like?: InputMaybe<TaskStatus>;
2432
- lt?: InputMaybe<TaskStatus>;
2433
- lte?: InputMaybe<TaskStatus>;
2434
- neq?: InputMaybe<TaskStatus>;
2435
- notILike?: InputMaybe<TaskStatus>;
2436
- notIn?: InputMaybe<Array<TaskStatus>>;
2437
- notLike?: InputMaybe<TaskStatus>;
2421
+ eq?: Maybe<TaskStatus>;
2422
+ gt?: Maybe<TaskStatus>;
2423
+ gte?: Maybe<TaskStatus>;
2424
+ iLike?: Maybe<TaskStatus>;
2425
+ in?: Maybe<Array<TaskStatus>>;
2426
+ is?: Maybe<Scalars['Boolean']>;
2427
+ isNot?: Maybe<Scalars['Boolean']>;
2428
+ like?: Maybe<TaskStatus>;
2429
+ lt?: Maybe<TaskStatus>;
2430
+ lte?: Maybe<TaskStatus>;
2431
+ neq?: Maybe<TaskStatus>;
2432
+ notILike?: Maybe<TaskStatus>;
2433
+ notIn?: Maybe<Array<TaskStatus>>;
2434
+ notLike?: Maybe<TaskStatus>;
2438
2435
  };
2439
2436
  export declare enum TaskType {
2440
2437
  ImportIntegrationCatalog = "IMPORT_INTEGRATION_CATALOG",
@@ -2443,20 +2440,20 @@ export declare enum TaskType {
2443
2440
  SubscriptionMigration = "SUBSCRIPTION_MIGRATION"
2444
2441
  }
2445
2442
  export declare type TaskTypeFilterComparison = {
2446
- eq?: InputMaybe<TaskType>;
2447
- gt?: InputMaybe<TaskType>;
2448
- gte?: InputMaybe<TaskType>;
2449
- iLike?: InputMaybe<TaskType>;
2450
- in?: InputMaybe<Array<TaskType>>;
2451
- is?: InputMaybe<Scalars['Boolean']>;
2452
- isNot?: InputMaybe<Scalars['Boolean']>;
2453
- like?: InputMaybe<TaskType>;
2454
- lt?: InputMaybe<TaskType>;
2455
- lte?: InputMaybe<TaskType>;
2456
- neq?: InputMaybe<TaskType>;
2457
- notILike?: InputMaybe<TaskType>;
2458
- notIn?: InputMaybe<Array<TaskType>>;
2459
- notLike?: InputMaybe<TaskType>;
2443
+ eq?: Maybe<TaskType>;
2444
+ gt?: Maybe<TaskType>;
2445
+ gte?: Maybe<TaskType>;
2446
+ iLike?: Maybe<TaskType>;
2447
+ in?: Maybe<Array<TaskType>>;
2448
+ is?: Maybe<Scalars['Boolean']>;
2449
+ isNot?: Maybe<Scalars['Boolean']>;
2450
+ like?: Maybe<TaskType>;
2451
+ lt?: Maybe<TaskType>;
2452
+ lte?: Maybe<TaskType>;
2453
+ neq?: Maybe<TaskType>;
2454
+ notILike?: Maybe<TaskType>;
2455
+ notIn?: Maybe<Array<TaskType>>;
2456
+ notLike?: Maybe<TaskType>;
2460
2457
  };
2461
2458
  export declare type TaxExempt = {
2462
2459
  type: Scalars['String'];
@@ -2473,97 +2470,97 @@ export declare enum TrialPeriodUnits {
2473
2470
  Month = "MONTH"
2474
2471
  }
2475
2472
  export declare type TypographyConfigurationInput = {
2476
- body?: InputMaybe<FontVariantInput>;
2477
- fontFamily?: InputMaybe<Scalars['String']>;
2478
- h1?: InputMaybe<FontVariantInput>;
2479
- h2?: InputMaybe<FontVariantInput>;
2480
- h3?: InputMaybe<FontVariantInput>;
2473
+ body?: Maybe<FontVariantInput>;
2474
+ fontFamily?: Maybe<Scalars['String']>;
2475
+ h1?: Maybe<FontVariantInput>;
2476
+ h2?: Maybe<FontVariantInput>;
2477
+ h3?: Maybe<FontVariantInput>;
2481
2478
  };
2482
2479
  export declare type UpdateAccountInput = {
2483
2480
  displayName: Scalars['String'];
2484
2481
  id: Scalars['String'];
2485
- subscriptionBillingAnchor?: InputMaybe<BillingAnchor>;
2486
- subscriptionProrationBehavior?: InputMaybe<ProrationBehavior>;
2487
- timezone?: InputMaybe<Scalars['String']>;
2482
+ subscriptionBillingAnchor?: Maybe<BillingAnchor>;
2483
+ subscriptionProrationBehavior?: Maybe<ProrationBehavior>;
2484
+ timezone?: Maybe<Scalars['String']>;
2488
2485
  };
2489
2486
  export declare type UpdateCouponInput = {
2490
- additionalMetaData?: InputMaybe<Scalars['JSON']>;
2491
- description?: InputMaybe<Scalars['String']>;
2492
- environmentId?: InputMaybe<Scalars['String']>;
2487
+ additionalMetaData?: Maybe<Scalars['JSON']>;
2488
+ description?: Maybe<Scalars['String']>;
2489
+ environmentId?: Maybe<Scalars['String']>;
2493
2490
  name: Scalars['String'];
2494
2491
  refId: Scalars['String'];
2495
2492
  };
2496
2493
  export declare type UpdateCustomerInput = {
2497
- additionalMetaData?: InputMaybe<Scalars['JSON']>;
2498
- billingId?: InputMaybe<Scalars['String']>;
2499
- billingInformation?: InputMaybe<CustomerBillingInfo>;
2500
- couponRefId?: InputMaybe<Scalars['String']>;
2501
- crmId?: InputMaybe<Scalars['String']>;
2502
- customerId?: InputMaybe<Scalars['String']>;
2503
- email?: InputMaybe<Scalars['String']>;
2504
- environmentId?: InputMaybe<Scalars['String']>;
2505
- name?: InputMaybe<Scalars['String']>;
2506
- refId?: InputMaybe<Scalars['String']>;
2494
+ additionalMetaData?: Maybe<Scalars['JSON']>;
2495
+ billingId?: Maybe<Scalars['String']>;
2496
+ billingInformation?: Maybe<CustomerBillingInfo>;
2497
+ couponRefId?: Maybe<Scalars['String']>;
2498
+ crmId?: Maybe<Scalars['String']>;
2499
+ customerId?: Maybe<Scalars['String']>;
2500
+ email?: Maybe<Scalars['String']>;
2501
+ environmentId?: Maybe<Scalars['String']>;
2502
+ name?: Maybe<Scalars['String']>;
2503
+ refId?: Maybe<Scalars['String']>;
2507
2504
  };
2508
2505
  export declare type UpdateEnvironment = {
2509
- createdAt?: InputMaybe<Scalars['DateTime']>;
2510
- description?: InputMaybe<Scalars['String']>;
2511
- displayName?: InputMaybe<Scalars['String']>;
2512
- hardenClientAccessEnabled?: InputMaybe<Scalars['Boolean']>;
2513
- id?: InputMaybe<Scalars['String']>;
2514
- provisionStatus?: InputMaybe<EnvironmentProvisionStatus>;
2515
- signingToken?: InputMaybe<Scalars['String']>;
2516
- slug?: InputMaybe<Scalars['String']>;
2506
+ createdAt?: Maybe<Scalars['DateTime']>;
2507
+ description?: Maybe<Scalars['String']>;
2508
+ displayName?: Maybe<Scalars['String']>;
2509
+ hardenClientAccessEnabled?: Maybe<Scalars['Boolean']>;
2510
+ id?: Maybe<Scalars['String']>;
2511
+ provisionStatus?: Maybe<EnvironmentProvisionStatus>;
2512
+ signingToken?: Maybe<Scalars['String']>;
2513
+ slug?: Maybe<Scalars['String']>;
2517
2514
  };
2518
2515
  export declare type UpdateExperimentInput = {
2519
- controlGroupName?: InputMaybe<Scalars['String']>;
2520
- description?: InputMaybe<Scalars['String']>;
2521
- environmentId?: InputMaybe<Scalars['String']>;
2522
- name?: InputMaybe<Scalars['String']>;
2523
- productId?: InputMaybe<Scalars['String']>;
2524
- productSettings?: InputMaybe<ProductSettingsInput>;
2516
+ controlGroupName?: Maybe<Scalars['String']>;
2517
+ description?: Maybe<Scalars['String']>;
2518
+ environmentId?: Maybe<Scalars['String']>;
2519
+ name?: Maybe<Scalars['String']>;
2520
+ productId?: Maybe<Scalars['String']>;
2521
+ productSettings?: Maybe<ProductSettingsInput>;
2525
2522
  refId: Scalars['String'];
2526
- variantGroupName?: InputMaybe<Scalars['String']>;
2527
- variantPercentage?: InputMaybe<Scalars['Float']>;
2523
+ variantGroupName?: Maybe<Scalars['String']>;
2524
+ variantPercentage?: Maybe<Scalars['Float']>;
2528
2525
  };
2529
2526
  export declare type UpdateFeature = {
2530
- additionalMetaData?: InputMaybe<Scalars['JSON']>;
2531
- createdAt?: InputMaybe<Scalars['DateTime']>;
2532
- description?: InputMaybe<Scalars['String']>;
2533
- displayName?: InputMaybe<Scalars['String']>;
2534
- environmentId?: InputMaybe<Scalars['String']>;
2535
- featureStatus?: InputMaybe<FeatureStatus>;
2536
- featureType?: InputMaybe<FeatureType>;
2537
- featureUnits?: InputMaybe<Scalars['String']>;
2538
- featureUnitsPlural?: InputMaybe<Scalars['String']>;
2539
- id?: InputMaybe<Scalars['String']>;
2540
- meterType?: InputMaybe<MeterType>;
2541
- refId?: InputMaybe<Scalars['String']>;
2542
- updatedAt?: InputMaybe<Scalars['DateTime']>;
2527
+ additionalMetaData?: Maybe<Scalars['JSON']>;
2528
+ createdAt?: Maybe<Scalars['DateTime']>;
2529
+ description?: Maybe<Scalars['String']>;
2530
+ displayName?: Maybe<Scalars['String']>;
2531
+ environmentId?: Maybe<Scalars['String']>;
2532
+ featureStatus?: Maybe<FeatureStatus>;
2533
+ featureType?: Maybe<FeatureType>;
2534
+ featureUnits?: Maybe<Scalars['String']>;
2535
+ featureUnitsPlural?: Maybe<Scalars['String']>;
2536
+ id?: Maybe<Scalars['String']>;
2537
+ meterType?: Maybe<MeterType>;
2538
+ refId?: Maybe<Scalars['String']>;
2539
+ updatedAt?: Maybe<Scalars['DateTime']>;
2543
2540
  };
2544
2541
  export declare type UpdateFeatureInput = {
2545
- additionalMetaData?: InputMaybe<Scalars['JSON']>;
2546
- description?: InputMaybe<Scalars['String']>;
2547
- displayName?: InputMaybe<Scalars['String']>;
2542
+ additionalMetaData?: Maybe<Scalars['JSON']>;
2543
+ description?: Maybe<Scalars['String']>;
2544
+ displayName?: Maybe<Scalars['String']>;
2548
2545
  environmentId: Scalars['String'];
2549
- featureUnits?: InputMaybe<Scalars['String']>;
2550
- featureUnitsPlural?: InputMaybe<Scalars['String']>;
2546
+ featureUnits?: Maybe<Scalars['String']>;
2547
+ featureUnitsPlural?: Maybe<Scalars['String']>;
2551
2548
  refId: Scalars['String'];
2552
2549
  };
2553
2550
  export declare type UpdateHook = {
2554
- createdAt?: InputMaybe<Scalars['DateTime']>;
2555
- description?: InputMaybe<Scalars['String']>;
2556
- endpoint?: InputMaybe<Scalars['String']>;
2557
- environmentId?: InputMaybe<Scalars['String']>;
2558
- eventLogTypes?: InputMaybe<Array<EventLogType>>;
2559
- id?: InputMaybe<Scalars['String']>;
2560
- secretKey?: InputMaybe<Scalars['String']>;
2561
- status?: InputMaybe<HookStatus>;
2551
+ createdAt?: Maybe<Scalars['DateTime']>;
2552
+ description?: Maybe<Scalars['String']>;
2553
+ endpoint?: Maybe<Scalars['String']>;
2554
+ environmentId?: Maybe<Scalars['String']>;
2555
+ eventLogTypes?: Maybe<Array<EventLogType>>;
2556
+ id?: Maybe<Scalars['String']>;
2557
+ secretKey?: Maybe<Scalars['String']>;
2558
+ status?: Maybe<HookStatus>;
2562
2559
  };
2563
2560
  export declare type UpdateIntegrationInput = {
2564
- stripeCredentials?: InputMaybe<StripeCredentialsInput>;
2561
+ stripeCredentials?: Maybe<StripeCredentialsInput>;
2565
2562
  vendorIdentifier: VendorIdentifier;
2566
- zuoraCredentials?: InputMaybe<ZuoraCredentialsInput>;
2563
+ zuoraCredentials?: Maybe<ZuoraCredentialsInput>;
2567
2564
  };
2568
2565
  export declare type UpdateOneEnvironmentInput = {
2569
2566
  /** The id of the record to update */
@@ -2609,93 +2606,93 @@ export declare type UpdateOnePromotionalEntitlementInput = {
2609
2606
  };
2610
2607
  export declare type UpdatePackageEntitlementOrderInput = {
2611
2608
  entitlements: Array<UpdatePackageEntitlementOrderItemInput>;
2612
- environmentId?: InputMaybe<Scalars['String']>;
2609
+ environmentId?: Maybe<Scalars['String']>;
2613
2610
  packageId: Scalars['String'];
2614
2611
  };
2615
2612
  export declare type UpdatePackageEntitlementOrderItemInput = {
2616
2613
  id: Scalars['String'];
2617
- order?: InputMaybe<Scalars['Float']>;
2614
+ order?: Maybe<Scalars['Float']>;
2618
2615
  };
2619
2616
  export declare type UpdateSubscriptionEntitlementInput = {
2620
- hasUnlimitedUsage?: InputMaybe<Scalars['Boolean']>;
2617
+ hasUnlimitedUsage?: Maybe<Scalars['Boolean']>;
2621
2618
  id: Scalars['String'];
2622
- monthlyResetPeriodConfiguration?: InputMaybe<MonthlyResetPeriodConfigInput>;
2623
- resetPeriod?: InputMaybe<EntitlementResetPeriod>;
2624
- usageLimit?: InputMaybe<Scalars['Float']>;
2625
- weeklyResetPeriodConfiguration?: InputMaybe<WeeklyResetPeriodConfigInput>;
2619
+ monthlyResetPeriodConfiguration?: Maybe<MonthlyResetPeriodConfigInput>;
2620
+ resetPeriod?: Maybe<EntitlementResetPeriod>;
2621
+ usageLimit?: Maybe<Scalars['Float']>;
2622
+ weeklyResetPeriodConfiguration?: Maybe<WeeklyResetPeriodConfigInput>;
2626
2623
  };
2627
2624
  export declare type UpdateSubscriptionInput = {
2628
- additionalMetaData?: InputMaybe<Scalars['JSON']>;
2629
- addons?: InputMaybe<Array<SubscriptionAddonInput>>;
2630
- billingPeriod?: InputMaybe<BillingPeriod>;
2631
- environmentId?: InputMaybe<Scalars['String']>;
2632
- promotionCode?: InputMaybe<Scalars['String']>;
2633
- refId?: InputMaybe<Scalars['String']>;
2634
- subscriptionEntitlements?: InputMaybe<Array<UpdateSubscriptionEntitlementInput>>;
2635
- subscriptionId?: InputMaybe<Scalars['String']>;
2636
- trialEndDate?: InputMaybe<Scalars['DateTime']>;
2637
- unitQuantity?: InputMaybe<Scalars['Float']>;
2625
+ additionalMetaData?: Maybe<Scalars['JSON']>;
2626
+ addons?: Maybe<Array<SubscriptionAddonInput>>;
2627
+ billingPeriod?: Maybe<BillingPeriod>;
2628
+ environmentId?: Maybe<Scalars['String']>;
2629
+ promotionCode?: Maybe<Scalars['String']>;
2630
+ refId?: Maybe<Scalars['String']>;
2631
+ subscriptionEntitlements?: Maybe<Array<UpdateSubscriptionEntitlementInput>>;
2632
+ subscriptionId?: Maybe<Scalars['String']>;
2633
+ trialEndDate?: Maybe<Scalars['DateTime']>;
2634
+ unitQuantity?: Maybe<Scalars['Float']>;
2638
2635
  };
2639
2636
  export declare type UsageHistoryInput = {
2640
2637
  customerRefId: Scalars['String'];
2641
- endDate?: InputMaybe<Scalars['DateTime']>;
2642
- environmentId?: InputMaybe<Scalars['String']>;
2638
+ endDate?: Maybe<Scalars['DateTime']>;
2639
+ environmentId?: Maybe<Scalars['String']>;
2643
2640
  featureRefId: Scalars['String'];
2644
- monthlyResetPeriodConfiguration?: InputMaybe<MonthlyResetPeriodConfigInput>;
2645
- resetPeriod?: InputMaybe<EntitlementResetPeriod>;
2641
+ monthlyResetPeriodConfiguration?: Maybe<MonthlyResetPeriodConfigInput>;
2642
+ resetPeriod?: Maybe<EntitlementResetPeriod>;
2646
2643
  startDate: Scalars['DateTime'];
2647
- weeklyResetPeriodConfiguration?: InputMaybe<WeeklyResetPeriodConfigInput>;
2644
+ weeklyResetPeriodConfiguration?: Maybe<WeeklyResetPeriodConfigInput>;
2648
2645
  };
2649
2646
  export declare type UsageMeasurementCreateInput = {
2650
- createdAt?: InputMaybe<Scalars['DateTime']>;
2647
+ createdAt?: Maybe<Scalars['DateTime']>;
2651
2648
  customerId: Scalars['String'];
2652
- environmentId?: InputMaybe<Scalars['String']>;
2649
+ environmentId?: Maybe<Scalars['String']>;
2653
2650
  featureId: Scalars['String'];
2654
2651
  value: Scalars['Float'];
2655
2652
  };
2656
2653
  export declare type UsageMeasurementFilter = {
2657
- and?: InputMaybe<Array<UsageMeasurementFilter>>;
2658
- createdAt?: InputMaybe<DateFieldComparison>;
2659
- customer?: InputMaybe<UsageMeasurementFilterCustomerFilter>;
2660
- environmentId?: InputMaybe<StringFieldComparison>;
2661
- feature?: InputMaybe<UsageMeasurementFilterFeatureFilter>;
2662
- id?: InputMaybe<StringFieldComparison>;
2663
- or?: InputMaybe<Array<UsageMeasurementFilter>>;
2654
+ and?: Maybe<Array<UsageMeasurementFilter>>;
2655
+ createdAt?: Maybe<DateFieldComparison>;
2656
+ customer?: Maybe<UsageMeasurementFilterCustomerFilter>;
2657
+ environmentId?: Maybe<StringFieldComparison>;
2658
+ feature?: Maybe<UsageMeasurementFilterFeatureFilter>;
2659
+ id?: Maybe<StringFieldComparison>;
2660
+ or?: Maybe<Array<UsageMeasurementFilter>>;
2664
2661
  };
2665
2662
  export declare type UsageMeasurementFilterCustomerFilter = {
2666
- and?: InputMaybe<Array<UsageMeasurementFilterCustomerFilter>>;
2667
- billingId?: InputMaybe<StringFieldComparison>;
2668
- createdAt?: InputMaybe<DateFieldComparison>;
2669
- crmHubspotCompanyId?: InputMaybe<StringFieldComparison>;
2670
- crmHubspotCompanyUrl?: InputMaybe<StringFieldComparison>;
2671
- crmId?: InputMaybe<StringFieldComparison>;
2672
- customerId?: InputMaybe<StringFieldComparison>;
2673
- email?: InputMaybe<StringFieldComparison>;
2674
- environmentId?: InputMaybe<StringFieldComparison>;
2675
- id?: InputMaybe<StringFieldComparison>;
2676
- name?: InputMaybe<StringFieldComparison>;
2677
- or?: InputMaybe<Array<UsageMeasurementFilterCustomerFilter>>;
2678
- refId?: InputMaybe<StringFieldComparison>;
2679
- updatedAt?: InputMaybe<DateFieldComparison>;
2663
+ and?: Maybe<Array<UsageMeasurementFilterCustomerFilter>>;
2664
+ billingId?: Maybe<StringFieldComparison>;
2665
+ createdAt?: Maybe<DateFieldComparison>;
2666
+ crmHubspotCompanyId?: Maybe<StringFieldComparison>;
2667
+ crmHubspotCompanyUrl?: Maybe<StringFieldComparison>;
2668
+ crmId?: Maybe<StringFieldComparison>;
2669
+ customerId?: Maybe<StringFieldComparison>;
2670
+ email?: Maybe<StringFieldComparison>;
2671
+ environmentId?: Maybe<StringFieldComparison>;
2672
+ id?: Maybe<StringFieldComparison>;
2673
+ name?: Maybe<StringFieldComparison>;
2674
+ or?: Maybe<Array<UsageMeasurementFilterCustomerFilter>>;
2675
+ refId?: Maybe<StringFieldComparison>;
2676
+ updatedAt?: Maybe<DateFieldComparison>;
2680
2677
  };
2681
2678
  export declare type UsageMeasurementFilterFeatureFilter = {
2682
- and?: InputMaybe<Array<UsageMeasurementFilterFeatureFilter>>;
2683
- createdAt?: InputMaybe<DateFieldComparison>;
2684
- description?: InputMaybe<StringFieldComparison>;
2685
- displayName?: InputMaybe<StringFieldComparison>;
2686
- environmentId?: InputMaybe<StringFieldComparison>;
2687
- featureStatus?: InputMaybe<FeatureStatusFilterComparison>;
2688
- featureType?: InputMaybe<FeatureTypeFilterComparison>;
2689
- id?: InputMaybe<StringFieldComparison>;
2690
- meterType?: InputMaybe<MeterTypeFilterComparison>;
2691
- or?: InputMaybe<Array<UsageMeasurementFilterFeatureFilter>>;
2692
- refId?: InputMaybe<StringFieldComparison>;
2693
- updatedAt?: InputMaybe<DateFieldComparison>;
2679
+ and?: Maybe<Array<UsageMeasurementFilterFeatureFilter>>;
2680
+ createdAt?: Maybe<DateFieldComparison>;
2681
+ description?: Maybe<StringFieldComparison>;
2682
+ displayName?: Maybe<StringFieldComparison>;
2683
+ environmentId?: Maybe<StringFieldComparison>;
2684
+ featureStatus?: Maybe<FeatureStatusFilterComparison>;
2685
+ featureType?: Maybe<FeatureTypeFilterComparison>;
2686
+ id?: Maybe<StringFieldComparison>;
2687
+ meterType?: Maybe<MeterTypeFilterComparison>;
2688
+ or?: Maybe<Array<UsageMeasurementFilterFeatureFilter>>;
2689
+ refId?: Maybe<StringFieldComparison>;
2690
+ updatedAt?: Maybe<DateFieldComparison>;
2694
2691
  };
2695
2692
  export declare type UsageMeasurementSort = {
2696
2693
  direction: SortDirection;
2697
2694
  field: UsageMeasurementSortFields;
2698
- nulls?: InputMaybe<SortNulls>;
2695
+ nulls?: Maybe<SortNulls>;
2699
2696
  };
2700
2697
  export declare enum UsageMeasurementSortFields {
2701
2698
  CreatedAt = "createdAt",
@@ -2708,20 +2705,20 @@ export declare enum VendorIdentifier {
2708
2705
  Zuora = "ZUORA"
2709
2706
  }
2710
2707
  export declare type VendorIdentifierFilterComparison = {
2711
- eq?: InputMaybe<VendorIdentifier>;
2712
- gt?: InputMaybe<VendorIdentifier>;
2713
- gte?: InputMaybe<VendorIdentifier>;
2714
- iLike?: InputMaybe<VendorIdentifier>;
2715
- in?: InputMaybe<Array<VendorIdentifier>>;
2716
- is?: InputMaybe<Scalars['Boolean']>;
2717
- isNot?: InputMaybe<Scalars['Boolean']>;
2718
- like?: InputMaybe<VendorIdentifier>;
2719
- lt?: InputMaybe<VendorIdentifier>;
2720
- lte?: InputMaybe<VendorIdentifier>;
2721
- neq?: InputMaybe<VendorIdentifier>;
2722
- notILike?: InputMaybe<VendorIdentifier>;
2723
- notIn?: InputMaybe<Array<VendorIdentifier>>;
2724
- notLike?: InputMaybe<VendorIdentifier>;
2708
+ eq?: Maybe<VendorIdentifier>;
2709
+ gt?: Maybe<VendorIdentifier>;
2710
+ gte?: Maybe<VendorIdentifier>;
2711
+ iLike?: Maybe<VendorIdentifier>;
2712
+ in?: Maybe<Array<VendorIdentifier>>;
2713
+ is?: Maybe<Scalars['Boolean']>;
2714
+ isNot?: Maybe<Scalars['Boolean']>;
2715
+ like?: Maybe<VendorIdentifier>;
2716
+ lt?: Maybe<VendorIdentifier>;
2717
+ lte?: Maybe<VendorIdentifier>;
2718
+ neq?: Maybe<VendorIdentifier>;
2719
+ notILike?: Maybe<VendorIdentifier>;
2720
+ notIn?: Maybe<Array<VendorIdentifier>>;
2721
+ notLike?: Maybe<VendorIdentifier>;
2725
2722
  };
2726
2723
  /** Weekly reset period according to configuration */
2727
2724
  export declare enum WeeklyAccordingTo {
@@ -2738,9 +2735,9 @@ export declare type WeeklyResetPeriodConfigInput = {
2738
2735
  accordingTo: WeeklyAccordingTo;
2739
2736
  };
2740
2737
  export declare type WidgetConfigurationUpdateInput = {
2741
- customerPortalConfiguration?: InputMaybe<CustomerPortalConfigurationInput>;
2742
- environmentId?: InputMaybe<Scalars['String']>;
2743
- paywallConfiguration?: InputMaybe<PaywallConfigurationInput>;
2738
+ customerPortalConfiguration?: Maybe<CustomerPortalConfigurationInput>;
2739
+ environmentId?: Maybe<Scalars['String']>;
2740
+ paywallConfiguration?: Maybe<PaywallConfigurationInput>;
2744
2741
  };
2745
2742
  /** The widget type */
2746
2743
  export declare enum WidgetType {
@@ -2762,29 +2759,29 @@ export declare type CouponFragment = {
2762
2759
  id: string;
2763
2760
  discountValue: number;
2764
2761
  type: CouponType;
2765
- additionalMetaData?: any | null;
2762
+ additionalMetaData?: any | null | undefined;
2766
2763
  refId: string;
2767
2764
  name: string;
2768
- description?: string | null;
2765
+ description?: string | null | undefined;
2769
2766
  createdAt: any;
2770
2767
  updatedAt: any;
2771
- billingId?: string | null;
2772
- billingLinkUrl?: string | null;
2768
+ billingId?: string | null | undefined;
2769
+ billingLinkUrl?: string | null | undefined;
2773
2770
  status: CouponStatus;
2774
2771
  syncStates?: Array<{
2775
2772
  __typename?: 'SyncState';
2776
2773
  vendorIdentifier: VendorIdentifier;
2777
2774
  status: SyncStatus;
2778
- }> | null;
2775
+ }> | null | undefined;
2779
2776
  customers?: Array<{
2780
2777
  __typename?: 'Customer';
2781
2778
  id: string;
2782
- }> | null;
2779
+ }> | null | undefined;
2783
2780
  };
2784
2781
  export declare type FetchCouponsQueryVariables = Exact<{
2785
- filter?: InputMaybe<CouponFilter>;
2786
- sorting?: InputMaybe<Array<CouponSort> | CouponSort>;
2787
- paging?: InputMaybe<CursorPaging>;
2782
+ filter?: Maybe<CouponFilter>;
2783
+ sorting?: Maybe<Array<CouponSort> | CouponSort>;
2784
+ paging?: Maybe<CursorPaging>;
2788
2785
  }>;
2789
2786
  export declare type FetchCouponsQuery = {
2790
2787
  __typename?: 'Query';
@@ -2802,9 +2799,9 @@ export declare type PriceFragment = {
2802
2799
  __typename?: 'Price';
2803
2800
  billingModel: BillingModel;
2804
2801
  billingPeriod: BillingPeriod;
2805
- billingId?: string | null;
2806
- minUnitQuantity?: number | null;
2807
- maxUnitQuantity?: number | null;
2802
+ billingId?: string | null | undefined;
2803
+ minUnitQuantity?: number | null | undefined;
2804
+ maxUnitQuantity?: number | null | undefined;
2808
2805
  price: {
2809
2806
  __typename?: 'Money';
2810
2807
  amount: number;
@@ -2812,10 +2809,10 @@ export declare type PriceFragment = {
2812
2809
  };
2813
2810
  feature?: {
2814
2811
  __typename?: 'Feature';
2815
- featureUnits?: string | null;
2816
- featureUnitsPlural?: string | null;
2812
+ featureUnits?: string | null | undefined;
2813
+ featureUnitsPlural?: string | null | undefined;
2817
2814
  displayName: string;
2818
- } | null;
2815
+ } | null | undefined;
2819
2816
  };
2820
2817
  export declare type TotalPriceFragment = {
2821
2818
  __typename?: 'CustomerSubscriptionTotalPrice';
@@ -2830,93 +2827,16 @@ export declare type TotalPriceFragment = {
2830
2827
  currency: Currency;
2831
2828
  };
2832
2829
  };
2833
- export declare type PackageEntitlementFragment = {
2834
- __typename?: 'PackageEntitlement';
2835
- usageLimit?: number | null;
2836
- hasUnlimitedUsage?: boolean | null;
2837
- featureId: string;
2838
- resetPeriod?: EntitlementResetPeriod | null;
2839
- feature: {
2840
- __typename?: 'Feature';
2841
- featureType: FeatureType;
2842
- meterType?: MeterType | null;
2843
- featureUnits?: string | null;
2844
- featureUnitsPlural?: string | null;
2845
- displayName: string;
2846
- description?: string | null;
2847
- refId: string;
2848
- additionalMetaData?: any | null;
2849
- };
2850
- };
2851
- export declare type AddonFragment = {
2852
- __typename?: 'Addon';
2853
- refId: string;
2854
- billingId?: string | null;
2855
- displayName: string;
2856
- description?: string | null;
2857
- additionalMetaData?: any | null;
2858
- pricingType?: PricingType | null;
2859
- entitlements?: Array<{
2860
- __typename?: 'PackageEntitlement';
2861
- } & PackageEntitlementFragment> | null;
2862
- };
2863
- export declare type PlanFragment = {
2864
- __typename?: 'Plan';
2865
- refId: string;
2866
- displayName: string;
2867
- description?: string | null;
2868
- billingId?: string | null;
2869
- additionalMetaData?: any | null;
2870
- pricingType?: PricingType | null;
2871
- product: {
2872
- __typename?: 'Product';
2873
- refId: string;
2874
- displayName?: string | null;
2875
- description?: string | null;
2876
- additionalMetaData?: any | null;
2877
- productSettings: {
2878
- __typename?: 'ProductSettings';
2879
- downgradePlan?: {
2880
- __typename?: 'Plan';
2881
- refId: string;
2882
- displayName: string;
2883
- } | null;
2884
- };
2885
- };
2886
- basePlan?: {
2887
- __typename?: 'Plan';
2888
- id: string;
2889
- refId: string;
2890
- displayName: string;
2891
- } | null;
2892
- entitlements?: Array<{
2893
- __typename?: 'PackageEntitlement';
2894
- } & PackageEntitlementFragment> | null;
2895
- inheritedEntitlements?: Array<{
2896
- __typename?: 'PackageEntitlement';
2897
- } & PackageEntitlementFragment> | null;
2898
- compatibleAddons?: Array<{
2899
- __typename?: 'Addon';
2900
- } & AddonFragment> | null;
2901
- prices?: Array<{
2902
- __typename?: 'Price';
2903
- } & PriceFragment> | null;
2904
- defaultTrialConfig?: {
2905
- __typename?: 'DefaultTrialConfig';
2906
- duration: number;
2907
- units: TrialPeriodUnits;
2908
- } | null;
2909
- };
2910
2830
  export declare type SlimSubscriptionFragment = {
2911
2831
  __typename?: 'CustomerSubscription';
2912
2832
  id: string;
2913
2833
  refId: string;
2914
2834
  status: SubscriptionStatus;
2915
- additionalMetaData?: any | null;
2916
- billingId?: string | null;
2917
- billingLinkUrl?: string | null;
2918
- effectiveEndDate?: any | null;
2919
- currentBillingPeriodEnd?: any | null;
2835
+ additionalMetaData?: any | null | undefined;
2836
+ billingId?: string | null | undefined;
2837
+ billingLinkUrl?: string | null | undefined;
2838
+ effectiveEndDate?: any | null | undefined;
2839
+ currentBillingPeriodEnd?: any | null | undefined;
2920
2840
  pricingType: PricingType;
2921
2841
  experimentInfo?: {
2922
2842
  __typename?: 'experimentInfo';
@@ -2924,17 +2844,17 @@ export declare type SlimSubscriptionFragment = {
2924
2844
  id: string;
2925
2845
  groupName: string;
2926
2846
  groupType: ExperimentGroupType;
2927
- } | null;
2847
+ } | null | undefined;
2928
2848
  prices?: Array<{
2929
2849
  __typename?: 'SubscriptionPrice';
2930
- usageLimit?: number | null;
2850
+ usageLimit?: number | null | undefined;
2931
2851
  price?: ({
2932
2852
  __typename?: 'Price';
2933
- } & PriceFragment) | null;
2934
- }> | null;
2853
+ } & PriceFragment) | null | undefined;
2854
+ }> | null | undefined;
2935
2855
  totalPrice?: ({
2936
2856
  __typename?: 'CustomerSubscriptionTotalPrice';
2937
- } & TotalPriceFragment) | null;
2857
+ } & TotalPriceFragment) | null | undefined;
2938
2858
  plan: {
2939
2859
  __typename?: 'Plan';
2940
2860
  id: string;
@@ -2948,135 +2868,13 @@ export declare type SlimSubscriptionFragment = {
2948
2868
  id: string;
2949
2869
  refId: string;
2950
2870
  };
2951
- }> | null;
2871
+ }> | null | undefined;
2952
2872
  customer: {
2953
2873
  __typename?: 'Customer';
2954
2874
  id: string;
2955
2875
  refId: string;
2956
2876
  };
2957
2877
  };
2958
- export declare type SubscriptionScheduledUpdateDataFragment = {
2959
- __typename?: 'SubscriptionScheduledUpdate';
2960
- subscriptionScheduleType: SubscriptionScheduleType;
2961
- scheduleStatus: SubscriptionScheduleStatus;
2962
- scheduledExecutionTime: any;
2963
- scheduleVariables?: {
2964
- __typename?: 'BillingPeriodChangeVariables';
2965
- billingPeriod?: BillingPeriod | null | undefined;
2966
- } | {
2967
- __typename?: 'DowngradeChangeVariables';
2968
- addonRefIds?: string | null | undefined;
2969
- billingPeriod?: BillingPeriod | null | undefined;
2970
- downgradePlanRefId: string;
2971
- } | {
2972
- __typename?: 'UnitAmountChangeVariables';
2973
- newUnitAmount?: number | null | undefined;
2974
- } | null | undefined;
2975
- };
2976
- export declare type SubscriptionFragment = {
2977
- __typename?: 'CustomerSubscription';
2978
- id: string;
2979
- startDate: any;
2980
- endDate?: any | null;
2981
- trialEndDate?: any | null;
2982
- cancellationDate?: any | null;
2983
- effectiveEndDate?: any | null;
2984
- status: SubscriptionStatus;
2985
- refId: string;
2986
- currentBillingPeriodEnd?: any | null;
2987
- additionalMetaData?: any | null;
2988
- billingId?: string | null;
2989
- billingLinkUrl?: string | null;
2990
- pricingType: PricingType;
2991
- experimentInfo?: {
2992
- __typename?: 'experimentInfo';
2993
- name: string;
2994
- groupType: ExperimentGroupType;
2995
- groupName: string;
2996
- id: string;
2997
- } | null;
2998
- prices?: Array<{
2999
- __typename?: 'SubscriptionPrice';
3000
- usageLimit?: number | null;
3001
- price?: ({
3002
- __typename?: 'Price';
3003
- } & PriceFragment) | null;
3004
- }> | null;
3005
- totalPrice?: ({
3006
- __typename?: 'CustomerSubscriptionTotalPrice';
3007
- } & TotalPriceFragment) | null;
3008
- plan: {
3009
- __typename?: 'Plan';
3010
- } & PlanFragment;
3011
- addons?: Array<{
3012
- __typename?: 'SubscriptionAddon';
3013
- id: string;
3014
- quantity: number;
3015
- addon: {
3016
- __typename?: 'Addon';
3017
- } & AddonFragment;
3018
- }> | null | undefined;
3019
- scheduledUpdates?: Array<{
3020
- __typename?: 'SubscriptionScheduledUpdate';
3021
- } & SubscriptionScheduledUpdateDataFragment> | null | undefined;
3022
- };
3023
- export declare type PromotionalEntitlementFragment = {
3024
- __typename?: 'PromotionalEntitlement';
3025
- status: PromotionalEntitlementStatus;
3026
- usageLimit?: number | null;
3027
- featureId: string;
3028
- hasUnlimitedUsage?: boolean | null;
3029
- resetPeriod?: EntitlementResetPeriod | null;
3030
- endDate?: any | null;
3031
- isVisible: boolean;
3032
- feature: {
3033
- __typename?: 'Feature';
3034
- featureType: FeatureType;
3035
- meterType?: MeterType | null;
3036
- featureUnits?: string | null;
3037
- featureUnitsPlural?: string | null;
3038
- displayName: string;
3039
- description?: string | null;
3040
- refId: string;
3041
- additionalMetaData?: any | null;
3042
- };
3043
- };
3044
- export declare type CustomerFragment = {
3045
- __typename?: 'Customer';
3046
- id: string;
3047
- name?: string | null;
3048
- email?: string | null;
3049
- createdAt?: any | null;
3050
- updatedAt: any;
3051
- hasPaymentMethod: boolean;
3052
- refId: string;
3053
- billingId?: string | null;
3054
- defaultPaymentExpirationMonth?: number | null;
3055
- defaultPaymentExpirationYear?: number | null;
3056
- defaultPaymentMethodLast4Digits?: string | null;
3057
- additionalMetaData?: any | null;
3058
- trialedPlans?: Array<{
3059
- __typename?: 'TrialedPlan';
3060
- productRefId?: string | null;
3061
- planRefId?: string | null;
3062
- }> | null;
3063
- experimentInfo?: {
3064
- __typename?: 'experimentInfo';
3065
- groupType: ExperimentGroupType;
3066
- groupName: string;
3067
- id: string;
3068
- name: string;
3069
- } | null;
3070
- coupon?: ({
3071
- __typename?: 'Coupon';
3072
- } & CouponFragment) | null;
3073
- promotionalEntitlements: Array<{
3074
- __typename?: 'PromotionalEntitlement';
3075
- } & PromotionalEntitlementFragment>;
3076
- subscriptions?: Array<{
3077
- __typename?: 'CustomerSubscription';
3078
- } & SubscriptionFragment> | null;
3079
- };
3080
2878
  export declare type SubscriptionPreviewFragment = {
3081
2879
  __typename?: 'SubscriptionPreview';
3082
2880
  subTotal: {
@@ -3091,8 +2889,8 @@ export declare type SubscriptionPreviewFragment = {
3091
2889
  };
3092
2890
  billingPeriodRange: {
3093
2891
  __typename?: 'DateRange';
3094
- start?: any | null;
3095
- end?: any | null;
2892
+ start?: any | null | undefined;
2893
+ end?: any | null | undefined;
3096
2894
  };
3097
2895
  proration?: {
3098
2896
  __typename?: 'SubscriptionPreviewProrations';
@@ -3107,16 +2905,7 @@ export declare type SubscriptionPreviewFragment = {
3107
2905
  amount: number;
3108
2906
  currency: Currency;
3109
2907
  };
3110
- } | null;
3111
- };
3112
- export declare type GetEntitlementsQueryVariables = Exact<{
3113
- query: FetchEntitlementsQuery;
3114
- }>;
3115
- export declare type GetEntitlementsQuery = {
3116
- __typename?: 'Query';
3117
- entitlements: Array<{
3118
- __typename?: 'Entitlement';
3119
- } & EntitlementFragment>;
2908
+ } | null | undefined;
3120
2909
  };
3121
2910
  export declare type CreateUsageMeasurementMutationVariables = Exact<{
3122
2911
  usageMeasurement: UsageMeasurementCreateInput;
@@ -3135,35 +2924,34 @@ export declare type ReportEntitlementCheckRequestedMutation = {
3135
2924
  __typename?: 'Mutation';
3136
2925
  reportEntitlementCheckRequested: boolean;
3137
2926
  };
3138
- export declare type FeatureFragment = {
3139
- __typename?: 'EntitlementFeature';
3140
- featureType: FeatureType;
3141
- meterType?: MeterType | null;
3142
- featureUnits?: string | null;
3143
- featureUnitsPlural?: string | null;
3144
- refId: string;
3145
- };
3146
- export declare type EntitlementFragment = {
2927
+ export declare type UpdatedEntitlementFragment = {
3147
2928
  __typename?: 'Entitlement';
3148
2929
  isGranted: boolean;
3149
- accessDeniedReason?: AccessDeniedReason | null;
3150
- customerId?: string | null;
3151
- usageLimit?: number | null;
2930
+ accessDeniedReason?: AccessDeniedReason | null | undefined;
2931
+ customerId?: string | null | undefined;
2932
+ usageLimit?: number | null | undefined;
3152
2933
  hasUnlimitedUsage: boolean;
3153
- currentUsage?: number | null;
3154
- requestedUsage?: number | null;
3155
- usageUpdatedAt?: number | null;
3156
- entitlementUpdatedAt?: number | null;
3157
- nextResetDate?: any | null;
3158
- resetPeriod?: EntitlementResetPeriod | null;
2934
+ currentUsage?: number | null | undefined;
2935
+ requestedUsage?: number | null | undefined;
2936
+ usageUpdatedAt?: number | null | undefined;
2937
+ entitlementUpdatedAt?: number | null | undefined;
2938
+ nextResetDate?: any | null | undefined;
2939
+ resetPeriod?: EntitlementResetPeriod | null | undefined;
3159
2940
  resetPeriodConfiguration?: ({
3160
2941
  __typename?: 'MonthlyResetPeriodConfig';
3161
2942
  } & ResetPeriodConfigurationFragment_MonthlyResetPeriodConfig_) | ({
3162
2943
  __typename?: 'WeeklyResetPeriodConfig';
3163
- } & ResetPeriodConfigurationFragment_WeeklyResetPeriodConfig_) | null;
3164
- feature?: ({
2944
+ } & ResetPeriodConfigurationFragment_WeeklyResetPeriodConfig_) | null | undefined;
2945
+ feature?: {
3165
2946
  __typename?: 'EntitlementFeature';
3166
- } & FeatureFragment) | null;
2947
+ featureType: FeatureType;
2948
+ meterType?: MeterType | null | undefined;
2949
+ featureUnits?: string | null | undefined;
2950
+ featureUnitsPlural?: string | null | undefined;
2951
+ description?: string | null | undefined;
2952
+ displayName: string;
2953
+ refId: string;
2954
+ } | null | undefined;
3167
2955
  };
3168
2956
  declare type ResetPeriodConfigurationFragment_MonthlyResetPeriodConfig_ = {
3169
2957
  __typename: 'MonthlyResetPeriodConfig';
@@ -3174,11 +2962,11 @@ declare type ResetPeriodConfigurationFragment_WeeklyResetPeriodConfig_ = {
3174
2962
  export declare type ResetPeriodConfigurationFragment = ResetPeriodConfigurationFragment_MonthlyResetPeriodConfig_ | ResetPeriodConfigurationFragment_WeeklyResetPeriodConfig_;
3175
2963
  export declare type MonthlyResetPeriodConfigFragment = {
3176
2964
  __typename?: 'MonthlyResetPeriodConfig';
3177
- monthlyAccordingTo?: MonthlyAccordingTo | null;
2965
+ monthlyAccordingTo?: MonthlyAccordingTo | null | undefined;
3178
2966
  };
3179
2967
  export declare type WeeklyResetPeriodConfigFragment = {
3180
2968
  __typename?: 'WeeklyResetPeriodConfig';
3181
- weeklyAccordingTo?: WeeklyAccordingTo | null;
2969
+ weeklyAccordingTo?: WeeklyAccordingTo | null | undefined;
3182
2970
  };
3183
2971
  export declare type EntitlementsUpdatedSubscriptionVariables = Exact<{
3184
2972
  [key: string]: never;
@@ -3194,7 +2982,7 @@ export declare type EntitlementsUpdatedPayloadFragment = {
3194
2982
  customerId: string;
3195
2983
  entitlements: Array<{
3196
2984
  __typename?: 'Entitlement';
3197
- } & EntitlementFragment>;
2985
+ } & UpdatedEntitlementFragment>;
3198
2986
  };
3199
2987
  export declare type UsageUpdatedSubscriptionVariables = Exact<{
3200
2988
  [key: string]: never;
@@ -3212,11 +3000,11 @@ export declare type EntitlementUsageUpdatedFragment = {
3212
3000
  customerId: string;
3213
3001
  featureId: string;
3214
3002
  currentUsage: number;
3215
- nextResetDate?: number | null;
3003
+ nextResetDate?: number | null | undefined;
3216
3004
  };
3217
3005
  entitlement: {
3218
3006
  __typename?: 'Entitlement';
3219
- } & EntitlementFragment;
3007
+ } & UpdatedEntitlementFragment;
3220
3008
  };
3221
3009
  export declare type CreateCustomerMutationVariables = Exact<{
3222
3010
  input: CustomerInput;
@@ -3242,7 +3030,7 @@ export declare type ProvisionCustomerMutation = {
3242
3030
  };
3243
3031
  subscription?: ({
3244
3032
  __typename?: 'CustomerSubscription';
3245
- } & SlimSubscriptionFragment) | null;
3033
+ } & SlimSubscriptionFragment) | null | undefined;
3246
3034
  };
3247
3035
  };
3248
3036
  export declare type ImportCustomerMutationVariables = Exact<{
@@ -3265,15 +3053,6 @@ export declare type UpdateOneCustomerMutation = {
3265
3053
  refId: string;
3266
3054
  };
3267
3055
  };
3268
- export declare type GetCustomerByRefIdQueryVariables = Exact<{
3269
- input: GetCustomerByRefIdInput;
3270
- }>;
3271
- export declare type GetCustomerByRefIdQuery = {
3272
- __typename?: 'Query';
3273
- getCustomerByRefId?: ({
3274
- __typename?: 'Customer';
3275
- } & CustomerFragment) | null;
3276
- };
3277
3056
  export declare type UpdateOneSubscriptionMutationVariables = Exact<{
3278
3057
  input: UpdateSubscriptionInput;
3279
3058
  }>;
@@ -3299,11 +3078,11 @@ export declare type ProvisionSubscriptionMutation = {
3299
3078
  __typename?: 'Mutation';
3300
3079
  provisionSubscription: {
3301
3080
  __typename?: 'ProvisionSubscriptionResult';
3302
- checkoutUrl?: string | null;
3081
+ checkoutUrl?: string | null | undefined;
3303
3082
  status: ProvisionSubscriptionStatus;
3304
3083
  subscription?: ({
3305
3084
  __typename?: 'CustomerSubscription';
3306
- } & SlimSubscriptionFragment) | null;
3085
+ } & SlimSubscriptionFragment) | null | undefined;
3307
3086
  };
3308
3087
  };
3309
3088
  export declare type CancelSubscriptionMutationVariables = Exact<{
@@ -3326,18 +3105,6 @@ export declare type InitiateCheckoutMutation = {
3326
3105
  checkoutBillingId: string;
3327
3106
  };
3328
3107
  };
3329
- export declare type GetPaywallQueryVariables = Exact<{
3330
- input: GetPaywallInput;
3331
- }>;
3332
- export declare type GetPaywallQuery = {
3333
- __typename?: 'Query';
3334
- paywall: {
3335
- __typename?: 'Paywall';
3336
- plans: Array<{
3337
- __typename?: 'Plan';
3338
- } & PaywallPlanFragment>;
3339
- };
3340
- };
3341
3108
  export declare type EstimateSubscriptionMutationVariables = Exact<{
3342
3109
  input: EstimateSubscriptionInput;
3343
3110
  }>;
@@ -3363,85 +3130,6 @@ export declare type CancelSubscriptionUpdatesMutation = {
3363
3130
  __typename?: 'Mutation';
3364
3131
  cancelSchedule: string;
3365
3132
  };
3366
- export declare type PaywallPackageEntitlementFragment = {
3367
- __typename?: 'PackageEntitlement';
3368
- usageLimit?: number | null;
3369
- hasUnlimitedUsage?: boolean | null;
3370
- featureId: string;
3371
- resetPeriod?: EntitlementResetPeriod | null;
3372
- feature: {
3373
- __typename?: 'Feature';
3374
- featureType: FeatureType;
3375
- meterType?: MeterType | null;
3376
- featureUnits?: string | null;
3377
- featureUnitsPlural?: string | null;
3378
- displayName: string;
3379
- description?: string | null;
3380
- refId: string;
3381
- additionalMetaData?: any | null;
3382
- };
3383
- };
3384
- export declare type PaywallAddonFragment = {
3385
- __typename?: 'Addon';
3386
- refId: string;
3387
- displayName: string;
3388
- billingId?: string | null;
3389
- description?: string | null;
3390
- additionalMetaData?: any | null;
3391
- pricingType?: PricingType | null;
3392
- entitlements?: Array<{
3393
- __typename?: 'PackageEntitlement';
3394
- } & PaywallPackageEntitlementFragment> | null;
3395
- prices?: Array<{
3396
- __typename?: 'Price';
3397
- } & PriceFragment> | null;
3398
- };
3399
- export declare type PaywallPlanFragment = {
3400
- __typename?: 'Plan';
3401
- refId: string;
3402
- description?: string | null;
3403
- displayName: string;
3404
- billingId?: string | null;
3405
- additionalMetaData?: any | null;
3406
- pricingType?: PricingType | null;
3407
- product: {
3408
- __typename?: 'Product';
3409
- refId: string;
3410
- displayName?: string | null;
3411
- description?: string | null;
3412
- additionalMetaData?: any | null;
3413
- productSettings: {
3414
- __typename?: 'ProductSettings';
3415
- downgradePlan?: {
3416
- __typename?: 'Plan';
3417
- refId: string;
3418
- displayName: string;
3419
- } | null;
3420
- };
3421
- };
3422
- basePlan?: {
3423
- __typename?: 'Plan';
3424
- refId: string;
3425
- displayName: string;
3426
- } | null;
3427
- entitlements?: Array<{
3428
- __typename?: 'PackageEntitlement';
3429
- } & PaywallPackageEntitlementFragment> | null;
3430
- inheritedEntitlements?: Array<{
3431
- __typename?: 'PackageEntitlement';
3432
- } & PaywallPackageEntitlementFragment> | null;
3433
- prices?: Array<{
3434
- __typename?: 'Price';
3435
- } & PriceFragment> | null;
3436
- defaultTrialConfig?: {
3437
- __typename?: 'DefaultTrialConfig';
3438
- duration: number;
3439
- units: TrialPeriodUnits;
3440
- } | null;
3441
- compatibleAddons?: Array<{
3442
- __typename?: 'Addon';
3443
- } & PaywallAddonFragment> | null;
3444
- };
3445
3133
  export declare type SdkConfigurationQueryVariables = Exact<{
3446
3134
  [key: string]: never;
3447
3135
  }>;
@@ -3449,7 +3137,7 @@ export declare type SdkConfigurationQuery = {
3449
3137
  __typename?: 'Query';
3450
3138
  sdkConfiguration?: {
3451
3139
  __typename?: 'SdkConfiguration';
3452
- sentryDsn?: string | null;
3453
- } | null;
3140
+ sentryDsn?: string | null | undefined;
3141
+ } | null | undefined;
3454
3142
  };
3455
3143
  export {};