@code0-tech/sagittarius-graphql-types 0.0.0-6f0b32a0eb18c9c3569a090f089c6adf1b4d666c → 0.0.0-967667e8c736081887d32d99a5e2ab0445718798

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 +1259 -160
  2. package/package.json +4 -4
package/index.d.ts CHANGED
@@ -7,59 +7,61 @@ export type MakeEmpty<T extends { [key: string]: unknown }, K extends keyof T> =
7
7
  export type Incremental<T> = T | { [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never };
8
8
  /** All built-in and custom scalars, mapped to their actual values */
9
9
  export interface Scalars {
10
- ID: { input: string; output: string; }
10
+ ID: { input: `gid://sagittarius//${number}`; output: `gid://sagittarius//${number}`; }
11
11
  String: { input: string; output: string; }
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
- DataTypeID: { input: any; output: any; }
17
- /** A unique identifier for all Namespace entities of the application */
18
- NamespaceID: { input: any; output: any; }
19
- /** A unique identifier for all NamespaceLicense entities of the application */
20
- NamespaceLicenseID: { input: any; output: any; }
21
- /** A unique identifier for all NamespaceMember entities of the application */
22
- NamespaceMemberID: { input: any; output: any; }
23
- /** A unique identifier for all NamespaceMemberRole entities of the application */
24
- NamespaceMemberRoleID: { input: any; output: any; }
25
- /** A unique identifier for all NamespaceProject entities of the application */
26
- NamespaceProjectID: { input: any; output: any; }
27
- /** A unique identifier for all NamespaceRole entities of the application */
28
- NamespaceRoleID: { input: any; output: any; }
29
- /** A unique identifier for all Organization entities of the application */
30
- OrganizationID: { input: any; output: any; }
31
- /** A unique identifier for all Runtime entities of the application */
32
- RuntimeID: { input: any; output: any; }
33
- /**
34
- * Time represented in ISO 8601.
35
- *
36
- * For example: "2023-12-15T17:31:00Z".
37
- */
38
- Time: { input: any; output: any; }
39
- /** A unique identifier for all User entities of the application */
40
- UserID: { input: any; output: any; }
41
- /** A unique identifier for all UserIdentity entities of the application */
42
- UserIdentityID: { input: any; output: any; }
43
- /** A unique identifier for all UserSession entities of the application */
44
- UserSessionID: { input: any; output: any; }
15
+ DataTypeID: { input: `gid://sagittarius/DataType/${number}`; output: `gid://sagittarius/DataType/${number}`; }
16
+ DataTypeIdentifierID: { input: `gid://sagittarius/DataTypeIdentifier/${number}`; output: `gid://sagittarius/DataTypeIdentifier/${number}`; }
17
+ DataTypeRuleID: { input: `gid://sagittarius/DataTypeRule/${number}`; output: `gid://sagittarius/DataTypeRule/${number}`; }
18
+ FlowID: { input: `gid://sagittarius/Flow/${number}`; output: `gid://sagittarius/Flow/${number}`; }
19
+ FlowSettingID: { input: `gid://sagittarius/FlowSetting/${number}`; output: `gid://sagittarius/FlowSetting/${number}`; }
20
+ FlowTypeID: { input: `gid://sagittarius/FlowType/${number}`; output: `gid://sagittarius/FlowType/${number}`; }
21
+ FlowTypeSettingID: { input: `gid://sagittarius/FlowTypeSetting/${number}`; output: `gid://sagittarius/FlowTypeSetting/${number}`; }
22
+ FunctionDefinitionID: { input: `gid://sagittarius/FunctionDefinition/${number}`; output: `gid://sagittarius/FunctionDefinition/${number}`; }
23
+ GenericCombinationStrategyID: { input: `gid://sagittarius/GenericCombinationStrategy/${number}`; output: `gid://sagittarius/GenericCombinationStrategy/${number}`; }
24
+ GenericMapperID: { input: `gid://sagittarius/GenericMapper/${number}`; output: `gid://sagittarius/GenericMapper/${number}`; }
25
+ GenericTypeID: { input: `gid://sagittarius/GenericType/${number}`; output: `gid://sagittarius/GenericType/${number}`; }
26
+ JSON: { input: any; output: any; }
27
+ NamespaceID: { input: `gid://sagittarius/Namespace/${number}`; output: `gid://sagittarius/Namespace/${number}`; }
28
+ NamespaceLicenseID: { input: `gid://sagittarius/NamespaceLicense/${number}`; output: `gid://sagittarius/NamespaceLicense/${number}`; }
29
+ NamespaceMemberID: { input: `gid://sagittarius/NamespaceMember/${number}`; output: `gid://sagittarius/NamespaceMember/${number}`; }
30
+ NamespaceMemberRoleID: { input: `gid://sagittarius/NamespaceMemberRole/${number}`; output: `gid://sagittarius/NamespaceMemberRole/${number}`; }
31
+ NamespaceProjectID: { input: `gid://sagittarius/NamespaceProject/${number}`; output: `gid://sagittarius/NamespaceProject/${number}`; }
32
+ NamespaceRoleID: { input: `gid://sagittarius/NamespaceRole/${number}`; output: `gid://sagittarius/NamespaceRole/${number}`; }
33
+ NodeFunctionID: { input: `gid://sagittarius/NodeFunction/${number}`; output: `gid://sagittarius/NodeFunction/${number}`; }
34
+ NodeParameterID: { input: `gid://sagittarius/NodeParameter/${number}`; output: `gid://sagittarius/NodeParameter/${number}`; }
35
+ OrganizationID: { input: `gid://sagittarius/Organization/${number}`; output: `gid://sagittarius/Organization/${number}`; }
36
+ ParameterDefinitionID: { input: `gid://sagittarius/ParameterDefinition/${number}`; output: `gid://sagittarius/ParameterDefinition/${number}`; }
37
+ ReferencePathID: { input: `gid://sagittarius/ReferencePath/${number}`; output: `gid://sagittarius/ReferencePath/${number}`; }
38
+ ReferenceValueID: { input: `gid://sagittarius/ReferenceValue/${number}`; output: `gid://sagittarius/ReferenceValue/${number}`; }
39
+ RuntimeFunctionDefinitionID: { input: `gid://sagittarius/RuntimeFunctionDefinition/${number}`; output: `gid://sagittarius/RuntimeFunctionDefinition/${number}`; }
40
+ RuntimeID: { input: `gid://sagittarius/Runtime/${number}`; output: `gid://sagittarius/Runtime/${number}`; }
41
+ RuntimeParameterDefinitionID: { input: `gid://sagittarius/RuntimeParameterDefinition/${number}`; output: `gid://sagittarius/RuntimeParameterDefinition/${number}`; }
42
+ Time: { input: string; output: string; }
43
+ TypesFlowTypeID: { input: `gid://sagittarius/TypesFlowType/${number}`; output: `gid://sagittarius/TypesFlowType/${number}`; }
44
+ UserID: { input: `gid://sagittarius/User/${number}`; output: `gid://sagittarius/User/${number}`; }
45
+ UserIdentityID: { input: `gid://sagittarius/UserIdentity/${number}`; output: `gid://sagittarius/UserIdentity/${number}`; }
46
+ UserSessionID: { input: `gid://sagittarius/UserSession/${number}`; output: `gid://sagittarius/UserSession/${number}`; }
45
47
  }
46
48
 
47
49
  /** Represents an active model error */
48
50
  export interface ActiveModelError {
49
51
  __typename?: 'ActiveModelError';
50
52
  /** The affected attribute on the model */
51
- attribute: Scalars['String']['output'];
53
+ attribute?: Maybe<Scalars['String']['output']>;
52
54
  /** The validation type that failed for the attribute */
53
- type: Scalars['String']['output'];
55
+ type?: Maybe<Scalars['String']['output']>;
54
56
  }
55
57
 
56
58
  /** Represents the application settings */
57
59
  export interface ApplicationSettings {
58
60
  __typename?: 'ApplicationSettings';
59
61
  /** Shows if organization creation is restricted to administrators */
60
- organizationCreationRestricted: Scalars['Boolean']['output'];
62
+ organizationCreationRestricted?: Maybe<Scalars['Boolean']['output']>;
61
63
  /** Shows if user registration is enabled */
62
- userRegistrationEnabled: Scalars['Boolean']['output'];
64
+ userRegistrationEnabled?: Maybe<Scalars['Boolean']['output']>;
63
65
  }
64
66
 
65
67
  /** Autogenerated input type of ApplicationSettingsUpdate */
@@ -80,7 +82,7 @@ export interface ApplicationSettingsUpdatePayload {
80
82
  /** A unique identifier for the client performing the mutation. */
81
83
  clientMutationId?: Maybe<Scalars['String']['output']>;
82
84
  /** Errors encountered during execution of the mutation. */
83
- errors: Array<Error>;
85
+ errors?: Maybe<Array<Error>>;
84
86
  }
85
87
 
86
88
  /** Objects that can present an authentication */
@@ -90,47 +92,235 @@ export type Authentication = UserSession;
90
92
  export interface DataType {
91
93
  __typename?: 'DataType';
92
94
  /** Time when this DataType was created */
93
- createdAt: Scalars['Time']['output'];
95
+ createdAt?: Maybe<Scalars['Time']['output']>;
96
+ /** Generic keys of the datatype */
97
+ genericKeys?: Maybe<Array<Scalars['String']['output']>>;
94
98
  /** Global ID of this DataType */
95
- id: Scalars['DataTypeID']['output'];
99
+ id?: Maybe<Scalars['DataTypeID']['output']>;
96
100
  /** The identifier scoped to the namespace */
97
- identifier: Scalars['String']['output'];
101
+ identifier?: Maybe<Scalars['String']['output']>;
102
+ /** Names of the flow type setting */
103
+ name?: Maybe<TranslationConnection>;
98
104
  /** The namespace where this datatype belongs to */
99
105
  namespace?: Maybe<Namespace>;
106
+ /** The parent datatype */
107
+ parent?: Maybe<DataTypeIdentifier>;
108
+ /** Rules of the datatype */
109
+ rules?: Maybe<DataTypeRuleConnection>;
100
110
  /** Time when this DataType was last updated */
101
- updatedAt: Scalars['Time']['output'];
111
+ updatedAt?: Maybe<Scalars['Time']['output']>;
102
112
  /** The type of the datatype */
103
- variant: DataTypeVariant;
113
+ variant?: Maybe<DataTypeVariant>;
114
+ }
115
+
116
+
117
+ /** Represents a DataType */
118
+ export interface DataTypeNameArgs {
119
+ after?: InputMaybe<Scalars['String']['input']>;
120
+ before?: InputMaybe<Scalars['String']['input']>;
121
+ first?: InputMaybe<Scalars['Int']['input']>;
122
+ last?: InputMaybe<Scalars['Int']['input']>;
123
+ }
124
+
125
+
126
+ /** Represents a DataType */
127
+ export interface DataTypeRulesArgs {
128
+ after?: InputMaybe<Scalars['String']['input']>;
129
+ before?: InputMaybe<Scalars['String']['input']>;
130
+ first?: InputMaybe<Scalars['Int']['input']>;
131
+ last?: InputMaybe<Scalars['Int']['input']>;
104
132
  }
105
133
 
106
134
  /** The connection type for DataType. */
107
135
  export interface DataTypeConnection {
108
136
  __typename?: 'DataTypeConnection';
109
137
  /** Total count of collection. */
110
- count: Scalars['Int']['output'];
138
+ count?: Maybe<Scalars['Int']['output']>;
111
139
  /** A list of edges. */
112
140
  edges?: Maybe<Array<Maybe<DataTypeEdge>>>;
113
141
  /** A list of nodes. */
114
142
  nodes?: Maybe<Array<Maybe<DataType>>>;
115
143
  /** Information to aid in pagination. */
116
- pageInfo: PageInfo;
144
+ pageInfo?: Maybe<PageInfo>;
117
145
  }
118
146
 
119
147
  /** An edge in a connection. */
120
148
  export interface DataTypeEdge {
121
149
  __typename?: 'DataTypeEdge';
122
150
  /** A cursor for use in pagination. */
123
- cursor: Scalars['String']['output'];
151
+ cursor?: Maybe<Scalars['String']['output']>;
124
152
  /** The item at the end of the edge. */
125
153
  node?: Maybe<DataType>;
126
154
  }
127
155
 
156
+ /** Represents a data type identifier. */
157
+ export interface DataTypeIdentifier {
158
+ __typename?: 'DataTypeIdentifier';
159
+ /** Time when this DataTypeIdentifier was created */
160
+ createdAt?: Maybe<Scalars['Time']['output']>;
161
+ /** The data type of the data type identifier. */
162
+ dataType?: Maybe<DataType>;
163
+ /** The generic key of the data type identifier. */
164
+ genericKey?: Maybe<Scalars['String']['output']>;
165
+ /** The generic type of the data type identifier. */
166
+ genericType?: Maybe<GenericType>;
167
+ /** Global ID of this DataTypeIdentifier */
168
+ id?: Maybe<Scalars['DataTypeIdentifierID']['output']>;
169
+ /** Time when this DataTypeIdentifier was last updated */
170
+ updatedAt?: Maybe<Scalars['Time']['output']>;
171
+ }
172
+
173
+ /** Input type for data type identifier */
174
+ export interface DataTypeIdentifierInput {
175
+ /** Data type ID */
176
+ dataTypeId?: InputMaybe<Scalars['DataTypeID']['input']>;
177
+ /** Generic key value */
178
+ genericKey?: InputMaybe<Scalars['String']['input']>;
179
+ /** Generic type information */
180
+ genericType?: InputMaybe<GenericTypeInput>;
181
+ }
182
+
183
+ /** Represents a rule that can be applied to a data type. */
184
+ export interface DataTypeRule {
185
+ __typename?: 'DataTypeRule';
186
+ /** The configuration of the rule */
187
+ config?: Maybe<DataTypeRulesConfig>;
188
+ /** Time when this DataTypeRule was created */
189
+ createdAt?: Maybe<Scalars['Time']['output']>;
190
+ /** Global ID of this DataTypeRule */
191
+ id?: Maybe<Scalars['DataTypeRuleID']['output']>;
192
+ /** Time when this DataTypeRule was last updated */
193
+ updatedAt?: Maybe<Scalars['Time']['output']>;
194
+ /** The type of the rule */
195
+ variant?: Maybe<DataTypeRulesVariant>;
196
+ }
197
+
198
+ /** The connection type for DataTypeRule. */
199
+ export interface DataTypeRuleConnection {
200
+ __typename?: 'DataTypeRuleConnection';
201
+ /** Total count of collection. */
202
+ count?: Maybe<Scalars['Int']['output']>;
203
+ /** A list of edges. */
204
+ edges?: Maybe<Array<Maybe<DataTypeRuleEdge>>>;
205
+ /** A list of nodes. */
206
+ nodes?: Maybe<Array<Maybe<DataTypeRule>>>;
207
+ /** Information to aid in pagination. */
208
+ pageInfo?: Maybe<PageInfo>;
209
+ }
210
+
211
+ /** An edge in a connection. */
212
+ export interface DataTypeRuleEdge {
213
+ __typename?: 'DataTypeRuleEdge';
214
+ /** A cursor for use in pagination. */
215
+ cursor?: Maybe<Scalars['String']['output']>;
216
+ /** The item at the end of the edge. */
217
+ node?: Maybe<DataTypeRule>;
218
+ }
219
+
220
+ /** Represents a rule that can be applied to a data type. */
221
+ export type DataTypeRulesConfig = DataTypeRulesContainsKeyConfig | DataTypeRulesContainsTypeConfig | DataTypeRulesInputTypesConfig | DataTypeRulesItemOfCollectionConfig | DataTypeRulesNumberRangeConfig | DataTypeRulesParentTypeConfig | DataTypeRulesRegexConfig | DataTypeRulesReturnTypeConfig;
222
+
223
+ /** Represents a rule that can be applied to a data type. */
224
+ export interface DataTypeRulesContainsKeyConfig {
225
+ __typename?: 'DataTypeRulesContainsKeyConfig';
226
+ /** The identifier of the data type this rule belongs to */
227
+ dataTypeIdentifier?: Maybe<DataTypeIdentifier>;
228
+ /** The key of the rule */
229
+ key?: Maybe<Scalars['String']['output']>;
230
+ }
231
+
232
+ /** Represents a rule that can be applied to a data type. */
233
+ export interface DataTypeRulesContainsTypeConfig {
234
+ __typename?: 'DataTypeRulesContainsTypeConfig';
235
+ /** The identifier of the data type this rule belongs to */
236
+ dataTypeIdentifier?: Maybe<DataTypeIdentifier>;
237
+ }
238
+
239
+ /** Represents a subtype of input type configuration for a input data type. */
240
+ export interface DataTypeRulesInputTypeConfig {
241
+ __typename?: 'DataTypeRulesInputTypeConfig';
242
+ /** The identifier of the data type this input type belongs to */
243
+ dataTypeIdentifier?: Maybe<DataTypeIdentifier>;
244
+ /** The input data type that this configuration applies to */
245
+ inputType?: Maybe<DataType>;
246
+ }
247
+
248
+ /** Represents a rule that can be applied to a data type. */
249
+ export interface DataTypeRulesInputTypesConfig {
250
+ __typename?: 'DataTypeRulesInputTypesConfig';
251
+ /** The input types that can be used in this data type rule */
252
+ inputTypes?: Maybe<Array<DataTypeRulesInputTypeConfig>>;
253
+ }
254
+
255
+ /** Represents a rule that can be applied to a data type. */
256
+ export interface DataTypeRulesItemOfCollectionConfig {
257
+ __typename?: 'DataTypeRulesItemOfCollectionConfig';
258
+ /** The items that can be configured for this rule. */
259
+ items?: Maybe<Array<Scalars['JSON']['output']>>;
260
+ }
261
+
262
+ /** Represents a rule that can be applied to a data type. */
263
+ export interface DataTypeRulesNumberRangeConfig {
264
+ __typename?: 'DataTypeRulesNumberRangeConfig';
265
+ /** The minimum value of the range */
266
+ from?: Maybe<Scalars['Int']['output']>;
267
+ /** The step value for the range, if applicable */
268
+ steps?: Maybe<Scalars['Int']['output']>;
269
+ /** The maximum value of the range */
270
+ to?: Maybe<Scalars['Int']['output']>;
271
+ }
272
+
273
+ /** Represents a rule that can be applied to a data type. */
274
+ export interface DataTypeRulesParentTypeConfig {
275
+ __typename?: 'DataTypeRulesParentTypeConfig';
276
+ /** The data type identifier for the parent type. */
277
+ dataTypeIdentifier?: Maybe<DataTypeIdentifier>;
278
+ }
279
+
280
+ /** Represents a rule that can be applied to a data type. */
281
+ export interface DataTypeRulesRegexConfig {
282
+ __typename?: 'DataTypeRulesRegexConfig';
283
+ /** The regex pattern to match against the data type value. */
284
+ pattern?: Maybe<Scalars['String']['output']>;
285
+ }
286
+
287
+ /** Represents a rule that can be applied to a data type. */
288
+ export interface DataTypeRulesReturnTypeConfig {
289
+ __typename?: 'DataTypeRulesReturnTypeConfig';
290
+ /** The data type identifier for the return type. */
291
+ dataTypeIdentifier?: Maybe<DataTypeIdentifier>;
292
+ }
293
+
294
+ /** The type of rule that can be applied to a data type. */
295
+ export enum DataTypeRulesVariant {
296
+ /** The rule checks if a key is present in the data type. */
297
+ ContainsKey = 'CONTAINS_KEY',
298
+ /** The rule checks if a specific type is present in the data type. */
299
+ ContainsType = 'CONTAINS_TYPE',
300
+ /** The rule checks if the data type matches a specific input type. */
301
+ InputType = 'INPUT_TYPE',
302
+ /** The rule checks if an item is part of a collection in the data type. */
303
+ ItemOfCollection = 'ITEM_OF_COLLECTION',
304
+ /** The rule checks if a number falls within a specified range. */
305
+ NumberRange = 'NUMBER_RANGE',
306
+ /** The rule checks if the data type is a child of a specific parent type. */
307
+ ParentType = 'PARENT_TYPE',
308
+ /** The rule checks if a string matches a specified regular expression. */
309
+ Regex = 'REGEX',
310
+ /** The rule checks if the data type matches a specific return type. */
311
+ ReturnType = 'RETURN_TYPE'
312
+ }
313
+
128
314
  /** Represent all available types of a datatype */
129
315
  export enum DataTypeVariant {
130
316
  /** Represents an array */
131
317
  Array = 'ARRAY',
132
318
  /** Represents an data type containing a data type */
133
319
  DataType = 'DATA_TYPE',
320
+ /** Represents a error */
321
+ Error = 'ERROR',
322
+ /** Represents a node */
323
+ Node = 'NODE',
134
324
  /** Represents an object */
135
325
  Object = 'OBJECT',
136
326
  /** Represents a primitive datatype */
@@ -153,7 +343,7 @@ export interface EchoPayload {
153
343
  /** A unique identifier for the client performing the mutation. */
154
344
  clientMutationId?: Maybe<Scalars['String']['output']>;
155
345
  /** Errors encountered during execution of the mutation. */
156
- errors: Array<Error>;
346
+ errors?: Maybe<Array<Error>>;
157
347
  /** Message returned to the user. */
158
348
  message?: Maybe<Scalars['String']['output']>;
159
349
  }
@@ -161,17 +351,388 @@ export interface EchoPayload {
161
351
  /** Objects that can present an error */
162
352
  export type Error = ActiveModelError | MessageError;
163
353
 
354
+ /** Represents a flow */
355
+ export interface Flow {
356
+ __typename?: 'Flow';
357
+ /** Time when this Flow was created */
358
+ createdAt?: Maybe<Scalars['Time']['output']>;
359
+ /** Global ID of this Flow */
360
+ id?: Maybe<Scalars['FlowID']['output']>;
361
+ /** The input data type of the flow */
362
+ inputType?: Maybe<DataType>;
363
+ /** Nodes of the flow */
364
+ nodes?: Maybe<NodeFunctionConnection>;
365
+ /** The return data type of the flow */
366
+ returnType?: Maybe<DataType>;
367
+ /** The settings of the flow */
368
+ settings?: Maybe<Array<FlowSetting>>;
369
+ /** The ID of the starting node of the flow */
370
+ startingNodeId?: Maybe<Scalars['NodeFunctionID']['output']>;
371
+ /** The flow type of the flow */
372
+ type?: Maybe<FlowType>;
373
+ /** Time when this Flow was last updated */
374
+ updatedAt?: Maybe<Scalars['Time']['output']>;
375
+ }
376
+
377
+
378
+ /** Represents a flow */
379
+ export interface FlowNodesArgs {
380
+ after?: InputMaybe<Scalars['String']['input']>;
381
+ before?: InputMaybe<Scalars['String']['input']>;
382
+ first?: InputMaybe<Scalars['Int']['input']>;
383
+ last?: InputMaybe<Scalars['Int']['input']>;
384
+ }
385
+
386
+ /** The connection type for Flow. */
387
+ export interface FlowConnection {
388
+ __typename?: 'FlowConnection';
389
+ /** Total count of collection. */
390
+ count?: Maybe<Scalars['Int']['output']>;
391
+ /** A list of edges. */
392
+ edges?: Maybe<Array<Maybe<FlowEdge>>>;
393
+ /** A list of nodes. */
394
+ nodes?: Maybe<Array<Maybe<Flow>>>;
395
+ /** Information to aid in pagination. */
396
+ pageInfo?: Maybe<PageInfo>;
397
+ }
398
+
399
+ /** An edge in a connection. */
400
+ export interface FlowEdge {
401
+ __typename?: 'FlowEdge';
402
+ /** A cursor for use in pagination. */
403
+ cursor?: Maybe<Scalars['String']['output']>;
404
+ /** The item at the end of the edge. */
405
+ node?: Maybe<Flow>;
406
+ }
407
+
408
+ /** Input type for creating or updating a flow */
409
+ export interface FlowInput {
410
+ /** The settings of the flow */
411
+ settings?: InputMaybe<Array<FlowSettingInput>>;
412
+ /** The starting node of the flow */
413
+ startingNode: NodeFunctionInput;
414
+ /** The identifier of the flow type */
415
+ type: Scalars['FlowTypeID']['input'];
416
+ }
417
+
418
+ /** Represents a flow setting */
419
+ export interface FlowSetting {
420
+ __typename?: 'FlowSetting';
421
+ /** Time when this FlowSetting was created */
422
+ createdAt?: Maybe<Scalars['Time']['output']>;
423
+ /** The identifier of the flow setting */
424
+ flowSettingId?: Maybe<Scalars['String']['output']>;
425
+ /** Global ID of this FlowSetting */
426
+ id?: Maybe<Scalars['FlowSettingID']['output']>;
427
+ /** Time when this FlowSetting was last updated */
428
+ updatedAt?: Maybe<Scalars['Time']['output']>;
429
+ /** The value of the flow setting */
430
+ value?: Maybe<Scalars['JSON']['output']>;
431
+ }
432
+
433
+ /** Input type for flow settings */
434
+ export interface FlowSettingInput {
435
+ /** The identifier (not database id) of the flow setting */
436
+ flowSettingId: Scalars['String']['input'];
437
+ /** The value of the flow setting */
438
+ object: Scalars['JSON']['input'];
439
+ }
440
+
441
+ /** Represents a flow type */
442
+ export interface FlowType {
443
+ __typename?: 'FlowType';
444
+ /** Time when this FlowType was created */
445
+ createdAt?: Maybe<Scalars['Time']['output']>;
446
+ /** Descriptions of the flow type */
447
+ descriptions?: Maybe<TranslationConnection>;
448
+ /** Editable status of the flow type */
449
+ editable?: Maybe<Scalars['Boolean']['output']>;
450
+ /** Flow type settings of the flow type */
451
+ flowTypeSettings?: Maybe<Array<FlowTypeSetting>>;
452
+ /** Global ID of this FlowType */
453
+ id?: Maybe<Scalars['TypesFlowTypeID']['output']>;
454
+ /** Identifier of the flow type */
455
+ identifier?: Maybe<Scalars['String']['output']>;
456
+ /** Input type of the flow type */
457
+ inputType?: Maybe<DataType>;
458
+ /** Names of the flow type */
459
+ names?: Maybe<TranslationConnection>;
460
+ /** Return type of the flow type */
461
+ returnType?: Maybe<DataType>;
462
+ /** Time when this FlowType was last updated */
463
+ updatedAt?: Maybe<Scalars['Time']['output']>;
464
+ }
465
+
466
+
467
+ /** Represents a flow type */
468
+ export interface FlowTypeDescriptionsArgs {
469
+ after?: InputMaybe<Scalars['String']['input']>;
470
+ before?: InputMaybe<Scalars['String']['input']>;
471
+ first?: InputMaybe<Scalars['Int']['input']>;
472
+ last?: InputMaybe<Scalars['Int']['input']>;
473
+ }
474
+
475
+
476
+ /** Represents a flow type */
477
+ export interface FlowTypeNamesArgs {
478
+ after?: InputMaybe<Scalars['String']['input']>;
479
+ before?: InputMaybe<Scalars['String']['input']>;
480
+ first?: InputMaybe<Scalars['Int']['input']>;
481
+ last?: InputMaybe<Scalars['Int']['input']>;
482
+ }
483
+
484
+ /** The connection type for FlowType. */
485
+ export interface FlowTypeConnection {
486
+ __typename?: 'FlowTypeConnection';
487
+ /** Total count of collection. */
488
+ count?: Maybe<Scalars['Int']['output']>;
489
+ /** A list of edges. */
490
+ edges?: Maybe<Array<Maybe<FlowTypeEdge>>>;
491
+ /** A list of nodes. */
492
+ nodes?: Maybe<Array<Maybe<FlowType>>>;
493
+ /** Information to aid in pagination. */
494
+ pageInfo?: Maybe<PageInfo>;
495
+ }
496
+
497
+ /** An edge in a connection. */
498
+ export interface FlowTypeEdge {
499
+ __typename?: 'FlowTypeEdge';
500
+ /** A cursor for use in pagination. */
501
+ cursor?: Maybe<Scalars['String']['output']>;
502
+ /** The item at the end of the edge. */
503
+ node?: Maybe<FlowType>;
504
+ }
505
+
506
+ /** Represents a flow type setting */
507
+ export interface FlowTypeSetting {
508
+ __typename?: 'FlowTypeSetting';
509
+ /** Time when this FlowTypeSetting was created */
510
+ createdAt?: Maybe<Scalars['Time']['output']>;
511
+ /** Data type of the flow type setting */
512
+ dataType?: Maybe<DataType>;
513
+ /** Descriptions of the flow type setting */
514
+ descriptions?: Maybe<TranslationConnection>;
515
+ /** Flow type of the flow type setting */
516
+ flowType?: Maybe<FlowType>;
517
+ /** Global ID of this FlowTypeSetting */
518
+ id?: Maybe<Scalars['FlowTypeSettingID']['output']>;
519
+ /** Identifier of the flow type setting */
520
+ identifier?: Maybe<Scalars['String']['output']>;
521
+ /** Names of the flow type setting */
522
+ names?: Maybe<TranslationConnection>;
523
+ /** Unique status of the flow type setting */
524
+ unique?: Maybe<Scalars['Boolean']['output']>;
525
+ /** Time when this FlowTypeSetting was last updated */
526
+ updatedAt?: Maybe<Scalars['Time']['output']>;
527
+ }
528
+
529
+
530
+ /** Represents a flow type setting */
531
+ export interface FlowTypeSettingDescriptionsArgs {
532
+ after?: InputMaybe<Scalars['String']['input']>;
533
+ before?: InputMaybe<Scalars['String']['input']>;
534
+ first?: InputMaybe<Scalars['Int']['input']>;
535
+ last?: InputMaybe<Scalars['Int']['input']>;
536
+ }
537
+
538
+
539
+ /** Represents a flow type setting */
540
+ export interface FlowTypeSettingNamesArgs {
541
+ after?: InputMaybe<Scalars['String']['input']>;
542
+ before?: InputMaybe<Scalars['String']['input']>;
543
+ first?: InputMaybe<Scalars['Int']['input']>;
544
+ last?: InputMaybe<Scalars['Int']['input']>;
545
+ }
546
+
547
+ /** Represents a function definition */
548
+ export interface FunctionDefinition {
549
+ __typename?: 'FunctionDefinition';
550
+ /** Time when this FunctionDefinition was created */
551
+ createdAt?: Maybe<Scalars['Time']['output']>;
552
+ /** Deprecation message of the function */
553
+ deprecationMessages?: Maybe<TranslationConnection>;
554
+ /** Description of the function */
555
+ descriptions?: Maybe<TranslationConnection>;
556
+ /** Documentation of the function */
557
+ documentations?: Maybe<TranslationConnection>;
558
+ /** Generic keys of the function */
559
+ genericKeys?: Maybe<Array<Scalars['String']['output']>>;
560
+ /** Global ID of this FunctionDefinition */
561
+ id?: Maybe<Scalars['FunctionDefinitionID']['output']>;
562
+ /** Name of the function */
563
+ names?: Maybe<TranslationConnection>;
564
+ /** Parameters of the function */
565
+ parameterDefinitions?: Maybe<ParameterDefinitionConnection>;
566
+ /** Return type of the function */
567
+ returnType?: Maybe<DataTypeIdentifier>;
568
+ /** Runtime function definition */
569
+ runtimeFunctionDefinition?: Maybe<RuntimeFunctionDefinition>;
570
+ /** Indicates if the function can throw an error */
571
+ throwsError?: Maybe<Scalars['Boolean']['output']>;
572
+ /** Time when this FunctionDefinition was last updated */
573
+ updatedAt?: Maybe<Scalars['Time']['output']>;
574
+ }
575
+
576
+
577
+ /** Represents a function definition */
578
+ export interface FunctionDefinitionDeprecationMessagesArgs {
579
+ after?: InputMaybe<Scalars['String']['input']>;
580
+ before?: InputMaybe<Scalars['String']['input']>;
581
+ first?: InputMaybe<Scalars['Int']['input']>;
582
+ last?: InputMaybe<Scalars['Int']['input']>;
583
+ }
584
+
585
+
586
+ /** Represents a function definition */
587
+ export interface FunctionDefinitionDescriptionsArgs {
588
+ after?: InputMaybe<Scalars['String']['input']>;
589
+ before?: InputMaybe<Scalars['String']['input']>;
590
+ first?: InputMaybe<Scalars['Int']['input']>;
591
+ last?: InputMaybe<Scalars['Int']['input']>;
592
+ }
593
+
594
+
595
+ /** Represents a function definition */
596
+ export interface FunctionDefinitionDocumentationsArgs {
597
+ after?: InputMaybe<Scalars['String']['input']>;
598
+ before?: InputMaybe<Scalars['String']['input']>;
599
+ first?: InputMaybe<Scalars['Int']['input']>;
600
+ last?: InputMaybe<Scalars['Int']['input']>;
601
+ }
602
+
603
+
604
+ /** Represents a function definition */
605
+ export interface FunctionDefinitionNamesArgs {
606
+ after?: InputMaybe<Scalars['String']['input']>;
607
+ before?: InputMaybe<Scalars['String']['input']>;
608
+ first?: InputMaybe<Scalars['Int']['input']>;
609
+ last?: InputMaybe<Scalars['Int']['input']>;
610
+ }
611
+
612
+
613
+ /** Represents a function definition */
614
+ export interface FunctionDefinitionParameterDefinitionsArgs {
615
+ after?: InputMaybe<Scalars['String']['input']>;
616
+ before?: InputMaybe<Scalars['String']['input']>;
617
+ first?: InputMaybe<Scalars['Int']['input']>;
618
+ last?: InputMaybe<Scalars['Int']['input']>;
619
+ }
620
+
621
+ /** The connection type for FunctionDefinition. */
622
+ export interface FunctionDefinitionConnection {
623
+ __typename?: 'FunctionDefinitionConnection';
624
+ /** Total count of collection. */
625
+ count?: Maybe<Scalars['Int']['output']>;
626
+ /** A list of edges. */
627
+ edges?: Maybe<Array<Maybe<FunctionDefinitionEdge>>>;
628
+ /** A list of nodes. */
629
+ nodes?: Maybe<Array<Maybe<FunctionDefinition>>>;
630
+ /** Information to aid in pagination. */
631
+ pageInfo?: Maybe<PageInfo>;
632
+ }
633
+
634
+ /** An edge in a connection. */
635
+ export interface FunctionDefinitionEdge {
636
+ __typename?: 'FunctionDefinitionEdge';
637
+ /** A cursor for use in pagination. */
638
+ cursor?: Maybe<Scalars['String']['output']>;
639
+ /** The item at the end of the edge. */
640
+ node?: Maybe<FunctionDefinition>;
641
+ }
642
+
643
+ /** Represents a combination strategy with AND/OR logic used by a generic mapper. */
644
+ export interface GenericCombinationStrategy {
645
+ __typename?: 'GenericCombinationStrategy';
646
+ /** Time when this GenericCombinationStrategy was created */
647
+ createdAt?: Maybe<Scalars['Time']['output']>;
648
+ /** The associated generic mapper, if any. */
649
+ genericMapper?: Maybe<GenericMapper>;
650
+ /** Global ID of this GenericCombinationStrategy */
651
+ id?: Maybe<Scalars['GenericCombinationStrategyID']['output']>;
652
+ /** The combination type ('AND' or 'OR'). */
653
+ type?: Maybe<GenericCombinationStrategyType>;
654
+ /** Time when this GenericCombinationStrategy was last updated */
655
+ updatedAt?: Maybe<Scalars['Time']['output']>;
656
+ }
657
+
658
+ /** The available combination strategy types. */
659
+ export enum GenericCombinationStrategyType {
660
+ /** Represents a logical AND combination. */
661
+ And = 'AND',
662
+ /** Represents a logical OR combination. */
663
+ Or = 'OR'
664
+ }
665
+
666
+ /** Represents a mapping between a source data type and a target key for generic values. */
667
+ export interface GenericMapper {
668
+ __typename?: 'GenericMapper';
669
+ /** Time when this GenericMapper was created */
670
+ createdAt?: Maybe<Scalars['Time']['output']>;
671
+ /** Combination strategies associated with this generic mapper. */
672
+ genericCombinationStrategies?: Maybe<Array<GenericCombinationStrategy>>;
673
+ /** Global ID of this GenericMapper */
674
+ id?: Maybe<Scalars['GenericMapperID']['output']>;
675
+ /** The source data type identifier. */
676
+ sources?: Maybe<Array<DataTypeIdentifier>>;
677
+ /** The target key for the generic value. */
678
+ target?: Maybe<Scalars['String']['output']>;
679
+ /** Time when this GenericMapper was last updated */
680
+ updatedAt?: Maybe<Scalars['Time']['output']>;
681
+ }
682
+
683
+ /** Input type for generic mappers */
684
+ export interface GenericMapperInput {
685
+ /** The source data type identifier for the mapper */
686
+ sources: Array<DataTypeIdentifierInput>;
687
+ /** The target data type identifier for the mapper */
688
+ target: Scalars['String']['input'];
689
+ }
690
+
691
+ /** Represents a generic type that can be used in various contexts. */
692
+ export interface GenericType {
693
+ __typename?: 'GenericType';
694
+ /** Time when this GenericType was created */
695
+ createdAt?: Maybe<Scalars['Time']['output']>;
696
+ /** The data type associated with this generic type. */
697
+ dataType?: Maybe<DataType>;
698
+ /** The mappers associated with this generic type. */
699
+ genericMappers?: Maybe<Array<GenericMapper>>;
700
+ /** Global ID of this GenericType */
701
+ id?: Maybe<Scalars['GenericTypeID']['output']>;
702
+ /** Time when this GenericType was last updated */
703
+ updatedAt?: Maybe<Scalars['Time']['output']>;
704
+ }
705
+
706
+ /** Input type for generic type operations. */
707
+ export interface GenericTypeInput {
708
+ /** The data type associated with this generic type. */
709
+ dataTypeId: Scalars['DataTypeID']['input'];
710
+ /** The mappers associated with this generic type. */
711
+ genericMappers: Array<GenericMapperInput>;
712
+ }
713
+
164
714
  /** Represents the input for external user identity validation */
165
715
  export interface IdentityInput {
166
716
  /** This validation code will be used for the oAuth validation process */
167
717
  code?: InputMaybe<Scalars['String']['input']>;
168
718
  }
169
719
 
720
+ /** Represents a literal value, such as a string or number. */
721
+ export interface LiteralValue {
722
+ __typename?: 'LiteralValue';
723
+ /** Time when this LiteralValue was created */
724
+ createdAt?: Maybe<Scalars['Time']['output']>;
725
+ /** Time when this LiteralValue was last updated */
726
+ updatedAt?: Maybe<Scalars['Time']['output']>;
727
+ /** The literal value itself as JSON. */
728
+ value?: Maybe<Scalars['JSON']['output']>;
729
+ }
730
+
170
731
  /** Represents an error message */
171
732
  export interface MessageError {
172
733
  __typename?: 'MessageError';
173
734
  /** The message provided from the error */
174
- message: Scalars['String']['output'];
735
+ message?: Maybe<Scalars['String']['output']>;
175
736
  }
176
737
 
177
738
  /** Represents the input for mfa authentication */
@@ -200,6 +761,7 @@ export interface Mutation {
200
761
  *
201
762
  * This is expected to be used for testing of endpoints, to verify
202
763
  * that a user has mutation access.
764
+ *
203
765
  */
204
766
  echo?: Maybe<EchoPayload>;
205
767
  /** Create a new namespace license. */
@@ -212,10 +774,16 @@ export interface Mutation {
212
774
  namespacesMembersDelete?: Maybe<NamespacesMembersDeletePayload>;
213
775
  /** Invite a new member to a namespace. */
214
776
  namespacesMembersInvite?: Maybe<NamespacesMembersInvitePayload>;
777
+ /** Assign runtimes to a project */
778
+ namespacesProjectsAssignRuntimes?: Maybe<NamespacesProjectsAssignRuntimesPayload>;
215
779
  /** Creates a new namespace project. */
216
780
  namespacesProjectsCreate?: Maybe<NamespacesProjectsCreatePayload>;
217
781
  /** Deletes a namespace project. */
218
782
  namespacesProjectsDelete?: Maybe<NamespacesProjectsDeletePayload>;
783
+ /** Creates a new flow. */
784
+ namespacesProjectsFlowsCreate?: Maybe<NamespacesProjectsFlowsCreatePayload>;
785
+ /** Deletes a namespace project. */
786
+ namespacesProjectsFlowsDelete?: Maybe<NamespacesProjectsFlowsDeletePayload>;
219
787
  /** Updates a namespace project. */
220
788
  namespacesProjectsUpdate?: Maybe<NamespacesProjectsUpdatePayload>;
221
789
  /** Update the abilities a role is granted. */
@@ -242,6 +810,8 @@ export interface Mutation {
242
810
  runtimesRotateToken?: Maybe<RuntimesRotateTokenPayload>;
243
811
  /** Update an existing runtime. */
244
812
  runtimesUpdate?: Maybe<RuntimesUpdatePayload>;
813
+ /** Verify your email when changing it or signing up */
814
+ usersEmailVerification?: Maybe<UsersEmailVerificationPayload>;
245
815
  /** Links an external identity to an existing user */
246
816
  usersIdentityLink?: Maybe<UsersIdentityLinkPayload>;
247
817
  /** Login to an existing user via an external identity */
@@ -309,6 +879,12 @@ export interface MutationNamespacesMembersInviteArgs {
309
879
  }
310
880
 
311
881
 
882
+ /** Root Mutation type */
883
+ export interface MutationNamespacesProjectsAssignRuntimesArgs {
884
+ input: NamespacesProjectsAssignRuntimesInput;
885
+ }
886
+
887
+
312
888
  /** Root Mutation type */
313
889
  export interface MutationNamespacesProjectsCreateArgs {
314
890
  input: NamespacesProjectsCreateInput;
@@ -321,6 +897,18 @@ export interface MutationNamespacesProjectsDeleteArgs {
321
897
  }
322
898
 
323
899
 
900
+ /** Root Mutation type */
901
+ export interface MutationNamespacesProjectsFlowsCreateArgs {
902
+ input: NamespacesProjectsFlowsCreateInput;
903
+ }
904
+
905
+
906
+ /** Root Mutation type */
907
+ export interface MutationNamespacesProjectsFlowsDeleteArgs {
908
+ input: NamespacesProjectsFlowsDeleteInput;
909
+ }
910
+
911
+
324
912
  /** Root Mutation type */
325
913
  export interface MutationNamespacesProjectsUpdateArgs {
326
914
  input: NamespacesProjectsUpdateInput;
@@ -399,6 +987,12 @@ export interface MutationRuntimesUpdateArgs {
399
987
  }
400
988
 
401
989
 
990
+ /** Root Mutation type */
991
+ export interface MutationUsersEmailVerificationArgs {
992
+ input: UsersEmailVerificationInput;
993
+ }
994
+
995
+
402
996
  /** Root Mutation type */
403
997
  export interface MutationUsersIdentityLinkArgs {
404
998
  input: UsersIdentityLinkInput;
@@ -468,23 +1062,23 @@ export interface MutationUsersUpdateArgs {
468
1062
  export interface Namespace {
469
1063
  __typename?: 'Namespace';
470
1064
  /** Time when this Namespace was created */
471
- createdAt: Scalars['Time']['output'];
1065
+ createdAt?: Maybe<Scalars['Time']['output']>;
472
1066
  /** Global ID of this Namespace */
473
- id: Scalars['NamespaceID']['output'];
1067
+ id?: Maybe<Scalars['NamespaceID']['output']>;
474
1068
  /** Members of the namespace */
475
- members: NamespaceMemberConnection;
1069
+ members?: Maybe<NamespaceMemberConnection>;
476
1070
  /** Licenses of the namespace */
477
- namespaceLicenses: NamespaceLicenseConnection;
1071
+ namespaceLicenses?: Maybe<NamespaceLicenseConnection>;
478
1072
  /** Parent of this namespace */
479
- parent: NamespaceParent;
1073
+ parent?: Maybe<NamespaceParent>;
480
1074
  /** Projects of the namespace */
481
- projects: NamespaceProjectConnection;
1075
+ projects?: Maybe<NamespaceProjectConnection>;
482
1076
  /** Roles of the namespace */
483
- roles: NamespaceRoleConnection;
1077
+ roles?: Maybe<NamespaceRoleConnection>;
484
1078
  /** Runtime of the namespace */
485
- runtimes: RuntimeConnection;
1079
+ runtimes?: Maybe<RuntimeConnection>;
486
1080
  /** Time when this Namespace was last updated */
487
- updatedAt: Scalars['Time']['output'];
1081
+ updatedAt?: Maybe<Scalars['Time']['output']>;
488
1082
  }
489
1083
 
490
1084
 
@@ -536,33 +1130,33 @@ export interface NamespaceRuntimesArgs {
536
1130
  export interface NamespaceLicense {
537
1131
  __typename?: 'NamespaceLicense';
538
1132
  /** Time when this NamespaceLicense was created */
539
- createdAt: Scalars['Time']['output'];
1133
+ createdAt?: Maybe<Scalars['Time']['output']>;
540
1134
  /** Global ID of this NamespaceLicense */
541
- id: Scalars['NamespaceLicenseID']['output'];
1135
+ id?: Maybe<Scalars['NamespaceLicenseID']['output']>;
542
1136
  /** The namespace the license belongs to */
543
- namespace: Namespace;
1137
+ namespace?: Maybe<Namespace>;
544
1138
  /** Time when this NamespaceLicense was last updated */
545
- updatedAt: Scalars['Time']['output'];
1139
+ updatedAt?: Maybe<Scalars['Time']['output']>;
546
1140
  }
547
1141
 
548
1142
  /** The connection type for NamespaceLicense. */
549
1143
  export interface NamespaceLicenseConnection {
550
1144
  __typename?: 'NamespaceLicenseConnection';
551
1145
  /** Total count of collection. */
552
- count: Scalars['Int']['output'];
1146
+ count?: Maybe<Scalars['Int']['output']>;
553
1147
  /** A list of edges. */
554
1148
  edges?: Maybe<Array<Maybe<NamespaceLicenseEdge>>>;
555
1149
  /** A list of nodes. */
556
1150
  nodes?: Maybe<Array<Maybe<NamespaceLicense>>>;
557
1151
  /** Information to aid in pagination. */
558
- pageInfo: PageInfo;
1152
+ pageInfo?: Maybe<PageInfo>;
559
1153
  }
560
1154
 
561
1155
  /** An edge in a connection. */
562
1156
  export interface NamespaceLicenseEdge {
563
1157
  __typename?: 'NamespaceLicenseEdge';
564
1158
  /** A cursor for use in pagination. */
565
- cursor: Scalars['String']['output'];
1159
+ cursor?: Maybe<Scalars['String']['output']>;
566
1160
  /** The item at the end of the edge. */
567
1161
  node?: Maybe<NamespaceLicense>;
568
1162
  }
@@ -571,35 +1165,35 @@ export interface NamespaceLicenseEdge {
571
1165
  export interface NamespaceMember {
572
1166
  __typename?: 'NamespaceMember';
573
1167
  /** Time when this NamespaceMember was created */
574
- createdAt: Scalars['Time']['output'];
1168
+ createdAt?: Maybe<Scalars['Time']['output']>;
575
1169
  /** Global ID of this NamespaceMember */
576
- id: Scalars['NamespaceMemberID']['output'];
1170
+ id?: Maybe<Scalars['NamespaceMemberID']['output']>;
577
1171
  /** Namespace this member belongs to */
578
- namespace: Namespace;
1172
+ namespace?: Maybe<Namespace>;
579
1173
  /** Time when this NamespaceMember was last updated */
580
- updatedAt: Scalars['Time']['output'];
1174
+ updatedAt?: Maybe<Scalars['Time']['output']>;
581
1175
  /** User this member belongs to */
582
- user: User;
1176
+ user?: Maybe<User>;
583
1177
  }
584
1178
 
585
1179
  /** The connection type for NamespaceMember. */
586
1180
  export interface NamespaceMemberConnection {
587
1181
  __typename?: 'NamespaceMemberConnection';
588
1182
  /** Total count of collection. */
589
- count: Scalars['Int']['output'];
1183
+ count?: Maybe<Scalars['Int']['output']>;
590
1184
  /** A list of edges. */
591
1185
  edges?: Maybe<Array<Maybe<NamespaceMemberEdge>>>;
592
1186
  /** A list of nodes. */
593
1187
  nodes?: Maybe<Array<Maybe<NamespaceMember>>>;
594
1188
  /** Information to aid in pagination. */
595
- pageInfo: PageInfo;
1189
+ pageInfo?: Maybe<PageInfo>;
596
1190
  }
597
1191
 
598
1192
  /** An edge in a connection. */
599
1193
  export interface NamespaceMemberEdge {
600
1194
  __typename?: 'NamespaceMemberEdge';
601
1195
  /** A cursor for use in pagination. */
602
- cursor: Scalars['String']['output'];
1196
+ cursor?: Maybe<Scalars['String']['output']>;
603
1197
  /** The item at the end of the edge. */
604
1198
  node?: Maybe<NamespaceMember>;
605
1199
  }
@@ -608,15 +1202,15 @@ export interface NamespaceMemberEdge {
608
1202
  export interface NamespaceMemberRole {
609
1203
  __typename?: 'NamespaceMemberRole';
610
1204
  /** Time when this NamespaceMemberRole was created */
611
- createdAt: Scalars['Time']['output'];
1205
+ createdAt?: Maybe<Scalars['Time']['output']>;
612
1206
  /** Global ID of this NamespaceMemberRole */
613
- id: Scalars['NamespaceMemberRoleID']['output'];
1207
+ id?: Maybe<Scalars['NamespaceMemberRoleID']['output']>;
614
1208
  /** The member the role is assigned to */
615
1209
  member?: Maybe<NamespaceMember>;
616
1210
  /** The assigned role */
617
1211
  role?: Maybe<NamespaceRole>;
618
1212
  /** Time when this NamespaceMemberRole was last updated */
619
- updatedAt: Scalars['Time']['output'];
1213
+ updatedAt?: Maybe<Scalars['Time']['output']>;
620
1214
  }
621
1215
 
622
1216
  /** Objects that can present a namespace */
@@ -626,37 +1220,69 @@ export type NamespaceParent = Organization;
626
1220
  export interface NamespaceProject {
627
1221
  __typename?: 'NamespaceProject';
628
1222
  /** Time when this NamespaceProject was created */
629
- createdAt: Scalars['Time']['output'];
1223
+ createdAt?: Maybe<Scalars['Time']['output']>;
630
1224
  /** Description of the project */
631
- description: Scalars['String']['output'];
1225
+ description?: Maybe<Scalars['String']['output']>;
1226
+ /** Fetches an flow given by its ID */
1227
+ flow?: Maybe<Flow>;
1228
+ /** Fetches all flows in this project */
1229
+ flows?: Maybe<FlowConnection>;
632
1230
  /** Global ID of this NamespaceProject */
633
- id: Scalars['NamespaceProjectID']['output'];
1231
+ id?: Maybe<Scalars['NamespaceProjectID']['output']>;
634
1232
  /** Name of the project */
635
- name: Scalars['String']['output'];
1233
+ name?: Maybe<Scalars['String']['output']>;
636
1234
  /** The namespace where this project belongs to */
637
- namespace: Namespace;
1235
+ namespace?: Maybe<Namespace>;
1236
+ /** The primary runtime for the project */
1237
+ primaryRuntime?: Maybe<Runtime>;
1238
+ /** Runtimes assigned to this project */
1239
+ runtimes?: Maybe<RuntimeConnection>;
638
1240
  /** Time when this NamespaceProject was last updated */
639
- updatedAt: Scalars['Time']['output'];
1241
+ updatedAt?: Maybe<Scalars['Time']['output']>;
1242
+ }
1243
+
1244
+
1245
+ /** Represents a namespace project */
1246
+ export interface NamespaceProjectFlowArgs {
1247
+ id: Scalars['FlowID']['input'];
1248
+ }
1249
+
1250
+
1251
+ /** Represents a namespace project */
1252
+ export interface NamespaceProjectFlowsArgs {
1253
+ after?: InputMaybe<Scalars['String']['input']>;
1254
+ before?: InputMaybe<Scalars['String']['input']>;
1255
+ first?: InputMaybe<Scalars['Int']['input']>;
1256
+ last?: InputMaybe<Scalars['Int']['input']>;
1257
+ }
1258
+
1259
+
1260
+ /** Represents a namespace project */
1261
+ export interface NamespaceProjectRuntimesArgs {
1262
+ after?: InputMaybe<Scalars['String']['input']>;
1263
+ before?: InputMaybe<Scalars['String']['input']>;
1264
+ first?: InputMaybe<Scalars['Int']['input']>;
1265
+ last?: InputMaybe<Scalars['Int']['input']>;
640
1266
  }
641
1267
 
642
1268
  /** The connection type for NamespaceProject. */
643
1269
  export interface NamespaceProjectConnection {
644
1270
  __typename?: 'NamespaceProjectConnection';
645
1271
  /** Total count of collection. */
646
- count: Scalars['Int']['output'];
1272
+ count?: Maybe<Scalars['Int']['output']>;
647
1273
  /** A list of edges. */
648
1274
  edges?: Maybe<Array<Maybe<NamespaceProjectEdge>>>;
649
1275
  /** A list of nodes. */
650
1276
  nodes?: Maybe<Array<Maybe<NamespaceProject>>>;
651
1277
  /** Information to aid in pagination. */
652
- pageInfo: PageInfo;
1278
+ pageInfo?: Maybe<PageInfo>;
653
1279
  }
654
1280
 
655
1281
  /** An edge in a connection. */
656
1282
  export interface NamespaceProjectEdge {
657
1283
  __typename?: 'NamespaceProjectEdge';
658
1284
  /** A cursor for use in pagination. */
659
- cursor: Scalars['String']['output'];
1285
+ cursor?: Maybe<Scalars['String']['output']>;
660
1286
  /** The item at the end of the edge. */
661
1287
  node?: Maybe<NamespaceProject>;
662
1288
  }
@@ -665,19 +1291,19 @@ export interface NamespaceProjectEdge {
665
1291
  export interface NamespaceRole {
666
1292
  __typename?: 'NamespaceRole';
667
1293
  /** The abilities the role is granted */
668
- abilities: Array<NamespaceRoleAbility>;
1294
+ abilities?: Maybe<Array<NamespaceRoleAbility>>;
669
1295
  /** The projects this role is assigned to */
670
1296
  assignedProjects?: Maybe<NamespaceProjectConnection>;
671
1297
  /** Time when this NamespaceRole was created */
672
- createdAt: Scalars['Time']['output'];
1298
+ createdAt?: Maybe<Scalars['Time']['output']>;
673
1299
  /** Global ID of this NamespaceRole */
674
- id: Scalars['NamespaceRoleID']['output'];
1300
+ id?: Maybe<Scalars['NamespaceRoleID']['output']>;
675
1301
  /** The name of this role */
676
- name: Scalars['String']['output'];
1302
+ name?: Maybe<Scalars['String']['output']>;
677
1303
  /** The namespace where this role belongs to */
678
1304
  namespace?: Maybe<Namespace>;
679
1305
  /** Time when this NamespaceRole was last updated */
680
- updatedAt: Scalars['Time']['output'];
1306
+ updatedAt?: Maybe<Scalars['Time']['output']>;
681
1307
  }
682
1308
 
683
1309
 
@@ -693,10 +1319,14 @@ export interface NamespaceRoleAssignedProjectsArgs {
693
1319
  export enum NamespaceRoleAbility {
694
1320
  /** Allows to change the roles of a namespace member */
695
1321
  AssignMemberRoles = 'ASSIGN_MEMBER_ROLES',
1322
+ /** Allows to assign runtimes to a project in the namespace */
1323
+ AssignProjectRuntimes = 'ASSIGN_PROJECT_RUNTIMES',
696
1324
  /** Allows to change the abilities of a namespace role */
697
1325
  AssignRoleAbilities = 'ASSIGN_ROLE_ABILITIES',
698
1326
  /** Allows to change the assigned projects of a namespace role */
699
1327
  AssignRoleProjects = 'ASSIGN_ROLE_PROJECTS',
1328
+ /** Allows to create flows in a namespace project */
1329
+ CreateFlows = 'CREATE_FLOWS',
700
1330
  /** Allows to create a license for the namespace */
701
1331
  CreateNamespaceLicense = 'CREATE_NAMESPACE_LICENSE',
702
1332
  /** Allows to create a project in the namespace */
@@ -705,6 +1335,8 @@ export enum NamespaceRoleAbility {
705
1335
  CreateNamespaceRole = 'CREATE_NAMESPACE_ROLE',
706
1336
  /** Allows to create a runtime globally or for the namespace */
707
1337
  CreateRuntime = 'CREATE_RUNTIME',
1338
+ /** Allows to delete flows in a namespace project */
1339
+ DeleteFlows = 'DELETE_FLOWS',
708
1340
  /** Allows to remove members of a namespace */
709
1341
  DeleteMember = 'DELETE_MEMBER',
710
1342
  /** Allows to delete the license of the namespace */
@@ -727,6 +1359,8 @@ export enum NamespaceRoleAbility {
727
1359
  ReadNamespaceProject = 'READ_NAMESPACE_PROJECT',
728
1360
  /** Allows to regenerate a runtime token */
729
1361
  RotateRuntimeToken = 'ROTATE_RUNTIME_TOKEN',
1362
+ /** Allows to update flows in the project */
1363
+ UpdateFlows = 'UPDATE_FLOWS',
730
1364
  /** Allows to update the project of the namespace */
731
1365
  UpdateNamespaceProject = 'UPDATE_NAMESPACE_PROJECT',
732
1366
  /** Allows to update the namespace role */
@@ -741,20 +1375,20 @@ export enum NamespaceRoleAbility {
741
1375
  export interface NamespaceRoleConnection {
742
1376
  __typename?: 'NamespaceRoleConnection';
743
1377
  /** Total count of collection. */
744
- count: Scalars['Int']['output'];
1378
+ count?: Maybe<Scalars['Int']['output']>;
745
1379
  /** A list of edges. */
746
1380
  edges?: Maybe<Array<Maybe<NamespaceRoleEdge>>>;
747
1381
  /** A list of nodes. */
748
1382
  nodes?: Maybe<Array<Maybe<NamespaceRole>>>;
749
1383
  /** Information to aid in pagination. */
750
- pageInfo: PageInfo;
1384
+ pageInfo?: Maybe<PageInfo>;
751
1385
  }
752
1386
 
753
1387
  /** An edge in a connection. */
754
1388
  export interface NamespaceRoleEdge {
755
1389
  __typename?: 'NamespaceRoleEdge';
756
1390
  /** A cursor for use in pagination. */
757
- cursor: Scalars['String']['output'];
1391
+ cursor?: Maybe<Scalars['String']['output']>;
758
1392
  /** The item at the end of the edge. */
759
1393
  node?: Maybe<NamespaceRole>;
760
1394
  }
@@ -775,7 +1409,7 @@ export interface NamespacesLicensesCreatePayload {
775
1409
  /** A unique identifier for the client performing the mutation. */
776
1410
  clientMutationId?: Maybe<Scalars['String']['output']>;
777
1411
  /** Errors encountered during execution of the mutation. */
778
- errors: Array<Error>;
1412
+ errors?: Maybe<Array<Error>>;
779
1413
  /** The newly created license. */
780
1414
  namespaceLicense?: Maybe<NamespaceLicense>;
781
1415
  }
@@ -794,7 +1428,7 @@ export interface NamespacesLicensesDeletePayload {
794
1428
  /** A unique identifier for the client performing the mutation. */
795
1429
  clientMutationId?: Maybe<Scalars['String']['output']>;
796
1430
  /** Errors encountered during execution of the mutation. */
797
- errors: Array<Error>;
1431
+ errors?: Maybe<Array<Error>>;
798
1432
  /** The deleted namespace license. */
799
1433
  namespaceLicense?: Maybe<NamespaceLicense>;
800
1434
  }
@@ -815,7 +1449,7 @@ export interface NamespacesMembersAssignRolesPayload {
815
1449
  /** A unique identifier for the client performing the mutation. */
816
1450
  clientMutationId?: Maybe<Scalars['String']['output']>;
817
1451
  /** Errors encountered during execution of the mutation. */
818
- errors: Array<Error>;
1452
+ errors?: Maybe<Array<Error>>;
819
1453
  /** The roles the member is now assigned to */
820
1454
  namespaceMemberRoles?: Maybe<Array<NamespaceMemberRole>>;
821
1455
  }
@@ -834,7 +1468,7 @@ export interface NamespacesMembersDeletePayload {
834
1468
  /** A unique identifier for the client performing the mutation. */
835
1469
  clientMutationId?: Maybe<Scalars['String']['output']>;
836
1470
  /** Errors encountered during execution of the mutation. */
837
- errors: Array<Error>;
1471
+ errors?: Maybe<Array<Error>>;
838
1472
  /** The removed namespace member */
839
1473
  namespaceMember?: Maybe<NamespaceMember>;
840
1474
  }
@@ -855,11 +1489,32 @@ export interface NamespacesMembersInvitePayload {
855
1489
  /** A unique identifier for the client performing the mutation. */
856
1490
  clientMutationId?: Maybe<Scalars['String']['output']>;
857
1491
  /** Errors encountered during execution of the mutation. */
858
- errors: Array<Error>;
1492
+ errors?: Maybe<Array<Error>>;
859
1493
  /** The newly created namespace member */
860
1494
  namespaceMember?: Maybe<NamespaceMember>;
861
1495
  }
862
1496
 
1497
+ /** Autogenerated input type of NamespacesProjectsAssignRuntimes */
1498
+ export interface NamespacesProjectsAssignRuntimesInput {
1499
+ /** A unique identifier for the client performing the mutation. */
1500
+ clientMutationId?: InputMaybe<Scalars['String']['input']>;
1501
+ /** ID of the project to assign runtimes to */
1502
+ namespaceProjectId: Scalars['NamespaceProjectID']['input'];
1503
+ /** The new runtimes assigned to the project */
1504
+ runtimeIds: Array<Scalars['RuntimeID']['input']>;
1505
+ }
1506
+
1507
+ /** Autogenerated return type of NamespacesProjectsAssignRuntimes. */
1508
+ export interface NamespacesProjectsAssignRuntimesPayload {
1509
+ __typename?: 'NamespacesProjectsAssignRuntimesPayload';
1510
+ /** A unique identifier for the client performing the mutation. */
1511
+ clientMutationId?: Maybe<Scalars['String']['output']>;
1512
+ /** Errors encountered during execution of the mutation. */
1513
+ errors?: Maybe<Array<Error>>;
1514
+ /** The updated project with assigned runtimes */
1515
+ namespaceProject?: Maybe<NamespaceProject>;
1516
+ }
1517
+
863
1518
  /** Autogenerated input type of NamespacesProjectsCreate */
864
1519
  export interface NamespacesProjectsCreateInput {
865
1520
  /** A unique identifier for the client performing the mutation. */
@@ -878,7 +1533,7 @@ export interface NamespacesProjectsCreatePayload {
878
1533
  /** A unique identifier for the client performing the mutation. */
879
1534
  clientMutationId?: Maybe<Scalars['String']['output']>;
880
1535
  /** Errors encountered during execution of the mutation. */
881
- errors: Array<Error>;
1536
+ errors?: Maybe<Array<Error>>;
882
1537
  /** The newly created project. */
883
1538
  namespaceProject?: Maybe<NamespaceProject>;
884
1539
  }
@@ -897,11 +1552,51 @@ export interface NamespacesProjectsDeletePayload {
897
1552
  /** A unique identifier for the client performing the mutation. */
898
1553
  clientMutationId?: Maybe<Scalars['String']['output']>;
899
1554
  /** Errors encountered during execution of the mutation. */
900
- errors: Array<Error>;
1555
+ errors?: Maybe<Array<Error>>;
901
1556
  /** The deleted project. */
902
1557
  namespaceProject?: Maybe<NamespaceProject>;
903
1558
  }
904
1559
 
1560
+ /** Autogenerated input type of NamespacesProjectsFlowsCreate */
1561
+ export interface NamespacesProjectsFlowsCreateInput {
1562
+ /** A unique identifier for the client performing the mutation. */
1563
+ clientMutationId?: InputMaybe<Scalars['String']['input']>;
1564
+ /** The flow to create */
1565
+ flow: FlowInput;
1566
+ /** The ID of the project to which the flow belongs to */
1567
+ projectId: Scalars['NamespaceProjectID']['input'];
1568
+ }
1569
+
1570
+ /** Autogenerated return type of NamespacesProjectsFlowsCreate. */
1571
+ export interface NamespacesProjectsFlowsCreatePayload {
1572
+ __typename?: 'NamespacesProjectsFlowsCreatePayload';
1573
+ /** A unique identifier for the client performing the mutation. */
1574
+ clientMutationId?: Maybe<Scalars['String']['output']>;
1575
+ /** Errors encountered during execution of the mutation. */
1576
+ errors?: Maybe<Array<Error>>;
1577
+ /** The newly created flow. */
1578
+ flow?: Maybe<Flow>;
1579
+ }
1580
+
1581
+ /** Autogenerated input type of NamespacesProjectsFlowsDelete */
1582
+ export interface NamespacesProjectsFlowsDeleteInput {
1583
+ /** A unique identifier for the client performing the mutation. */
1584
+ clientMutationId?: InputMaybe<Scalars['String']['input']>;
1585
+ /** The id of the flow which will be deleted */
1586
+ flowId: Scalars['FlowID']['input'];
1587
+ }
1588
+
1589
+ /** Autogenerated return type of NamespacesProjectsFlowsDelete. */
1590
+ export interface NamespacesProjectsFlowsDeletePayload {
1591
+ __typename?: 'NamespacesProjectsFlowsDeletePayload';
1592
+ /** A unique identifier for the client performing the mutation. */
1593
+ clientMutationId?: Maybe<Scalars['String']['output']>;
1594
+ /** Errors encountered during execution of the mutation. */
1595
+ errors?: Maybe<Array<Error>>;
1596
+ /** The deleted flow. */
1597
+ flow?: Maybe<Flow>;
1598
+ }
1599
+
905
1600
  /** Autogenerated input type of NamespacesProjectsUpdate */
906
1601
  export interface NamespacesProjectsUpdateInput {
907
1602
  /** A unique identifier for the client performing the mutation. */
@@ -912,6 +1607,8 @@ export interface NamespacesProjectsUpdateInput {
912
1607
  name?: InputMaybe<Scalars['String']['input']>;
913
1608
  /** The id of the namespace project which will be updated */
914
1609
  namespaceProjectId: Scalars['NamespaceProjectID']['input'];
1610
+ /** The primary runtime for the updated project. */
1611
+ primaryRuntimeId?: InputMaybe<Scalars['RuntimeID']['input']>;
915
1612
  }
916
1613
 
917
1614
  /** Autogenerated return type of NamespacesProjectsUpdate. */
@@ -920,7 +1617,7 @@ export interface NamespacesProjectsUpdatePayload {
920
1617
  /** A unique identifier for the client performing the mutation. */
921
1618
  clientMutationId?: Maybe<Scalars['String']['output']>;
922
1619
  /** Errors encountered during execution of the mutation. */
923
- errors: Array<Error>;
1620
+ errors?: Maybe<Array<Error>>;
924
1621
  /** The updated project. */
925
1622
  namespaceProject?: Maybe<NamespaceProject>;
926
1623
  }
@@ -943,7 +1640,7 @@ export interface NamespacesRolesAssignAbilitiesPayload {
943
1640
  /** A unique identifier for the client performing the mutation. */
944
1641
  clientMutationId?: Maybe<Scalars['String']['output']>;
945
1642
  /** Errors encountered during execution of the mutation. */
946
- errors: Array<Error>;
1643
+ errors?: Maybe<Array<Error>>;
947
1644
  }
948
1645
 
949
1646
  /** Autogenerated input type of NamespacesRolesAssignProjects */
@@ -962,7 +1659,7 @@ export interface NamespacesRolesAssignProjectsPayload {
962
1659
  /** A unique identifier for the client performing the mutation. */
963
1660
  clientMutationId?: Maybe<Scalars['String']['output']>;
964
1661
  /** Errors encountered during execution of the mutation. */
965
- errors: Array<Error>;
1662
+ errors?: Maybe<Array<Error>>;
966
1663
  /** The now assigned projects */
967
1664
  projects?: Maybe<Array<NamespaceProject>>;
968
1665
  }
@@ -983,7 +1680,7 @@ export interface NamespacesRolesCreatePayload {
983
1680
  /** A unique identifier for the client performing the mutation. */
984
1681
  clientMutationId?: Maybe<Scalars['String']['output']>;
985
1682
  /** Errors encountered during execution of the mutation. */
986
- errors: Array<Error>;
1683
+ errors?: Maybe<Array<Error>>;
987
1684
  /** The newly created namespace role */
988
1685
  namespaceRole?: Maybe<NamespaceRole>;
989
1686
  }
@@ -1002,7 +1699,7 @@ export interface NamespacesRolesDeletePayload {
1002
1699
  /** A unique identifier for the client performing the mutation. */
1003
1700
  clientMutationId?: Maybe<Scalars['String']['output']>;
1004
1701
  /** Errors encountered during execution of the mutation. */
1005
- errors: Array<Error>;
1702
+ errors?: Maybe<Array<Error>>;
1006
1703
  /** The deleted namespace role */
1007
1704
  namespaceRole?: Maybe<NamespaceRole>;
1008
1705
  }
@@ -1023,7 +1720,7 @@ export interface NamespacesRolesUpdatePayload {
1023
1720
  /** A unique identifier for the client performing the mutation. */
1024
1721
  clientMutationId?: Maybe<Scalars['String']['output']>;
1025
1722
  /** Errors encountered during execution of the mutation. */
1026
- errors: Array<Error>;
1723
+ errors?: Maybe<Array<Error>>;
1027
1724
  /** The updated namespace role. */
1028
1725
  namespaceRole?: Maybe<NamespaceRole>;
1029
1726
  }
@@ -1031,22 +1728,138 @@ export interface NamespacesRolesUpdatePayload {
1031
1728
  /** An object with an ID. */
1032
1729
  export interface Node {
1033
1730
  /** ID of the object. */
1034
- id: Scalars['ID']['output'];
1731
+ id?: Maybe<Scalars['ID']['output']>;
1732
+ }
1733
+
1734
+ /** Represents a Node Function */
1735
+ export interface NodeFunction {
1736
+ __typename?: 'NodeFunction';
1737
+ /** Time when this NodeFunction was created */
1738
+ createdAt?: Maybe<Scalars['Time']['output']>;
1739
+ /** Global ID of this NodeFunction */
1740
+ id?: Maybe<Scalars['NodeFunctionID']['output']>;
1741
+ /** The ID of the next Node Function in the flow */
1742
+ nextNodeId?: Maybe<Scalars['NodeFunctionID']['output']>;
1743
+ /** The parameters of the Node Function */
1744
+ parameters?: Maybe<NodeParameterConnection>;
1745
+ /** The definition of the Node Function */
1746
+ runtimeFunction?: Maybe<RuntimeFunctionDefinition>;
1747
+ /** Time when this NodeFunction was last updated */
1748
+ updatedAt?: Maybe<Scalars['Time']['output']>;
1749
+ }
1750
+
1751
+
1752
+ /** Represents a Node Function */
1753
+ export interface NodeFunctionParametersArgs {
1754
+ after?: InputMaybe<Scalars['String']['input']>;
1755
+ before?: InputMaybe<Scalars['String']['input']>;
1756
+ first?: InputMaybe<Scalars['Int']['input']>;
1757
+ last?: InputMaybe<Scalars['Int']['input']>;
1758
+ }
1759
+
1760
+ /** The connection type for NodeFunction. */
1761
+ export interface NodeFunctionConnection {
1762
+ __typename?: 'NodeFunctionConnection';
1763
+ /** Total count of collection. */
1764
+ count?: Maybe<Scalars['Int']['output']>;
1765
+ /** A list of edges. */
1766
+ edges?: Maybe<Array<Maybe<NodeFunctionEdge>>>;
1767
+ /** A list of nodes. */
1768
+ nodes?: Maybe<Array<Maybe<NodeFunction>>>;
1769
+ /** Information to aid in pagination. */
1770
+ pageInfo?: Maybe<PageInfo>;
1771
+ }
1772
+
1773
+ /** An edge in a connection. */
1774
+ export interface NodeFunctionEdge {
1775
+ __typename?: 'NodeFunctionEdge';
1776
+ /** A cursor for use in pagination. */
1777
+ cursor?: Maybe<Scalars['String']['output']>;
1778
+ /** The item at the end of the edge. */
1779
+ node?: Maybe<NodeFunction>;
1780
+ }
1781
+
1782
+ /** Input type for a Node Function */
1783
+ export interface NodeFunctionInput {
1784
+ /** The next Node Function in the flow */
1785
+ nextNode?: InputMaybe<NodeFunctionInput>;
1786
+ /** The parameters of the Node Function */
1787
+ parameters: Array<NodeParameterInput>;
1788
+ /** The identifier of the Runtime Function Definition */
1789
+ runtimeFunctionId: Scalars['RuntimeFunctionDefinitionID']['input'];
1790
+ }
1791
+
1792
+ /** Represents a Node parameter */
1793
+ export interface NodeParameter {
1794
+ __typename?: 'NodeParameter';
1795
+ /** Time when this NodeParameter was created */
1796
+ createdAt?: Maybe<Scalars['Time']['output']>;
1797
+ /** Global ID of this NodeParameter */
1798
+ id?: Maybe<Scalars['NodeParameterID']['output']>;
1799
+ /** The definition of the parameter */
1800
+ runtimeParameter?: Maybe<RuntimeParameterDefinition>;
1801
+ /** Time when this NodeParameter was last updated */
1802
+ updatedAt?: Maybe<Scalars['Time']['output']>;
1803
+ /** The value of the parameter */
1804
+ value?: Maybe<NodeParameterValue>;
1805
+ }
1806
+
1807
+ /** The connection type for NodeParameter. */
1808
+ export interface NodeParameterConnection {
1809
+ __typename?: 'NodeParameterConnection';
1810
+ /** Total count of collection. */
1811
+ count?: Maybe<Scalars['Int']['output']>;
1812
+ /** A list of edges. */
1813
+ edges?: Maybe<Array<Maybe<NodeParameterEdge>>>;
1814
+ /** A list of nodes. */
1815
+ nodes?: Maybe<Array<Maybe<NodeParameter>>>;
1816
+ /** Information to aid in pagination. */
1817
+ pageInfo?: Maybe<PageInfo>;
1818
+ }
1819
+
1820
+ /** An edge in a connection. */
1821
+ export interface NodeParameterEdge {
1822
+ __typename?: 'NodeParameterEdge';
1823
+ /** A cursor for use in pagination. */
1824
+ cursor?: Maybe<Scalars['String']['output']>;
1825
+ /** The item at the end of the edge. */
1826
+ node?: Maybe<NodeParameter>;
1827
+ }
1828
+
1829
+ /** Input type for Node parameter */
1830
+ export interface NodeParameterInput {
1831
+ /** The identifier of the Runtime Parameter Definition */
1832
+ runtimeParameterDefinitionId: Scalars['RuntimeParameterDefinitionID']['input'];
1833
+ /** The value of the parameter */
1834
+ value?: InputMaybe<NodeParameterValueInput>;
1835
+ }
1836
+
1837
+ /** Represents a parameter value for a node. */
1838
+ export type NodeParameterValue = LiteralValue | NodeFunction | ReferenceValue;
1839
+
1840
+ /** Input type for parameter value */
1841
+ export interface NodeParameterValueInput {
1842
+ /** The function value of the parameter */
1843
+ functionValue?: InputMaybe<NodeFunctionInput>;
1844
+ /** The literal value of the parameter */
1845
+ literalValue?: InputMaybe<Scalars['JSON']['input']>;
1846
+ /** The reference value of the parameter */
1847
+ referenceValue?: InputMaybe<ReferenceValueInput>;
1035
1848
  }
1036
1849
 
1037
1850
  /** Represents a Organization */
1038
1851
  export interface Organization {
1039
1852
  __typename?: 'Organization';
1040
1853
  /** Time when this Organization was created */
1041
- createdAt: Scalars['Time']['output'];
1854
+ createdAt?: Maybe<Scalars['Time']['output']>;
1042
1855
  /** Global ID of this Organization */
1043
- id: Scalars['OrganizationID']['output'];
1856
+ id?: Maybe<Scalars['OrganizationID']['output']>;
1044
1857
  /** Name of the organization */
1045
- name: Scalars['String']['output'];
1858
+ name?: Maybe<Scalars['String']['output']>;
1046
1859
  /** Namespace of this organization */
1047
- namespace: Namespace;
1860
+ namespace?: Maybe<Namespace>;
1048
1861
  /** Time when this Organization was last updated */
1049
- updatedAt: Scalars['Time']['output'];
1862
+ updatedAt?: Maybe<Scalars['Time']['output']>;
1050
1863
  }
1051
1864
 
1052
1865
  /** Autogenerated input type of OrganizationsCreate */
@@ -1063,7 +1876,7 @@ export interface OrganizationsCreatePayload {
1063
1876
  /** A unique identifier for the client performing the mutation. */
1064
1877
  clientMutationId?: Maybe<Scalars['String']['output']>;
1065
1878
  /** Errors encountered during execution of the mutation. */
1066
- errors: Array<Error>;
1879
+ errors?: Maybe<Array<Error>>;
1067
1880
  /** The newly created organization. */
1068
1881
  organization?: Maybe<Organization>;
1069
1882
  }
@@ -1082,7 +1895,7 @@ export interface OrganizationsDeletePayload {
1082
1895
  /** A unique identifier for the client performing the mutation. */
1083
1896
  clientMutationId?: Maybe<Scalars['String']['output']>;
1084
1897
  /** Errors encountered during execution of the mutation. */
1085
- errors: Array<Error>;
1898
+ errors?: Maybe<Array<Error>>;
1086
1899
  /** The deleted organization. */
1087
1900
  organization?: Maybe<Organization>;
1088
1901
  }
@@ -1103,7 +1916,7 @@ export interface OrganizationsUpdatePayload {
1103
1916
  /** A unique identifier for the client performing the mutation. */
1104
1917
  clientMutationId?: Maybe<Scalars['String']['output']>;
1105
1918
  /** Errors encountered during execution of the mutation. */
1106
- errors: Array<Error>;
1919
+ errors?: Maybe<Array<Error>>;
1107
1920
  /** The updated organization. */
1108
1921
  organization?: Maybe<Organization>;
1109
1922
  }
@@ -1114,13 +1927,81 @@ export interface PageInfo {
1114
1927
  /** When paginating forwards, the cursor to continue. */
1115
1928
  endCursor?: Maybe<Scalars['String']['output']>;
1116
1929
  /** When paginating forwards, are there more items? */
1117
- hasNextPage: Scalars['Boolean']['output'];
1930
+ hasNextPage?: Maybe<Scalars['Boolean']['output']>;
1118
1931
  /** When paginating backwards, are there more items? */
1119
- hasPreviousPage: Scalars['Boolean']['output'];
1932
+ hasPreviousPage?: Maybe<Scalars['Boolean']['output']>;
1120
1933
  /** When paginating backwards, the cursor to continue. */
1121
1934
  startCursor?: Maybe<Scalars['String']['output']>;
1122
1935
  }
1123
1936
 
1937
+ /** Represents a parameter definition */
1938
+ export interface ParameterDefinition {
1939
+ __typename?: 'ParameterDefinition';
1940
+ /** Time when this ParameterDefinition was created */
1941
+ createdAt?: Maybe<Scalars['Time']['output']>;
1942
+ /** Data type of the parameter */
1943
+ dataType?: Maybe<DataTypeIdentifier>;
1944
+ /** Description of the parameter */
1945
+ descriptions?: Maybe<TranslationConnection>;
1946
+ /** Documentation of the parameter */
1947
+ documentations?: Maybe<TranslationConnection>;
1948
+ /** Global ID of this ParameterDefinition */
1949
+ id?: Maybe<Scalars['ParameterDefinitionID']['output']>;
1950
+ /** Name of the parameter */
1951
+ names?: Maybe<TranslationConnection>;
1952
+ /** Time when this ParameterDefinition was last updated */
1953
+ updatedAt?: Maybe<Scalars['Time']['output']>;
1954
+ }
1955
+
1956
+
1957
+ /** Represents a parameter definition */
1958
+ export interface ParameterDefinitionDescriptionsArgs {
1959
+ after?: InputMaybe<Scalars['String']['input']>;
1960
+ before?: InputMaybe<Scalars['String']['input']>;
1961
+ first?: InputMaybe<Scalars['Int']['input']>;
1962
+ last?: InputMaybe<Scalars['Int']['input']>;
1963
+ }
1964
+
1965
+
1966
+ /** Represents a parameter definition */
1967
+ export interface ParameterDefinitionDocumentationsArgs {
1968
+ after?: InputMaybe<Scalars['String']['input']>;
1969
+ before?: InputMaybe<Scalars['String']['input']>;
1970
+ first?: InputMaybe<Scalars['Int']['input']>;
1971
+ last?: InputMaybe<Scalars['Int']['input']>;
1972
+ }
1973
+
1974
+
1975
+ /** Represents a parameter definition */
1976
+ export interface ParameterDefinitionNamesArgs {
1977
+ after?: InputMaybe<Scalars['String']['input']>;
1978
+ before?: InputMaybe<Scalars['String']['input']>;
1979
+ first?: InputMaybe<Scalars['Int']['input']>;
1980
+ last?: InputMaybe<Scalars['Int']['input']>;
1981
+ }
1982
+
1983
+ /** The connection type for ParameterDefinition. */
1984
+ export interface ParameterDefinitionConnection {
1985
+ __typename?: 'ParameterDefinitionConnection';
1986
+ /** Total count of collection. */
1987
+ count?: Maybe<Scalars['Int']['output']>;
1988
+ /** A list of edges. */
1989
+ edges?: Maybe<Array<Maybe<ParameterDefinitionEdge>>>;
1990
+ /** A list of nodes. */
1991
+ nodes?: Maybe<Array<Maybe<ParameterDefinition>>>;
1992
+ /** Information to aid in pagination. */
1993
+ pageInfo?: Maybe<PageInfo>;
1994
+ }
1995
+
1996
+ /** An edge in a connection. */
1997
+ export interface ParameterDefinitionEdge {
1998
+ __typename?: 'ParameterDefinitionEdge';
1999
+ /** A cursor for use in pagination. */
2000
+ cursor?: Maybe<Scalars['String']['output']>;
2001
+ /** The item at the end of the edge. */
2002
+ node?: Maybe<ParameterDefinition>;
2003
+ }
2004
+
1124
2005
  /** Root Query type */
1125
2006
  export interface Query {
1126
2007
  __typename?: 'Query';
@@ -1131,9 +2012,9 @@ export interface Query {
1131
2012
  /** Get the currently logged in user */
1132
2013
  currentUser?: Maybe<User>;
1133
2014
  /** Field available for use to test API access */
1134
- echo: Scalars['String']['output'];
2015
+ echo?: Maybe<Scalars['String']['output']>;
1135
2016
  /** Find runtimes */
1136
- globalRuntimes: RuntimeConnection;
2017
+ globalRuntimes?: Maybe<RuntimeConnection>;
1137
2018
  /** Find a namespace */
1138
2019
  namespace?: Maybe<Namespace>;
1139
2020
  /** Fetches an object given its ID */
@@ -1142,6 +2023,8 @@ export interface Query {
1142
2023
  nodes?: Maybe<Array<Maybe<Node>>>;
1143
2024
  /** Find a organization */
1144
2025
  organization?: Maybe<Organization>;
2026
+ /** Find users */
2027
+ users?: Maybe<UserConnection>;
1145
2028
  }
1146
2029
 
1147
2030
 
@@ -1184,25 +2067,98 @@ export interface QueryOrganizationArgs {
1184
2067
  name?: InputMaybe<Scalars['String']['input']>;
1185
2068
  }
1186
2069
 
2070
+
2071
+ /** Root Query type */
2072
+ export interface QueryUsersArgs {
2073
+ after?: InputMaybe<Scalars['String']['input']>;
2074
+ before?: InputMaybe<Scalars['String']['input']>;
2075
+ first?: InputMaybe<Scalars['Int']['input']>;
2076
+ last?: InputMaybe<Scalars['Int']['input']>;
2077
+ }
2078
+
2079
+ /** Represents a reference path in a flow */
2080
+ export interface ReferencePath {
2081
+ __typename?: 'ReferencePath';
2082
+ /** The array index of the referenced data by the path */
2083
+ arrayIndex?: Maybe<Scalars['Int']['output']>;
2084
+ /** Time when this ReferencePath was created */
2085
+ createdAt?: Maybe<Scalars['Time']['output']>;
2086
+ /** Global ID of this ReferencePath */
2087
+ id?: Maybe<Scalars['ReferencePathID']['output']>;
2088
+ /** The path to the reference in the flow */
2089
+ path?: Maybe<Scalars['String']['output']>;
2090
+ /** Time when this ReferencePath was last updated */
2091
+ updatedAt?: Maybe<Scalars['Time']['output']>;
2092
+ }
2093
+
2094
+ /** Input type for reference path */
2095
+ export interface ReferencePathInput {
2096
+ /** Array index if applicable */
2097
+ arrayIndex?: InputMaybe<Scalars['Int']['input']>;
2098
+ /** The path to the reference in the flow */
2099
+ path?: InputMaybe<Scalars['String']['input']>;
2100
+ }
2101
+
2102
+ /** Represents a reference value in the system. */
2103
+ export interface ReferenceValue {
2104
+ __typename?: 'ReferenceValue';
2105
+ /** Time when this ReferenceValue was created */
2106
+ createdAt?: Maybe<Scalars['Time']['output']>;
2107
+ /** The identifier of the data type this reference value belongs to. */
2108
+ dataTypeIdentifier?: Maybe<DataTypeIdentifier>;
2109
+ /** The depth of the reference value. */
2110
+ depth?: Maybe<Scalars['Int']['output']>;
2111
+ /** Global ID of this ReferenceValue */
2112
+ id?: Maybe<Scalars['ReferenceValueID']['output']>;
2113
+ /** The node of the reference value. */
2114
+ node?: Maybe<Scalars['Int']['output']>;
2115
+ /** The paths associated with this reference value. */
2116
+ referencePath?: Maybe<Array<ReferencePath>>;
2117
+ /** The scope of the reference value. */
2118
+ scope?: Maybe<Array<Scalars['Int']['output']>>;
2119
+ /** Time when this ReferenceValue was last updated */
2120
+ updatedAt?: Maybe<Scalars['Time']['output']>;
2121
+ }
2122
+
2123
+ /** Input type for reference value */
2124
+ export interface ReferenceValueInput {
2125
+ /** The identifier of the data type this reference value belongs to */
2126
+ dataTypeIdentifier: DataTypeIdentifierInput;
2127
+ /** The primary level of the reference value */
2128
+ primaryLevel: Scalars['Int']['input'];
2129
+ /** The paths associated with this reference value */
2130
+ referencePath: Array<ReferencePathInput>;
2131
+ /** The secondary level of the reference value */
2132
+ secondaryLevel: Scalars['Int']['input'];
2133
+ /** The tertiary level of the reference value */
2134
+ tertiaryLevel?: InputMaybe<Scalars['Int']['input']>;
2135
+ }
2136
+
1187
2137
  /** Represents a runtime */
1188
2138
  export interface Runtime {
1189
2139
  __typename?: 'Runtime';
1190
2140
  /** Time when this Runtime was created */
1191
- createdAt: Scalars['Time']['output'];
2141
+ createdAt?: Maybe<Scalars['Time']['output']>;
1192
2142
  /** DataTypes of the runtime */
1193
- dataTypes: DataTypeConnection;
2143
+ dataTypes?: Maybe<DataTypeConnection>;
1194
2144
  /** The description for the runtime if present */
1195
- description: Scalars['String']['output'];
2145
+ description?: Maybe<Scalars['String']['output']>;
2146
+ /** FlowTypes of the runtime */
2147
+ flowTypes?: Maybe<FlowTypeConnection>;
1196
2148
  /** Global ID of this Runtime */
1197
- id: Scalars['RuntimeID']['output'];
2149
+ id?: Maybe<Scalars['RuntimeID']['output']>;
1198
2150
  /** The name for the runtime */
1199
- name: Scalars['String']['output'];
2151
+ name?: Maybe<Scalars['String']['output']>;
1200
2152
  /** The parent namespace for the runtime */
1201
2153
  namespace?: Maybe<Namespace>;
2154
+ /** Projects associated with the runtime */
2155
+ projects?: Maybe<NamespaceProjectConnection>;
2156
+ /** The status of the runtime */
2157
+ status?: Maybe<RuntimeStatusType>;
1202
2158
  /** Token belonging to the runtime, only present on creation */
1203
2159
  token?: Maybe<Scalars['String']['output']>;
1204
2160
  /** Time when this Runtime was last updated */
1205
- updatedAt: Scalars['Time']['output'];
2161
+ updatedAt?: Maybe<Scalars['Time']['output']>;
1206
2162
  }
1207
2163
 
1208
2164
 
@@ -1214,28 +2170,91 @@ export interface RuntimeDataTypesArgs {
1214
2170
  last?: InputMaybe<Scalars['Int']['input']>;
1215
2171
  }
1216
2172
 
2173
+
2174
+ /** Represents a runtime */
2175
+ export interface RuntimeFlowTypesArgs {
2176
+ after?: InputMaybe<Scalars['String']['input']>;
2177
+ before?: InputMaybe<Scalars['String']['input']>;
2178
+ first?: InputMaybe<Scalars['Int']['input']>;
2179
+ last?: InputMaybe<Scalars['Int']['input']>;
2180
+ }
2181
+
2182
+
2183
+ /** Represents a runtime */
2184
+ export interface RuntimeProjectsArgs {
2185
+ after?: InputMaybe<Scalars['String']['input']>;
2186
+ before?: InputMaybe<Scalars['String']['input']>;
2187
+ first?: InputMaybe<Scalars['Int']['input']>;
2188
+ last?: InputMaybe<Scalars['Int']['input']>;
2189
+ }
2190
+
1217
2191
  /** The connection type for Runtime. */
1218
2192
  export interface RuntimeConnection {
1219
2193
  __typename?: 'RuntimeConnection';
1220
2194
  /** Total count of collection. */
1221
- count: Scalars['Int']['output'];
2195
+ count?: Maybe<Scalars['Int']['output']>;
1222
2196
  /** A list of edges. */
1223
2197
  edges?: Maybe<Array<Maybe<RuntimeEdge>>>;
1224
2198
  /** A list of nodes. */
1225
2199
  nodes?: Maybe<Array<Maybe<Runtime>>>;
1226
2200
  /** Information to aid in pagination. */
1227
- pageInfo: PageInfo;
2201
+ pageInfo?: Maybe<PageInfo>;
1228
2202
  }
1229
2203
 
1230
2204
  /** An edge in a connection. */
1231
2205
  export interface RuntimeEdge {
1232
2206
  __typename?: 'RuntimeEdge';
1233
2207
  /** A cursor for use in pagination. */
1234
- cursor: Scalars['String']['output'];
2208
+ cursor?: Maybe<Scalars['String']['output']>;
1235
2209
  /** The item at the end of the edge. */
1236
2210
  node?: Maybe<Runtime>;
1237
2211
  }
1238
2212
 
2213
+ /** Represents a Node Function definition */
2214
+ export interface RuntimeFunctionDefinition {
2215
+ __typename?: 'RuntimeFunctionDefinition';
2216
+ /** Time when this RuntimeFunctionDefinition was created */
2217
+ createdAt?: Maybe<Scalars['Time']['output']>;
2218
+ /** Function definitions of the Node Function */
2219
+ functionDefinitions?: Maybe<FunctionDefinitionConnection>;
2220
+ /** Global ID of this RuntimeFunctionDefinition */
2221
+ id?: Maybe<Scalars['RuntimeParameterDefinitionID']['output']>;
2222
+ /** Identifier of the Node Function */
2223
+ identifier?: Maybe<Scalars['String']['output']>;
2224
+ /** The runtime this Node Function belongs to */
2225
+ runtime?: Maybe<Runtime>;
2226
+ /** Time when this RuntimeFunctionDefinition was last updated */
2227
+ updatedAt?: Maybe<Scalars['Time']['output']>;
2228
+ }
2229
+
2230
+
2231
+ /** Represents a Node Function definition */
2232
+ export interface RuntimeFunctionDefinitionFunctionDefinitionsArgs {
2233
+ after?: InputMaybe<Scalars['String']['input']>;
2234
+ before?: InputMaybe<Scalars['String']['input']>;
2235
+ first?: InputMaybe<Scalars['Int']['input']>;
2236
+ last?: InputMaybe<Scalars['Int']['input']>;
2237
+ }
2238
+
2239
+ /** Represents a Node parameter definition */
2240
+ export interface RuntimeParameterDefinition {
2241
+ __typename?: 'RuntimeParameterDefinition';
2242
+ /** Time when this RuntimeParameterDefinition was created */
2243
+ createdAt?: Maybe<Scalars['Time']['output']>;
2244
+ /** Global ID of this RuntimeParameterDefinition */
2245
+ id?: Maybe<Scalars['RuntimeParameterDefinitionID']['output']>;
2246
+ /** Time when this RuntimeParameterDefinition was last updated */
2247
+ updatedAt?: Maybe<Scalars['Time']['output']>;
2248
+ }
2249
+
2250
+ /** Represent all available types of statuses of a runtime */
2251
+ export enum RuntimeStatusType {
2252
+ /** No problem with connection, everything works as expected */
2253
+ Connected = 'CONNECTED',
2254
+ /** The runtime is disconnected, cause unknown */
2255
+ Disconnected = 'DISCONNECTED'
2256
+ }
2257
+
1239
2258
  /** Autogenerated input type of RuntimesCreate */
1240
2259
  export interface RuntimesCreateInput {
1241
2260
  /** A unique identifier for the client performing the mutation. */
@@ -1254,7 +2273,7 @@ export interface RuntimesCreatePayload {
1254
2273
  /** A unique identifier for the client performing the mutation. */
1255
2274
  clientMutationId?: Maybe<Scalars['String']['output']>;
1256
2275
  /** Errors encountered during execution of the mutation. */
1257
- errors: Array<Error>;
2276
+ errors?: Maybe<Array<Error>>;
1258
2277
  /** The newly created runtime. */
1259
2278
  runtime?: Maybe<Runtime>;
1260
2279
  }
@@ -1273,7 +2292,7 @@ export interface RuntimesDeletePayload {
1273
2292
  /** A unique identifier for the client performing the mutation. */
1274
2293
  clientMutationId?: Maybe<Scalars['String']['output']>;
1275
2294
  /** Errors encountered during execution of the mutation. */
1276
- errors: Array<Error>;
2295
+ errors?: Maybe<Array<Error>>;
1277
2296
  /** The updated organization. */
1278
2297
  runtime?: Maybe<Runtime>;
1279
2298
  }
@@ -1292,7 +2311,7 @@ export interface RuntimesRotateTokenPayload {
1292
2311
  /** A unique identifier for the client performing the mutation. */
1293
2312
  clientMutationId?: Maybe<Scalars['String']['output']>;
1294
2313
  /** Errors encountered during execution of the mutation. */
1295
- errors: Array<Error>;
2314
+ errors?: Maybe<Array<Error>>;
1296
2315
  /** The updated runtime. */
1297
2316
  runtime?: Maybe<Runtime>;
1298
2317
  }
@@ -1315,36 +2334,67 @@ export interface RuntimesUpdatePayload {
1315
2334
  /** A unique identifier for the client performing the mutation. */
1316
2335
  clientMutationId?: Maybe<Scalars['String']['output']>;
1317
2336
  /** Errors encountered during execution of the mutation. */
1318
- errors: Array<Error>;
2337
+ errors?: Maybe<Array<Error>>;
1319
2338
  /** The updated runtime. */
1320
2339
  runtime?: Maybe<Runtime>;
1321
2340
  }
1322
2341
 
2342
+ /** Represents a translation */
2343
+ export interface Translation {
2344
+ __typename?: 'Translation';
2345
+ /** Code of the translation */
2346
+ code?: Maybe<Scalars['String']['output']>;
2347
+ /** Content of the translation */
2348
+ content?: Maybe<Scalars['String']['output']>;
2349
+ }
2350
+
2351
+ /** The connection type for Translation. */
2352
+ export interface TranslationConnection {
2353
+ __typename?: 'TranslationConnection';
2354
+ /** Total count of collection. */
2355
+ count?: Maybe<Scalars['Int']['output']>;
2356
+ /** A list of edges. */
2357
+ edges?: Maybe<Array<Maybe<TranslationEdge>>>;
2358
+ /** A list of nodes. */
2359
+ nodes?: Maybe<Array<Maybe<Translation>>>;
2360
+ /** Information to aid in pagination. */
2361
+ pageInfo?: Maybe<PageInfo>;
2362
+ }
2363
+
2364
+ /** An edge in a connection. */
2365
+ export interface TranslationEdge {
2366
+ __typename?: 'TranslationEdge';
2367
+ /** A cursor for use in pagination. */
2368
+ cursor?: Maybe<Scalars['String']['output']>;
2369
+ /** The item at the end of the edge. */
2370
+ node?: Maybe<Translation>;
2371
+ }
2372
+
1323
2373
  /** Represents a user */
1324
2374
  export interface User {
1325
2375
  __typename?: 'User';
1326
2376
  /** Global admin status of the user */
1327
- admin: Scalars['Boolean']['output'];
2377
+ admin?: Maybe<Scalars['Boolean']['output']>;
1328
2378
  /** The avatar if present of the user */
1329
2379
  avatarPath?: Maybe<Scalars['String']['output']>;
1330
2380
  /** Time when this User was created */
1331
- createdAt: Scalars['Time']['output'];
2381
+ createdAt?: Maybe<Scalars['Time']['output']>;
1332
2382
  /** Email of the user */
1333
- email: Scalars['String']['output'];
2383
+ email?: Maybe<Scalars['String']['output']>;
1334
2384
  /** Firstname of the user */
1335
- firstname: Scalars['String']['output'];
2385
+ firstname?: Maybe<Scalars['String']['output']>;
1336
2386
  /** Global ID of this User */
1337
- id: Scalars['UserID']['output'];
2387
+ id?: Maybe<Scalars['UserID']['output']>;
1338
2388
  /** Lastname of the user */
1339
- lastname: Scalars['String']['output'];
2389
+ lastname?: Maybe<Scalars['String']['output']>;
1340
2390
  /** Namespace of this user */
1341
2391
  namespace?: Maybe<Namespace>;
1342
2392
  /** Namespace Memberships of this user */
1343
- namespaceMemberships: NamespaceMemberConnection;
2393
+ namespaceMemberships?: Maybe<NamespaceMemberConnection>;
1344
2394
  /** Time when this User was last updated */
1345
- updatedAt: Scalars['Time']['output'];
2395
+ updatedAt?: Maybe<Scalars['Time']['output']>;
1346
2396
  /** Username of the user */
1347
- username: Scalars['String']['output'];
2397
+ username?: Maybe<Scalars['String']['output']>;
1348
2398
  }
1349
2399
 
1350
2400
 
@@ -1356,38 +2406,79 @@ export interface UserNamespaceMembershipsArgs {
1356
2406
  last?: InputMaybe<Scalars['Int']['input']>;
1357
2407
  }
1358
2408
 
2409
+ /** The connection type for User. */
2410
+ export interface UserConnection {
2411
+ __typename?: 'UserConnection';
2412
+ /** Total count of collection. */
2413
+ count?: Maybe<Scalars['Int']['output']>;
2414
+ /** A list of edges. */
2415
+ edges?: Maybe<Array<Maybe<UserEdge>>>;
2416
+ /** A list of nodes. */
2417
+ nodes?: Maybe<Array<Maybe<User>>>;
2418
+ /** Information to aid in pagination. */
2419
+ pageInfo?: Maybe<PageInfo>;
2420
+ }
2421
+
2422
+ /** An edge in a connection. */
2423
+ export interface UserEdge {
2424
+ __typename?: 'UserEdge';
2425
+ /** A cursor for use in pagination. */
2426
+ cursor?: Maybe<Scalars['String']['output']>;
2427
+ /** The item at the end of the edge. */
2428
+ node?: Maybe<User>;
2429
+ }
2430
+
1359
2431
  /** Represents an external user identity */
1360
2432
  export interface UserIdentity {
1361
2433
  __typename?: 'UserIdentity';
1362
2434
  /** Time when this UserIdentity was created */
1363
- createdAt: Scalars['Time']['output'];
2435
+ createdAt?: Maybe<Scalars['Time']['output']>;
1364
2436
  /** Global ID of this UserIdentity */
1365
- id: Scalars['UserIdentityID']['output'];
2437
+ id?: Maybe<Scalars['UserIdentityID']['output']>;
1366
2438
  /** The description for the runtime if present */
1367
- identifier: Scalars['String']['output'];
2439
+ identifier?: Maybe<Scalars['String']['output']>;
1368
2440
  /** The name for the runtime */
1369
- providerId: Scalars['String']['output'];
2441
+ providerId?: Maybe<Scalars['String']['output']>;
1370
2442
  /** Time when this UserIdentity was last updated */
1371
- updatedAt: Scalars['Time']['output'];
2443
+ updatedAt?: Maybe<Scalars['Time']['output']>;
1372
2444
  /** The correlating user of the identity */
1373
- user: User;
2445
+ user?: Maybe<User>;
1374
2446
  }
1375
2447
 
1376
2448
  /** Represents a user session */
1377
2449
  export interface UserSession {
1378
2450
  __typename?: 'UserSession';
1379
2451
  /** Whether or not the session is active and can be used */
1380
- active: Scalars['Boolean']['output'];
2452
+ active?: Maybe<Scalars['Boolean']['output']>;
1381
2453
  /** Time when this UserSession was created */
1382
- createdAt: Scalars['Time']['output'];
2454
+ createdAt?: Maybe<Scalars['Time']['output']>;
1383
2455
  /** Global ID of this UserSession */
1384
- id: Scalars['UserSessionID']['output'];
2456
+ id?: Maybe<Scalars['UserSessionID']['output']>;
1385
2457
  /** Token belonging to the session, only present on creation */
1386
2458
  token?: Maybe<Scalars['String']['output']>;
1387
2459
  /** Time when this UserSession was last updated */
1388
- updatedAt: Scalars['Time']['output'];
2460
+ updatedAt?: Maybe<Scalars['Time']['output']>;
1389
2461
  /** User that belongs to the session */
1390
- user: User;
2462
+ user?: Maybe<User>;
2463
+ }
2464
+
2465
+ /** Autogenerated input type of UsersEmailVerification */
2466
+ export interface UsersEmailVerificationInput {
2467
+ /** A unique identifier for the client performing the mutation. */
2468
+ clientMutationId?: InputMaybe<Scalars['String']['input']>;
2469
+ /** The email verification token */
2470
+ token: Scalars['String']['input'];
2471
+ }
2472
+
2473
+ /** Autogenerated return type of UsersEmailVerification. */
2474
+ export interface UsersEmailVerificationPayload {
2475
+ __typename?: 'UsersEmailVerificationPayload';
2476
+ /** A unique identifier for the client performing the mutation. */
2477
+ clientMutationId?: Maybe<Scalars['String']['output']>;
2478
+ /** Errors encountered during execution of the mutation. */
2479
+ errors?: Maybe<Array<Error>>;
2480
+ /** The user whose email was verified */
2481
+ user?: Maybe<User>;
1391
2482
  }
1392
2483
 
1393
2484
  /** Autogenerated input type of UsersIdentityLink */
@@ -1406,7 +2497,7 @@ export interface UsersIdentityLinkPayload {
1406
2497
  /** A unique identifier for the client performing the mutation. */
1407
2498
  clientMutationId?: Maybe<Scalars['String']['output']>;
1408
2499
  /** Errors encountered during execution of the mutation. */
1409
- errors: Array<Error>;
2500
+ errors?: Maybe<Array<Error>>;
1410
2501
  /** The created user identity */
1411
2502
  userIdentity?: Maybe<UserIdentity>;
1412
2503
  }
@@ -1427,7 +2518,7 @@ export interface UsersIdentityLoginPayload {
1427
2518
  /** A unique identifier for the client performing the mutation. */
1428
2519
  clientMutationId?: Maybe<Scalars['String']['output']>;
1429
2520
  /** Errors encountered during execution of the mutation. */
1430
- errors: Array<Error>;
2521
+ errors?: Maybe<Array<Error>>;
1431
2522
  /** The created user session */
1432
2523
  userSession?: Maybe<UserSession>;
1433
2524
  }
@@ -1448,7 +2539,7 @@ export interface UsersIdentityRegisterPayload {
1448
2539
  /** A unique identifier for the client performing the mutation. */
1449
2540
  clientMutationId?: Maybe<Scalars['String']['output']>;
1450
2541
  /** Errors encountered during execution of the mutation. */
1451
- errors: Array<Error>;
2542
+ errors?: Maybe<Array<Error>>;
1452
2543
  /** The created users session */
1453
2544
  userSession?: Maybe<UserSession>;
1454
2545
  }
@@ -1467,7 +2558,7 @@ export interface UsersIdentityUnlinkPayload {
1467
2558
  /** A unique identifier for the client performing the mutation. */
1468
2559
  clientMutationId?: Maybe<Scalars['String']['output']>;
1469
2560
  /** Errors encountered during execution of the mutation. */
1470
- errors: Array<Error>;
2561
+ errors?: Maybe<Array<Error>>;
1471
2562
  /** The removed identity */
1472
2563
  userIdentity?: Maybe<UserIdentity>;
1473
2564
  }
@@ -1492,7 +2583,7 @@ export interface UsersLoginPayload {
1492
2583
  /** A unique identifier for the client performing the mutation. */
1493
2584
  clientMutationId?: Maybe<Scalars['String']['output']>;
1494
2585
  /** Errors encountered during execution of the mutation. */
1495
- errors: Array<Error>;
2586
+ errors?: Maybe<Array<Error>>;
1496
2587
  /** The created user session */
1497
2588
  userSession?: Maybe<UserSession>;
1498
2589
  }
@@ -1511,7 +2602,7 @@ export interface UsersLogoutPayload {
1511
2602
  /** A unique identifier for the client performing the mutation. */
1512
2603
  clientMutationId?: Maybe<Scalars['String']['output']>;
1513
2604
  /** Errors encountered during execution of the mutation. */
1514
- errors: Array<Error>;
2605
+ errors?: Maybe<Array<Error>>;
1515
2606
  /** The logged out user session */
1516
2607
  userSession?: Maybe<UserSession>;
1517
2608
  }
@@ -1530,7 +2621,7 @@ export interface UsersMfaBackupCodesRotatePayload {
1530
2621
  /** The newly rotated backup codes. */
1531
2622
  codes?: Maybe<Array<Scalars['String']['output']>>;
1532
2623
  /** Errors encountered during execution of the mutation. */
1533
- errors: Array<Error>;
2624
+ errors?: Maybe<Array<Error>>;
1534
2625
  }
1535
2626
 
1536
2627
  /** Autogenerated input type of UsersMfaTotpGenerateSecret */
@@ -1545,7 +2636,7 @@ export interface UsersMfaTotpGenerateSecretPayload {
1545
2636
  /** A unique identifier for the client performing the mutation. */
1546
2637
  clientMutationId?: Maybe<Scalars['String']['output']>;
1547
2638
  /** Errors encountered during execution of the mutation. */
1548
- errors: Array<Error>;
2639
+ errors?: Maybe<Array<Error>>;
1549
2640
  /** The created and signed secret */
1550
2641
  secret?: Maybe<Scalars['String']['output']>;
1551
2642
  }
@@ -1569,7 +2660,7 @@ export interface UsersMfaTotpValidateSecretPayload {
1569
2660
  /** A unique identifier for the client performing the mutation. */
1570
2661
  clientMutationId?: Maybe<Scalars['String']['output']>;
1571
2662
  /** Errors encountered during execution of the mutation. */
1572
- errors: Array<Error>;
2663
+ errors?: Maybe<Array<Error>>;
1573
2664
  /** The modified user */
1574
2665
  user?: Maybe<User>;
1575
2666
  }
@@ -1582,6 +2673,8 @@ export interface UsersRegisterInput {
1582
2673
  email: Scalars['String']['input'];
1583
2674
  /** Password of the user */
1584
2675
  password: Scalars['String']['input'];
2676
+ /** The repeated password of the user to check for typos */
2677
+ passwordRepeat: Scalars['String']['input'];
1585
2678
  /** Username of the user */
1586
2679
  username: Scalars['String']['input'];
1587
2680
  }
@@ -1592,7 +2685,7 @@ export interface UsersRegisterPayload {
1592
2685
  /** A unique identifier for the client performing the mutation. */
1593
2686
  clientMutationId?: Maybe<Scalars['String']['output']>;
1594
2687
  /** Errors encountered during execution of the mutation. */
1595
- errors: Array<Error>;
2688
+ errors?: Maybe<Array<Error>>;
1596
2689
  /** The created users session */
1597
2690
  userSession?: Maybe<UserSession>;
1598
2691
  }
@@ -1609,6 +2702,12 @@ export interface UsersUpdateInput {
1609
2702
  firstname?: InputMaybe<Scalars['String']['input']>;
1610
2703
  /** New lastname for the user. */
1611
2704
  lastname?: InputMaybe<Scalars['String']['input']>;
2705
+ /** The data of the mfa validation */
2706
+ mfa?: InputMaybe<MfaInput>;
2707
+ /** New password for the user. */
2708
+ password?: InputMaybe<Scalars['String']['input']>;
2709
+ /** New password repeat for the user to check for typos, required if password is set. */
2710
+ passwordRepeat?: InputMaybe<Scalars['String']['input']>;
1612
2711
  /** ID of the user to update. */
1613
2712
  userId: Scalars['UserID']['input'];
1614
2713
  /** New username for the user. */
@@ -1621,7 +2720,7 @@ export interface UsersUpdatePayload {
1621
2720
  /** A unique identifier for the client performing the mutation. */
1622
2721
  clientMutationId?: Maybe<Scalars['String']['output']>;
1623
2722
  /** Errors encountered during execution of the mutation. */
1624
- errors: Array<Error>;
2723
+ errors?: Maybe<Array<Error>>;
1625
2724
  /** The updated user. */
1626
2725
  user?: Maybe<User>;
1627
2726
  }