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

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