@code0-tech/sagittarius-graphql-types 0.0.0-25fbf0c9e886bd28673ab74a9e554aa777aff987 → 0.0.0-3dbc1d7dffaa541501b2cb0954dabc06a9288cf6

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 (2) hide show
  1. package/index.d.ts +586 -366
  2. package/package.json +4 -5
package/index.d.ts CHANGED
@@ -12,71 +12,37 @@ export interface Scalars {
12
12
  Boolean: { input: boolean; output: boolean; }
13
13
  Int: { input: number; output: number; }
14
14
  Float: { input: number; output: number; }
15
- /** A unique identifier for all DataType entities of the application */
16
15
  DataTypeID: { input: `gid://sagittarius/DataType/${number}`; output: `gid://sagittarius/DataType/${number}`; }
17
- /** A unique identifier for all DataTypeIdentifier entities of the application */
18
16
  DataTypeIdentifierID: { input: `gid://sagittarius/DataTypeIdentifier/${number}`; output: `gid://sagittarius/DataTypeIdentifier/${number}`; }
19
- /** A unique identifier for all DataTypeRule entities of the application */
20
17
  DataTypeRuleID: { input: `gid://sagittarius/DataTypeRule/${number}`; output: `gid://sagittarius/DataTypeRule/${number}`; }
21
- /** A unique identifier for all Flow entities of the application */
22
18
  FlowID: { input: `gid://sagittarius/Flow/${number}`; output: `gid://sagittarius/Flow/${number}`; }
23
- /** A unique identifier for all FlowSetting entities of the application */
24
19
  FlowSettingID: { input: `gid://sagittarius/FlowSetting/${number}`; output: `gid://sagittarius/FlowSetting/${number}`; }
25
- /** A unique identifier for all FlowType entities of the application */
26
20
  FlowTypeID: { input: `gid://sagittarius/FlowType/${number}`; output: `gid://sagittarius/FlowType/${number}`; }
27
- /** A unique identifier for all FlowTypeSetting entities of the application */
28
21
  FlowTypeSettingID: { input: `gid://sagittarius/FlowTypeSetting/${number}`; output: `gid://sagittarius/FlowTypeSetting/${number}`; }
29
- /** A unique identifier for all FunctionDefinition entities of the application */
30
22
  FunctionDefinitionID: { input: `gid://sagittarius/FunctionDefinition/${number}`; output: `gid://sagittarius/FunctionDefinition/${number}`; }
31
- /** A unique identifier for all GenericMapper entities of the application */
23
+ GenericCombinationStrategyID: { input: `gid://sagittarius/GenericCombinationStrategy/${number}`; output: `gid://sagittarius/GenericCombinationStrategy/${number}`; }
32
24
  GenericMapperID: { input: `gid://sagittarius/GenericMapper/${number}`; output: `gid://sagittarius/GenericMapper/${number}`; }
33
- /** A unique identifier for all GenericType entities of the application */
34
25
  GenericTypeID: { input: `gid://sagittarius/GenericType/${number}`; output: `gid://sagittarius/GenericType/${number}`; }
35
- /** Represents untyped JSON */
36
26
  JSON: { input: any; output: any; }
37
- /** A unique identifier for all Namespace entities of the application */
38
27
  NamespaceID: { input: `gid://sagittarius/Namespace/${number}`; output: `gid://sagittarius/Namespace/${number}`; }
39
- /** A unique identifier for all NamespaceLicense entities of the application */
40
28
  NamespaceLicenseID: { input: `gid://sagittarius/NamespaceLicense/${number}`; output: `gid://sagittarius/NamespaceLicense/${number}`; }
41
- /** A unique identifier for all NamespaceMember entities of the application */
42
29
  NamespaceMemberID: { input: `gid://sagittarius/NamespaceMember/${number}`; output: `gid://sagittarius/NamespaceMember/${number}`; }
43
- /** A unique identifier for all NamespaceMemberRole entities of the application */
44
30
  NamespaceMemberRoleID: { input: `gid://sagittarius/NamespaceMemberRole/${number}`; output: `gid://sagittarius/NamespaceMemberRole/${number}`; }
45
- /** A unique identifier for all NamespaceProject entities of the application */
46
31
  NamespaceProjectID: { input: `gid://sagittarius/NamespaceProject/${number}`; output: `gid://sagittarius/NamespaceProject/${number}`; }
47
- /** A unique identifier for all NamespaceRole entities of the application */
48
32
  NamespaceRoleID: { input: `gid://sagittarius/NamespaceRole/${number}`; output: `gid://sagittarius/NamespaceRole/${number}`; }
49
- /** A unique identifier for all NodeFunction entities of the application */
50
33
  NodeFunctionID: { input: `gid://sagittarius/NodeFunction/${number}`; output: `gid://sagittarius/NodeFunction/${number}`; }
51
- /** A unique identifier for all NodeParameter entities of the application */
52
34
  NodeParameterID: { input: `gid://sagittarius/NodeParameter/${number}`; output: `gid://sagittarius/NodeParameter/${number}`; }
53
- /** A unique identifier for all Organization entities of the application */
54
35
  OrganizationID: { input: `gid://sagittarius/Organization/${number}`; output: `gid://sagittarius/Organization/${number}`; }
55
- /** A unique identifier for all ParameterDefinition entities of the application */
56
36
  ParameterDefinitionID: { input: `gid://sagittarius/ParameterDefinition/${number}`; output: `gid://sagittarius/ParameterDefinition/${number}`; }
57
- /** A unique identifier for all ReferencePath entities of the application */
58
37
  ReferencePathID: { input: `gid://sagittarius/ReferencePath/${number}`; output: `gid://sagittarius/ReferencePath/${number}`; }
59
- /** A unique identifier for all ReferenceValue entities of the application */
60
38
  ReferenceValueID: { input: `gid://sagittarius/ReferenceValue/${number}`; output: `gid://sagittarius/ReferenceValue/${number}`; }
61
- /** A unique identifier for all RuntimeFunctionDefinition entities of the application */
62
39
  RuntimeFunctionDefinitionID: { input: `gid://sagittarius/RuntimeFunctionDefinition/${number}`; output: `gid://sagittarius/RuntimeFunctionDefinition/${number}`; }
63
- /** A unique identifier for all Runtime entities of the application */
64
40
  RuntimeID: { input: `gid://sagittarius/Runtime/${number}`; output: `gid://sagittarius/Runtime/${number}`; }
65
- /** A unique identifier for all RuntimeParameterDefinition entities of the application */
66
41
  RuntimeParameterDefinitionID: { input: `gid://sagittarius/RuntimeParameterDefinition/${number}`; output: `gid://sagittarius/RuntimeParameterDefinition/${number}`; }
67
- /**
68
- * Time represented in ISO 8601.
69
- *
70
- * For example: "2023-12-15T17:31:00Z".
71
- */
72
42
  Time: { input: string; output: string; }
73
- /** A unique identifier for all Types::FlowType entities of the application */
74
43
  TypesFlowTypeID: { input: `gid://sagittarius/TypesFlowType/${number}`; output: `gid://sagittarius/TypesFlowType/${number}`; }
75
- /** A unique identifier for all User entities of the application */
76
44
  UserID: { input: `gid://sagittarius/User/${number}`; output: `gid://sagittarius/User/${number}`; }
77
- /** A unique identifier for all UserIdentity entities of the application */
78
45
  UserIdentityID: { input: `gid://sagittarius/UserIdentity/${number}`; output: `gid://sagittarius/UserIdentity/${number}`; }
79
- /** A unique identifier for all UserSession entities of the application */
80
46
  UserSessionID: { input: `gid://sagittarius/UserSession/${number}`; output: `gid://sagittarius/UserSession/${number}`; }
81
47
  }
82
48
 
@@ -84,18 +50,18 @@ export interface Scalars {
84
50
  export interface ActiveModelError {
85
51
  __typename?: 'ActiveModelError';
86
52
  /** The affected attribute on the model */
87
- attribute: Scalars['String']['output'];
53
+ attribute?: Maybe<Scalars['String']['output']>;
88
54
  /** The validation type that failed for the attribute */
89
- type: Scalars['String']['output'];
55
+ type?: Maybe<Scalars['String']['output']>;
90
56
  }
91
57
 
92
58
  /** Represents the application settings */
93
59
  export interface ApplicationSettings {
94
60
  __typename?: 'ApplicationSettings';
95
61
  /** Shows if organization creation is restricted to administrators */
96
- organizationCreationRestricted: Scalars['Boolean']['output'];
62
+ organizationCreationRestricted?: Maybe<Scalars['Boolean']['output']>;
97
63
  /** Shows if user registration is enabled */
98
- userRegistrationEnabled: Scalars['Boolean']['output'];
64
+ userRegistrationEnabled?: Maybe<Scalars['Boolean']['output']>;
99
65
  }
100
66
 
101
67
  /** Autogenerated input type of ApplicationSettingsUpdate */
@@ -116,54 +82,33 @@ export interface ApplicationSettingsUpdatePayload {
116
82
  /** A unique identifier for the client performing the mutation. */
117
83
  clientMutationId?: Maybe<Scalars['String']['output']>;
118
84
  /** Errors encountered during execution of the mutation. */
119
- errors: Array<Error>;
85
+ errors?: Maybe<Array<Error>>;
120
86
  }
121
87
 
122
88
  /** Objects that can present an authentication */
123
89
  export type Authentication = UserSession;
124
90
 
125
- /** Represents a rule that can be applied to a data type. */
126
- export type Config = ContainsKeyConfig | ContainsTypeConfig | InputTypesConfig | ItemOfCollectionConfig | NumberRangeConfig | RegexConfig | ReturnTypeConfig;
127
-
128
- /** Represents a rule that can be applied to a data type. */
129
- export interface ContainsKeyConfig {
130
- __typename?: 'ContainsKeyConfig';
131
- /** The identifier of the data type this rule belongs to */
132
- dataTypeIdentifier: DataTypeIdentifier;
133
- /** The key of the rule */
134
- key: Scalars['String']['output'];
135
- }
136
-
137
- /** Represents a rule that can be applied to a data type. */
138
- export interface ContainsTypeConfig {
139
- __typename?: 'ContainsTypeConfig';
140
- /** The identifier of the data type this rule belongs to */
141
- dataTypeIdentifier: DataTypeIdentifier;
142
- }
143
-
144
91
  /** Represents a DataType */
145
92
  export interface DataType {
146
93
  __typename?: 'DataType';
147
94
  /** Time when this DataType was created */
148
- createdAt: Scalars['Time']['output'];
95
+ createdAt?: Maybe<Scalars['Time']['output']>;
149
96
  /** Generic keys of the datatype */
150
97
  genericKeys?: Maybe<Array<Scalars['String']['output']>>;
151
98
  /** Global ID of this DataType */
152
- id: Scalars['DataTypeID']['output'];
99
+ id?: Maybe<Scalars['DataTypeID']['output']>;
153
100
  /** The identifier scoped to the namespace */
154
- identifier: Scalars['String']['output'];
101
+ identifier?: Maybe<Scalars['String']['output']>;
155
102
  /** Names of the flow type setting */
156
- name: TranslationConnection;
157
- /** The namespace where this datatype belongs to */
158
- namespace?: Maybe<Namespace>;
159
- /** The parent datatype */
160
- parent?: Maybe<DataTypeIdentifier>;
103
+ name?: Maybe<TranslationConnection>;
161
104
  /** Rules of the datatype */
162
- rules: DataTypeRuleConnection;
105
+ rules?: Maybe<DataTypeRuleConnection>;
106
+ /** The runtime where this datatype belongs to */
107
+ runtime?: Maybe<Runtime>;
163
108
  /** Time when this DataType was last updated */
164
- updatedAt: Scalars['Time']['output'];
109
+ updatedAt?: Maybe<Scalars['Time']['output']>;
165
110
  /** The type of the datatype */
166
- variant: DataTypeVariant;
111
+ variant?: Maybe<DataTypeVariant>;
167
112
  }
168
113
 
169
114
 
@@ -188,20 +133,20 @@ export interface DataTypeRulesArgs {
188
133
  export interface DataTypeConnection {
189
134
  __typename?: 'DataTypeConnection';
190
135
  /** Total count of collection. */
191
- count: Scalars['Int']['output'];
136
+ count?: Maybe<Scalars['Int']['output']>;
192
137
  /** A list of edges. */
193
138
  edges?: Maybe<Array<Maybe<DataTypeEdge>>>;
194
139
  /** A list of nodes. */
195
140
  nodes?: Maybe<Array<Maybe<DataType>>>;
196
141
  /** Information to aid in pagination. */
197
- pageInfo: PageInfo;
142
+ pageInfo?: Maybe<PageInfo>;
198
143
  }
199
144
 
200
145
  /** An edge in a connection. */
201
146
  export interface DataTypeEdge {
202
147
  __typename?: 'DataTypeEdge';
203
148
  /** A cursor for use in pagination. */
204
- cursor: Scalars['String']['output'];
149
+ cursor?: Maybe<Scalars['String']['output']>;
205
150
  /** The item at the end of the edge. */
206
151
  node?: Maybe<DataType>;
207
152
  }
@@ -210,7 +155,7 @@ export interface DataTypeEdge {
210
155
  export interface DataTypeIdentifier {
211
156
  __typename?: 'DataTypeIdentifier';
212
157
  /** Time when this DataTypeIdentifier was created */
213
- createdAt: Scalars['Time']['output'];
158
+ createdAt?: Maybe<Scalars['Time']['output']>;
214
159
  /** The data type of the data type identifier. */
215
160
  dataType?: Maybe<DataType>;
216
161
  /** The generic key of the data type identifier. */
@@ -218,9 +163,9 @@ export interface DataTypeIdentifier {
218
163
  /** The generic type of the data type identifier. */
219
164
  genericType?: Maybe<GenericType>;
220
165
  /** Global ID of this DataTypeIdentifier */
221
- id: Scalars['DataTypeIdentifierID']['output'];
166
+ id?: Maybe<Scalars['DataTypeIdentifierID']['output']>;
222
167
  /** Time when this DataTypeIdentifier was last updated */
223
- updatedAt: Scalars['Time']['output'];
168
+ updatedAt?: Maybe<Scalars['Time']['output']>;
224
169
  }
225
170
 
226
171
  /** Input type for data type identifier */
@@ -237,41 +182,115 @@ export interface DataTypeIdentifierInput {
237
182
  export interface DataTypeRule {
238
183
  __typename?: 'DataTypeRule';
239
184
  /** The configuration of the rule */
240
- config: Config;
185
+ config?: Maybe<DataTypeRulesConfig>;
241
186
  /** Time when this DataTypeRule was created */
242
- createdAt: Scalars['Time']['output'];
187
+ createdAt?: Maybe<Scalars['Time']['output']>;
243
188
  /** Global ID of this DataTypeRule */
244
- id: Scalars['DataTypeRuleID']['output'];
189
+ id?: Maybe<Scalars['DataTypeRuleID']['output']>;
245
190
  /** Time when this DataTypeRule was last updated */
246
- updatedAt: Scalars['Time']['output'];
191
+ updatedAt?: Maybe<Scalars['Time']['output']>;
247
192
  /** The type of the rule */
248
- variant: DataTypeRulesDataTypeRuleVariant;
193
+ variant?: Maybe<DataTypeRulesVariant>;
249
194
  }
250
195
 
251
196
  /** The connection type for DataTypeRule. */
252
197
  export interface DataTypeRuleConnection {
253
198
  __typename?: 'DataTypeRuleConnection';
254
199
  /** Total count of collection. */
255
- count: Scalars['Int']['output'];
200
+ count?: Maybe<Scalars['Int']['output']>;
256
201
  /** A list of edges. */
257
202
  edges?: Maybe<Array<Maybe<DataTypeRuleEdge>>>;
258
203
  /** A list of nodes. */
259
204
  nodes?: Maybe<Array<Maybe<DataTypeRule>>>;
260
205
  /** Information to aid in pagination. */
261
- pageInfo: PageInfo;
206
+ pageInfo?: Maybe<PageInfo>;
262
207
  }
263
208
 
264
209
  /** An edge in a connection. */
265
210
  export interface DataTypeRuleEdge {
266
211
  __typename?: 'DataTypeRuleEdge';
267
212
  /** A cursor for use in pagination. */
268
- cursor: Scalars['String']['output'];
213
+ cursor?: Maybe<Scalars['String']['output']>;
269
214
  /** The item at the end of the edge. */
270
215
  node?: Maybe<DataTypeRule>;
271
216
  }
272
217
 
218
+ /** Represents a rule that can be applied to a data type. */
219
+ export type DataTypeRulesConfig = DataTypeRulesContainsKeyConfig | DataTypeRulesContainsTypeConfig | DataTypeRulesInputTypesConfig | DataTypeRulesItemOfCollectionConfig | DataTypeRulesNumberRangeConfig | DataTypeRulesParentTypeConfig | DataTypeRulesRegexConfig | DataTypeRulesReturnTypeConfig;
220
+
221
+ /** Represents a rule that can be applied to a data type. */
222
+ export interface DataTypeRulesContainsKeyConfig {
223
+ __typename?: 'DataTypeRulesContainsKeyConfig';
224
+ /** The identifier of the data type this rule belongs to */
225
+ dataTypeIdentifier?: Maybe<DataTypeIdentifier>;
226
+ /** The key of the rule */
227
+ key?: Maybe<Scalars['String']['output']>;
228
+ }
229
+
230
+ /** Represents a rule that can be applied to a data type. */
231
+ export interface DataTypeRulesContainsTypeConfig {
232
+ __typename?: 'DataTypeRulesContainsTypeConfig';
233
+ /** The identifier of the data type this rule belongs to */
234
+ dataTypeIdentifier?: Maybe<DataTypeIdentifier>;
235
+ }
236
+
237
+ /** Represents a subtype of input type configuration for a input data type. */
238
+ export interface DataTypeRulesInputTypeConfig {
239
+ __typename?: 'DataTypeRulesInputTypeConfig';
240
+ /** The identifier of the data type this input type belongs to */
241
+ dataTypeIdentifier?: Maybe<DataTypeIdentifier>;
242
+ /** The input data type that this configuration applies to */
243
+ inputType?: Maybe<DataType>;
244
+ }
245
+
246
+ /** Represents a rule that can be applied to a data type. */
247
+ export interface DataTypeRulesInputTypesConfig {
248
+ __typename?: 'DataTypeRulesInputTypesConfig';
249
+ /** The input types that can be used in this data type rule */
250
+ inputTypes?: Maybe<Array<DataTypeRulesInputTypeConfig>>;
251
+ }
252
+
253
+ /** Represents a rule that can be applied to a data type. */
254
+ export interface DataTypeRulesItemOfCollectionConfig {
255
+ __typename?: 'DataTypeRulesItemOfCollectionConfig';
256
+ /** The items that can be configured for this rule. */
257
+ items?: Maybe<Array<Scalars['JSON']['output']>>;
258
+ }
259
+
260
+ /** Represents a rule that can be applied to a data type. */
261
+ export interface DataTypeRulesNumberRangeConfig {
262
+ __typename?: 'DataTypeRulesNumberRangeConfig';
263
+ /** The minimum value of the range */
264
+ from?: Maybe<Scalars['Int']['output']>;
265
+ /** The step value for the range, if applicable */
266
+ steps?: Maybe<Scalars['Int']['output']>;
267
+ /** The maximum value of the range */
268
+ to?: Maybe<Scalars['Int']['output']>;
269
+ }
270
+
271
+ /** Represents a rule that can be applied to a data type. */
272
+ export interface DataTypeRulesParentTypeConfig {
273
+ __typename?: 'DataTypeRulesParentTypeConfig';
274
+ /** The data type identifier for the parent type. */
275
+ dataTypeIdentifier?: Maybe<DataTypeIdentifier>;
276
+ }
277
+
278
+ /** Represents a rule that can be applied to a data type. */
279
+ export interface DataTypeRulesRegexConfig {
280
+ __typename?: 'DataTypeRulesRegexConfig';
281
+ /** The regex pattern to match against the data type value. */
282
+ pattern?: Maybe<Scalars['String']['output']>;
283
+ }
284
+
285
+ /** Represents a rule that can be applied to a data type. */
286
+ export interface DataTypeRulesReturnTypeConfig {
287
+ __typename?: 'DataTypeRulesReturnTypeConfig';
288
+ /** The data type identifier for the return type. */
289
+ dataTypeIdentifier?: Maybe<DataTypeIdentifier>;
290
+ }
291
+
273
292
  /** The type of rule that can be applied to a data type. */
274
- export enum DataTypeRulesDataTypeRuleVariant {
293
+ export enum DataTypeRulesVariant {
275
294
  /** The rule checks if a key is present in the data type. */
276
295
  ContainsKey = 'CONTAINS_KEY',
277
296
  /** The rule checks if a specific type is present in the data type. */
@@ -282,6 +301,8 @@ export enum DataTypeRulesDataTypeRuleVariant {
282
301
  ItemOfCollection = 'ITEM_OF_COLLECTION',
283
302
  /** The rule checks if a number falls within a specified range. */
284
303
  NumberRange = 'NUMBER_RANGE',
304
+ /** The rule checks if the data type is a child of a specific parent type. */
305
+ ParentType = 'PARENT_TYPE',
285
306
  /** The rule checks if a string matches a specified regular expression. */
286
307
  Regex = 'REGEX',
287
308
  /** The rule checks if the data type matches a specific return type. */
@@ -320,7 +341,7 @@ export interface EchoPayload {
320
341
  /** A unique identifier for the client performing the mutation. */
321
342
  clientMutationId?: Maybe<Scalars['String']['output']>;
322
343
  /** Errors encountered during execution of the mutation. */
323
- errors: Array<Error>;
344
+ errors?: Maybe<Array<Error>>;
324
345
  /** Message returned to the user. */
325
346
  message?: Maybe<Scalars['String']['output']>;
326
347
  }
@@ -332,41 +353,61 @@ export type Error = ActiveModelError | MessageError;
332
353
  export interface Flow {
333
354
  __typename?: 'Flow';
334
355
  /** Time when this Flow was created */
335
- createdAt: Scalars['Time']['output'];
356
+ createdAt?: Maybe<Scalars['Time']['output']>;
336
357
  /** Global ID of this Flow */
337
- id: Scalars['FlowID']['output'];
358
+ id?: Maybe<Scalars['FlowID']['output']>;
338
359
  /** The input data type of the flow */
339
360
  inputType?: Maybe<DataType>;
361
+ /** Nodes of the flow */
362
+ nodes?: Maybe<NodeFunctionConnection>;
340
363
  /** The return data type of the flow */
341
364
  returnType?: Maybe<DataType>;
342
365
  /** The settings of the flow */
343
- settings?: Maybe<Array<FlowSetting>>;
344
- /** The starting node of the flow */
345
- startingNode: NodeFunction;
366
+ settings?: Maybe<FlowSettingConnection>;
367
+ /** The ID of the starting node of the flow */
368
+ startingNodeId?: Maybe<Scalars['NodeFunctionID']['output']>;
346
369
  /** The flow type of the flow */
347
- type: FlowType;
370
+ type?: Maybe<FlowType>;
348
371
  /** Time when this Flow was last updated */
349
- updatedAt: Scalars['Time']['output'];
372
+ updatedAt?: Maybe<Scalars['Time']['output']>;
373
+ }
374
+
375
+
376
+ /** Represents a flow */
377
+ export interface FlowNodesArgs {
378
+ after?: InputMaybe<Scalars['String']['input']>;
379
+ before?: InputMaybe<Scalars['String']['input']>;
380
+ first?: InputMaybe<Scalars['Int']['input']>;
381
+ last?: InputMaybe<Scalars['Int']['input']>;
382
+ }
383
+
384
+
385
+ /** Represents a flow */
386
+ export interface FlowSettingsArgs {
387
+ after?: InputMaybe<Scalars['String']['input']>;
388
+ before?: InputMaybe<Scalars['String']['input']>;
389
+ first?: InputMaybe<Scalars['Int']['input']>;
390
+ last?: InputMaybe<Scalars['Int']['input']>;
350
391
  }
351
392
 
352
393
  /** The connection type for Flow. */
353
394
  export interface FlowConnection {
354
395
  __typename?: 'FlowConnection';
355
396
  /** Total count of collection. */
356
- count: Scalars['Int']['output'];
397
+ count?: Maybe<Scalars['Int']['output']>;
357
398
  /** A list of edges. */
358
399
  edges?: Maybe<Array<Maybe<FlowEdge>>>;
359
400
  /** A list of nodes. */
360
401
  nodes?: Maybe<Array<Maybe<Flow>>>;
361
402
  /** Information to aid in pagination. */
362
- pageInfo: PageInfo;
403
+ pageInfo?: Maybe<PageInfo>;
363
404
  }
364
405
 
365
406
  /** An edge in a connection. */
366
407
  export interface FlowEdge {
367
408
  __typename?: 'FlowEdge';
368
409
  /** A cursor for use in pagination. */
369
- cursor: Scalars['String']['output'];
410
+ cursor?: Maybe<Scalars['String']['output']>;
370
411
  /** The item at the end of the edge. */
371
412
  node?: Maybe<Flow>;
372
413
  }
@@ -385,15 +426,37 @@ export interface FlowInput {
385
426
  export interface FlowSetting {
386
427
  __typename?: 'FlowSetting';
387
428
  /** Time when this FlowSetting was created */
388
- createdAt: Scalars['Time']['output'];
429
+ createdAt?: Maybe<Scalars['Time']['output']>;
389
430
  /** The identifier of the flow setting */
390
- flowSettingId: Scalars['String']['output'];
431
+ flowSettingIdentifier?: Maybe<Scalars['String']['output']>;
391
432
  /** Global ID of this FlowSetting */
392
- id: Scalars['FlowSettingID']['output'];
433
+ id?: Maybe<Scalars['FlowSettingID']['output']>;
393
434
  /** Time when this FlowSetting was last updated */
394
- updatedAt: Scalars['Time']['output'];
435
+ updatedAt?: Maybe<Scalars['Time']['output']>;
395
436
  /** The value of the flow setting */
396
- value: Scalars['JSON']['output'];
437
+ value?: Maybe<Scalars['JSON']['output']>;
438
+ }
439
+
440
+ /** The connection type for FlowSetting. */
441
+ export interface FlowSettingConnection {
442
+ __typename?: 'FlowSettingConnection';
443
+ /** Total count of collection. */
444
+ count?: Maybe<Scalars['Int']['output']>;
445
+ /** A list of edges. */
446
+ edges?: Maybe<Array<Maybe<FlowSettingEdge>>>;
447
+ /** A list of nodes. */
448
+ nodes?: Maybe<Array<Maybe<FlowSetting>>>;
449
+ /** Information to aid in pagination. */
450
+ pageInfo?: Maybe<PageInfo>;
451
+ }
452
+
453
+ /** An edge in a connection. */
454
+ export interface FlowSettingEdge {
455
+ __typename?: 'FlowSettingEdge';
456
+ /** A cursor for use in pagination. */
457
+ cursor?: Maybe<Scalars['String']['output']>;
458
+ /** The item at the end of the edge. */
459
+ node?: Maybe<FlowSetting>;
397
460
  }
398
461
 
399
462
  /** Input type for flow settings */
@@ -408,17 +471,17 @@ export interface FlowSettingInput {
408
471
  export interface FlowType {
409
472
  __typename?: 'FlowType';
410
473
  /** Time when this FlowType was created */
411
- createdAt: Scalars['Time']['output'];
474
+ createdAt?: Maybe<Scalars['Time']['output']>;
412
475
  /** Descriptions of the flow type */
413
476
  descriptions?: Maybe<TranslationConnection>;
414
477
  /** Editable status of the flow type */
415
- editable: Scalars['Boolean']['output'];
478
+ editable?: Maybe<Scalars['Boolean']['output']>;
416
479
  /** Flow type settings of the flow type */
417
- flowTypeSettings: Array<FlowTypeSetting>;
480
+ flowTypeSettings?: Maybe<Array<FlowTypeSetting>>;
418
481
  /** Global ID of this FlowType */
419
- id: Scalars['TypesFlowTypeID']['output'];
482
+ id?: Maybe<Scalars['TypesFlowTypeID']['output']>;
420
483
  /** Identifier of the flow type */
421
- identifier: Scalars['String']['output'];
484
+ identifier?: Maybe<Scalars['String']['output']>;
422
485
  /** Input type of the flow type */
423
486
  inputType?: Maybe<DataType>;
424
487
  /** Names of the flow type */
@@ -426,7 +489,7 @@ export interface FlowType {
426
489
  /** Return type of the flow type */
427
490
  returnType?: Maybe<DataType>;
428
491
  /** Time when this FlowType was last updated */
429
- updatedAt: Scalars['Time']['output'];
492
+ updatedAt?: Maybe<Scalars['Time']['output']>;
430
493
  }
431
494
 
432
495
 
@@ -451,20 +514,20 @@ export interface FlowTypeNamesArgs {
451
514
  export interface FlowTypeConnection {
452
515
  __typename?: 'FlowTypeConnection';
453
516
  /** Total count of collection. */
454
- count: Scalars['Int']['output'];
517
+ count?: Maybe<Scalars['Int']['output']>;
455
518
  /** A list of edges. */
456
519
  edges?: Maybe<Array<Maybe<FlowTypeEdge>>>;
457
520
  /** A list of nodes. */
458
521
  nodes?: Maybe<Array<Maybe<FlowType>>>;
459
522
  /** Information to aid in pagination. */
460
- pageInfo: PageInfo;
523
+ pageInfo?: Maybe<PageInfo>;
461
524
  }
462
525
 
463
526
  /** An edge in a connection. */
464
527
  export interface FlowTypeEdge {
465
528
  __typename?: 'FlowTypeEdge';
466
529
  /** A cursor for use in pagination. */
467
- cursor: Scalars['String']['output'];
530
+ cursor?: Maybe<Scalars['String']['output']>;
468
531
  /** The item at the end of the edge. */
469
532
  node?: Maybe<FlowType>;
470
533
  }
@@ -473,23 +536,23 @@ export interface FlowTypeEdge {
473
536
  export interface FlowTypeSetting {
474
537
  __typename?: 'FlowTypeSetting';
475
538
  /** Time when this FlowTypeSetting was created */
476
- createdAt: Scalars['Time']['output'];
539
+ createdAt?: Maybe<Scalars['Time']['output']>;
477
540
  /** Data type of the flow type setting */
478
541
  dataType?: Maybe<DataType>;
479
542
  /** Descriptions of the flow type setting */
480
- descriptions: TranslationConnection;
543
+ descriptions?: Maybe<TranslationConnection>;
481
544
  /** Flow type of the flow type setting */
482
545
  flowType?: Maybe<FlowType>;
483
546
  /** Global ID of this FlowTypeSetting */
484
- id: Scalars['FlowTypeSettingID']['output'];
547
+ id?: Maybe<Scalars['FlowTypeSettingID']['output']>;
485
548
  /** Identifier of the flow type setting */
486
- identifier: Scalars['String']['output'];
549
+ identifier?: Maybe<Scalars['String']['output']>;
487
550
  /** Names of the flow type setting */
488
- names: TranslationConnection;
551
+ names?: Maybe<TranslationConnection>;
489
552
  /** Unique status of the flow type setting */
490
- unique: Scalars['Boolean']['output'];
553
+ unique?: Maybe<Scalars['Boolean']['output']>;
491
554
  /** Time when this FlowTypeSetting was last updated */
492
- updatedAt: Scalars['Time']['output'];
555
+ updatedAt?: Maybe<Scalars['Time']['output']>;
493
556
  }
494
557
 
495
558
 
@@ -514,21 +577,40 @@ export interface FlowTypeSettingNamesArgs {
514
577
  export interface FunctionDefinition {
515
578
  __typename?: 'FunctionDefinition';
516
579
  /** Time when this FunctionDefinition was created */
517
- createdAt: Scalars['Time']['output'];
580
+ createdAt?: Maybe<Scalars['Time']['output']>;
581
+ /** Deprecation message of the function */
582
+ deprecationMessages?: Maybe<TranslationConnection>;
518
583
  /** Description of the function */
519
584
  descriptions?: Maybe<TranslationConnection>;
520
585
  /** Documentation of the function */
521
586
  documentations?: Maybe<TranslationConnection>;
587
+ /** Generic keys of the function */
588
+ genericKeys?: Maybe<Array<Scalars['String']['output']>>;
522
589
  /** Global ID of this FunctionDefinition */
523
- id: Scalars['FunctionDefinitionID']['output'];
590
+ id?: Maybe<Scalars['FunctionDefinitionID']['output']>;
591
+ /** Identifier of the function */
592
+ identifier?: Maybe<Scalars['String']['output']>;
524
593
  /** Name of the function */
525
594
  names?: Maybe<TranslationConnection>;
526
595
  /** Parameters of the function */
527
596
  parameterDefinitions?: Maybe<ParameterDefinitionConnection>;
528
597
  /** Return type of the function */
529
598
  returnType?: Maybe<DataTypeIdentifier>;
599
+ /** Runtime function definition */
600
+ runtimeFunctionDefinition?: Maybe<RuntimeFunctionDefinition>;
601
+ /** Indicates if the function can throw an error */
602
+ throwsError?: Maybe<Scalars['Boolean']['output']>;
530
603
  /** Time when this FunctionDefinition was last updated */
531
- updatedAt: Scalars['Time']['output'];
604
+ updatedAt?: Maybe<Scalars['Time']['output']>;
605
+ }
606
+
607
+
608
+ /** Represents a function definition */
609
+ export interface FunctionDefinitionDeprecationMessagesArgs {
610
+ after?: InputMaybe<Scalars['String']['input']>;
611
+ before?: InputMaybe<Scalars['String']['input']>;
612
+ first?: InputMaybe<Scalars['Int']['input']>;
613
+ last?: InputMaybe<Scalars['Int']['input']>;
532
614
  }
533
615
 
534
616
 
@@ -571,37 +653,62 @@ export interface FunctionDefinitionParameterDefinitionsArgs {
571
653
  export interface FunctionDefinitionConnection {
572
654
  __typename?: 'FunctionDefinitionConnection';
573
655
  /** Total count of collection. */
574
- count: Scalars['Int']['output'];
656
+ count?: Maybe<Scalars['Int']['output']>;
575
657
  /** A list of edges. */
576
658
  edges?: Maybe<Array<Maybe<FunctionDefinitionEdge>>>;
577
659
  /** A list of nodes. */
578
660
  nodes?: Maybe<Array<Maybe<FunctionDefinition>>>;
579
661
  /** Information to aid in pagination. */
580
- pageInfo: PageInfo;
662
+ pageInfo?: Maybe<PageInfo>;
581
663
  }
582
664
 
583
665
  /** An edge in a connection. */
584
666
  export interface FunctionDefinitionEdge {
585
667
  __typename?: 'FunctionDefinitionEdge';
586
668
  /** A cursor for use in pagination. */
587
- cursor: Scalars['String']['output'];
669
+ cursor?: Maybe<Scalars['String']['output']>;
588
670
  /** The item at the end of the edge. */
589
671
  node?: Maybe<FunctionDefinition>;
590
672
  }
591
673
 
674
+ /** Represents a combination strategy with AND/OR logic used by a generic mapper. */
675
+ export interface GenericCombinationStrategy {
676
+ __typename?: 'GenericCombinationStrategy';
677
+ /** Time when this GenericCombinationStrategy was created */
678
+ createdAt?: Maybe<Scalars['Time']['output']>;
679
+ /** The associated generic mapper, if any. */
680
+ genericMapper?: Maybe<GenericMapper>;
681
+ /** Global ID of this GenericCombinationStrategy */
682
+ id?: Maybe<Scalars['GenericCombinationStrategyID']['output']>;
683
+ /** The combination type ('AND' or 'OR'). */
684
+ type?: Maybe<GenericCombinationStrategyType>;
685
+ /** Time when this GenericCombinationStrategy was last updated */
686
+ updatedAt?: Maybe<Scalars['Time']['output']>;
687
+ }
688
+
689
+ /** The available combination strategy types. */
690
+ export enum GenericCombinationStrategyType {
691
+ /** Represents a logical AND combination. */
692
+ And = 'AND',
693
+ /** Represents a logical OR combination. */
694
+ Or = 'OR'
695
+ }
696
+
592
697
  /** Represents a mapping between a source data type and a target key for generic values. */
593
698
  export interface GenericMapper {
594
699
  __typename?: 'GenericMapper';
595
700
  /** Time when this GenericMapper was created */
596
- createdAt: Scalars['Time']['output'];
701
+ createdAt?: Maybe<Scalars['Time']['output']>;
702
+ /** Combination strategies associated with this generic mapper. */
703
+ genericCombinationStrategies?: Maybe<Array<GenericCombinationStrategy>>;
597
704
  /** Global ID of this GenericMapper */
598
- id: Scalars['GenericMapperID']['output'];
705
+ id?: Maybe<Scalars['GenericMapperID']['output']>;
599
706
  /** The source data type identifier. */
600
- source: DataTypeIdentifier;
707
+ sourceDataTypeIdentifiers?: Maybe<Array<DataTypeIdentifier>>;
601
708
  /** The target key for the generic value. */
602
- target: Scalars['String']['output'];
709
+ target?: Maybe<Scalars['String']['output']>;
603
710
  /** Time when this GenericMapper was last updated */
604
- updatedAt: Scalars['Time']['output'];
711
+ updatedAt?: Maybe<Scalars['Time']['output']>;
605
712
  }
606
713
 
607
714
  /** Input type for generic mappers */
@@ -616,15 +723,15 @@ export interface GenericMapperInput {
616
723
  export interface GenericType {
617
724
  __typename?: 'GenericType';
618
725
  /** Time when this GenericType was created */
619
- createdAt: Scalars['Time']['output'];
726
+ createdAt?: Maybe<Scalars['Time']['output']>;
620
727
  /** The data type associated with this generic type. */
621
- dataType: DataType;
728
+ dataType?: Maybe<DataType>;
622
729
  /** The mappers associated with this generic type. */
623
- genericMappers: Array<GenericMapper>;
730
+ genericMappers?: Maybe<Array<GenericMapper>>;
624
731
  /** Global ID of this GenericType */
625
- id: Scalars['GenericTypeID']['output'];
732
+ id?: Maybe<Scalars['GenericTypeID']['output']>;
626
733
  /** Time when this GenericType was last updated */
627
- updatedAt: Scalars['Time']['output'];
734
+ updatedAt?: Maybe<Scalars['Time']['output']>;
628
735
  }
629
736
 
630
737
  /** Input type for generic type operations. */
@@ -641,45 +748,22 @@ export interface IdentityInput {
641
748
  code?: InputMaybe<Scalars['String']['input']>;
642
749
  }
643
750
 
644
- /** Represents a subtype of input type configuration for a input data type. */
645
- export interface InputTypeConfig {
646
- __typename?: 'InputTypeConfig';
647
- /** The identifier of the data type this input type belongs to */
648
- dataTypeIdentifier: DataTypeIdentifier;
649
- /** The input data type that this configuration applies to */
650
- inputType: DataType;
651
- }
652
-
653
- /** Represents a rule that can be applied to a data type. */
654
- export interface InputTypesConfig {
655
- __typename?: 'InputTypesConfig';
656
- /** The input types that can be used in this data type rule */
657
- inputTypes: Array<InputTypeConfig>;
658
- }
659
-
660
- /** Represents a rule that can be applied to a data type. */
661
- export interface ItemOfCollectionConfig {
662
- __typename?: 'ItemOfCollectionConfig';
663
- /** The items that can be configured for this rule. */
664
- items?: Maybe<Array<Scalars['JSON']['output']>>;
665
- }
666
-
667
751
  /** Represents a literal value, such as a string or number. */
668
752
  export interface LiteralValue {
669
753
  __typename?: 'LiteralValue';
670
754
  /** Time when this LiteralValue was created */
671
- createdAt: Scalars['Time']['output'];
755
+ createdAt?: Maybe<Scalars['Time']['output']>;
672
756
  /** Time when this LiteralValue was last updated */
673
- updatedAt: Scalars['Time']['output'];
757
+ updatedAt?: Maybe<Scalars['Time']['output']>;
674
758
  /** The literal value itself as JSON. */
675
- value: Scalars['JSON']['output'];
759
+ value?: Maybe<Scalars['JSON']['output']>;
676
760
  }
677
761
 
678
762
  /** Represents an error message */
679
763
  export interface MessageError {
680
764
  __typename?: 'MessageError';
681
765
  /** The message provided from the error */
682
- message: Scalars['String']['output'];
766
+ message?: Maybe<Scalars['String']['output']>;
683
767
  }
684
768
 
685
769
  /** Represents the input for mfa authentication */
@@ -708,11 +792,12 @@ export interface Mutation {
708
792
  *
709
793
  * This is expected to be used for testing of endpoints, to verify
710
794
  * that a user has mutation access.
795
+ *
711
796
  */
712
797
  echo?: Maybe<EchoPayload>;
713
- /** Create a new namespace license. */
798
+ /** (EE only) Create a new namespace license. */
714
799
  namespacesLicensesCreate?: Maybe<NamespacesLicensesCreatePayload>;
715
- /** Deletes an namespace license. */
800
+ /** (EE only) Deletes an namespace license. */
716
801
  namespacesLicensesDelete?: Maybe<NamespacesLicensesDeletePayload>;
717
802
  /** Update the roles a member is assigned to. */
718
803
  namespacesMembersAssignRoles?: Maybe<NamespacesMembersAssignRolesPayload>;
@@ -756,6 +841,8 @@ export interface Mutation {
756
841
  runtimesRotateToken?: Maybe<RuntimesRotateTokenPayload>;
757
842
  /** Update an existing runtime. */
758
843
  runtimesUpdate?: Maybe<RuntimesUpdatePayload>;
844
+ /** Verify your email when changing it or signing up */
845
+ usersEmailVerification?: Maybe<UsersEmailVerificationPayload>;
759
846
  /** Links an external identity to an existing user */
760
847
  usersIdentityLink?: Maybe<UsersIdentityLinkPayload>;
761
848
  /** Login to an existing user via an external identity */
@@ -931,6 +1018,12 @@ export interface MutationRuntimesUpdateArgs {
931
1018
  }
932
1019
 
933
1020
 
1021
+ /** Root Mutation type */
1022
+ export interface MutationUsersEmailVerificationArgs {
1023
+ input: UsersEmailVerificationInput;
1024
+ }
1025
+
1026
+
934
1027
  /** Root Mutation type */
935
1028
  export interface MutationUsersIdentityLinkArgs {
936
1029
  input: UsersIdentityLinkInput;
@@ -1000,23 +1093,23 @@ export interface MutationUsersUpdateArgs {
1000
1093
  export interface Namespace {
1001
1094
  __typename?: 'Namespace';
1002
1095
  /** Time when this Namespace was created */
1003
- createdAt: Scalars['Time']['output'];
1096
+ createdAt?: Maybe<Scalars['Time']['output']>;
1004
1097
  /** Global ID of this Namespace */
1005
- id: Scalars['NamespaceID']['output'];
1098
+ id?: Maybe<Scalars['NamespaceID']['output']>;
1006
1099
  /** Members of the namespace */
1007
- members: NamespaceMemberConnection;
1008
- /** Licenses of the namespace */
1009
- namespaceLicenses: NamespaceLicenseConnection;
1100
+ members?: Maybe<NamespaceMemberConnection>;
1101
+ /** (EE only) Licenses of the namespace */
1102
+ namespaceLicenses?: Maybe<NamespaceLicenseConnection>;
1010
1103
  /** Parent of this namespace */
1011
- parent: NamespaceParent;
1104
+ parent?: Maybe<NamespaceParent>;
1012
1105
  /** Projects of the namespace */
1013
- projects: NamespaceProjectConnection;
1106
+ projects?: Maybe<NamespaceProjectConnection>;
1014
1107
  /** Roles of the namespace */
1015
- roles: NamespaceRoleConnection;
1108
+ roles?: Maybe<NamespaceRoleConnection>;
1016
1109
  /** Runtime of the namespace */
1017
- runtimes: RuntimeConnection;
1110
+ runtimes?: Maybe<RuntimeConnection>;
1018
1111
  /** Time when this Namespace was last updated */
1019
- updatedAt: Scalars['Time']['output'];
1112
+ updatedAt?: Maybe<Scalars['Time']['output']>;
1020
1113
  }
1021
1114
 
1022
1115
 
@@ -1064,37 +1157,43 @@ export interface NamespaceRuntimesArgs {
1064
1157
  last?: InputMaybe<Scalars['Int']['input']>;
1065
1158
  }
1066
1159
 
1067
- /** Represents a Namespace License */
1160
+ /** (EE only) Represents a Namespace License */
1068
1161
  export interface NamespaceLicense {
1069
1162
  __typename?: 'NamespaceLicense';
1070
1163
  /** Time when this NamespaceLicense was created */
1071
- createdAt: Scalars['Time']['output'];
1164
+ createdAt?: Maybe<Scalars['Time']['output']>;
1165
+ /** The end date of the license */
1166
+ endDate?: Maybe<Scalars['Time']['output']>;
1072
1167
  /** Global ID of this NamespaceLicense */
1073
- id: Scalars['NamespaceLicenseID']['output'];
1168
+ id?: Maybe<Scalars['NamespaceLicenseID']['output']>;
1169
+ /** The licensee information */
1170
+ licensee?: Maybe<Scalars['JSON']['output']>;
1074
1171
  /** The namespace the license belongs to */
1075
- namespace: Namespace;
1172
+ namespace?: Maybe<Namespace>;
1173
+ /** The start date of the license */
1174
+ startDate?: Maybe<Scalars['Time']['output']>;
1076
1175
  /** Time when this NamespaceLicense was last updated */
1077
- updatedAt: Scalars['Time']['output'];
1176
+ updatedAt?: Maybe<Scalars['Time']['output']>;
1078
1177
  }
1079
1178
 
1080
1179
  /** The connection type for NamespaceLicense. */
1081
1180
  export interface NamespaceLicenseConnection {
1082
1181
  __typename?: 'NamespaceLicenseConnection';
1083
1182
  /** Total count of collection. */
1084
- count: Scalars['Int']['output'];
1183
+ count?: Maybe<Scalars['Int']['output']>;
1085
1184
  /** A list of edges. */
1086
1185
  edges?: Maybe<Array<Maybe<NamespaceLicenseEdge>>>;
1087
1186
  /** A list of nodes. */
1088
1187
  nodes?: Maybe<Array<Maybe<NamespaceLicense>>>;
1089
1188
  /** Information to aid in pagination. */
1090
- pageInfo: PageInfo;
1189
+ pageInfo?: Maybe<PageInfo>;
1091
1190
  }
1092
1191
 
1093
1192
  /** An edge in a connection. */
1094
1193
  export interface NamespaceLicenseEdge {
1095
1194
  __typename?: 'NamespaceLicenseEdge';
1096
1195
  /** A cursor for use in pagination. */
1097
- cursor: Scalars['String']['output'];
1196
+ cursor?: Maybe<Scalars['String']['output']>;
1098
1197
  /** The item at the end of the edge. */
1099
1198
  node?: Maybe<NamespaceLicense>;
1100
1199
  }
@@ -1103,35 +1202,35 @@ export interface NamespaceLicenseEdge {
1103
1202
  export interface NamespaceMember {
1104
1203
  __typename?: 'NamespaceMember';
1105
1204
  /** Time when this NamespaceMember was created */
1106
- createdAt: Scalars['Time']['output'];
1205
+ createdAt?: Maybe<Scalars['Time']['output']>;
1107
1206
  /** Global ID of this NamespaceMember */
1108
- id: Scalars['NamespaceMemberID']['output'];
1207
+ id?: Maybe<Scalars['NamespaceMemberID']['output']>;
1109
1208
  /** Namespace this member belongs to */
1110
- namespace: Namespace;
1209
+ namespace?: Maybe<Namespace>;
1111
1210
  /** Time when this NamespaceMember was last updated */
1112
- updatedAt: Scalars['Time']['output'];
1211
+ updatedAt?: Maybe<Scalars['Time']['output']>;
1113
1212
  /** User this member belongs to */
1114
- user: User;
1213
+ user?: Maybe<User>;
1115
1214
  }
1116
1215
 
1117
1216
  /** The connection type for NamespaceMember. */
1118
1217
  export interface NamespaceMemberConnection {
1119
1218
  __typename?: 'NamespaceMemberConnection';
1120
1219
  /** Total count of collection. */
1121
- count: Scalars['Int']['output'];
1220
+ count?: Maybe<Scalars['Int']['output']>;
1122
1221
  /** A list of edges. */
1123
1222
  edges?: Maybe<Array<Maybe<NamespaceMemberEdge>>>;
1124
1223
  /** A list of nodes. */
1125
1224
  nodes?: Maybe<Array<Maybe<NamespaceMember>>>;
1126
1225
  /** Information to aid in pagination. */
1127
- pageInfo: PageInfo;
1226
+ pageInfo?: Maybe<PageInfo>;
1128
1227
  }
1129
1228
 
1130
1229
  /** An edge in a connection. */
1131
1230
  export interface NamespaceMemberEdge {
1132
1231
  __typename?: 'NamespaceMemberEdge';
1133
1232
  /** A cursor for use in pagination. */
1134
- cursor: Scalars['String']['output'];
1233
+ cursor?: Maybe<Scalars['String']['output']>;
1135
1234
  /** The item at the end of the edge. */
1136
1235
  node?: Maybe<NamespaceMember>;
1137
1236
  }
@@ -1140,43 +1239,43 @@ export interface NamespaceMemberEdge {
1140
1239
  export interface NamespaceMemberRole {
1141
1240
  __typename?: 'NamespaceMemberRole';
1142
1241
  /** Time when this NamespaceMemberRole was created */
1143
- createdAt: Scalars['Time']['output'];
1242
+ createdAt?: Maybe<Scalars['Time']['output']>;
1144
1243
  /** Global ID of this NamespaceMemberRole */
1145
- id: Scalars['NamespaceMemberRoleID']['output'];
1244
+ id?: Maybe<Scalars['NamespaceMemberRoleID']['output']>;
1146
1245
  /** The member the role is assigned to */
1147
1246
  member?: Maybe<NamespaceMember>;
1148
1247
  /** The assigned role */
1149
1248
  role?: Maybe<NamespaceRole>;
1150
1249
  /** Time when this NamespaceMemberRole was last updated */
1151
- updatedAt: Scalars['Time']['output'];
1250
+ updatedAt?: Maybe<Scalars['Time']['output']>;
1152
1251
  }
1153
1252
 
1154
1253
  /** Objects that can present a namespace */
1155
- export type NamespaceParent = Organization;
1254
+ export type NamespaceParent = Organization | User;
1156
1255
 
1157
1256
  /** Represents a namespace project */
1158
1257
  export interface NamespaceProject {
1159
1258
  __typename?: 'NamespaceProject';
1160
1259
  /** Time when this NamespaceProject was created */
1161
- createdAt: Scalars['Time']['output'];
1260
+ createdAt?: Maybe<Scalars['Time']['output']>;
1162
1261
  /** Description of the project */
1163
- description: Scalars['String']['output'];
1262
+ description?: Maybe<Scalars['String']['output']>;
1164
1263
  /** Fetches an flow given by its ID */
1165
1264
  flow?: Maybe<Flow>;
1166
1265
  /** Fetches all flows in this project */
1167
1266
  flows?: Maybe<FlowConnection>;
1168
1267
  /** Global ID of this NamespaceProject */
1169
- id: Scalars['NamespaceProjectID']['output'];
1268
+ id?: Maybe<Scalars['NamespaceProjectID']['output']>;
1170
1269
  /** Name of the project */
1171
- name: Scalars['String']['output'];
1270
+ name?: Maybe<Scalars['String']['output']>;
1172
1271
  /** The namespace where this project belongs to */
1173
- namespace: Namespace;
1272
+ namespace?: Maybe<Namespace>;
1174
1273
  /** The primary runtime for the project */
1175
1274
  primaryRuntime?: Maybe<Runtime>;
1176
1275
  /** Runtimes assigned to this project */
1177
- runtimes: RuntimeConnection;
1276
+ runtimes?: Maybe<RuntimeConnection>;
1178
1277
  /** Time when this NamespaceProject was last updated */
1179
- updatedAt: Scalars['Time']['output'];
1278
+ updatedAt?: Maybe<Scalars['Time']['output']>;
1180
1279
  }
1181
1280
 
1182
1281
 
@@ -1207,20 +1306,20 @@ export interface NamespaceProjectRuntimesArgs {
1207
1306
  export interface NamespaceProjectConnection {
1208
1307
  __typename?: 'NamespaceProjectConnection';
1209
1308
  /** Total count of collection. */
1210
- count: Scalars['Int']['output'];
1309
+ count?: Maybe<Scalars['Int']['output']>;
1211
1310
  /** A list of edges. */
1212
1311
  edges?: Maybe<Array<Maybe<NamespaceProjectEdge>>>;
1213
1312
  /** A list of nodes. */
1214
1313
  nodes?: Maybe<Array<Maybe<NamespaceProject>>>;
1215
1314
  /** Information to aid in pagination. */
1216
- pageInfo: PageInfo;
1315
+ pageInfo?: Maybe<PageInfo>;
1217
1316
  }
1218
1317
 
1219
1318
  /** An edge in a connection. */
1220
1319
  export interface NamespaceProjectEdge {
1221
1320
  __typename?: 'NamespaceProjectEdge';
1222
1321
  /** A cursor for use in pagination. */
1223
- cursor: Scalars['String']['output'];
1322
+ cursor?: Maybe<Scalars['String']['output']>;
1224
1323
  /** The item at the end of the edge. */
1225
1324
  node?: Maybe<NamespaceProject>;
1226
1325
  }
@@ -1229,19 +1328,19 @@ export interface NamespaceProjectEdge {
1229
1328
  export interface NamespaceRole {
1230
1329
  __typename?: 'NamespaceRole';
1231
1330
  /** The abilities the role is granted */
1232
- abilities: Array<NamespaceRoleAbility>;
1331
+ abilities?: Maybe<Array<NamespaceRoleAbility>>;
1233
1332
  /** The projects this role is assigned to */
1234
1333
  assignedProjects?: Maybe<NamespaceProjectConnection>;
1235
1334
  /** Time when this NamespaceRole was created */
1236
- createdAt: Scalars['Time']['output'];
1335
+ createdAt?: Maybe<Scalars['Time']['output']>;
1237
1336
  /** Global ID of this NamespaceRole */
1238
- id: Scalars['NamespaceRoleID']['output'];
1337
+ id?: Maybe<Scalars['NamespaceRoleID']['output']>;
1239
1338
  /** The name of this role */
1240
- name: Scalars['String']['output'];
1339
+ name?: Maybe<Scalars['String']['output']>;
1241
1340
  /** The namespace where this role belongs to */
1242
1341
  namespace?: Maybe<Namespace>;
1243
1342
  /** Time when this NamespaceRole was last updated */
1244
- updatedAt: Scalars['Time']['output'];
1343
+ updatedAt?: Maybe<Scalars['Time']['output']>;
1245
1344
  }
1246
1345
 
1247
1346
 
@@ -1313,20 +1412,20 @@ export enum NamespaceRoleAbility {
1313
1412
  export interface NamespaceRoleConnection {
1314
1413
  __typename?: 'NamespaceRoleConnection';
1315
1414
  /** Total count of collection. */
1316
- count: Scalars['Int']['output'];
1415
+ count?: Maybe<Scalars['Int']['output']>;
1317
1416
  /** A list of edges. */
1318
1417
  edges?: Maybe<Array<Maybe<NamespaceRoleEdge>>>;
1319
1418
  /** A list of nodes. */
1320
1419
  nodes?: Maybe<Array<Maybe<NamespaceRole>>>;
1321
1420
  /** Information to aid in pagination. */
1322
- pageInfo: PageInfo;
1421
+ pageInfo?: Maybe<PageInfo>;
1323
1422
  }
1324
1423
 
1325
1424
  /** An edge in a connection. */
1326
1425
  export interface NamespaceRoleEdge {
1327
1426
  __typename?: 'NamespaceRoleEdge';
1328
1427
  /** A cursor for use in pagination. */
1329
- cursor: Scalars['String']['output'];
1428
+ cursor?: Maybe<Scalars['String']['output']>;
1330
1429
  /** The item at the end of the edge. */
1331
1430
  node?: Maybe<NamespaceRole>;
1332
1431
  }
@@ -1347,7 +1446,7 @@ export interface NamespacesLicensesCreatePayload {
1347
1446
  /** A unique identifier for the client performing the mutation. */
1348
1447
  clientMutationId?: Maybe<Scalars['String']['output']>;
1349
1448
  /** Errors encountered during execution of the mutation. */
1350
- errors: Array<Error>;
1449
+ errors?: Maybe<Array<Error>>;
1351
1450
  /** The newly created license. */
1352
1451
  namespaceLicense?: Maybe<NamespaceLicense>;
1353
1452
  }
@@ -1366,7 +1465,7 @@ export interface NamespacesLicensesDeletePayload {
1366
1465
  /** A unique identifier for the client performing the mutation. */
1367
1466
  clientMutationId?: Maybe<Scalars['String']['output']>;
1368
1467
  /** Errors encountered during execution of the mutation. */
1369
- errors: Array<Error>;
1468
+ errors?: Maybe<Array<Error>>;
1370
1469
  /** The deleted namespace license. */
1371
1470
  namespaceLicense?: Maybe<NamespaceLicense>;
1372
1471
  }
@@ -1387,7 +1486,7 @@ export interface NamespacesMembersAssignRolesPayload {
1387
1486
  /** A unique identifier for the client performing the mutation. */
1388
1487
  clientMutationId?: Maybe<Scalars['String']['output']>;
1389
1488
  /** Errors encountered during execution of the mutation. */
1390
- errors: Array<Error>;
1489
+ errors?: Maybe<Array<Error>>;
1391
1490
  /** The roles the member is now assigned to */
1392
1491
  namespaceMemberRoles?: Maybe<Array<NamespaceMemberRole>>;
1393
1492
  }
@@ -1406,7 +1505,7 @@ export interface NamespacesMembersDeletePayload {
1406
1505
  /** A unique identifier for the client performing the mutation. */
1407
1506
  clientMutationId?: Maybe<Scalars['String']['output']>;
1408
1507
  /** Errors encountered during execution of the mutation. */
1409
- errors: Array<Error>;
1508
+ errors?: Maybe<Array<Error>>;
1410
1509
  /** The removed namespace member */
1411
1510
  namespaceMember?: Maybe<NamespaceMember>;
1412
1511
  }
@@ -1427,7 +1526,7 @@ export interface NamespacesMembersInvitePayload {
1427
1526
  /** A unique identifier for the client performing the mutation. */
1428
1527
  clientMutationId?: Maybe<Scalars['String']['output']>;
1429
1528
  /** Errors encountered during execution of the mutation. */
1430
- errors: Array<Error>;
1529
+ errors?: Maybe<Array<Error>>;
1431
1530
  /** The newly created namespace member */
1432
1531
  namespaceMember?: Maybe<NamespaceMember>;
1433
1532
  }
@@ -1448,7 +1547,7 @@ export interface NamespacesProjectsAssignRuntimesPayload {
1448
1547
  /** A unique identifier for the client performing the mutation. */
1449
1548
  clientMutationId?: Maybe<Scalars['String']['output']>;
1450
1549
  /** Errors encountered during execution of the mutation. */
1451
- errors: Array<Error>;
1550
+ errors?: Maybe<Array<Error>>;
1452
1551
  /** The updated project with assigned runtimes */
1453
1552
  namespaceProject?: Maybe<NamespaceProject>;
1454
1553
  }
@@ -1471,7 +1570,7 @@ export interface NamespacesProjectsCreatePayload {
1471
1570
  /** A unique identifier for the client performing the mutation. */
1472
1571
  clientMutationId?: Maybe<Scalars['String']['output']>;
1473
1572
  /** Errors encountered during execution of the mutation. */
1474
- errors: Array<Error>;
1573
+ errors?: Maybe<Array<Error>>;
1475
1574
  /** The newly created project. */
1476
1575
  namespaceProject?: Maybe<NamespaceProject>;
1477
1576
  }
@@ -1490,7 +1589,7 @@ export interface NamespacesProjectsDeletePayload {
1490
1589
  /** A unique identifier for the client performing the mutation. */
1491
1590
  clientMutationId?: Maybe<Scalars['String']['output']>;
1492
1591
  /** Errors encountered during execution of the mutation. */
1493
- errors: Array<Error>;
1592
+ errors?: Maybe<Array<Error>>;
1494
1593
  /** The deleted project. */
1495
1594
  namespaceProject?: Maybe<NamespaceProject>;
1496
1595
  }
@@ -1511,7 +1610,7 @@ export interface NamespacesProjectsFlowsCreatePayload {
1511
1610
  /** A unique identifier for the client performing the mutation. */
1512
1611
  clientMutationId?: Maybe<Scalars['String']['output']>;
1513
1612
  /** Errors encountered during execution of the mutation. */
1514
- errors: Array<Error>;
1613
+ errors?: Maybe<Array<Error>>;
1515
1614
  /** The newly created flow. */
1516
1615
  flow?: Maybe<Flow>;
1517
1616
  }
@@ -1530,7 +1629,7 @@ export interface NamespacesProjectsFlowsDeletePayload {
1530
1629
  /** A unique identifier for the client performing the mutation. */
1531
1630
  clientMutationId?: Maybe<Scalars['String']['output']>;
1532
1631
  /** Errors encountered during execution of the mutation. */
1533
- errors: Array<Error>;
1632
+ errors?: Maybe<Array<Error>>;
1534
1633
  /** The deleted flow. */
1535
1634
  flow?: Maybe<Flow>;
1536
1635
  }
@@ -1555,7 +1654,7 @@ export interface NamespacesProjectsUpdatePayload {
1555
1654
  /** A unique identifier for the client performing the mutation. */
1556
1655
  clientMutationId?: Maybe<Scalars['String']['output']>;
1557
1656
  /** Errors encountered during execution of the mutation. */
1558
- errors: Array<Error>;
1657
+ errors?: Maybe<Array<Error>>;
1559
1658
  /** The updated project. */
1560
1659
  namespaceProject?: Maybe<NamespaceProject>;
1561
1660
  }
@@ -1578,7 +1677,7 @@ export interface NamespacesRolesAssignAbilitiesPayload {
1578
1677
  /** A unique identifier for the client performing the mutation. */
1579
1678
  clientMutationId?: Maybe<Scalars['String']['output']>;
1580
1679
  /** Errors encountered during execution of the mutation. */
1581
- errors: Array<Error>;
1680
+ errors?: Maybe<Array<Error>>;
1582
1681
  }
1583
1682
 
1584
1683
  /** Autogenerated input type of NamespacesRolesAssignProjects */
@@ -1597,7 +1696,7 @@ export interface NamespacesRolesAssignProjectsPayload {
1597
1696
  /** A unique identifier for the client performing the mutation. */
1598
1697
  clientMutationId?: Maybe<Scalars['String']['output']>;
1599
1698
  /** Errors encountered during execution of the mutation. */
1600
- errors: Array<Error>;
1699
+ errors?: Maybe<Array<Error>>;
1601
1700
  /** The now assigned projects */
1602
1701
  projects?: Maybe<Array<NamespaceProject>>;
1603
1702
  }
@@ -1618,7 +1717,7 @@ export interface NamespacesRolesCreatePayload {
1618
1717
  /** A unique identifier for the client performing the mutation. */
1619
1718
  clientMutationId?: Maybe<Scalars['String']['output']>;
1620
1719
  /** Errors encountered during execution of the mutation. */
1621
- errors: Array<Error>;
1720
+ errors?: Maybe<Array<Error>>;
1622
1721
  /** The newly created namespace role */
1623
1722
  namespaceRole?: Maybe<NamespaceRole>;
1624
1723
  }
@@ -1637,7 +1736,7 @@ export interface NamespacesRolesDeletePayload {
1637
1736
  /** A unique identifier for the client performing the mutation. */
1638
1737
  clientMutationId?: Maybe<Scalars['String']['output']>;
1639
1738
  /** Errors encountered during execution of the mutation. */
1640
- errors: Array<Error>;
1739
+ errors?: Maybe<Array<Error>>;
1641
1740
  /** The deleted namespace role */
1642
1741
  namespaceRole?: Maybe<NamespaceRole>;
1643
1742
  }
@@ -1658,7 +1757,7 @@ export interface NamespacesRolesUpdatePayload {
1658
1757
  /** A unique identifier for the client performing the mutation. */
1659
1758
  clientMutationId?: Maybe<Scalars['String']['output']>;
1660
1759
  /** Errors encountered during execution of the mutation. */
1661
- errors: Array<Error>;
1760
+ errors?: Maybe<Array<Error>>;
1662
1761
  /** The updated namespace role. */
1663
1762
  namespaceRole?: Maybe<NamespaceRole>;
1664
1763
  }
@@ -1666,24 +1765,24 @@ export interface NamespacesRolesUpdatePayload {
1666
1765
  /** An object with an ID. */
1667
1766
  export interface Node {
1668
1767
  /** ID of the object. */
1669
- id: Scalars['ID']['output'];
1768
+ id?: Maybe<Scalars['ID']['output']>;
1670
1769
  }
1671
1770
 
1672
1771
  /** Represents a Node Function */
1673
1772
  export interface NodeFunction {
1674
1773
  __typename?: 'NodeFunction';
1675
1774
  /** Time when this NodeFunction was created */
1676
- createdAt: Scalars['Time']['output'];
1775
+ createdAt?: Maybe<Scalars['Time']['output']>;
1776
+ /** The definition of the Node Function */
1777
+ functionDefinition?: Maybe<FunctionDefinition>;
1677
1778
  /** Global ID of this NodeFunction */
1678
- id: Scalars['NodeFunctionID']['output'];
1679
- /** The next Node Function in the flow */
1680
- nextNode?: Maybe<NodeFunction>;
1779
+ id?: Maybe<Scalars['NodeFunctionID']['output']>;
1780
+ /** The ID of the next Node Function in the flow */
1781
+ nextNodeId?: Maybe<Scalars['NodeFunctionID']['output']>;
1681
1782
  /** The parameters of the Node Function */
1682
- parameters: NodeParameterConnection;
1683
- /** The definition of the Node Function */
1684
- runtimeFunction: RuntimeFunctionDefinition;
1783
+ parameters?: Maybe<NodeParameterConnection>;
1685
1784
  /** Time when this NodeFunction was last updated */
1686
- updatedAt: Scalars['Time']['output'];
1785
+ updatedAt?: Maybe<Scalars['Time']['output']>;
1687
1786
  }
1688
1787
 
1689
1788
 
@@ -1695,6 +1794,28 @@ export interface NodeFunctionParametersArgs {
1695
1794
  last?: InputMaybe<Scalars['Int']['input']>;
1696
1795
  }
1697
1796
 
1797
+ /** The connection type for NodeFunction. */
1798
+ export interface NodeFunctionConnection {
1799
+ __typename?: 'NodeFunctionConnection';
1800
+ /** Total count of collection. */
1801
+ count?: Maybe<Scalars['Int']['output']>;
1802
+ /** A list of edges. */
1803
+ edges?: Maybe<Array<Maybe<NodeFunctionEdge>>>;
1804
+ /** A list of nodes. */
1805
+ nodes?: Maybe<Array<Maybe<NodeFunction>>>;
1806
+ /** Information to aid in pagination. */
1807
+ pageInfo?: Maybe<PageInfo>;
1808
+ }
1809
+
1810
+ /** An edge in a connection. */
1811
+ export interface NodeFunctionEdge {
1812
+ __typename?: 'NodeFunctionEdge';
1813
+ /** A cursor for use in pagination. */
1814
+ cursor?: Maybe<Scalars['String']['output']>;
1815
+ /** The item at the end of the edge. */
1816
+ node?: Maybe<NodeFunction>;
1817
+ }
1818
+
1698
1819
  /** Input type for a Node Function */
1699
1820
  export interface NodeFunctionInput {
1700
1821
  /** The next Node Function in the flow */
@@ -1709,13 +1830,13 @@ export interface NodeFunctionInput {
1709
1830
  export interface NodeParameter {
1710
1831
  __typename?: 'NodeParameter';
1711
1832
  /** Time when this NodeParameter was created */
1712
- createdAt: Scalars['Time']['output'];
1833
+ createdAt?: Maybe<Scalars['Time']['output']>;
1713
1834
  /** Global ID of this NodeParameter */
1714
- id: Scalars['NodeParameterID']['output'];
1835
+ id?: Maybe<Scalars['NodeParameterID']['output']>;
1715
1836
  /** The definition of the parameter */
1716
- runtimeParameter: RuntimeParameterDefinition;
1837
+ runtimeParameter?: Maybe<RuntimeParameterDefinition>;
1717
1838
  /** Time when this NodeParameter was last updated */
1718
- updatedAt: Scalars['Time']['output'];
1839
+ updatedAt?: Maybe<Scalars['Time']['output']>;
1719
1840
  /** The value of the parameter */
1720
1841
  value?: Maybe<NodeParameterValue>;
1721
1842
  }
@@ -1724,20 +1845,20 @@ export interface NodeParameter {
1724
1845
  export interface NodeParameterConnection {
1725
1846
  __typename?: 'NodeParameterConnection';
1726
1847
  /** Total count of collection. */
1727
- count: Scalars['Int']['output'];
1848
+ count?: Maybe<Scalars['Int']['output']>;
1728
1849
  /** A list of edges. */
1729
1850
  edges?: Maybe<Array<Maybe<NodeParameterEdge>>>;
1730
1851
  /** A list of nodes. */
1731
1852
  nodes?: Maybe<Array<Maybe<NodeParameter>>>;
1732
1853
  /** Information to aid in pagination. */
1733
- pageInfo: PageInfo;
1854
+ pageInfo?: Maybe<PageInfo>;
1734
1855
  }
1735
1856
 
1736
1857
  /** An edge in a connection. */
1737
1858
  export interface NodeParameterEdge {
1738
1859
  __typename?: 'NodeParameterEdge';
1739
1860
  /** A cursor for use in pagination. */
1740
- cursor: Scalars['String']['output'];
1861
+ cursor?: Maybe<Scalars['String']['output']>;
1741
1862
  /** The item at the end of the edge. */
1742
1863
  node?: Maybe<NodeParameter>;
1743
1864
  }
@@ -1763,30 +1884,19 @@ export interface NodeParameterValueInput {
1763
1884
  referenceValue?: InputMaybe<ReferenceValueInput>;
1764
1885
  }
1765
1886
 
1766
- /** Represents a rule that can be applied to a data type. */
1767
- export interface NumberRangeConfig {
1768
- __typename?: 'NumberRangeConfig';
1769
- /** The minimum value of the range */
1770
- from: Scalars['Int']['output'];
1771
- /** The step value for the range, if applicable */
1772
- steps?: Maybe<Scalars['Int']['output']>;
1773
- /** The maximum value of the range */
1774
- to: Scalars['Int']['output'];
1775
- }
1776
-
1777
1887
  /** Represents a Organization */
1778
1888
  export interface Organization {
1779
1889
  __typename?: 'Organization';
1780
1890
  /** Time when this Organization was created */
1781
- createdAt: Scalars['Time']['output'];
1891
+ createdAt?: Maybe<Scalars['Time']['output']>;
1782
1892
  /** Global ID of this Organization */
1783
- id: Scalars['OrganizationID']['output'];
1893
+ id?: Maybe<Scalars['OrganizationID']['output']>;
1784
1894
  /** Name of the organization */
1785
- name: Scalars['String']['output'];
1895
+ name?: Maybe<Scalars['String']['output']>;
1786
1896
  /** Namespace of this organization */
1787
- namespace: Namespace;
1897
+ namespace?: Maybe<Namespace>;
1788
1898
  /** Time when this Organization was last updated */
1789
- updatedAt: Scalars['Time']['output'];
1899
+ updatedAt?: Maybe<Scalars['Time']['output']>;
1790
1900
  }
1791
1901
 
1792
1902
  /** Autogenerated input type of OrganizationsCreate */
@@ -1803,7 +1913,7 @@ export interface OrganizationsCreatePayload {
1803
1913
  /** A unique identifier for the client performing the mutation. */
1804
1914
  clientMutationId?: Maybe<Scalars['String']['output']>;
1805
1915
  /** Errors encountered during execution of the mutation. */
1806
- errors: Array<Error>;
1916
+ errors?: Maybe<Array<Error>>;
1807
1917
  /** The newly created organization. */
1808
1918
  organization?: Maybe<Organization>;
1809
1919
  }
@@ -1822,7 +1932,7 @@ export interface OrganizationsDeletePayload {
1822
1932
  /** A unique identifier for the client performing the mutation. */
1823
1933
  clientMutationId?: Maybe<Scalars['String']['output']>;
1824
1934
  /** Errors encountered during execution of the mutation. */
1825
- errors: Array<Error>;
1935
+ errors?: Maybe<Array<Error>>;
1826
1936
  /** The deleted organization. */
1827
1937
  organization?: Maybe<Organization>;
1828
1938
  }
@@ -1843,7 +1953,7 @@ export interface OrganizationsUpdatePayload {
1843
1953
  /** A unique identifier for the client performing the mutation. */
1844
1954
  clientMutationId?: Maybe<Scalars['String']['output']>;
1845
1955
  /** Errors encountered during execution of the mutation. */
1846
- errors: Array<Error>;
1956
+ errors?: Maybe<Array<Error>>;
1847
1957
  /** The updated organization. */
1848
1958
  organization?: Maybe<Organization>;
1849
1959
  }
@@ -1854,9 +1964,9 @@ export interface PageInfo {
1854
1964
  /** When paginating forwards, the cursor to continue. */
1855
1965
  endCursor?: Maybe<Scalars['String']['output']>;
1856
1966
  /** When paginating forwards, are there more items? */
1857
- hasNextPage: Scalars['Boolean']['output'];
1967
+ hasNextPage?: Maybe<Scalars['Boolean']['output']>;
1858
1968
  /** When paginating backwards, are there more items? */
1859
- hasPreviousPage: Scalars['Boolean']['output'];
1969
+ hasPreviousPage?: Maybe<Scalars['Boolean']['output']>;
1860
1970
  /** When paginating backwards, the cursor to continue. */
1861
1971
  startCursor?: Maybe<Scalars['String']['output']>;
1862
1972
  }
@@ -1865,19 +1975,21 @@ export interface PageInfo {
1865
1975
  export interface ParameterDefinition {
1866
1976
  __typename?: 'ParameterDefinition';
1867
1977
  /** Time when this ParameterDefinition was created */
1868
- createdAt: Scalars['Time']['output'];
1978
+ createdAt?: Maybe<Scalars['Time']['output']>;
1869
1979
  /** Data type of the parameter */
1870
- dataType?: Maybe<DataTypeIdentifier>;
1980
+ dataTypeIdentifier?: Maybe<DataTypeIdentifier>;
1871
1981
  /** Description of the parameter */
1872
1982
  descriptions?: Maybe<TranslationConnection>;
1873
1983
  /** Documentation of the parameter */
1874
1984
  documentations?: Maybe<TranslationConnection>;
1875
1985
  /** Global ID of this ParameterDefinition */
1876
- id: Scalars['ParameterDefinitionID']['output'];
1986
+ id?: Maybe<Scalars['ParameterDefinitionID']['output']>;
1987
+ /** Identifier of the parameter */
1988
+ identifier?: Maybe<Scalars['String']['output']>;
1877
1989
  /** Name of the parameter */
1878
1990
  names?: Maybe<TranslationConnection>;
1879
1991
  /** Time when this ParameterDefinition was last updated */
1880
- updatedAt: Scalars['Time']['output'];
1992
+ updatedAt?: Maybe<Scalars['Time']['output']>;
1881
1993
  }
1882
1994
 
1883
1995
 
@@ -1911,20 +2023,20 @@ export interface ParameterDefinitionNamesArgs {
1911
2023
  export interface ParameterDefinitionConnection {
1912
2024
  __typename?: 'ParameterDefinitionConnection';
1913
2025
  /** Total count of collection. */
1914
- count: Scalars['Int']['output'];
2026
+ count?: Maybe<Scalars['Int']['output']>;
1915
2027
  /** A list of edges. */
1916
2028
  edges?: Maybe<Array<Maybe<ParameterDefinitionEdge>>>;
1917
2029
  /** A list of nodes. */
1918
2030
  nodes?: Maybe<Array<Maybe<ParameterDefinition>>>;
1919
2031
  /** Information to aid in pagination. */
1920
- pageInfo: PageInfo;
2032
+ pageInfo?: Maybe<PageInfo>;
1921
2033
  }
1922
2034
 
1923
2035
  /** An edge in a connection. */
1924
2036
  export interface ParameterDefinitionEdge {
1925
2037
  __typename?: 'ParameterDefinitionEdge';
1926
2038
  /** A cursor for use in pagination. */
1927
- cursor: Scalars['String']['output'];
2039
+ cursor?: Maybe<Scalars['String']['output']>;
1928
2040
  /** The item at the end of the edge. */
1929
2041
  node?: Maybe<ParameterDefinition>;
1930
2042
  }
@@ -1939,9 +2051,9 @@ export interface Query {
1939
2051
  /** Get the currently logged in user */
1940
2052
  currentUser?: Maybe<User>;
1941
2053
  /** Field available for use to test API access */
1942
- echo: Scalars['String']['output'];
2054
+ echo?: Maybe<Scalars['String']['output']>;
1943
2055
  /** Find runtimes */
1944
- globalRuntimes: RuntimeConnection;
2056
+ globalRuntimes?: Maybe<RuntimeConnection>;
1945
2057
  /** Find a namespace */
1946
2058
  namespace?: Maybe<Namespace>;
1947
2059
  /** Fetches an object given its ID */
@@ -1951,7 +2063,7 @@ export interface Query {
1951
2063
  /** Find a organization */
1952
2064
  organization?: Maybe<Organization>;
1953
2065
  /** Find users */
1954
- users: UserConnection;
2066
+ users?: Maybe<UserConnection>;
1955
2067
  }
1956
2068
 
1957
2069
 
@@ -2009,13 +2121,13 @@ export interface ReferencePath {
2009
2121
  /** The array index of the referenced data by the path */
2010
2122
  arrayIndex?: Maybe<Scalars['Int']['output']>;
2011
2123
  /** Time when this ReferencePath was created */
2012
- createdAt: Scalars['Time']['output'];
2124
+ createdAt?: Maybe<Scalars['Time']['output']>;
2013
2125
  /** Global ID of this ReferencePath */
2014
- id: Scalars['ReferencePathID']['output'];
2126
+ id?: Maybe<Scalars['ReferencePathID']['output']>;
2015
2127
  /** The path to the reference in the flow */
2016
2128
  path?: Maybe<Scalars['String']['output']>;
2017
2129
  /** Time when this ReferencePath was last updated */
2018
- updatedAt: Scalars['Time']['output'];
2130
+ updatedAt?: Maybe<Scalars['Time']['output']>;
2019
2131
  }
2020
2132
 
2021
2133
  /** Input type for reference path */
@@ -2030,21 +2142,21 @@ export interface ReferencePathInput {
2030
2142
  export interface ReferenceValue {
2031
2143
  __typename?: 'ReferenceValue';
2032
2144
  /** Time when this ReferenceValue was created */
2033
- createdAt: Scalars['Time']['output'];
2145
+ createdAt?: Maybe<Scalars['Time']['output']>;
2034
2146
  /** The identifier of the data type this reference value belongs to. */
2035
- dataTypeIdentifier: DataTypeIdentifier;
2147
+ dataTypeIdentifier?: Maybe<DataTypeIdentifier>;
2148
+ /** The depth of the reference value. */
2149
+ depth?: Maybe<Scalars['Int']['output']>;
2036
2150
  /** Global ID of this ReferenceValue */
2037
- id: Scalars['ReferenceValueID']['output'];
2038
- /** The primary level of the reference value. */
2039
- primaryLevel: Scalars['Int']['output'];
2151
+ id?: Maybe<Scalars['ReferenceValueID']['output']>;
2152
+ /** The node of the reference value. */
2153
+ node?: Maybe<Scalars['Int']['output']>;
2040
2154
  /** The paths associated with this reference value. */
2041
- referencePath: Array<ReferencePath>;
2042
- /** The secondary level of the reference value. */
2043
- secondaryLevel: Scalars['Int']['output'];
2044
- /** The tertiary level of the reference value, if applicable. */
2045
- tertiaryLevel?: Maybe<Scalars['Int']['output']>;
2155
+ referencePath?: Maybe<Array<ReferencePath>>;
2156
+ /** The scope of the reference value. */
2157
+ scope?: Maybe<Array<Scalars['Int']['output']>>;
2046
2158
  /** Time when this ReferenceValue was last updated */
2047
- updatedAt: Scalars['Time']['output'];
2159
+ updatedAt?: Maybe<Scalars['Time']['output']>;
2048
2160
  }
2049
2161
 
2050
2162
  /** Input type for reference value */
@@ -2061,45 +2173,31 @@ export interface ReferenceValueInput {
2061
2173
  tertiaryLevel?: InputMaybe<Scalars['Int']['input']>;
2062
2174
  }
2063
2175
 
2064
- /** Represents a rule that can be applied to a data type. */
2065
- export interface RegexConfig {
2066
- __typename?: 'RegexConfig';
2067
- /** The regex pattern to match against the data type value. */
2068
- pattern: Scalars['String']['output'];
2069
- }
2070
-
2071
- /** Represents a rule that can be applied to a data type. */
2072
- export interface ReturnTypeConfig {
2073
- __typename?: 'ReturnTypeConfig';
2074
- /** The data type identifier for the return type. */
2075
- dataTypeIdentifier: DataTypeIdentifier;
2076
- }
2077
-
2078
2176
  /** Represents a runtime */
2079
2177
  export interface Runtime {
2080
2178
  __typename?: 'Runtime';
2081
2179
  /** Time when this Runtime was created */
2082
- createdAt: Scalars['Time']['output'];
2180
+ createdAt?: Maybe<Scalars['Time']['output']>;
2083
2181
  /** DataTypes of the runtime */
2084
- dataTypes: DataTypeConnection;
2182
+ dataTypes?: Maybe<DataTypeConnection>;
2085
2183
  /** The description for the runtime if present */
2086
- description: Scalars['String']['output'];
2184
+ description?: Maybe<Scalars['String']['output']>;
2087
2185
  /** FlowTypes of the runtime */
2088
- flowTypes: FlowTypeConnection;
2186
+ flowTypes?: Maybe<FlowTypeConnection>;
2089
2187
  /** Global ID of this Runtime */
2090
- id: Scalars['RuntimeID']['output'];
2188
+ id?: Maybe<Scalars['RuntimeID']['output']>;
2091
2189
  /** The name for the runtime */
2092
- name: Scalars['String']['output'];
2190
+ name?: Maybe<Scalars['String']['output']>;
2093
2191
  /** The parent namespace for the runtime */
2094
2192
  namespace?: Maybe<Namespace>;
2095
2193
  /** Projects associated with the runtime */
2096
- projects: NamespaceProjectConnection;
2194
+ projects?: Maybe<NamespaceProjectConnection>;
2097
2195
  /** The status of the runtime */
2098
- status: RuntimeStatusType;
2196
+ status?: Maybe<RuntimeStatusType>;
2099
2197
  /** Token belonging to the runtime, only present on creation */
2100
2198
  token?: Maybe<Scalars['String']['output']>;
2101
2199
  /** Time when this Runtime was last updated */
2102
- updatedAt: Scalars['Time']['output'];
2200
+ updatedAt?: Maybe<Scalars['Time']['output']>;
2103
2201
  }
2104
2202
 
2105
2203
 
@@ -2133,39 +2231,45 @@ export interface RuntimeProjectsArgs {
2133
2231
  export interface RuntimeConnection {
2134
2232
  __typename?: 'RuntimeConnection';
2135
2233
  /** Total count of collection. */
2136
- count: Scalars['Int']['output'];
2234
+ count?: Maybe<Scalars['Int']['output']>;
2137
2235
  /** A list of edges. */
2138
2236
  edges?: Maybe<Array<Maybe<RuntimeEdge>>>;
2139
2237
  /** A list of nodes. */
2140
2238
  nodes?: Maybe<Array<Maybe<Runtime>>>;
2141
2239
  /** Information to aid in pagination. */
2142
- pageInfo: PageInfo;
2240
+ pageInfo?: Maybe<PageInfo>;
2143
2241
  }
2144
2242
 
2145
2243
  /** An edge in a connection. */
2146
2244
  export interface RuntimeEdge {
2147
2245
  __typename?: 'RuntimeEdge';
2148
2246
  /** A cursor for use in pagination. */
2149
- cursor: Scalars['String']['output'];
2247
+ cursor?: Maybe<Scalars['String']['output']>;
2150
2248
  /** The item at the end of the edge. */
2151
2249
  node?: Maybe<Runtime>;
2152
2250
  }
2153
2251
 
2154
- /** Represents a Node Function definition */
2252
+ /** Represents a runtime function definition */
2155
2253
  export interface RuntimeFunctionDefinition {
2156
2254
  __typename?: 'RuntimeFunctionDefinition';
2157
2255
  /** Time when this RuntimeFunctionDefinition was created */
2158
- createdAt: Scalars['Time']['output'];
2159
- /** Function definitions of the Node Function */
2256
+ createdAt?: Maybe<Scalars['Time']['output']>;
2257
+ /** Function definitions of the runtime function definition */
2160
2258
  functionDefinitions?: Maybe<FunctionDefinitionConnection>;
2161
2259
  /** Global ID of this RuntimeFunctionDefinition */
2162
- id: Scalars['RuntimeParameterDefinitionID']['output'];
2260
+ id?: Maybe<Scalars['RuntimeFunctionDefinitionID']['output']>;
2261
+ /** Identifier of the runtime function definition */
2262
+ identifier?: Maybe<Scalars['String']['output']>;
2263
+ /** The runtime this runtime function definition belongs to */
2264
+ runtime?: Maybe<Runtime>;
2265
+ /** Parameter definitions of the runtime function definition */
2266
+ runtimeParameterDefinitions?: Maybe<RuntimeParameterDefinitionConnection>;
2163
2267
  /** Time when this RuntimeFunctionDefinition was last updated */
2164
- updatedAt: Scalars['Time']['output'];
2268
+ updatedAt?: Maybe<Scalars['Time']['output']>;
2165
2269
  }
2166
2270
 
2167
2271
 
2168
- /** Represents a Node Function definition */
2272
+ /** Represents a runtime function definition */
2169
2273
  export interface RuntimeFunctionDefinitionFunctionDefinitionsArgs {
2170
2274
  after?: InputMaybe<Scalars['String']['input']>;
2171
2275
  before?: InputMaybe<Scalars['String']['input']>;
@@ -2173,15 +2277,46 @@ export interface RuntimeFunctionDefinitionFunctionDefinitionsArgs {
2173
2277
  last?: InputMaybe<Scalars['Int']['input']>;
2174
2278
  }
2175
2279
 
2176
- /** Represents a Node parameter definition */
2280
+
2281
+ /** Represents a runtime function definition */
2282
+ export interface RuntimeFunctionDefinitionRuntimeParameterDefinitionsArgs {
2283
+ after?: InputMaybe<Scalars['String']['input']>;
2284
+ before?: InputMaybe<Scalars['String']['input']>;
2285
+ first?: InputMaybe<Scalars['Int']['input']>;
2286
+ last?: InputMaybe<Scalars['Int']['input']>;
2287
+ }
2288
+
2289
+ /** Represents a runtime parameter definition */
2177
2290
  export interface RuntimeParameterDefinition {
2178
2291
  __typename?: 'RuntimeParameterDefinition';
2179
2292
  /** Time when this RuntimeParameterDefinition was created */
2180
- createdAt: Scalars['Time']['output'];
2293
+ createdAt?: Maybe<Scalars['Time']['output']>;
2181
2294
  /** Global ID of this RuntimeParameterDefinition */
2182
- id: Scalars['RuntimeParameterDefinitionID']['output'];
2295
+ id?: Maybe<Scalars['RuntimeParameterDefinitionID']['output']>;
2183
2296
  /** Time when this RuntimeParameterDefinition was last updated */
2184
- updatedAt: Scalars['Time']['output'];
2297
+ updatedAt?: Maybe<Scalars['Time']['output']>;
2298
+ }
2299
+
2300
+ /** The connection type for RuntimeParameterDefinition. */
2301
+ export interface RuntimeParameterDefinitionConnection {
2302
+ __typename?: 'RuntimeParameterDefinitionConnection';
2303
+ /** Total count of collection. */
2304
+ count?: Maybe<Scalars['Int']['output']>;
2305
+ /** A list of edges. */
2306
+ edges?: Maybe<Array<Maybe<RuntimeParameterDefinitionEdge>>>;
2307
+ /** A list of nodes. */
2308
+ nodes?: Maybe<Array<Maybe<RuntimeParameterDefinition>>>;
2309
+ /** Information to aid in pagination. */
2310
+ pageInfo?: Maybe<PageInfo>;
2311
+ }
2312
+
2313
+ /** An edge in a connection. */
2314
+ export interface RuntimeParameterDefinitionEdge {
2315
+ __typename?: 'RuntimeParameterDefinitionEdge';
2316
+ /** A cursor for use in pagination. */
2317
+ cursor?: Maybe<Scalars['String']['output']>;
2318
+ /** The item at the end of the edge. */
2319
+ node?: Maybe<RuntimeParameterDefinition>;
2185
2320
  }
2186
2321
 
2187
2322
  /** Represent all available types of statuses of a runtime */
@@ -2210,7 +2345,7 @@ export interface RuntimesCreatePayload {
2210
2345
  /** A unique identifier for the client performing the mutation. */
2211
2346
  clientMutationId?: Maybe<Scalars['String']['output']>;
2212
2347
  /** Errors encountered during execution of the mutation. */
2213
- errors: Array<Error>;
2348
+ errors?: Maybe<Array<Error>>;
2214
2349
  /** The newly created runtime. */
2215
2350
  runtime?: Maybe<Runtime>;
2216
2351
  }
@@ -2229,7 +2364,7 @@ export interface RuntimesDeletePayload {
2229
2364
  /** A unique identifier for the client performing the mutation. */
2230
2365
  clientMutationId?: Maybe<Scalars['String']['output']>;
2231
2366
  /** Errors encountered during execution of the mutation. */
2232
- errors: Array<Error>;
2367
+ errors?: Maybe<Array<Error>>;
2233
2368
  /** The updated organization. */
2234
2369
  runtime?: Maybe<Runtime>;
2235
2370
  }
@@ -2248,7 +2383,7 @@ export interface RuntimesRotateTokenPayload {
2248
2383
  /** A unique identifier for the client performing the mutation. */
2249
2384
  clientMutationId?: Maybe<Scalars['String']['output']>;
2250
2385
  /** Errors encountered during execution of the mutation. */
2251
- errors: Array<Error>;
2386
+ errors?: Maybe<Array<Error>>;
2252
2387
  /** The updated runtime. */
2253
2388
  runtime?: Maybe<Runtime>;
2254
2389
  }
@@ -2271,7 +2406,7 @@ export interface RuntimesUpdatePayload {
2271
2406
  /** A unique identifier for the client performing the mutation. */
2272
2407
  clientMutationId?: Maybe<Scalars['String']['output']>;
2273
2408
  /** Errors encountered during execution of the mutation. */
2274
- errors: Array<Error>;
2409
+ errors?: Maybe<Array<Error>>;
2275
2410
  /** The updated runtime. */
2276
2411
  runtime?: Maybe<Runtime>;
2277
2412
  }
@@ -2280,29 +2415,29 @@ export interface RuntimesUpdatePayload {
2280
2415
  export interface Translation {
2281
2416
  __typename?: 'Translation';
2282
2417
  /** Code of the translation */
2283
- code: Scalars['String']['output'];
2418
+ code?: Maybe<Scalars['String']['output']>;
2284
2419
  /** Content of the translation */
2285
- content: Scalars['String']['output'];
2420
+ content?: Maybe<Scalars['String']['output']>;
2286
2421
  }
2287
2422
 
2288
2423
  /** The connection type for Translation. */
2289
2424
  export interface TranslationConnection {
2290
2425
  __typename?: 'TranslationConnection';
2291
2426
  /** Total count of collection. */
2292
- count: Scalars['Int']['output'];
2427
+ count?: Maybe<Scalars['Int']['output']>;
2293
2428
  /** A list of edges. */
2294
2429
  edges?: Maybe<Array<Maybe<TranslationEdge>>>;
2295
2430
  /** A list of nodes. */
2296
2431
  nodes?: Maybe<Array<Maybe<Translation>>>;
2297
2432
  /** Information to aid in pagination. */
2298
- pageInfo: PageInfo;
2433
+ pageInfo?: Maybe<PageInfo>;
2299
2434
  }
2300
2435
 
2301
2436
  /** An edge in a connection. */
2302
2437
  export interface TranslationEdge {
2303
2438
  __typename?: 'TranslationEdge';
2304
2439
  /** A cursor for use in pagination. */
2305
- cursor: Scalars['String']['output'];
2440
+ cursor?: Maybe<Scalars['String']['output']>;
2306
2441
  /** The item at the end of the edge. */
2307
2442
  node?: Maybe<Translation>;
2308
2443
  }
@@ -2311,27 +2446,40 @@ export interface TranslationEdge {
2311
2446
  export interface User {
2312
2447
  __typename?: 'User';
2313
2448
  /** Global admin status of the user */
2314
- admin: Scalars['Boolean']['output'];
2449
+ admin?: Maybe<Scalars['Boolean']['output']>;
2315
2450
  /** The avatar if present of the user */
2316
2451
  avatarPath?: Maybe<Scalars['String']['output']>;
2317
2452
  /** Time when this User was created */
2318
- createdAt: Scalars['Time']['output'];
2453
+ createdAt?: Maybe<Scalars['Time']['output']>;
2319
2454
  /** Email of the user */
2320
- email: Scalars['String']['output'];
2455
+ email?: Maybe<Scalars['String']['output']>;
2321
2456
  /** Firstname of the user */
2322
- firstname: Scalars['String']['output'];
2457
+ firstname?: Maybe<Scalars['String']['output']>;
2323
2458
  /** Global ID of this User */
2324
- id: Scalars['UserID']['output'];
2459
+ id?: Maybe<Scalars['UserID']['output']>;
2460
+ /** Identities of this user */
2461
+ identities?: Maybe<UserIdentityConnection>;
2325
2462
  /** Lastname of the user */
2326
- lastname: Scalars['String']['output'];
2463
+ lastname?: Maybe<Scalars['String']['output']>;
2327
2464
  /** Namespace of this user */
2328
2465
  namespace?: Maybe<Namespace>;
2329
2466
  /** Namespace Memberships of this user */
2330
- namespaceMemberships: NamespaceMemberConnection;
2467
+ namespaceMemberships?: Maybe<NamespaceMemberConnection>;
2468
+ /** Sessions of this user */
2469
+ sessions?: Maybe<UserSessionConnection>;
2331
2470
  /** Time when this User was last updated */
2332
- updatedAt: Scalars['Time']['output'];
2471
+ updatedAt?: Maybe<Scalars['Time']['output']>;
2333
2472
  /** Username of the user */
2334
- username: Scalars['String']['output'];
2473
+ username?: Maybe<Scalars['String']['output']>;
2474
+ }
2475
+
2476
+
2477
+ /** Represents a user */
2478
+ export interface UserIdentitiesArgs {
2479
+ after?: InputMaybe<Scalars['String']['input']>;
2480
+ before?: InputMaybe<Scalars['String']['input']>;
2481
+ first?: InputMaybe<Scalars['Int']['input']>;
2482
+ last?: InputMaybe<Scalars['Int']['input']>;
2335
2483
  }
2336
2484
 
2337
2485
 
@@ -2343,24 +2491,33 @@ export interface UserNamespaceMembershipsArgs {
2343
2491
  last?: InputMaybe<Scalars['Int']['input']>;
2344
2492
  }
2345
2493
 
2494
+
2495
+ /** Represents a user */
2496
+ export interface UserSessionsArgs {
2497
+ after?: InputMaybe<Scalars['String']['input']>;
2498
+ before?: InputMaybe<Scalars['String']['input']>;
2499
+ first?: InputMaybe<Scalars['Int']['input']>;
2500
+ last?: InputMaybe<Scalars['Int']['input']>;
2501
+ }
2502
+
2346
2503
  /** The connection type for User. */
2347
2504
  export interface UserConnection {
2348
2505
  __typename?: 'UserConnection';
2349
2506
  /** Total count of collection. */
2350
- count: Scalars['Int']['output'];
2507
+ count?: Maybe<Scalars['Int']['output']>;
2351
2508
  /** A list of edges. */
2352
2509
  edges?: Maybe<Array<Maybe<UserEdge>>>;
2353
2510
  /** A list of nodes. */
2354
2511
  nodes?: Maybe<Array<Maybe<User>>>;
2355
2512
  /** Information to aid in pagination. */
2356
- pageInfo: PageInfo;
2513
+ pageInfo?: Maybe<PageInfo>;
2357
2514
  }
2358
2515
 
2359
2516
  /** An edge in a connection. */
2360
2517
  export interface UserEdge {
2361
2518
  __typename?: 'UserEdge';
2362
2519
  /** A cursor for use in pagination. */
2363
- cursor: Scalars['String']['output'];
2520
+ cursor?: Maybe<Scalars['String']['output']>;
2364
2521
  /** The item at the end of the edge. */
2365
2522
  node?: Maybe<User>;
2366
2523
  }
@@ -2369,34 +2526,97 @@ export interface UserEdge {
2369
2526
  export interface UserIdentity {
2370
2527
  __typename?: 'UserIdentity';
2371
2528
  /** Time when this UserIdentity was created */
2372
- createdAt: Scalars['Time']['output'];
2529
+ createdAt?: Maybe<Scalars['Time']['output']>;
2373
2530
  /** Global ID of this UserIdentity */
2374
- id: Scalars['UserIdentityID']['output'];
2531
+ id?: Maybe<Scalars['UserIdentityID']['output']>;
2375
2532
  /** The description for the runtime if present */
2376
- identifier: Scalars['String']['output'];
2533
+ identifier?: Maybe<Scalars['String']['output']>;
2377
2534
  /** The name for the runtime */
2378
- providerId: Scalars['String']['output'];
2535
+ providerId?: Maybe<Scalars['String']['output']>;
2379
2536
  /** Time when this UserIdentity was last updated */
2380
- updatedAt: Scalars['Time']['output'];
2537
+ updatedAt?: Maybe<Scalars['Time']['output']>;
2381
2538
  /** The correlating user of the identity */
2382
- user: User;
2539
+ user?: Maybe<User>;
2540
+ }
2541
+
2542
+ /** The connection type for UserIdentity. */
2543
+ export interface UserIdentityConnection {
2544
+ __typename?: 'UserIdentityConnection';
2545
+ /** Total count of collection. */
2546
+ count?: Maybe<Scalars['Int']['output']>;
2547
+ /** A list of edges. */
2548
+ edges?: Maybe<Array<Maybe<UserIdentityEdge>>>;
2549
+ /** A list of nodes. */
2550
+ nodes?: Maybe<Array<Maybe<UserIdentity>>>;
2551
+ /** Information to aid in pagination. */
2552
+ pageInfo?: Maybe<PageInfo>;
2553
+ }
2554
+
2555
+ /** An edge in a connection. */
2556
+ export interface UserIdentityEdge {
2557
+ __typename?: 'UserIdentityEdge';
2558
+ /** A cursor for use in pagination. */
2559
+ cursor?: Maybe<Scalars['String']['output']>;
2560
+ /** The item at the end of the edge. */
2561
+ node?: Maybe<UserIdentity>;
2383
2562
  }
2384
2563
 
2385
2564
  /** Represents a user session */
2386
2565
  export interface UserSession {
2387
2566
  __typename?: 'UserSession';
2388
2567
  /** Whether or not the session is active and can be used */
2389
- active: Scalars['Boolean']['output'];
2568
+ active?: Maybe<Scalars['Boolean']['output']>;
2390
2569
  /** Time when this UserSession was created */
2391
- createdAt: Scalars['Time']['output'];
2570
+ createdAt?: Maybe<Scalars['Time']['output']>;
2392
2571
  /** Global ID of this UserSession */
2393
- id: Scalars['UserSessionID']['output'];
2572
+ id?: Maybe<Scalars['UserSessionID']['output']>;
2394
2573
  /** Token belonging to the session, only present on creation */
2395
2574
  token?: Maybe<Scalars['String']['output']>;
2396
2575
  /** Time when this UserSession was last updated */
2397
- updatedAt: Scalars['Time']['output'];
2576
+ updatedAt?: Maybe<Scalars['Time']['output']>;
2398
2577
  /** User that belongs to the session */
2399
- user: User;
2578
+ user?: Maybe<User>;
2579
+ }
2580
+
2581
+ /** The connection type for UserSession. */
2582
+ export interface UserSessionConnection {
2583
+ __typename?: 'UserSessionConnection';
2584
+ /** Total count of collection. */
2585
+ count?: Maybe<Scalars['Int']['output']>;
2586
+ /** A list of edges. */
2587
+ edges?: Maybe<Array<Maybe<UserSessionEdge>>>;
2588
+ /** A list of nodes. */
2589
+ nodes?: Maybe<Array<Maybe<UserSession>>>;
2590
+ /** Information to aid in pagination. */
2591
+ pageInfo?: Maybe<PageInfo>;
2592
+ }
2593
+
2594
+ /** An edge in a connection. */
2595
+ export interface UserSessionEdge {
2596
+ __typename?: 'UserSessionEdge';
2597
+ /** A cursor for use in pagination. */
2598
+ cursor?: Maybe<Scalars['String']['output']>;
2599
+ /** The item at the end of the edge. */
2600
+ node?: Maybe<UserSession>;
2601
+ }
2602
+
2603
+ /** Autogenerated input type of UsersEmailVerification */
2604
+ export interface UsersEmailVerificationInput {
2605
+ /** A unique identifier for the client performing the mutation. */
2606
+ clientMutationId?: InputMaybe<Scalars['String']['input']>;
2607
+ /** The email verification token */
2608
+ token: Scalars['String']['input'];
2609
+ }
2610
+
2611
+ /** Autogenerated return type of UsersEmailVerification. */
2612
+ export interface UsersEmailVerificationPayload {
2613
+ __typename?: 'UsersEmailVerificationPayload';
2614
+ /** A unique identifier for the client performing the mutation. */
2615
+ clientMutationId?: Maybe<Scalars['String']['output']>;
2616
+ /** Errors encountered during execution of the mutation. */
2617
+ errors?: Maybe<Array<Error>>;
2618
+ /** The user whose email was verified */
2619
+ user?: Maybe<User>;
2400
2620
  }
2401
2621
 
2402
2622
  /** Autogenerated input type of UsersIdentityLink */
@@ -2415,7 +2635,7 @@ export interface UsersIdentityLinkPayload {
2415
2635
  /** A unique identifier for the client performing the mutation. */
2416
2636
  clientMutationId?: Maybe<Scalars['String']['output']>;
2417
2637
  /** Errors encountered during execution of the mutation. */
2418
- errors: Array<Error>;
2638
+ errors?: Maybe<Array<Error>>;
2419
2639
  /** The created user identity */
2420
2640
  userIdentity?: Maybe<UserIdentity>;
2421
2641
  }
@@ -2436,7 +2656,7 @@ export interface UsersIdentityLoginPayload {
2436
2656
  /** A unique identifier for the client performing the mutation. */
2437
2657
  clientMutationId?: Maybe<Scalars['String']['output']>;
2438
2658
  /** Errors encountered during execution of the mutation. */
2439
- errors: Array<Error>;
2659
+ errors?: Maybe<Array<Error>>;
2440
2660
  /** The created user session */
2441
2661
  userSession?: Maybe<UserSession>;
2442
2662
  }
@@ -2457,7 +2677,7 @@ export interface UsersIdentityRegisterPayload {
2457
2677
  /** A unique identifier for the client performing the mutation. */
2458
2678
  clientMutationId?: Maybe<Scalars['String']['output']>;
2459
2679
  /** Errors encountered during execution of the mutation. */
2460
- errors: Array<Error>;
2680
+ errors?: Maybe<Array<Error>>;
2461
2681
  /** The created users session */
2462
2682
  userSession?: Maybe<UserSession>;
2463
2683
  }
@@ -2476,7 +2696,7 @@ export interface UsersIdentityUnlinkPayload {
2476
2696
  /** A unique identifier for the client performing the mutation. */
2477
2697
  clientMutationId?: Maybe<Scalars['String']['output']>;
2478
2698
  /** Errors encountered during execution of the mutation. */
2479
- errors: Array<Error>;
2699
+ errors?: Maybe<Array<Error>>;
2480
2700
  /** The removed identity */
2481
2701
  userIdentity?: Maybe<UserIdentity>;
2482
2702
  }
@@ -2501,7 +2721,7 @@ export interface UsersLoginPayload {
2501
2721
  /** A unique identifier for the client performing the mutation. */
2502
2722
  clientMutationId?: Maybe<Scalars['String']['output']>;
2503
2723
  /** Errors encountered during execution of the mutation. */
2504
- errors: Array<Error>;
2724
+ errors?: Maybe<Array<Error>>;
2505
2725
  /** The created user session */
2506
2726
  userSession?: Maybe<UserSession>;
2507
2727
  }
@@ -2520,7 +2740,7 @@ export interface UsersLogoutPayload {
2520
2740
  /** A unique identifier for the client performing the mutation. */
2521
2741
  clientMutationId?: Maybe<Scalars['String']['output']>;
2522
2742
  /** Errors encountered during execution of the mutation. */
2523
- errors: Array<Error>;
2743
+ errors?: Maybe<Array<Error>>;
2524
2744
  /** The logged out user session */
2525
2745
  userSession?: Maybe<UserSession>;
2526
2746
  }
@@ -2539,7 +2759,7 @@ export interface UsersMfaBackupCodesRotatePayload {
2539
2759
  /** The newly rotated backup codes. */
2540
2760
  codes?: Maybe<Array<Scalars['String']['output']>>;
2541
2761
  /** Errors encountered during execution of the mutation. */
2542
- errors: Array<Error>;
2762
+ errors?: Maybe<Array<Error>>;
2543
2763
  }
2544
2764
 
2545
2765
  /** Autogenerated input type of UsersMfaTotpGenerateSecret */
@@ -2554,7 +2774,7 @@ export interface UsersMfaTotpGenerateSecretPayload {
2554
2774
  /** A unique identifier for the client performing the mutation. */
2555
2775
  clientMutationId?: Maybe<Scalars['String']['output']>;
2556
2776
  /** Errors encountered during execution of the mutation. */
2557
- errors: Array<Error>;
2777
+ errors?: Maybe<Array<Error>>;
2558
2778
  /** The created and signed secret */
2559
2779
  secret?: Maybe<Scalars['String']['output']>;
2560
2780
  }
@@ -2578,7 +2798,7 @@ export interface UsersMfaTotpValidateSecretPayload {
2578
2798
  /** A unique identifier for the client performing the mutation. */
2579
2799
  clientMutationId?: Maybe<Scalars['String']['output']>;
2580
2800
  /** Errors encountered during execution of the mutation. */
2581
- errors: Array<Error>;
2801
+ errors?: Maybe<Array<Error>>;
2582
2802
  /** The modified user */
2583
2803
  user?: Maybe<User>;
2584
2804
  }
@@ -2603,7 +2823,7 @@ export interface UsersRegisterPayload {
2603
2823
  /** A unique identifier for the client performing the mutation. */
2604
2824
  clientMutationId?: Maybe<Scalars['String']['output']>;
2605
2825
  /** Errors encountered during execution of the mutation. */
2606
- errors: Array<Error>;
2826
+ errors?: Maybe<Array<Error>>;
2607
2827
  /** The created users session */
2608
2828
  userSession?: Maybe<UserSession>;
2609
2829
  }
@@ -2638,7 +2858,7 @@ export interface UsersUpdatePayload {
2638
2858
  /** A unique identifier for the client performing the mutation. */
2639
2859
  clientMutationId?: Maybe<Scalars['String']['output']>;
2640
2860
  /** Errors encountered during execution of the mutation. */
2641
- errors: Array<Error>;
2861
+ errors?: Maybe<Array<Error>>;
2642
2862
  /** The updated user. */
2643
2863
  user?: Maybe<User>;
2644
2864
  }