@code0-tech/sagittarius-graphql-types 0.0.0-4b2e73eae302fe499001bf42fdb3a6bcc5be78aa → 0.0.0-65144a9920c6a8de3bcf24acdcb8eec4158cef73

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 (3) hide show
  1. package/index.d.ts +679 -330
  2. package/package.json +2 -3
  3. package/index.js +0 -0
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,73 +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 GenericCombinationStrategy entities of the application */
32
23
  GenericCombinationStrategyID: { input: `gid://sagittarius/GenericCombinationStrategy/${number}`; output: `gid://sagittarius/GenericCombinationStrategy/${number}`; }
33
- /** A unique identifier for all GenericMapper entities of the application */
34
24
  GenericMapperID: { input: `gid://sagittarius/GenericMapper/${number}`; output: `gid://sagittarius/GenericMapper/${number}`; }
35
- /** A unique identifier for all GenericType entities of the application */
36
25
  GenericTypeID: { input: `gid://sagittarius/GenericType/${number}`; output: `gid://sagittarius/GenericType/${number}`; }
37
- /** Represents untyped JSON */
38
26
  JSON: { input: any; output: any; }
39
- /** A unique identifier for all Namespace entities of the application */
40
27
  NamespaceID: { input: `gid://sagittarius/Namespace/${number}`; output: `gid://sagittarius/Namespace/${number}`; }
41
- /** A unique identifier for all NamespaceLicense entities of the application */
42
28
  NamespaceLicenseID: { input: `gid://sagittarius/NamespaceLicense/${number}`; output: `gid://sagittarius/NamespaceLicense/${number}`; }
43
- /** A unique identifier for all NamespaceMember entities of the application */
44
29
  NamespaceMemberID: { input: `gid://sagittarius/NamespaceMember/${number}`; output: `gid://sagittarius/NamespaceMember/${number}`; }
45
- /** A unique identifier for all NamespaceMemberRole entities of the application */
46
30
  NamespaceMemberRoleID: { input: `gid://sagittarius/NamespaceMemberRole/${number}`; output: `gid://sagittarius/NamespaceMemberRole/${number}`; }
47
- /** A unique identifier for all NamespaceProject entities of the application */
48
31
  NamespaceProjectID: { input: `gid://sagittarius/NamespaceProject/${number}`; output: `gid://sagittarius/NamespaceProject/${number}`; }
49
- /** A unique identifier for all NamespaceRole entities of the application */
50
32
  NamespaceRoleID: { input: `gid://sagittarius/NamespaceRole/${number}`; output: `gid://sagittarius/NamespaceRole/${number}`; }
51
- /** A unique identifier for all NodeFunction entities of the application */
52
33
  NodeFunctionID: { input: `gid://sagittarius/NodeFunction/${number}`; output: `gid://sagittarius/NodeFunction/${number}`; }
53
- /** A unique identifier for all NodeParameter entities of the application */
54
34
  NodeParameterID: { input: `gid://sagittarius/NodeParameter/${number}`; output: `gid://sagittarius/NodeParameter/${number}`; }
55
- /** A unique identifier for all Organization entities of the application */
56
35
  OrganizationID: { input: `gid://sagittarius/Organization/${number}`; output: `gid://sagittarius/Organization/${number}`; }
57
- /** A unique identifier for all ParameterDefinition entities of the application */
58
36
  ParameterDefinitionID: { input: `gid://sagittarius/ParameterDefinition/${number}`; output: `gid://sagittarius/ParameterDefinition/${number}`; }
59
- /** A unique identifier for all ReferencePath entities of the application */
60
37
  ReferencePathID: { input: `gid://sagittarius/ReferencePath/${number}`; output: `gid://sagittarius/ReferencePath/${number}`; }
61
- /** A unique identifier for all ReferenceValue entities of the application */
62
38
  ReferenceValueID: { input: `gid://sagittarius/ReferenceValue/${number}`; output: `gid://sagittarius/ReferenceValue/${number}`; }
63
- /** A unique identifier for all RuntimeFunctionDefinition entities of the application */
64
39
  RuntimeFunctionDefinitionID: { input: `gid://sagittarius/RuntimeFunctionDefinition/${number}`; output: `gid://sagittarius/RuntimeFunctionDefinition/${number}`; }
65
- /** A unique identifier for all Runtime entities of the application */
66
40
  RuntimeID: { input: `gid://sagittarius/Runtime/${number}`; output: `gid://sagittarius/Runtime/${number}`; }
67
- /** A unique identifier for all RuntimeParameterDefinition entities of the application */
68
41
  RuntimeParameterDefinitionID: { input: `gid://sagittarius/RuntimeParameterDefinition/${number}`; output: `gid://sagittarius/RuntimeParameterDefinition/${number}`; }
69
- /**
70
- * Time represented in ISO 8601.
71
- *
72
- * For example: "2023-12-15T17:31:00Z".
73
- */
74
42
  Time: { input: string; output: string; }
75
- /** A unique identifier for all Types::FlowType entities of the application */
76
43
  TypesFlowTypeID: { input: `gid://sagittarius/TypesFlowType/${number}`; output: `gid://sagittarius/TypesFlowType/${number}`; }
77
- /** A unique identifier for all User entities of the application */
78
44
  UserID: { input: `gid://sagittarius/User/${number}`; output: `gid://sagittarius/User/${number}`; }
79
- /** A unique identifier for all UserIdentity entities of the application */
80
45
  UserIdentityID: { input: `gid://sagittarius/UserIdentity/${number}`; output: `gid://sagittarius/UserIdentity/${number}`; }
81
- /** A unique identifier for all UserSession entities of the application */
82
46
  UserSessionID: { input: `gid://sagittarius/UserSession/${number}`; output: `gid://sagittarius/UserSession/${number}`; }
83
47
  }
84
48
 
@@ -86,18 +50,18 @@ export interface Scalars {
86
50
  export interface ActiveModelError {
87
51
  __typename?: 'ActiveModelError';
88
52
  /** The affected attribute on the model */
89
- attribute: Scalars['String']['output'];
53
+ attribute?: Maybe<Scalars['String']['output']>;
90
54
  /** The validation type that failed for the attribute */
91
- type: Scalars['String']['output'];
55
+ type?: Maybe<Scalars['String']['output']>;
92
56
  }
93
57
 
94
58
  /** Represents the application settings */
95
59
  export interface ApplicationSettings {
96
60
  __typename?: 'ApplicationSettings';
97
61
  /** Shows if organization creation is restricted to administrators */
98
- organizationCreationRestricted: Scalars['Boolean']['output'];
62
+ organizationCreationRestricted?: Maybe<Scalars['Boolean']['output']>;
99
63
  /** Shows if user registration is enabled */
100
- userRegistrationEnabled: Scalars['Boolean']['output'];
64
+ userRegistrationEnabled?: Maybe<Scalars['Boolean']['output']>;
101
65
  }
102
66
 
103
67
  /** Autogenerated input type of ApplicationSettingsUpdate */
@@ -118,7 +82,7 @@ export interface ApplicationSettingsUpdatePayload {
118
82
  /** A unique identifier for the client performing the mutation. */
119
83
  clientMutationId?: Maybe<Scalars['String']['output']>;
120
84
  /** Errors encountered during execution of the mutation. */
121
- errors: Array<Error>;
85
+ errors?: Maybe<Array<Error>>;
122
86
  }
123
87
 
124
88
  /** Objects that can present an authentication */
@@ -128,25 +92,23 @@ export type Authentication = UserSession;
128
92
  export interface DataType {
129
93
  __typename?: 'DataType';
130
94
  /** Time when this DataType was created */
131
- createdAt: Scalars['Time']['output'];
95
+ createdAt?: Maybe<Scalars['Time']['output']>;
132
96
  /** Generic keys of the datatype */
133
97
  genericKeys?: Maybe<Array<Scalars['String']['output']>>;
134
98
  /** Global ID of this DataType */
135
- id: Scalars['DataTypeID']['output'];
99
+ id?: Maybe<Scalars['DataTypeID']['output']>;
136
100
  /** The identifier scoped to the namespace */
137
- identifier: Scalars['String']['output'];
101
+ identifier?: Maybe<Scalars['String']['output']>;
138
102
  /** Names of the flow type setting */
139
- name: TranslationConnection;
140
- /** The namespace where this datatype belongs to */
141
- namespace?: Maybe<Namespace>;
142
- /** The parent datatype */
143
- parent?: Maybe<DataTypeIdentifier>;
103
+ name?: Maybe<TranslationConnection>;
144
104
  /** Rules of the datatype */
145
- rules: DataTypeRuleConnection;
105
+ rules?: Maybe<DataTypeRuleConnection>;
106
+ /** The runtime where this datatype belongs to */
107
+ runtime?: Maybe<Runtime>;
146
108
  /** Time when this DataType was last updated */
147
- updatedAt: Scalars['Time']['output'];
109
+ updatedAt?: Maybe<Scalars['Time']['output']>;
148
110
  /** The type of the datatype */
149
- variant: DataTypeVariant;
111
+ variant?: Maybe<DataTypeVariant>;
150
112
  }
151
113
 
152
114
 
@@ -171,20 +133,20 @@ export interface DataTypeRulesArgs {
171
133
  export interface DataTypeConnection {
172
134
  __typename?: 'DataTypeConnection';
173
135
  /** Total count of collection. */
174
- count: Scalars['Int']['output'];
136
+ count?: Maybe<Scalars['Int']['output']>;
175
137
  /** A list of edges. */
176
138
  edges?: Maybe<Array<Maybe<DataTypeEdge>>>;
177
139
  /** A list of nodes. */
178
140
  nodes?: Maybe<Array<Maybe<DataType>>>;
179
141
  /** Information to aid in pagination. */
180
- pageInfo: PageInfo;
142
+ pageInfo?: Maybe<PageInfo>;
181
143
  }
182
144
 
183
145
  /** An edge in a connection. */
184
146
  export interface DataTypeEdge {
185
147
  __typename?: 'DataTypeEdge';
186
148
  /** A cursor for use in pagination. */
187
- cursor: Scalars['String']['output'];
149
+ cursor?: Maybe<Scalars['String']['output']>;
188
150
  /** The item at the end of the edge. */
189
151
  node?: Maybe<DataType>;
190
152
  }
@@ -193,7 +155,7 @@ export interface DataTypeEdge {
193
155
  export interface DataTypeIdentifier {
194
156
  __typename?: 'DataTypeIdentifier';
195
157
  /** Time when this DataTypeIdentifier was created */
196
- createdAt: Scalars['Time']['output'];
158
+ createdAt?: Maybe<Scalars['Time']['output']>;
197
159
  /** The data type of the data type identifier. */
198
160
  dataType?: Maybe<DataType>;
199
161
  /** The generic key of the data type identifier. */
@@ -201,9 +163,9 @@ export interface DataTypeIdentifier {
201
163
  /** The generic type of the data type identifier. */
202
164
  genericType?: Maybe<GenericType>;
203
165
  /** Global ID of this DataTypeIdentifier */
204
- id: Scalars['DataTypeIdentifierID']['output'];
166
+ id?: Maybe<Scalars['DataTypeIdentifierID']['output']>;
205
167
  /** Time when this DataTypeIdentifier was last updated */
206
- updatedAt: Scalars['Time']['output'];
168
+ updatedAt?: Maybe<Scalars['Time']['output']>;
207
169
  }
208
170
 
209
171
  /** Input type for data type identifier */
@@ -220,72 +182,72 @@ export interface DataTypeIdentifierInput {
220
182
  export interface DataTypeRule {
221
183
  __typename?: 'DataTypeRule';
222
184
  /** The configuration of the rule */
223
- config: DataTypeRulesConfig;
185
+ config?: Maybe<DataTypeRulesConfig>;
224
186
  /** Time when this DataTypeRule was created */
225
- createdAt: Scalars['Time']['output'];
187
+ createdAt?: Maybe<Scalars['Time']['output']>;
226
188
  /** Global ID of this DataTypeRule */
227
- id: Scalars['DataTypeRuleID']['output'];
189
+ id?: Maybe<Scalars['DataTypeRuleID']['output']>;
228
190
  /** Time when this DataTypeRule was last updated */
229
- updatedAt: Scalars['Time']['output'];
191
+ updatedAt?: Maybe<Scalars['Time']['output']>;
230
192
  /** The type of the rule */
231
- variant: DataTypeRulesVariant;
193
+ variant?: Maybe<DataTypeRulesVariant>;
232
194
  }
233
195
 
234
196
  /** The connection type for DataTypeRule. */
235
197
  export interface DataTypeRuleConnection {
236
198
  __typename?: 'DataTypeRuleConnection';
237
199
  /** Total count of collection. */
238
- count: Scalars['Int']['output'];
200
+ count?: Maybe<Scalars['Int']['output']>;
239
201
  /** A list of edges. */
240
202
  edges?: Maybe<Array<Maybe<DataTypeRuleEdge>>>;
241
203
  /** A list of nodes. */
242
204
  nodes?: Maybe<Array<Maybe<DataTypeRule>>>;
243
205
  /** Information to aid in pagination. */
244
- pageInfo: PageInfo;
206
+ pageInfo?: Maybe<PageInfo>;
245
207
  }
246
208
 
247
209
  /** An edge in a connection. */
248
210
  export interface DataTypeRuleEdge {
249
211
  __typename?: 'DataTypeRuleEdge';
250
212
  /** A cursor for use in pagination. */
251
- cursor: Scalars['String']['output'];
213
+ cursor?: Maybe<Scalars['String']['output']>;
252
214
  /** The item at the end of the edge. */
253
215
  node?: Maybe<DataTypeRule>;
254
216
  }
255
217
 
256
218
  /** Represents a rule that can be applied to a data type. */
257
- export type DataTypeRulesConfig = DataTypeRulesContainsKeyConfig | DataTypeRulesContainsTypeConfig | DataTypeRulesInputTypesConfig | DataTypeRulesItemOfCollectionConfig | DataTypeRulesNumberRangeConfig | DataTypeRulesRegexConfig | DataTypeRulesReturnTypeConfig;
219
+ export type DataTypeRulesConfig = DataTypeRulesContainsKeyConfig | DataTypeRulesContainsTypeConfig | DataTypeRulesInputTypesConfig | DataTypeRulesItemOfCollectionConfig | DataTypeRulesNumberRangeConfig | DataTypeRulesParentTypeConfig | DataTypeRulesRegexConfig | DataTypeRulesReturnTypeConfig;
258
220
 
259
221
  /** Represents a rule that can be applied to a data type. */
260
222
  export interface DataTypeRulesContainsKeyConfig {
261
223
  __typename?: 'DataTypeRulesContainsKeyConfig';
262
224
  /** The identifier of the data type this rule belongs to */
263
- dataTypeIdentifier: DataTypeIdentifier;
225
+ dataTypeIdentifier?: Maybe<DataTypeIdentifier>;
264
226
  /** The key of the rule */
265
- key: Scalars['String']['output'];
227
+ key?: Maybe<Scalars['String']['output']>;
266
228
  }
267
229
 
268
230
  /** Represents a rule that can be applied to a data type. */
269
231
  export interface DataTypeRulesContainsTypeConfig {
270
232
  __typename?: 'DataTypeRulesContainsTypeConfig';
271
233
  /** The identifier of the data type this rule belongs to */
272
- dataTypeIdentifier: DataTypeIdentifier;
234
+ dataTypeIdentifier?: Maybe<DataTypeIdentifier>;
273
235
  }
274
236
 
275
237
  /** Represents a subtype of input type configuration for a input data type. */
276
238
  export interface DataTypeRulesInputTypeConfig {
277
239
  __typename?: 'DataTypeRulesInputTypeConfig';
278
240
  /** The identifier of the data type this input type belongs to */
279
- dataTypeIdentifier: DataTypeIdentifier;
280
- /** The input data type that this configuration applies to */
281
- inputType: DataType;
241
+ dataTypeIdentifier?: Maybe<DataTypeIdentifier>;
242
+ /** The input identifier that this configuration applies to */
243
+ inputIdentifier?: Maybe<Scalars['String']['output']>;
282
244
  }
283
245
 
284
246
  /** Represents a rule that can be applied to a data type. */
285
247
  export interface DataTypeRulesInputTypesConfig {
286
248
  __typename?: 'DataTypeRulesInputTypesConfig';
287
249
  /** The input types that can be used in this data type rule */
288
- inputTypes: Array<DataTypeRulesInputTypeConfig>;
250
+ inputTypes?: Maybe<Array<DataTypeRulesInputTypeConfig>>;
289
251
  }
290
252
 
291
253
  /** Represents a rule that can be applied to a data type. */
@@ -299,29 +261,36 @@ export interface DataTypeRulesItemOfCollectionConfig {
299
261
  export interface DataTypeRulesNumberRangeConfig {
300
262
  __typename?: 'DataTypeRulesNumberRangeConfig';
301
263
  /** The minimum value of the range */
302
- from: Scalars['Int']['output'];
264
+ from?: Maybe<Scalars['Int']['output']>;
303
265
  /** The step value for the range, if applicable */
304
266
  steps?: Maybe<Scalars['Int']['output']>;
305
267
  /** The maximum value of the range */
306
- to: Scalars['Int']['output'];
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>;
307
276
  }
308
277
 
309
278
  /** Represents a rule that can be applied to a data type. */
310
279
  export interface DataTypeRulesRegexConfig {
311
280
  __typename?: 'DataTypeRulesRegexConfig';
312
281
  /** The regex pattern to match against the data type value. */
313
- pattern: Scalars['String']['output'];
282
+ pattern?: Maybe<Scalars['String']['output']>;
314
283
  }
315
284
 
316
285
  /** Represents a rule that can be applied to a data type. */
317
286
  export interface DataTypeRulesReturnTypeConfig {
318
287
  __typename?: 'DataTypeRulesReturnTypeConfig';
319
288
  /** The data type identifier for the return type. */
320
- dataTypeIdentifier: DataTypeIdentifier;
289
+ dataTypeIdentifier?: Maybe<DataTypeIdentifier>;
321
290
  }
322
291
 
323
292
  /** The type of rule that can be applied to a data type. */
324
- export enum DataTypeRulesVariant {
293
+ export const enum DataTypeRulesVariant {
325
294
  /** The rule checks if a key is present in the data type. */
326
295
  ContainsKey = 'CONTAINS_KEY',
327
296
  /** The rule checks if a specific type is present in the data type. */
@@ -332,6 +301,8 @@ export enum DataTypeRulesVariant {
332
301
  ItemOfCollection = 'ITEM_OF_COLLECTION',
333
302
  /** The rule checks if a number falls within a specified range. */
334
303
  NumberRange = 'NUMBER_RANGE',
304
+ /** The rule checks if the data type is a child of a specific parent type. */
305
+ ParentType = 'PARENT_TYPE',
335
306
  /** The rule checks if a string matches a specified regular expression. */
336
307
  Regex = 'REGEX',
337
308
  /** The rule checks if the data type matches a specific return type. */
@@ -339,7 +310,7 @@ export enum DataTypeRulesVariant {
339
310
  }
340
311
 
341
312
  /** Represent all available types of a datatype */
342
- export enum DataTypeVariant {
313
+ export const enum DataTypeVariant {
343
314
  /** Represents an array */
344
315
  Array = 'ARRAY',
345
316
  /** Represents an data type containing a data type */
@@ -370,59 +341,150 @@ export interface EchoPayload {
370
341
  /** A unique identifier for the client performing the mutation. */
371
342
  clientMutationId?: Maybe<Scalars['String']['output']>;
372
343
  /** Errors encountered during execution of the mutation. */
373
- errors: Array<Error>;
344
+ errors?: Maybe<Array<Error>>;
374
345
  /** Message returned to the user. */
375
346
  message?: Maybe<Scalars['String']['output']>;
376
347
  }
377
348
 
378
349
  /** Objects that can present an error */
379
- export type Error = ActiveModelError | MessageError;
350
+ export type Error = ActiveModelError | ErrorCode | MessageError;
351
+
352
+ /** Represents an error code */
353
+ export interface ErrorCode {
354
+ __typename?: 'ErrorCode';
355
+ /** The error code */
356
+ errorCode?: Maybe<ErrorCodeEnum>;
357
+ }
358
+
359
+ /** Represents the available error responses */
360
+ export const enum ErrorCodeEnum {
361
+ /** This action would remove the last administrative role */
362
+ CannotDeleteLastAdminRole = 'CANNOT_DELETE_LAST_ADMIN_ROLE',
363
+ /** This action would remove the last administrator */
364
+ CannotRemoveLastAdministrator = 'CANNOT_REMOVE_LAST_ADMINISTRATOR',
365
+ /** This action would remove the last administrative ability */
366
+ CannotRemoveLastAdminAbility = 'CANNOT_REMOVE_LAST_ADMIN_ABILITY',
367
+ /** This external identity does not exist */
368
+ ExternalIdentityDoesNotExist = 'EXTERNAL_IDENTITY_DOES_NOT_EXIST',
369
+ /** The old backup codes could not be deleted */
370
+ FailedToInvalidateOldBackupCodes = 'FAILED_TO_INVALIDATE_OLD_BACKUP_CODES',
371
+ /** The new backup codes could not be saved */
372
+ FailedToSaveValidBackupCode = 'FAILED_TO_SAVE_VALID_BACKUP_CODE',
373
+ /** The given key was not found in the data type */
374
+ GenericKeyNotFound = 'GENERIC_KEY_NOT_FOUND',
375
+ /** Failed to validate the external identity */
376
+ IdentityValidationFailed = 'IDENTITY_VALIDATION_FAILED',
377
+ /** Resources are from different namespaces */
378
+ InconsistentNamespace = 'INCONSISTENT_NAMESPACE',
379
+ /** This external identity is invalid */
380
+ InvalidExternalIdentity = 'INVALID_EXTERNAL_IDENTITY',
381
+ /** Invalid login data provided */
382
+ InvalidLoginData = 'INVALID_LOGIN_DATA',
383
+ /** Invalid setting provided */
384
+ InvalidSetting = 'INVALID_SETTING',
385
+ /** Invalid verification code provided */
386
+ InvalidVerificationCode = 'INVALID_VERIFICATION_CODE',
387
+ /** Invalid MFA data provided */
388
+ MfaFailed = 'MFA_FAILED',
389
+ /** MFA is required */
390
+ MfaRequired = 'MFA_REQUIRED',
391
+ /** This external identity is missing data */
392
+ MissingIdentityData = 'MISSING_IDENTITY_DATA',
393
+ /** Not all required parameters are present */
394
+ MissingParameter = 'MISSING_PARAMETER',
395
+ /** The user is not permitted to perform this operation */
396
+ MissingPermission = 'MISSING_PERMISSION',
397
+ /** There are no free license seats to complete this operation */
398
+ NoFreeLicenseSeats = 'NO_FREE_LICENSE_SEATS',
399
+ /** The project does not have a primary runtime */
400
+ NoPrimaryRuntime = 'NO_PRIMARY_RUNTIME',
401
+ /** @deprecated Outdated concept */
402
+ PrimaryLevelNotFound = 'PRIMARY_LEVEL_NOT_FOUND',
403
+ /** Self-registration is disabled */
404
+ RegistrationDisabled = 'REGISTRATION_DISABLED',
405
+ /** Resources are from different runtimes */
406
+ RuntimeMismatch = 'RUNTIME_MISMATCH',
407
+ /** @deprecated Outdated concept */
408
+ SecondaryLevelNotFound = 'SECONDARY_LEVEL_NOT_FOUND',
409
+ /** @deprecated Outdated concept */
410
+ TertiaryLevelExceedsParameters = 'TERTIARY_LEVEL_EXCEEDS_PARAMETERS',
411
+ /** This user already has TOTP set up */
412
+ TotpSecretAlreadySet = 'TOTP_SECRET_ALREADY_SET',
413
+ /** The user is not permitted to modify this field */
414
+ UnmodifiableField = 'UNMODIFIABLE_FIELD',
415
+ /** Invalid TOTP code provided */
416
+ WrongTotp = 'WRONG_TOTP'
417
+ }
380
418
 
381
419
  /** Represents a flow */
382
420
  export interface Flow {
383
421
  __typename?: 'Flow';
384
422
  /** Time when this Flow was created */
385
- createdAt: Scalars['Time']['output'];
423
+ createdAt?: Maybe<Scalars['Time']['output']>;
386
424
  /** Global ID of this Flow */
387
- id: Scalars['FlowID']['output'];
425
+ id?: Maybe<Scalars['FlowID']['output']>;
388
426
  /** The input data type of the flow */
389
427
  inputType?: Maybe<DataType>;
428
+ /** Name of the flow */
429
+ name?: Maybe<Scalars['String']['output']>;
430
+ /** Nodes of the flow */
431
+ nodes?: Maybe<NodeFunctionConnection>;
390
432
  /** The return data type of the flow */
391
433
  returnType?: Maybe<DataType>;
392
434
  /** The settings of the flow */
393
- settings?: Maybe<Array<FlowSetting>>;
394
- /** The starting node of the flow */
395
- startingNode: NodeFunction;
435
+ settings?: Maybe<FlowSettingConnection>;
436
+ /** The ID of the starting node of the flow */
437
+ startingNodeId?: Maybe<Scalars['NodeFunctionID']['output']>;
396
438
  /** The flow type of the flow */
397
- type: FlowType;
439
+ type?: Maybe<FlowType>;
398
440
  /** Time when this Flow was last updated */
399
- updatedAt: Scalars['Time']['output'];
441
+ updatedAt?: Maybe<Scalars['Time']['output']>;
442
+ }
443
+
444
+
445
+ /** Represents a flow */
446
+ export interface FlowNodesArgs {
447
+ after?: InputMaybe<Scalars['String']['input']>;
448
+ before?: InputMaybe<Scalars['String']['input']>;
449
+ first?: InputMaybe<Scalars['Int']['input']>;
450
+ last?: InputMaybe<Scalars['Int']['input']>;
451
+ }
452
+
453
+
454
+ /** Represents a flow */
455
+ export interface FlowSettingsArgs {
456
+ after?: InputMaybe<Scalars['String']['input']>;
457
+ before?: InputMaybe<Scalars['String']['input']>;
458
+ first?: InputMaybe<Scalars['Int']['input']>;
459
+ last?: InputMaybe<Scalars['Int']['input']>;
400
460
  }
401
461
 
402
462
  /** The connection type for Flow. */
403
463
  export interface FlowConnection {
404
464
  __typename?: 'FlowConnection';
405
465
  /** Total count of collection. */
406
- count: Scalars['Int']['output'];
466
+ count?: Maybe<Scalars['Int']['output']>;
407
467
  /** A list of edges. */
408
468
  edges?: Maybe<Array<Maybe<FlowEdge>>>;
409
469
  /** A list of nodes. */
410
470
  nodes?: Maybe<Array<Maybe<Flow>>>;
411
471
  /** Information to aid in pagination. */
412
- pageInfo: PageInfo;
472
+ pageInfo?: Maybe<PageInfo>;
413
473
  }
414
474
 
415
475
  /** An edge in a connection. */
416
476
  export interface FlowEdge {
417
477
  __typename?: 'FlowEdge';
418
478
  /** A cursor for use in pagination. */
419
- cursor: Scalars['String']['output'];
479
+ cursor?: Maybe<Scalars['String']['output']>;
420
480
  /** The item at the end of the edge. */
421
481
  node?: Maybe<Flow>;
422
482
  }
423
483
 
424
484
  /** Input type for creating or updating a flow */
425
485
  export interface FlowInput {
486
+ /** The name of the flow */
487
+ name: Scalars['String']['input'];
426
488
  /** The settings of the flow */
427
489
  settings?: InputMaybe<Array<FlowSettingInput>>;
428
490
  /** The starting node of the flow */
@@ -435,15 +497,37 @@ export interface FlowInput {
435
497
  export interface FlowSetting {
436
498
  __typename?: 'FlowSetting';
437
499
  /** Time when this FlowSetting was created */
438
- createdAt: Scalars['Time']['output'];
500
+ createdAt?: Maybe<Scalars['Time']['output']>;
439
501
  /** The identifier of the flow setting */
440
- flowSettingId: Scalars['String']['output'];
502
+ flowSettingIdentifier?: Maybe<Scalars['String']['output']>;
441
503
  /** Global ID of this FlowSetting */
442
- id: Scalars['FlowSettingID']['output'];
504
+ id?: Maybe<Scalars['FlowSettingID']['output']>;
443
505
  /** Time when this FlowSetting was last updated */
444
- updatedAt: Scalars['Time']['output'];
506
+ updatedAt?: Maybe<Scalars['Time']['output']>;
445
507
  /** The value of the flow setting */
446
- value: Scalars['JSON']['output'];
508
+ value?: Maybe<Scalars['JSON']['output']>;
509
+ }
510
+
511
+ /** The connection type for FlowSetting. */
512
+ export interface FlowSettingConnection {
513
+ __typename?: 'FlowSettingConnection';
514
+ /** Total count of collection. */
515
+ count?: Maybe<Scalars['Int']['output']>;
516
+ /** A list of edges. */
517
+ edges?: Maybe<Array<Maybe<FlowSettingEdge>>>;
518
+ /** A list of nodes. */
519
+ nodes?: Maybe<Array<Maybe<FlowSetting>>>;
520
+ /** Information to aid in pagination. */
521
+ pageInfo?: Maybe<PageInfo>;
522
+ }
523
+
524
+ /** An edge in a connection. */
525
+ export interface FlowSettingEdge {
526
+ __typename?: 'FlowSettingEdge';
527
+ /** A cursor for use in pagination. */
528
+ cursor?: Maybe<Scalars['String']['output']>;
529
+ /** The item at the end of the edge. */
530
+ node?: Maybe<FlowSetting>;
447
531
  }
448
532
 
449
533
  /** Input type for flow settings */
@@ -458,17 +542,17 @@ export interface FlowSettingInput {
458
542
  export interface FlowType {
459
543
  __typename?: 'FlowType';
460
544
  /** Time when this FlowType was created */
461
- createdAt: Scalars['Time']['output'];
545
+ createdAt?: Maybe<Scalars['Time']['output']>;
462
546
  /** Descriptions of the flow type */
463
547
  descriptions?: Maybe<TranslationConnection>;
464
548
  /** Editable status of the flow type */
465
- editable: Scalars['Boolean']['output'];
549
+ editable?: Maybe<Scalars['Boolean']['output']>;
466
550
  /** Flow type settings of the flow type */
467
- flowTypeSettings: Array<FlowTypeSetting>;
551
+ flowTypeSettings?: Maybe<Array<FlowTypeSetting>>;
468
552
  /** Global ID of this FlowType */
469
- id: Scalars['TypesFlowTypeID']['output'];
553
+ id?: Maybe<Scalars['TypesFlowTypeID']['output']>;
470
554
  /** Identifier of the flow type */
471
- identifier: Scalars['String']['output'];
555
+ identifier?: Maybe<Scalars['String']['output']>;
472
556
  /** Input type of the flow type */
473
557
  inputType?: Maybe<DataType>;
474
558
  /** Names of the flow type */
@@ -476,7 +560,7 @@ export interface FlowType {
476
560
  /** Return type of the flow type */
477
561
  returnType?: Maybe<DataType>;
478
562
  /** Time when this FlowType was last updated */
479
- updatedAt: Scalars['Time']['output'];
563
+ updatedAt?: Maybe<Scalars['Time']['output']>;
480
564
  }
481
565
 
482
566
 
@@ -501,20 +585,20 @@ export interface FlowTypeNamesArgs {
501
585
  export interface FlowTypeConnection {
502
586
  __typename?: 'FlowTypeConnection';
503
587
  /** Total count of collection. */
504
- count: Scalars['Int']['output'];
588
+ count?: Maybe<Scalars['Int']['output']>;
505
589
  /** A list of edges. */
506
590
  edges?: Maybe<Array<Maybe<FlowTypeEdge>>>;
507
591
  /** A list of nodes. */
508
592
  nodes?: Maybe<Array<Maybe<FlowType>>>;
509
593
  /** Information to aid in pagination. */
510
- pageInfo: PageInfo;
594
+ pageInfo?: Maybe<PageInfo>;
511
595
  }
512
596
 
513
597
  /** An edge in a connection. */
514
598
  export interface FlowTypeEdge {
515
599
  __typename?: 'FlowTypeEdge';
516
600
  /** A cursor for use in pagination. */
517
- cursor: Scalars['String']['output'];
601
+ cursor?: Maybe<Scalars['String']['output']>;
518
602
  /** The item at the end of the edge. */
519
603
  node?: Maybe<FlowType>;
520
604
  }
@@ -523,23 +607,23 @@ export interface FlowTypeEdge {
523
607
  export interface FlowTypeSetting {
524
608
  __typename?: 'FlowTypeSetting';
525
609
  /** Time when this FlowTypeSetting was created */
526
- createdAt: Scalars['Time']['output'];
610
+ createdAt?: Maybe<Scalars['Time']['output']>;
527
611
  /** Data type of the flow type setting */
528
612
  dataType?: Maybe<DataType>;
529
613
  /** Descriptions of the flow type setting */
530
- descriptions: TranslationConnection;
614
+ descriptions?: Maybe<TranslationConnection>;
531
615
  /** Flow type of the flow type setting */
532
616
  flowType?: Maybe<FlowType>;
533
617
  /** Global ID of this FlowTypeSetting */
534
- id: Scalars['FlowTypeSettingID']['output'];
618
+ id?: Maybe<Scalars['FlowTypeSettingID']['output']>;
535
619
  /** Identifier of the flow type setting */
536
- identifier: Scalars['String']['output'];
620
+ identifier?: Maybe<Scalars['String']['output']>;
537
621
  /** Names of the flow type setting */
538
- names: TranslationConnection;
622
+ names?: Maybe<TranslationConnection>;
539
623
  /** Unique status of the flow type setting */
540
- unique: Scalars['Boolean']['output'];
624
+ unique?: Maybe<Scalars['Boolean']['output']>;
541
625
  /** Time when this FlowTypeSetting was last updated */
542
- updatedAt: Scalars['Time']['output'];
626
+ updatedAt?: Maybe<Scalars['Time']['output']>;
543
627
  }
544
628
 
545
629
 
@@ -564,7 +648,7 @@ export interface FlowTypeSettingNamesArgs {
564
648
  export interface FunctionDefinition {
565
649
  __typename?: 'FunctionDefinition';
566
650
  /** Time when this FunctionDefinition was created */
567
- createdAt: Scalars['Time']['output'];
651
+ createdAt?: Maybe<Scalars['Time']['output']>;
568
652
  /** Deprecation message of the function */
569
653
  deprecationMessages?: Maybe<TranslationConnection>;
570
654
  /** Description of the function */
@@ -574,7 +658,9 @@ export interface FunctionDefinition {
574
658
  /** Generic keys of the function */
575
659
  genericKeys?: Maybe<Array<Scalars['String']['output']>>;
576
660
  /** Global ID of this FunctionDefinition */
577
- id: Scalars['FunctionDefinitionID']['output'];
661
+ id?: Maybe<Scalars['FunctionDefinitionID']['output']>;
662
+ /** Identifier of the function */
663
+ identifier?: Maybe<Scalars['String']['output']>;
578
664
  /** Name of the function */
579
665
  names?: Maybe<TranslationConnection>;
580
666
  /** Parameters of the function */
@@ -584,9 +670,9 @@ export interface FunctionDefinition {
584
670
  /** Runtime function definition */
585
671
  runtimeFunctionDefinition?: Maybe<RuntimeFunctionDefinition>;
586
672
  /** Indicates if the function can throw an error */
587
- throwsError: Scalars['Boolean']['output'];
673
+ throwsError?: Maybe<Scalars['Boolean']['output']>;
588
674
  /** Time when this FunctionDefinition was last updated */
589
- updatedAt: Scalars['Time']['output'];
675
+ updatedAt?: Maybe<Scalars['Time']['output']>;
590
676
  }
591
677
 
592
678
 
@@ -638,20 +724,20 @@ export interface FunctionDefinitionParameterDefinitionsArgs {
638
724
  export interface FunctionDefinitionConnection {
639
725
  __typename?: 'FunctionDefinitionConnection';
640
726
  /** Total count of collection. */
641
- count: Scalars['Int']['output'];
727
+ count?: Maybe<Scalars['Int']['output']>;
642
728
  /** A list of edges. */
643
729
  edges?: Maybe<Array<Maybe<FunctionDefinitionEdge>>>;
644
730
  /** A list of nodes. */
645
731
  nodes?: Maybe<Array<Maybe<FunctionDefinition>>>;
646
732
  /** Information to aid in pagination. */
647
- pageInfo: PageInfo;
733
+ pageInfo?: Maybe<PageInfo>;
648
734
  }
649
735
 
650
736
  /** An edge in a connection. */
651
737
  export interface FunctionDefinitionEdge {
652
738
  __typename?: 'FunctionDefinitionEdge';
653
739
  /** A cursor for use in pagination. */
654
- cursor: Scalars['String']['output'];
740
+ cursor?: Maybe<Scalars['String']['output']>;
655
741
  /** The item at the end of the edge. */
656
742
  node?: Maybe<FunctionDefinition>;
657
743
  }
@@ -660,19 +746,19 @@ export interface FunctionDefinitionEdge {
660
746
  export interface GenericCombinationStrategy {
661
747
  __typename?: 'GenericCombinationStrategy';
662
748
  /** Time when this GenericCombinationStrategy was created */
663
- createdAt: Scalars['Time']['output'];
749
+ createdAt?: Maybe<Scalars['Time']['output']>;
664
750
  /** The associated generic mapper, if any. */
665
751
  genericMapper?: Maybe<GenericMapper>;
666
752
  /** Global ID of this GenericCombinationStrategy */
667
- id: Scalars['GenericCombinationStrategyID']['output'];
753
+ id?: Maybe<Scalars['GenericCombinationStrategyID']['output']>;
668
754
  /** The combination type ('AND' or 'OR'). */
669
- type: GenericCombinationStrategyType;
755
+ type?: Maybe<GenericCombinationStrategyType>;
670
756
  /** Time when this GenericCombinationStrategy was last updated */
671
- updatedAt: Scalars['Time']['output'];
757
+ updatedAt?: Maybe<Scalars['Time']['output']>;
672
758
  }
673
759
 
674
760
  /** The available combination strategy types. */
675
- export enum GenericCombinationStrategyType {
761
+ export const enum GenericCombinationStrategyType {
676
762
  /** Represents a logical AND combination. */
677
763
  And = 'AND',
678
764
  /** Represents a logical OR combination. */
@@ -683,17 +769,17 @@ export enum GenericCombinationStrategyType {
683
769
  export interface GenericMapper {
684
770
  __typename?: 'GenericMapper';
685
771
  /** Time when this GenericMapper was created */
686
- createdAt: Scalars['Time']['output'];
772
+ createdAt?: Maybe<Scalars['Time']['output']>;
687
773
  /** Combination strategies associated with this generic mapper. */
688
774
  genericCombinationStrategies?: Maybe<Array<GenericCombinationStrategy>>;
689
775
  /** Global ID of this GenericMapper */
690
- id: Scalars['GenericMapperID']['output'];
776
+ id?: Maybe<Scalars['GenericMapperID']['output']>;
691
777
  /** The source data type identifier. */
692
- sources: Array<DataTypeIdentifier>;
778
+ sourceDataTypeIdentifiers?: Maybe<Array<DataTypeIdentifier>>;
693
779
  /** The target key for the generic value. */
694
- target: Scalars['String']['output'];
780
+ target?: Maybe<Scalars['String']['output']>;
695
781
  /** Time when this GenericMapper was last updated */
696
- updatedAt: Scalars['Time']['output'];
782
+ updatedAt?: Maybe<Scalars['Time']['output']>;
697
783
  }
698
784
 
699
785
  /** Input type for generic mappers */
@@ -708,15 +794,15 @@ export interface GenericMapperInput {
708
794
  export interface GenericType {
709
795
  __typename?: 'GenericType';
710
796
  /** Time when this GenericType was created */
711
- createdAt: Scalars['Time']['output'];
797
+ createdAt?: Maybe<Scalars['Time']['output']>;
712
798
  /** The data type associated with this generic type. */
713
- dataType: DataType;
799
+ dataType?: Maybe<DataType>;
714
800
  /** The mappers associated with this generic type. */
715
- genericMappers: Array<GenericMapper>;
801
+ genericMappers?: Maybe<Array<GenericMapper>>;
716
802
  /** Global ID of this GenericType */
717
- id: Scalars['GenericTypeID']['output'];
803
+ id?: Maybe<Scalars['GenericTypeID']['output']>;
718
804
  /** Time when this GenericType was last updated */
719
- updatedAt: Scalars['Time']['output'];
805
+ updatedAt?: Maybe<Scalars['Time']['output']>;
720
806
  }
721
807
 
722
808
  /** Input type for generic type operations. */
@@ -737,18 +823,18 @@ export interface IdentityInput {
737
823
  export interface LiteralValue {
738
824
  __typename?: 'LiteralValue';
739
825
  /** Time when this LiteralValue was created */
740
- createdAt: Scalars['Time']['output'];
826
+ createdAt?: Maybe<Scalars['Time']['output']>;
741
827
  /** Time when this LiteralValue was last updated */
742
- updatedAt: Scalars['Time']['output'];
828
+ updatedAt?: Maybe<Scalars['Time']['output']>;
743
829
  /** The literal value itself as JSON. */
744
- value: Scalars['JSON']['output'];
830
+ value?: Maybe<Scalars['JSON']['output']>;
745
831
  }
746
832
 
747
833
  /** Represents an error message */
748
834
  export interface MessageError {
749
835
  __typename?: 'MessageError';
750
836
  /** The message provided from the error */
751
- message: Scalars['String']['output'];
837
+ message?: Maybe<Scalars['String']['output']>;
752
838
  }
753
839
 
754
840
  /** Represents the input for mfa authentication */
@@ -760,7 +846,7 @@ export interface MfaInput {
760
846
  }
761
847
 
762
848
  /** Represent all available types to authenticate with mfa */
763
- export enum MfaType {
849
+ export const enum MfaType {
764
850
  /** Single use backup code */
765
851
  BackupCode = 'BACKUP_CODE',
766
852
  /** Time based onetime password */
@@ -777,11 +863,12 @@ export interface Mutation {
777
863
  *
778
864
  * This is expected to be used for testing of endpoints, to verify
779
865
  * that a user has mutation access.
866
+ *
780
867
  */
781
868
  echo?: Maybe<EchoPayload>;
782
- /** Create a new namespace license. */
869
+ /** (EE only) Create a new namespace license. */
783
870
  namespacesLicensesCreate?: Maybe<NamespacesLicensesCreatePayload>;
784
- /** Deletes an namespace license. */
871
+ /** (EE only) Deletes an namespace license. */
785
872
  namespacesLicensesDelete?: Maybe<NamespacesLicensesDeletePayload>;
786
873
  /** Update the roles a member is assigned to. */
787
874
  namespacesMembersAssignRoles?: Maybe<NamespacesMembersAssignRolesPayload>;
@@ -825,6 +912,8 @@ export interface Mutation {
825
912
  runtimesRotateToken?: Maybe<RuntimesRotateTokenPayload>;
826
913
  /** Update an existing runtime. */
827
914
  runtimesUpdate?: Maybe<RuntimesUpdatePayload>;
915
+ /** Verify your email when changing it or signing up */
916
+ usersEmailVerification?: Maybe<UsersEmailVerificationPayload>;
828
917
  /** Links an external identity to an existing user */
829
918
  usersIdentityLink?: Maybe<UsersIdentityLinkPayload>;
830
919
  /** Login to an existing user via an external identity */
@@ -843,6 +932,10 @@ export interface Mutation {
843
932
  usersMfaTotpGenerateSecret?: Maybe<UsersMfaTotpGenerateSecretPayload>;
844
933
  /** Validates a TOTP value for the given secret and enables TOTP MFA for the user */
845
934
  usersMfaTotpValidateSecret?: Maybe<UsersMfaTotpValidateSecretPayload>;
935
+ /** Reset the password using a reset token */
936
+ usersPasswordReset?: Maybe<UsersPasswordResetPayload>;
937
+ /** Request an password reset */
938
+ usersPasswordResetRequest?: Maybe<UsersPasswordResetRequestPayload>;
846
939
  /** Register a new user */
847
940
  usersRegister?: Maybe<UsersRegisterPayload>;
848
941
  /** Update an existing user. */
@@ -1000,6 +1093,12 @@ export interface MutationRuntimesUpdateArgs {
1000
1093
  }
1001
1094
 
1002
1095
 
1096
+ /** Root Mutation type */
1097
+ export interface MutationUsersEmailVerificationArgs {
1098
+ input: UsersEmailVerificationInput;
1099
+ }
1100
+
1101
+
1003
1102
  /** Root Mutation type */
1004
1103
  export interface MutationUsersIdentityLinkArgs {
1005
1104
  input: UsersIdentityLinkInput;
@@ -1054,6 +1153,18 @@ export interface MutationUsersMfaTotpValidateSecretArgs {
1054
1153
  }
1055
1154
 
1056
1155
 
1156
+ /** Root Mutation type */
1157
+ export interface MutationUsersPasswordResetArgs {
1158
+ input: UsersPasswordResetInput;
1159
+ }
1160
+
1161
+
1162
+ /** Root Mutation type */
1163
+ export interface MutationUsersPasswordResetRequestArgs {
1164
+ input: UsersPasswordResetRequestInput;
1165
+ }
1166
+
1167
+
1057
1168
  /** Root Mutation type */
1058
1169
  export interface MutationUsersRegisterArgs {
1059
1170
  input: UsersRegisterInput;
@@ -1069,23 +1180,23 @@ export interface MutationUsersUpdateArgs {
1069
1180
  export interface Namespace {
1070
1181
  __typename?: 'Namespace';
1071
1182
  /** Time when this Namespace was created */
1072
- createdAt: Scalars['Time']['output'];
1183
+ createdAt?: Maybe<Scalars['Time']['output']>;
1073
1184
  /** Global ID of this Namespace */
1074
- id: Scalars['NamespaceID']['output'];
1185
+ id?: Maybe<Scalars['NamespaceID']['output']>;
1075
1186
  /** Members of the namespace */
1076
- members: NamespaceMemberConnection;
1077
- /** Licenses of the namespace */
1078
- namespaceLicenses: NamespaceLicenseConnection;
1187
+ members?: Maybe<NamespaceMemberConnection>;
1188
+ /** (EE only) Licenses of the namespace */
1189
+ namespaceLicenses?: Maybe<NamespaceLicenseConnection>;
1079
1190
  /** Parent of this namespace */
1080
- parent: NamespaceParent;
1191
+ parent?: Maybe<NamespaceParent>;
1081
1192
  /** Projects of the namespace */
1082
- projects: NamespaceProjectConnection;
1193
+ projects?: Maybe<NamespaceProjectConnection>;
1083
1194
  /** Roles of the namespace */
1084
- roles: NamespaceRoleConnection;
1195
+ roles?: Maybe<NamespaceRoleConnection>;
1085
1196
  /** Runtime of the namespace */
1086
- runtimes: RuntimeConnection;
1197
+ runtimes?: Maybe<RuntimeConnection>;
1087
1198
  /** Time when this Namespace was last updated */
1088
- updatedAt: Scalars['Time']['output'];
1199
+ updatedAt?: Maybe<Scalars['Time']['output']>;
1089
1200
  }
1090
1201
 
1091
1202
 
@@ -1133,37 +1244,43 @@ export interface NamespaceRuntimesArgs {
1133
1244
  last?: InputMaybe<Scalars['Int']['input']>;
1134
1245
  }
1135
1246
 
1136
- /** Represents a Namespace License */
1247
+ /** (EE only) Represents a Namespace License */
1137
1248
  export interface NamespaceLicense {
1138
1249
  __typename?: 'NamespaceLicense';
1139
1250
  /** Time when this NamespaceLicense was created */
1140
- createdAt: Scalars['Time']['output'];
1251
+ createdAt?: Maybe<Scalars['Time']['output']>;
1252
+ /** The end date of the license */
1253
+ endDate?: Maybe<Scalars['Time']['output']>;
1141
1254
  /** Global ID of this NamespaceLicense */
1142
- id: Scalars['NamespaceLicenseID']['output'];
1255
+ id?: Maybe<Scalars['NamespaceLicenseID']['output']>;
1256
+ /** The licensee information */
1257
+ licensee?: Maybe<Scalars['JSON']['output']>;
1143
1258
  /** The namespace the license belongs to */
1144
- namespace: Namespace;
1259
+ namespace?: Maybe<Namespace>;
1260
+ /** The start date of the license */
1261
+ startDate?: Maybe<Scalars['Time']['output']>;
1145
1262
  /** Time when this NamespaceLicense was last updated */
1146
- updatedAt: Scalars['Time']['output'];
1263
+ updatedAt?: Maybe<Scalars['Time']['output']>;
1147
1264
  }
1148
1265
 
1149
1266
  /** The connection type for NamespaceLicense. */
1150
1267
  export interface NamespaceLicenseConnection {
1151
1268
  __typename?: 'NamespaceLicenseConnection';
1152
1269
  /** Total count of collection. */
1153
- count: Scalars['Int']['output'];
1270
+ count?: Maybe<Scalars['Int']['output']>;
1154
1271
  /** A list of edges. */
1155
1272
  edges?: Maybe<Array<Maybe<NamespaceLicenseEdge>>>;
1156
1273
  /** A list of nodes. */
1157
1274
  nodes?: Maybe<Array<Maybe<NamespaceLicense>>>;
1158
1275
  /** Information to aid in pagination. */
1159
- pageInfo: PageInfo;
1276
+ pageInfo?: Maybe<PageInfo>;
1160
1277
  }
1161
1278
 
1162
1279
  /** An edge in a connection. */
1163
1280
  export interface NamespaceLicenseEdge {
1164
1281
  __typename?: 'NamespaceLicenseEdge';
1165
1282
  /** A cursor for use in pagination. */
1166
- cursor: Scalars['String']['output'];
1283
+ cursor?: Maybe<Scalars['String']['output']>;
1167
1284
  /** The item at the end of the edge. */
1168
1285
  node?: Maybe<NamespaceLicense>;
1169
1286
  }
@@ -1172,35 +1289,57 @@ export interface NamespaceLicenseEdge {
1172
1289
  export interface NamespaceMember {
1173
1290
  __typename?: 'NamespaceMember';
1174
1291
  /** Time when this NamespaceMember was created */
1175
- createdAt: Scalars['Time']['output'];
1292
+ createdAt?: Maybe<Scalars['Time']['output']>;
1176
1293
  /** Global ID of this NamespaceMember */
1177
- id: Scalars['NamespaceMemberID']['output'];
1294
+ id?: Maybe<Scalars['NamespaceMemberID']['output']>;
1295
+ /** Memberroles of the member */
1296
+ memberRoles?: Maybe<NamespaceMemberRoleConnection>;
1178
1297
  /** Namespace this member belongs to */
1179
- namespace: Namespace;
1298
+ namespace?: Maybe<Namespace>;
1299
+ /** Roles of the member */
1300
+ roles?: Maybe<NamespaceRoleConnection>;
1180
1301
  /** Time when this NamespaceMember was last updated */
1181
- updatedAt: Scalars['Time']['output'];
1302
+ updatedAt?: Maybe<Scalars['Time']['output']>;
1182
1303
  /** User this member belongs to */
1183
- user: User;
1304
+ user?: Maybe<User>;
1305
+ }
1306
+
1307
+
1308
+ /** Represents a namespace member */
1309
+ export interface NamespaceMemberMemberRolesArgs {
1310
+ after?: InputMaybe<Scalars['String']['input']>;
1311
+ before?: InputMaybe<Scalars['String']['input']>;
1312
+ first?: InputMaybe<Scalars['Int']['input']>;
1313
+ last?: InputMaybe<Scalars['Int']['input']>;
1314
+ }
1315
+
1316
+
1317
+ /** Represents a namespace member */
1318
+ export interface NamespaceMemberRolesArgs {
1319
+ after?: InputMaybe<Scalars['String']['input']>;
1320
+ before?: InputMaybe<Scalars['String']['input']>;
1321
+ first?: InputMaybe<Scalars['Int']['input']>;
1322
+ last?: InputMaybe<Scalars['Int']['input']>;
1184
1323
  }
1185
1324
 
1186
1325
  /** The connection type for NamespaceMember. */
1187
1326
  export interface NamespaceMemberConnection {
1188
1327
  __typename?: 'NamespaceMemberConnection';
1189
1328
  /** Total count of collection. */
1190
- count: Scalars['Int']['output'];
1329
+ count?: Maybe<Scalars['Int']['output']>;
1191
1330
  /** A list of edges. */
1192
1331
  edges?: Maybe<Array<Maybe<NamespaceMemberEdge>>>;
1193
1332
  /** A list of nodes. */
1194
1333
  nodes?: Maybe<Array<Maybe<NamespaceMember>>>;
1195
1334
  /** Information to aid in pagination. */
1196
- pageInfo: PageInfo;
1335
+ pageInfo?: Maybe<PageInfo>;
1197
1336
  }
1198
1337
 
1199
1338
  /** An edge in a connection. */
1200
1339
  export interface NamespaceMemberEdge {
1201
1340
  __typename?: 'NamespaceMemberEdge';
1202
1341
  /** A cursor for use in pagination. */
1203
- cursor: Scalars['String']['output'];
1342
+ cursor?: Maybe<Scalars['String']['output']>;
1204
1343
  /** The item at the end of the edge. */
1205
1344
  node?: Maybe<NamespaceMember>;
1206
1345
  }
@@ -1209,43 +1348,65 @@ export interface NamespaceMemberEdge {
1209
1348
  export interface NamespaceMemberRole {
1210
1349
  __typename?: 'NamespaceMemberRole';
1211
1350
  /** Time when this NamespaceMemberRole was created */
1212
- createdAt: Scalars['Time']['output'];
1351
+ createdAt?: Maybe<Scalars['Time']['output']>;
1213
1352
  /** Global ID of this NamespaceMemberRole */
1214
- id: Scalars['NamespaceMemberRoleID']['output'];
1353
+ id?: Maybe<Scalars['NamespaceMemberRoleID']['output']>;
1215
1354
  /** The member the role is assigned to */
1216
1355
  member?: Maybe<NamespaceMember>;
1217
1356
  /** The assigned role */
1218
1357
  role?: Maybe<NamespaceRole>;
1219
1358
  /** Time when this NamespaceMemberRole was last updated */
1220
- updatedAt: Scalars['Time']['output'];
1359
+ updatedAt?: Maybe<Scalars['Time']['output']>;
1360
+ }
1361
+
1362
+ /** The connection type for NamespaceMemberRole. */
1363
+ export interface NamespaceMemberRoleConnection {
1364
+ __typename?: 'NamespaceMemberRoleConnection';
1365
+ /** Total count of collection. */
1366
+ count?: Maybe<Scalars['Int']['output']>;
1367
+ /** A list of edges. */
1368
+ edges?: Maybe<Array<Maybe<NamespaceMemberRoleEdge>>>;
1369
+ /** A list of nodes. */
1370
+ nodes?: Maybe<Array<Maybe<NamespaceMemberRole>>>;
1371
+ /** Information to aid in pagination. */
1372
+ pageInfo?: Maybe<PageInfo>;
1373
+ }
1374
+
1375
+ /** An edge in a connection. */
1376
+ export interface NamespaceMemberRoleEdge {
1377
+ __typename?: 'NamespaceMemberRoleEdge';
1378
+ /** A cursor for use in pagination. */
1379
+ cursor?: Maybe<Scalars['String']['output']>;
1380
+ /** The item at the end of the edge. */
1381
+ node?: Maybe<NamespaceMemberRole>;
1221
1382
  }
1222
1383
 
1223
1384
  /** Objects that can present a namespace */
1224
- export type NamespaceParent = Organization;
1385
+ export type NamespaceParent = Organization | User;
1225
1386
 
1226
1387
  /** Represents a namespace project */
1227
1388
  export interface NamespaceProject {
1228
1389
  __typename?: 'NamespaceProject';
1229
1390
  /** Time when this NamespaceProject was created */
1230
- createdAt: Scalars['Time']['output'];
1391
+ createdAt?: Maybe<Scalars['Time']['output']>;
1231
1392
  /** Description of the project */
1232
- description: Scalars['String']['output'];
1393
+ description?: Maybe<Scalars['String']['output']>;
1233
1394
  /** Fetches an flow given by its ID */
1234
1395
  flow?: Maybe<Flow>;
1235
1396
  /** Fetches all flows in this project */
1236
1397
  flows?: Maybe<FlowConnection>;
1237
1398
  /** Global ID of this NamespaceProject */
1238
- id: Scalars['NamespaceProjectID']['output'];
1399
+ id?: Maybe<Scalars['NamespaceProjectID']['output']>;
1239
1400
  /** Name of the project */
1240
- name: Scalars['String']['output'];
1401
+ name?: Maybe<Scalars['String']['output']>;
1241
1402
  /** The namespace where this project belongs to */
1242
- namespace: Namespace;
1403
+ namespace?: Maybe<Namespace>;
1243
1404
  /** The primary runtime for the project */
1244
1405
  primaryRuntime?: Maybe<Runtime>;
1245
1406
  /** Runtimes assigned to this project */
1246
- runtimes: RuntimeConnection;
1407
+ runtimes?: Maybe<RuntimeConnection>;
1247
1408
  /** Time when this NamespaceProject was last updated */
1248
- updatedAt: Scalars['Time']['output'];
1409
+ updatedAt?: Maybe<Scalars['Time']['output']>;
1249
1410
  }
1250
1411
 
1251
1412
 
@@ -1276,20 +1437,20 @@ export interface NamespaceProjectRuntimesArgs {
1276
1437
  export interface NamespaceProjectConnection {
1277
1438
  __typename?: 'NamespaceProjectConnection';
1278
1439
  /** Total count of collection. */
1279
- count: Scalars['Int']['output'];
1440
+ count?: Maybe<Scalars['Int']['output']>;
1280
1441
  /** A list of edges. */
1281
1442
  edges?: Maybe<Array<Maybe<NamespaceProjectEdge>>>;
1282
1443
  /** A list of nodes. */
1283
1444
  nodes?: Maybe<Array<Maybe<NamespaceProject>>>;
1284
1445
  /** Information to aid in pagination. */
1285
- pageInfo: PageInfo;
1446
+ pageInfo?: Maybe<PageInfo>;
1286
1447
  }
1287
1448
 
1288
1449
  /** An edge in a connection. */
1289
1450
  export interface NamespaceProjectEdge {
1290
1451
  __typename?: 'NamespaceProjectEdge';
1291
1452
  /** A cursor for use in pagination. */
1292
- cursor: Scalars['String']['output'];
1453
+ cursor?: Maybe<Scalars['String']['output']>;
1293
1454
  /** The item at the end of the edge. */
1294
1455
  node?: Maybe<NamespaceProject>;
1295
1456
  }
@@ -1298,19 +1459,19 @@ export interface NamespaceProjectEdge {
1298
1459
  export interface NamespaceRole {
1299
1460
  __typename?: 'NamespaceRole';
1300
1461
  /** The abilities the role is granted */
1301
- abilities: Array<NamespaceRoleAbility>;
1462
+ abilities?: Maybe<Array<NamespaceRoleAbility>>;
1302
1463
  /** The projects this role is assigned to */
1303
1464
  assignedProjects?: Maybe<NamespaceProjectConnection>;
1304
1465
  /** Time when this NamespaceRole was created */
1305
- createdAt: Scalars['Time']['output'];
1466
+ createdAt?: Maybe<Scalars['Time']['output']>;
1306
1467
  /** Global ID of this NamespaceRole */
1307
- id: Scalars['NamespaceRoleID']['output'];
1468
+ id?: Maybe<Scalars['NamespaceRoleID']['output']>;
1308
1469
  /** The name of this role */
1309
- name: Scalars['String']['output'];
1470
+ name?: Maybe<Scalars['String']['output']>;
1310
1471
  /** The namespace where this role belongs to */
1311
1472
  namespace?: Maybe<Namespace>;
1312
1473
  /** Time when this NamespaceRole was last updated */
1313
- updatedAt: Scalars['Time']['output'];
1474
+ updatedAt?: Maybe<Scalars['Time']['output']>;
1314
1475
  }
1315
1476
 
1316
1477
 
@@ -1323,7 +1484,7 @@ export interface NamespaceRoleAssignedProjectsArgs {
1323
1484
  }
1324
1485
 
1325
1486
  /** Represents abilities that can be granted to roles in namespaces. */
1326
- export enum NamespaceRoleAbility {
1487
+ export const enum NamespaceRoleAbility {
1327
1488
  /** Allows to change the roles of a namespace member */
1328
1489
  AssignMemberRoles = 'ASSIGN_MEMBER_ROLES',
1329
1490
  /** Allows to assign runtimes to a project in the namespace */
@@ -1382,20 +1543,20 @@ export enum NamespaceRoleAbility {
1382
1543
  export interface NamespaceRoleConnection {
1383
1544
  __typename?: 'NamespaceRoleConnection';
1384
1545
  /** Total count of collection. */
1385
- count: Scalars['Int']['output'];
1546
+ count?: Maybe<Scalars['Int']['output']>;
1386
1547
  /** A list of edges. */
1387
1548
  edges?: Maybe<Array<Maybe<NamespaceRoleEdge>>>;
1388
1549
  /** A list of nodes. */
1389
1550
  nodes?: Maybe<Array<Maybe<NamespaceRole>>>;
1390
1551
  /** Information to aid in pagination. */
1391
- pageInfo: PageInfo;
1552
+ pageInfo?: Maybe<PageInfo>;
1392
1553
  }
1393
1554
 
1394
1555
  /** An edge in a connection. */
1395
1556
  export interface NamespaceRoleEdge {
1396
1557
  __typename?: 'NamespaceRoleEdge';
1397
1558
  /** A cursor for use in pagination. */
1398
- cursor: Scalars['String']['output'];
1559
+ cursor?: Maybe<Scalars['String']['output']>;
1399
1560
  /** The item at the end of the edge. */
1400
1561
  node?: Maybe<NamespaceRole>;
1401
1562
  }
@@ -1416,7 +1577,7 @@ export interface NamespacesLicensesCreatePayload {
1416
1577
  /** A unique identifier for the client performing the mutation. */
1417
1578
  clientMutationId?: Maybe<Scalars['String']['output']>;
1418
1579
  /** Errors encountered during execution of the mutation. */
1419
- errors: Array<Error>;
1580
+ errors?: Maybe<Array<Error>>;
1420
1581
  /** The newly created license. */
1421
1582
  namespaceLicense?: Maybe<NamespaceLicense>;
1422
1583
  }
@@ -1435,7 +1596,7 @@ export interface NamespacesLicensesDeletePayload {
1435
1596
  /** A unique identifier for the client performing the mutation. */
1436
1597
  clientMutationId?: Maybe<Scalars['String']['output']>;
1437
1598
  /** Errors encountered during execution of the mutation. */
1438
- errors: Array<Error>;
1599
+ errors?: Maybe<Array<Error>>;
1439
1600
  /** The deleted namespace license. */
1440
1601
  namespaceLicense?: Maybe<NamespaceLicense>;
1441
1602
  }
@@ -1456,7 +1617,7 @@ export interface NamespacesMembersAssignRolesPayload {
1456
1617
  /** A unique identifier for the client performing the mutation. */
1457
1618
  clientMutationId?: Maybe<Scalars['String']['output']>;
1458
1619
  /** Errors encountered during execution of the mutation. */
1459
- errors: Array<Error>;
1620
+ errors?: Maybe<Array<Error>>;
1460
1621
  /** The roles the member is now assigned to */
1461
1622
  namespaceMemberRoles?: Maybe<Array<NamespaceMemberRole>>;
1462
1623
  }
@@ -1475,7 +1636,7 @@ export interface NamespacesMembersDeletePayload {
1475
1636
  /** A unique identifier for the client performing the mutation. */
1476
1637
  clientMutationId?: Maybe<Scalars['String']['output']>;
1477
1638
  /** Errors encountered during execution of the mutation. */
1478
- errors: Array<Error>;
1639
+ errors?: Maybe<Array<Error>>;
1479
1640
  /** The removed namespace member */
1480
1641
  namespaceMember?: Maybe<NamespaceMember>;
1481
1642
  }
@@ -1496,7 +1657,7 @@ export interface NamespacesMembersInvitePayload {
1496
1657
  /** A unique identifier for the client performing the mutation. */
1497
1658
  clientMutationId?: Maybe<Scalars['String']['output']>;
1498
1659
  /** Errors encountered during execution of the mutation. */
1499
- errors: Array<Error>;
1660
+ errors?: Maybe<Array<Error>>;
1500
1661
  /** The newly created namespace member */
1501
1662
  namespaceMember?: Maybe<NamespaceMember>;
1502
1663
  }
@@ -1517,7 +1678,7 @@ export interface NamespacesProjectsAssignRuntimesPayload {
1517
1678
  /** A unique identifier for the client performing the mutation. */
1518
1679
  clientMutationId?: Maybe<Scalars['String']['output']>;
1519
1680
  /** Errors encountered during execution of the mutation. */
1520
- errors: Array<Error>;
1681
+ errors?: Maybe<Array<Error>>;
1521
1682
  /** The updated project with assigned runtimes */
1522
1683
  namespaceProject?: Maybe<NamespaceProject>;
1523
1684
  }
@@ -1540,7 +1701,7 @@ export interface NamespacesProjectsCreatePayload {
1540
1701
  /** A unique identifier for the client performing the mutation. */
1541
1702
  clientMutationId?: Maybe<Scalars['String']['output']>;
1542
1703
  /** Errors encountered during execution of the mutation. */
1543
- errors: Array<Error>;
1704
+ errors?: Maybe<Array<Error>>;
1544
1705
  /** The newly created project. */
1545
1706
  namespaceProject?: Maybe<NamespaceProject>;
1546
1707
  }
@@ -1559,7 +1720,7 @@ export interface NamespacesProjectsDeletePayload {
1559
1720
  /** A unique identifier for the client performing the mutation. */
1560
1721
  clientMutationId?: Maybe<Scalars['String']['output']>;
1561
1722
  /** Errors encountered during execution of the mutation. */
1562
- errors: Array<Error>;
1723
+ errors?: Maybe<Array<Error>>;
1563
1724
  /** The deleted project. */
1564
1725
  namespaceProject?: Maybe<NamespaceProject>;
1565
1726
  }
@@ -1580,7 +1741,7 @@ export interface NamespacesProjectsFlowsCreatePayload {
1580
1741
  /** A unique identifier for the client performing the mutation. */
1581
1742
  clientMutationId?: Maybe<Scalars['String']['output']>;
1582
1743
  /** Errors encountered during execution of the mutation. */
1583
- errors: Array<Error>;
1744
+ errors?: Maybe<Array<Error>>;
1584
1745
  /** The newly created flow. */
1585
1746
  flow?: Maybe<Flow>;
1586
1747
  }
@@ -1599,7 +1760,7 @@ export interface NamespacesProjectsFlowsDeletePayload {
1599
1760
  /** A unique identifier for the client performing the mutation. */
1600
1761
  clientMutationId?: Maybe<Scalars['String']['output']>;
1601
1762
  /** Errors encountered during execution of the mutation. */
1602
- errors: Array<Error>;
1763
+ errors?: Maybe<Array<Error>>;
1603
1764
  /** The deleted flow. */
1604
1765
  flow?: Maybe<Flow>;
1605
1766
  }
@@ -1624,7 +1785,7 @@ export interface NamespacesProjectsUpdatePayload {
1624
1785
  /** A unique identifier for the client performing the mutation. */
1625
1786
  clientMutationId?: Maybe<Scalars['String']['output']>;
1626
1787
  /** Errors encountered during execution of the mutation. */
1627
- errors: Array<Error>;
1788
+ errors?: Maybe<Array<Error>>;
1628
1789
  /** The updated project. */
1629
1790
  namespaceProject?: Maybe<NamespaceProject>;
1630
1791
  }
@@ -1647,7 +1808,7 @@ export interface NamespacesRolesAssignAbilitiesPayload {
1647
1808
  /** A unique identifier for the client performing the mutation. */
1648
1809
  clientMutationId?: Maybe<Scalars['String']['output']>;
1649
1810
  /** Errors encountered during execution of the mutation. */
1650
- errors: Array<Error>;
1811
+ errors?: Maybe<Array<Error>>;
1651
1812
  }
1652
1813
 
1653
1814
  /** Autogenerated input type of NamespacesRolesAssignProjects */
@@ -1666,7 +1827,7 @@ export interface NamespacesRolesAssignProjectsPayload {
1666
1827
  /** A unique identifier for the client performing the mutation. */
1667
1828
  clientMutationId?: Maybe<Scalars['String']['output']>;
1668
1829
  /** Errors encountered during execution of the mutation. */
1669
- errors: Array<Error>;
1830
+ errors?: Maybe<Array<Error>>;
1670
1831
  /** The now assigned projects */
1671
1832
  projects?: Maybe<Array<NamespaceProject>>;
1672
1833
  }
@@ -1687,7 +1848,7 @@ export interface NamespacesRolesCreatePayload {
1687
1848
  /** A unique identifier for the client performing the mutation. */
1688
1849
  clientMutationId?: Maybe<Scalars['String']['output']>;
1689
1850
  /** Errors encountered during execution of the mutation. */
1690
- errors: Array<Error>;
1851
+ errors?: Maybe<Array<Error>>;
1691
1852
  /** The newly created namespace role */
1692
1853
  namespaceRole?: Maybe<NamespaceRole>;
1693
1854
  }
@@ -1706,7 +1867,7 @@ export interface NamespacesRolesDeletePayload {
1706
1867
  /** A unique identifier for the client performing the mutation. */
1707
1868
  clientMutationId?: Maybe<Scalars['String']['output']>;
1708
1869
  /** Errors encountered during execution of the mutation. */
1709
- errors: Array<Error>;
1870
+ errors?: Maybe<Array<Error>>;
1710
1871
  /** The deleted namespace role */
1711
1872
  namespaceRole?: Maybe<NamespaceRole>;
1712
1873
  }
@@ -1727,7 +1888,7 @@ export interface NamespacesRolesUpdatePayload {
1727
1888
  /** A unique identifier for the client performing the mutation. */
1728
1889
  clientMutationId?: Maybe<Scalars['String']['output']>;
1729
1890
  /** Errors encountered during execution of the mutation. */
1730
- errors: Array<Error>;
1891
+ errors?: Maybe<Array<Error>>;
1731
1892
  /** The updated namespace role. */
1732
1893
  namespaceRole?: Maybe<NamespaceRole>;
1733
1894
  }
@@ -1735,24 +1896,24 @@ export interface NamespacesRolesUpdatePayload {
1735
1896
  /** An object with an ID. */
1736
1897
  export interface Node {
1737
1898
  /** ID of the object. */
1738
- id: Scalars['ID']['output'];
1899
+ id?: Maybe<Scalars['ID']['output']>;
1739
1900
  }
1740
1901
 
1741
1902
  /** Represents a Node Function */
1742
1903
  export interface NodeFunction {
1743
1904
  __typename?: 'NodeFunction';
1744
1905
  /** Time when this NodeFunction was created */
1745
- createdAt: Scalars['Time']['output'];
1906
+ createdAt?: Maybe<Scalars['Time']['output']>;
1907
+ /** The definition of the Node Function */
1908
+ functionDefinition?: Maybe<FunctionDefinition>;
1746
1909
  /** Global ID of this NodeFunction */
1747
- id: Scalars['NodeFunctionID']['output'];
1748
- /** The next Node Function in the flow */
1749
- nextNode?: Maybe<NodeFunction>;
1910
+ id?: Maybe<Scalars['NodeFunctionID']['output']>;
1911
+ /** The ID of the next Node Function in the flow */
1912
+ nextNodeId?: Maybe<Scalars['NodeFunctionID']['output']>;
1750
1913
  /** The parameters of the Node Function */
1751
- parameters: NodeParameterConnection;
1752
- /** The definition of the Node Function */
1753
- runtimeFunction: RuntimeFunctionDefinition;
1914
+ parameters?: Maybe<NodeParameterConnection>;
1754
1915
  /** Time when this NodeFunction was last updated */
1755
- updatedAt: Scalars['Time']['output'];
1916
+ updatedAt?: Maybe<Scalars['Time']['output']>;
1756
1917
  }
1757
1918
 
1758
1919
 
@@ -1764,6 +1925,28 @@ export interface NodeFunctionParametersArgs {
1764
1925
  last?: InputMaybe<Scalars['Int']['input']>;
1765
1926
  }
1766
1927
 
1928
+ /** The connection type for NodeFunction. */
1929
+ export interface NodeFunctionConnection {
1930
+ __typename?: 'NodeFunctionConnection';
1931
+ /** Total count of collection. */
1932
+ count?: Maybe<Scalars['Int']['output']>;
1933
+ /** A list of edges. */
1934
+ edges?: Maybe<Array<Maybe<NodeFunctionEdge>>>;
1935
+ /** A list of nodes. */
1936
+ nodes?: Maybe<Array<Maybe<NodeFunction>>>;
1937
+ /** Information to aid in pagination. */
1938
+ pageInfo?: Maybe<PageInfo>;
1939
+ }
1940
+
1941
+ /** An edge in a connection. */
1942
+ export interface NodeFunctionEdge {
1943
+ __typename?: 'NodeFunctionEdge';
1944
+ /** A cursor for use in pagination. */
1945
+ cursor?: Maybe<Scalars['String']['output']>;
1946
+ /** The item at the end of the edge. */
1947
+ node?: Maybe<NodeFunction>;
1948
+ }
1949
+
1767
1950
  /** Input type for a Node Function */
1768
1951
  export interface NodeFunctionInput {
1769
1952
  /** The next Node Function in the flow */
@@ -1778,13 +1961,13 @@ export interface NodeFunctionInput {
1778
1961
  export interface NodeParameter {
1779
1962
  __typename?: 'NodeParameter';
1780
1963
  /** Time when this NodeParameter was created */
1781
- createdAt: Scalars['Time']['output'];
1964
+ createdAt?: Maybe<Scalars['Time']['output']>;
1782
1965
  /** Global ID of this NodeParameter */
1783
- id: Scalars['NodeParameterID']['output'];
1966
+ id?: Maybe<Scalars['NodeParameterID']['output']>;
1784
1967
  /** The definition of the parameter */
1785
- runtimeParameter: RuntimeParameterDefinition;
1968
+ runtimeParameter?: Maybe<RuntimeParameterDefinition>;
1786
1969
  /** Time when this NodeParameter was last updated */
1787
- updatedAt: Scalars['Time']['output'];
1970
+ updatedAt?: Maybe<Scalars['Time']['output']>;
1788
1971
  /** The value of the parameter */
1789
1972
  value?: Maybe<NodeParameterValue>;
1790
1973
  }
@@ -1793,20 +1976,20 @@ export interface NodeParameter {
1793
1976
  export interface NodeParameterConnection {
1794
1977
  __typename?: 'NodeParameterConnection';
1795
1978
  /** Total count of collection. */
1796
- count: Scalars['Int']['output'];
1979
+ count?: Maybe<Scalars['Int']['output']>;
1797
1980
  /** A list of edges. */
1798
1981
  edges?: Maybe<Array<Maybe<NodeParameterEdge>>>;
1799
1982
  /** A list of nodes. */
1800
1983
  nodes?: Maybe<Array<Maybe<NodeParameter>>>;
1801
1984
  /** Information to aid in pagination. */
1802
- pageInfo: PageInfo;
1985
+ pageInfo?: Maybe<PageInfo>;
1803
1986
  }
1804
1987
 
1805
1988
  /** An edge in a connection. */
1806
1989
  export interface NodeParameterEdge {
1807
1990
  __typename?: 'NodeParameterEdge';
1808
1991
  /** A cursor for use in pagination. */
1809
- cursor: Scalars['String']['output'];
1992
+ cursor?: Maybe<Scalars['String']['output']>;
1810
1993
  /** The item at the end of the edge. */
1811
1994
  node?: Maybe<NodeParameter>;
1812
1995
  }
@@ -1836,15 +2019,15 @@ export interface NodeParameterValueInput {
1836
2019
  export interface Organization {
1837
2020
  __typename?: 'Organization';
1838
2021
  /** Time when this Organization was created */
1839
- createdAt: Scalars['Time']['output'];
2022
+ createdAt?: Maybe<Scalars['Time']['output']>;
1840
2023
  /** Global ID of this Organization */
1841
- id: Scalars['OrganizationID']['output'];
2024
+ id?: Maybe<Scalars['OrganizationID']['output']>;
1842
2025
  /** Name of the organization */
1843
- name: Scalars['String']['output'];
2026
+ name?: Maybe<Scalars['String']['output']>;
1844
2027
  /** Namespace of this organization */
1845
- namespace: Namespace;
2028
+ namespace?: Maybe<Namespace>;
1846
2029
  /** Time when this Organization was last updated */
1847
- updatedAt: Scalars['Time']['output'];
2030
+ updatedAt?: Maybe<Scalars['Time']['output']>;
1848
2031
  }
1849
2032
 
1850
2033
  /** Autogenerated input type of OrganizationsCreate */
@@ -1861,7 +2044,7 @@ export interface OrganizationsCreatePayload {
1861
2044
  /** A unique identifier for the client performing the mutation. */
1862
2045
  clientMutationId?: Maybe<Scalars['String']['output']>;
1863
2046
  /** Errors encountered during execution of the mutation. */
1864
- errors: Array<Error>;
2047
+ errors?: Maybe<Array<Error>>;
1865
2048
  /** The newly created organization. */
1866
2049
  organization?: Maybe<Organization>;
1867
2050
  }
@@ -1880,7 +2063,7 @@ export interface OrganizationsDeletePayload {
1880
2063
  /** A unique identifier for the client performing the mutation. */
1881
2064
  clientMutationId?: Maybe<Scalars['String']['output']>;
1882
2065
  /** Errors encountered during execution of the mutation. */
1883
- errors: Array<Error>;
2066
+ errors?: Maybe<Array<Error>>;
1884
2067
  /** The deleted organization. */
1885
2068
  organization?: Maybe<Organization>;
1886
2069
  }
@@ -1901,7 +2084,7 @@ export interface OrganizationsUpdatePayload {
1901
2084
  /** A unique identifier for the client performing the mutation. */
1902
2085
  clientMutationId?: Maybe<Scalars['String']['output']>;
1903
2086
  /** Errors encountered during execution of the mutation. */
1904
- errors: Array<Error>;
2087
+ errors?: Maybe<Array<Error>>;
1905
2088
  /** The updated organization. */
1906
2089
  organization?: Maybe<Organization>;
1907
2090
  }
@@ -1912,9 +2095,9 @@ export interface PageInfo {
1912
2095
  /** When paginating forwards, the cursor to continue. */
1913
2096
  endCursor?: Maybe<Scalars['String']['output']>;
1914
2097
  /** When paginating forwards, are there more items? */
1915
- hasNextPage: Scalars['Boolean']['output'];
2098
+ hasNextPage?: Maybe<Scalars['Boolean']['output']>;
1916
2099
  /** When paginating backwards, are there more items? */
1917
- hasPreviousPage: Scalars['Boolean']['output'];
2100
+ hasPreviousPage?: Maybe<Scalars['Boolean']['output']>;
1918
2101
  /** When paginating backwards, the cursor to continue. */
1919
2102
  startCursor?: Maybe<Scalars['String']['output']>;
1920
2103
  }
@@ -1923,19 +2106,21 @@ export interface PageInfo {
1923
2106
  export interface ParameterDefinition {
1924
2107
  __typename?: 'ParameterDefinition';
1925
2108
  /** Time when this ParameterDefinition was created */
1926
- createdAt: Scalars['Time']['output'];
2109
+ createdAt?: Maybe<Scalars['Time']['output']>;
1927
2110
  /** Data type of the parameter */
1928
- dataType?: Maybe<DataTypeIdentifier>;
2111
+ dataTypeIdentifier?: Maybe<DataTypeIdentifier>;
1929
2112
  /** Description of the parameter */
1930
2113
  descriptions?: Maybe<TranslationConnection>;
1931
2114
  /** Documentation of the parameter */
1932
2115
  documentations?: Maybe<TranslationConnection>;
1933
2116
  /** Global ID of this ParameterDefinition */
1934
- id: Scalars['ParameterDefinitionID']['output'];
2117
+ id?: Maybe<Scalars['ParameterDefinitionID']['output']>;
2118
+ /** Identifier of the parameter */
2119
+ identifier?: Maybe<Scalars['String']['output']>;
1935
2120
  /** Name of the parameter */
1936
2121
  names?: Maybe<TranslationConnection>;
1937
2122
  /** Time when this ParameterDefinition was last updated */
1938
- updatedAt: Scalars['Time']['output'];
2123
+ updatedAt?: Maybe<Scalars['Time']['output']>;
1939
2124
  }
1940
2125
 
1941
2126
 
@@ -1969,20 +2154,20 @@ export interface ParameterDefinitionNamesArgs {
1969
2154
  export interface ParameterDefinitionConnection {
1970
2155
  __typename?: 'ParameterDefinitionConnection';
1971
2156
  /** Total count of collection. */
1972
- count: Scalars['Int']['output'];
2157
+ count?: Maybe<Scalars['Int']['output']>;
1973
2158
  /** A list of edges. */
1974
2159
  edges?: Maybe<Array<Maybe<ParameterDefinitionEdge>>>;
1975
2160
  /** A list of nodes. */
1976
2161
  nodes?: Maybe<Array<Maybe<ParameterDefinition>>>;
1977
2162
  /** Information to aid in pagination. */
1978
- pageInfo: PageInfo;
2163
+ pageInfo?: Maybe<PageInfo>;
1979
2164
  }
1980
2165
 
1981
2166
  /** An edge in a connection. */
1982
2167
  export interface ParameterDefinitionEdge {
1983
2168
  __typename?: 'ParameterDefinitionEdge';
1984
2169
  /** A cursor for use in pagination. */
1985
- cursor: Scalars['String']['output'];
2170
+ cursor?: Maybe<Scalars['String']['output']>;
1986
2171
  /** The item at the end of the edge. */
1987
2172
  node?: Maybe<ParameterDefinition>;
1988
2173
  }
@@ -1997,9 +2182,9 @@ export interface Query {
1997
2182
  /** Get the currently logged in user */
1998
2183
  currentUser?: Maybe<User>;
1999
2184
  /** Field available for use to test API access */
2000
- echo: Scalars['String']['output'];
2185
+ echo?: Maybe<Scalars['String']['output']>;
2001
2186
  /** Find runtimes */
2002
- globalRuntimes: RuntimeConnection;
2187
+ globalRuntimes?: Maybe<RuntimeConnection>;
2003
2188
  /** Find a namespace */
2004
2189
  namespace?: Maybe<Namespace>;
2005
2190
  /** Fetches an object given its ID */
@@ -2009,7 +2194,7 @@ export interface Query {
2009
2194
  /** Find a organization */
2010
2195
  organization?: Maybe<Organization>;
2011
2196
  /** Find users */
2012
- users: UserConnection;
2197
+ users?: Maybe<UserConnection>;
2013
2198
  }
2014
2199
 
2015
2200
 
@@ -2067,13 +2252,13 @@ export interface ReferencePath {
2067
2252
  /** The array index of the referenced data by the path */
2068
2253
  arrayIndex?: Maybe<Scalars['Int']['output']>;
2069
2254
  /** Time when this ReferencePath was created */
2070
- createdAt: Scalars['Time']['output'];
2255
+ createdAt?: Maybe<Scalars['Time']['output']>;
2071
2256
  /** Global ID of this ReferencePath */
2072
- id: Scalars['ReferencePathID']['output'];
2257
+ id?: Maybe<Scalars['ReferencePathID']['output']>;
2073
2258
  /** The path to the reference in the flow */
2074
2259
  path?: Maybe<Scalars['String']['output']>;
2075
2260
  /** Time when this ReferencePath was last updated */
2076
- updatedAt: Scalars['Time']['output'];
2261
+ updatedAt?: Maybe<Scalars['Time']['output']>;
2077
2262
  }
2078
2263
 
2079
2264
  /** Input type for reference path */
@@ -2088,21 +2273,21 @@ export interface ReferencePathInput {
2088
2273
  export interface ReferenceValue {
2089
2274
  __typename?: 'ReferenceValue';
2090
2275
  /** Time when this ReferenceValue was created */
2091
- createdAt: Scalars['Time']['output'];
2276
+ createdAt?: Maybe<Scalars['Time']['output']>;
2092
2277
  /** The identifier of the data type this reference value belongs to. */
2093
- dataTypeIdentifier: DataTypeIdentifier;
2278
+ dataTypeIdentifier?: Maybe<DataTypeIdentifier>;
2279
+ /** The depth of the reference value. */
2280
+ depth?: Maybe<Scalars['Int']['output']>;
2094
2281
  /** Global ID of this ReferenceValue */
2095
- id: Scalars['ReferenceValueID']['output'];
2096
- /** The primary level of the reference value. */
2097
- primaryLevel: Scalars['Int']['output'];
2282
+ id?: Maybe<Scalars['ReferenceValueID']['output']>;
2283
+ /** The node of the reference value. */
2284
+ node?: Maybe<Scalars['Int']['output']>;
2098
2285
  /** The paths associated with this reference value. */
2099
- referencePath: Array<ReferencePath>;
2100
- /** The secondary level of the reference value. */
2101
- secondaryLevel: Scalars['Int']['output'];
2102
- /** The tertiary level of the reference value, if applicable. */
2103
- tertiaryLevel?: Maybe<Scalars['Int']['output']>;
2286
+ referencePath?: Maybe<Array<ReferencePath>>;
2287
+ /** The scope of the reference value. */
2288
+ scope?: Maybe<Array<Scalars['Int']['output']>>;
2104
2289
  /** Time when this ReferenceValue was last updated */
2105
- updatedAt: Scalars['Time']['output'];
2290
+ updatedAt?: Maybe<Scalars['Time']['output']>;
2106
2291
  }
2107
2292
 
2108
2293
  /** Input type for reference value */
@@ -2123,27 +2308,27 @@ export interface ReferenceValueInput {
2123
2308
  export interface Runtime {
2124
2309
  __typename?: 'Runtime';
2125
2310
  /** Time when this Runtime was created */
2126
- createdAt: Scalars['Time']['output'];
2311
+ createdAt?: Maybe<Scalars['Time']['output']>;
2127
2312
  /** DataTypes of the runtime */
2128
- dataTypes: DataTypeConnection;
2313
+ dataTypes?: Maybe<DataTypeConnection>;
2129
2314
  /** The description for the runtime if present */
2130
- description: Scalars['String']['output'];
2315
+ description?: Maybe<Scalars['String']['output']>;
2131
2316
  /** FlowTypes of the runtime */
2132
- flowTypes: FlowTypeConnection;
2317
+ flowTypes?: Maybe<FlowTypeConnection>;
2133
2318
  /** Global ID of this Runtime */
2134
- id: Scalars['RuntimeID']['output'];
2319
+ id?: Maybe<Scalars['RuntimeID']['output']>;
2135
2320
  /** The name for the runtime */
2136
- name: Scalars['String']['output'];
2321
+ name?: Maybe<Scalars['String']['output']>;
2137
2322
  /** The parent namespace for the runtime */
2138
2323
  namespace?: Maybe<Namespace>;
2139
2324
  /** Projects associated with the runtime */
2140
- projects: NamespaceProjectConnection;
2325
+ projects?: Maybe<NamespaceProjectConnection>;
2141
2326
  /** The status of the runtime */
2142
- status: RuntimeStatusType;
2327
+ status?: Maybe<RuntimeStatusType>;
2143
2328
  /** Token belonging to the runtime, only present on creation */
2144
2329
  token?: Maybe<Scalars['String']['output']>;
2145
2330
  /** Time when this Runtime was last updated */
2146
- updatedAt: Scalars['Time']['output'];
2331
+ updatedAt?: Maybe<Scalars['Time']['output']>;
2147
2332
  }
2148
2333
 
2149
2334
 
@@ -2177,41 +2362,45 @@ export interface RuntimeProjectsArgs {
2177
2362
  export interface RuntimeConnection {
2178
2363
  __typename?: 'RuntimeConnection';
2179
2364
  /** Total count of collection. */
2180
- count: Scalars['Int']['output'];
2365
+ count?: Maybe<Scalars['Int']['output']>;
2181
2366
  /** A list of edges. */
2182
2367
  edges?: Maybe<Array<Maybe<RuntimeEdge>>>;
2183
2368
  /** A list of nodes. */
2184
2369
  nodes?: Maybe<Array<Maybe<Runtime>>>;
2185
2370
  /** Information to aid in pagination. */
2186
- pageInfo: PageInfo;
2371
+ pageInfo?: Maybe<PageInfo>;
2187
2372
  }
2188
2373
 
2189
2374
  /** An edge in a connection. */
2190
2375
  export interface RuntimeEdge {
2191
2376
  __typename?: 'RuntimeEdge';
2192
2377
  /** A cursor for use in pagination. */
2193
- cursor: Scalars['String']['output'];
2378
+ cursor?: Maybe<Scalars['String']['output']>;
2194
2379
  /** The item at the end of the edge. */
2195
2380
  node?: Maybe<Runtime>;
2196
2381
  }
2197
2382
 
2198
- /** Represents a Node Function definition */
2383
+ /** Represents a runtime function definition */
2199
2384
  export interface RuntimeFunctionDefinition {
2200
2385
  __typename?: 'RuntimeFunctionDefinition';
2201
2386
  /** Time when this RuntimeFunctionDefinition was created */
2202
- createdAt: Scalars['Time']['output'];
2203
- /** Function definitions of the Node Function */
2387
+ createdAt?: Maybe<Scalars['Time']['output']>;
2388
+ /** Function definitions of the runtime function definition */
2204
2389
  functionDefinitions?: Maybe<FunctionDefinitionConnection>;
2205
2390
  /** Global ID of this RuntimeFunctionDefinition */
2206
- id: Scalars['RuntimeParameterDefinitionID']['output'];
2207
- /** The runtime this Node Function belongs to */
2208
- runtime: Runtime;
2391
+ id?: Maybe<Scalars['RuntimeFunctionDefinitionID']['output']>;
2392
+ /** Identifier of the runtime function definition */
2393
+ identifier?: Maybe<Scalars['String']['output']>;
2394
+ /** The runtime this runtime function definition belongs to */
2395
+ runtime?: Maybe<Runtime>;
2396
+ /** Parameter definitions of the runtime function definition */
2397
+ runtimeParameterDefinitions?: Maybe<RuntimeParameterDefinitionConnection>;
2209
2398
  /** Time when this RuntimeFunctionDefinition was last updated */
2210
- updatedAt: Scalars['Time']['output'];
2399
+ updatedAt?: Maybe<Scalars['Time']['output']>;
2211
2400
  }
2212
2401
 
2213
2402
 
2214
- /** Represents a Node Function definition */
2403
+ /** Represents a runtime function definition */
2215
2404
  export interface RuntimeFunctionDefinitionFunctionDefinitionsArgs {
2216
2405
  after?: InputMaybe<Scalars['String']['input']>;
2217
2406
  before?: InputMaybe<Scalars['String']['input']>;
@@ -2219,19 +2408,50 @@ export interface RuntimeFunctionDefinitionFunctionDefinitionsArgs {
2219
2408
  last?: InputMaybe<Scalars['Int']['input']>;
2220
2409
  }
2221
2410
 
2222
- /** Represents a Node parameter definition */
2411
+
2412
+ /** Represents a runtime function definition */
2413
+ export interface RuntimeFunctionDefinitionRuntimeParameterDefinitionsArgs {
2414
+ after?: InputMaybe<Scalars['String']['input']>;
2415
+ before?: InputMaybe<Scalars['String']['input']>;
2416
+ first?: InputMaybe<Scalars['Int']['input']>;
2417
+ last?: InputMaybe<Scalars['Int']['input']>;
2418
+ }
2419
+
2420
+ /** Represents a runtime parameter definition */
2223
2421
  export interface RuntimeParameterDefinition {
2224
2422
  __typename?: 'RuntimeParameterDefinition';
2225
2423
  /** Time when this RuntimeParameterDefinition was created */
2226
- createdAt: Scalars['Time']['output'];
2424
+ createdAt?: Maybe<Scalars['Time']['output']>;
2227
2425
  /** Global ID of this RuntimeParameterDefinition */
2228
- id: Scalars['RuntimeParameterDefinitionID']['output'];
2426
+ id?: Maybe<Scalars['RuntimeParameterDefinitionID']['output']>;
2229
2427
  /** Time when this RuntimeParameterDefinition was last updated */
2230
- updatedAt: Scalars['Time']['output'];
2428
+ updatedAt?: Maybe<Scalars['Time']['output']>;
2429
+ }
2430
+
2431
+ /** The connection type for RuntimeParameterDefinition. */
2432
+ export interface RuntimeParameterDefinitionConnection {
2433
+ __typename?: 'RuntimeParameterDefinitionConnection';
2434
+ /** Total count of collection. */
2435
+ count?: Maybe<Scalars['Int']['output']>;
2436
+ /** A list of edges. */
2437
+ edges?: Maybe<Array<Maybe<RuntimeParameterDefinitionEdge>>>;
2438
+ /** A list of nodes. */
2439
+ nodes?: Maybe<Array<Maybe<RuntimeParameterDefinition>>>;
2440
+ /** Information to aid in pagination. */
2441
+ pageInfo?: Maybe<PageInfo>;
2442
+ }
2443
+
2444
+ /** An edge in a connection. */
2445
+ export interface RuntimeParameterDefinitionEdge {
2446
+ __typename?: 'RuntimeParameterDefinitionEdge';
2447
+ /** A cursor for use in pagination. */
2448
+ cursor?: Maybe<Scalars['String']['output']>;
2449
+ /** The item at the end of the edge. */
2450
+ node?: Maybe<RuntimeParameterDefinition>;
2231
2451
  }
2232
2452
 
2233
2453
  /** Represent all available types of statuses of a runtime */
2234
- export enum RuntimeStatusType {
2454
+ export const enum RuntimeStatusType {
2235
2455
  /** No problem with connection, everything works as expected */
2236
2456
  Connected = 'CONNECTED',
2237
2457
  /** The runtime is disconnected, cause unknown */
@@ -2256,7 +2476,7 @@ export interface RuntimesCreatePayload {
2256
2476
  /** A unique identifier for the client performing the mutation. */
2257
2477
  clientMutationId?: Maybe<Scalars['String']['output']>;
2258
2478
  /** Errors encountered during execution of the mutation. */
2259
- errors: Array<Error>;
2479
+ errors?: Maybe<Array<Error>>;
2260
2480
  /** The newly created runtime. */
2261
2481
  runtime?: Maybe<Runtime>;
2262
2482
  }
@@ -2275,7 +2495,7 @@ export interface RuntimesDeletePayload {
2275
2495
  /** A unique identifier for the client performing the mutation. */
2276
2496
  clientMutationId?: Maybe<Scalars['String']['output']>;
2277
2497
  /** Errors encountered during execution of the mutation. */
2278
- errors: Array<Error>;
2498
+ errors?: Maybe<Array<Error>>;
2279
2499
  /** The updated organization. */
2280
2500
  runtime?: Maybe<Runtime>;
2281
2501
  }
@@ -2294,7 +2514,7 @@ export interface RuntimesRotateTokenPayload {
2294
2514
  /** A unique identifier for the client performing the mutation. */
2295
2515
  clientMutationId?: Maybe<Scalars['String']['output']>;
2296
2516
  /** Errors encountered during execution of the mutation. */
2297
- errors: Array<Error>;
2517
+ errors?: Maybe<Array<Error>>;
2298
2518
  /** The updated runtime. */
2299
2519
  runtime?: Maybe<Runtime>;
2300
2520
  }
@@ -2317,7 +2537,7 @@ export interface RuntimesUpdatePayload {
2317
2537
  /** A unique identifier for the client performing the mutation. */
2318
2538
  clientMutationId?: Maybe<Scalars['String']['output']>;
2319
2539
  /** Errors encountered during execution of the mutation. */
2320
- errors: Array<Error>;
2540
+ errors?: Maybe<Array<Error>>;
2321
2541
  /** The updated runtime. */
2322
2542
  runtime?: Maybe<Runtime>;
2323
2543
  }
@@ -2326,29 +2546,29 @@ export interface RuntimesUpdatePayload {
2326
2546
  export interface Translation {
2327
2547
  __typename?: 'Translation';
2328
2548
  /** Code of the translation */
2329
- code: Scalars['String']['output'];
2549
+ code?: Maybe<Scalars['String']['output']>;
2330
2550
  /** Content of the translation */
2331
- content: Scalars['String']['output'];
2551
+ content?: Maybe<Scalars['String']['output']>;
2332
2552
  }
2333
2553
 
2334
2554
  /** The connection type for Translation. */
2335
2555
  export interface TranslationConnection {
2336
2556
  __typename?: 'TranslationConnection';
2337
2557
  /** Total count of collection. */
2338
- count: Scalars['Int']['output'];
2558
+ count?: Maybe<Scalars['Int']['output']>;
2339
2559
  /** A list of edges. */
2340
2560
  edges?: Maybe<Array<Maybe<TranslationEdge>>>;
2341
2561
  /** A list of nodes. */
2342
2562
  nodes?: Maybe<Array<Maybe<Translation>>>;
2343
2563
  /** Information to aid in pagination. */
2344
- pageInfo: PageInfo;
2564
+ pageInfo?: Maybe<PageInfo>;
2345
2565
  }
2346
2566
 
2347
2567
  /** An edge in a connection. */
2348
2568
  export interface TranslationEdge {
2349
2569
  __typename?: 'TranslationEdge';
2350
2570
  /** A cursor for use in pagination. */
2351
- cursor: Scalars['String']['output'];
2571
+ cursor?: Maybe<Scalars['String']['output']>;
2352
2572
  /** The item at the end of the edge. */
2353
2573
  node?: Maybe<Translation>;
2354
2574
  }
@@ -2357,27 +2577,42 @@ export interface TranslationEdge {
2357
2577
  export interface User {
2358
2578
  __typename?: 'User';
2359
2579
  /** Global admin status of the user */
2360
- admin: Scalars['Boolean']['output'];
2580
+ admin?: Maybe<Scalars['Boolean']['output']>;
2361
2581
  /** The avatar if present of the user */
2362
2582
  avatarPath?: Maybe<Scalars['String']['output']>;
2363
2583
  /** Time when this User was created */
2364
- createdAt: Scalars['Time']['output'];
2584
+ createdAt?: Maybe<Scalars['Time']['output']>;
2365
2585
  /** Email of the user */
2366
- email: Scalars['String']['output'];
2586
+ email?: Maybe<Scalars['String']['output']>;
2587
+ /** Email verification date of the user if present */
2588
+ emailVerifiedAt?: Maybe<Scalars['Time']['output']>;
2367
2589
  /** Firstname of the user */
2368
- firstname: Scalars['String']['output'];
2590
+ firstname?: Maybe<Scalars['String']['output']>;
2369
2591
  /** Global ID of this User */
2370
- id: Scalars['UserID']['output'];
2592
+ id?: Maybe<Scalars['UserID']['output']>;
2593
+ /** Identities of this user */
2594
+ identities?: Maybe<UserIdentityConnection>;
2371
2595
  /** Lastname of the user */
2372
- lastname: Scalars['String']['output'];
2596
+ lastname?: Maybe<Scalars['String']['output']>;
2373
2597
  /** Namespace of this user */
2374
2598
  namespace?: Maybe<Namespace>;
2375
2599
  /** Namespace Memberships of this user */
2376
- namespaceMemberships: NamespaceMemberConnection;
2600
+ namespaceMemberships?: Maybe<NamespaceMemberConnection>;
2601
+ /** Sessions of this user */
2602
+ sessions?: Maybe<UserSessionConnection>;
2377
2603
  /** Time when this User was last updated */
2378
- updatedAt: Scalars['Time']['output'];
2604
+ updatedAt?: Maybe<Scalars['Time']['output']>;
2379
2605
  /** Username of the user */
2380
- username: Scalars['String']['output'];
2606
+ username?: Maybe<Scalars['String']['output']>;
2607
+ }
2608
+
2609
+
2610
+ /** Represents a user */
2611
+ export interface UserIdentitiesArgs {
2612
+ after?: InputMaybe<Scalars['String']['input']>;
2613
+ before?: InputMaybe<Scalars['String']['input']>;
2614
+ first?: InputMaybe<Scalars['Int']['input']>;
2615
+ last?: InputMaybe<Scalars['Int']['input']>;
2381
2616
  }
2382
2617
 
2383
2618
 
@@ -2389,24 +2624,33 @@ export interface UserNamespaceMembershipsArgs {
2389
2624
  last?: InputMaybe<Scalars['Int']['input']>;
2390
2625
  }
2391
2626
 
2627
+
2628
+ /** Represents a user */
2629
+ export interface UserSessionsArgs {
2630
+ after?: InputMaybe<Scalars['String']['input']>;
2631
+ before?: InputMaybe<Scalars['String']['input']>;
2632
+ first?: InputMaybe<Scalars['Int']['input']>;
2633
+ last?: InputMaybe<Scalars['Int']['input']>;
2634
+ }
2635
+
2392
2636
  /** The connection type for User. */
2393
2637
  export interface UserConnection {
2394
2638
  __typename?: 'UserConnection';
2395
2639
  /** Total count of collection. */
2396
- count: Scalars['Int']['output'];
2640
+ count?: Maybe<Scalars['Int']['output']>;
2397
2641
  /** A list of edges. */
2398
2642
  edges?: Maybe<Array<Maybe<UserEdge>>>;
2399
2643
  /** A list of nodes. */
2400
2644
  nodes?: Maybe<Array<Maybe<User>>>;
2401
2645
  /** Information to aid in pagination. */
2402
- pageInfo: PageInfo;
2646
+ pageInfo?: Maybe<PageInfo>;
2403
2647
  }
2404
2648
 
2405
2649
  /** An edge in a connection. */
2406
2650
  export interface UserEdge {
2407
2651
  __typename?: 'UserEdge';
2408
2652
  /** A cursor for use in pagination. */
2409
- cursor: Scalars['String']['output'];
2653
+ cursor?: Maybe<Scalars['String']['output']>;
2410
2654
  /** The item at the end of the edge. */
2411
2655
  node?: Maybe<User>;
2412
2656
  }
@@ -2415,34 +2659,97 @@ export interface UserEdge {
2415
2659
  export interface UserIdentity {
2416
2660
  __typename?: 'UserIdentity';
2417
2661
  /** Time when this UserIdentity was created */
2418
- createdAt: Scalars['Time']['output'];
2662
+ createdAt?: Maybe<Scalars['Time']['output']>;
2419
2663
  /** Global ID of this UserIdentity */
2420
- id: Scalars['UserIdentityID']['output'];
2664
+ id?: Maybe<Scalars['UserIdentityID']['output']>;
2421
2665
  /** The description for the runtime if present */
2422
- identifier: Scalars['String']['output'];
2666
+ identifier?: Maybe<Scalars['String']['output']>;
2423
2667
  /** The name for the runtime */
2424
- providerId: Scalars['String']['output'];
2668
+ providerId?: Maybe<Scalars['String']['output']>;
2425
2669
  /** Time when this UserIdentity was last updated */
2426
- updatedAt: Scalars['Time']['output'];
2670
+ updatedAt?: Maybe<Scalars['Time']['output']>;
2427
2671
  /** The correlating user of the identity */
2428
- user: User;
2672
+ user?: Maybe<User>;
2673
+ }
2674
+
2675
+ /** The connection type for UserIdentity. */
2676
+ export interface UserIdentityConnection {
2677
+ __typename?: 'UserIdentityConnection';
2678
+ /** Total count of collection. */
2679
+ count?: Maybe<Scalars['Int']['output']>;
2680
+ /** A list of edges. */
2681
+ edges?: Maybe<Array<Maybe<UserIdentityEdge>>>;
2682
+ /** A list of nodes. */
2683
+ nodes?: Maybe<Array<Maybe<UserIdentity>>>;
2684
+ /** Information to aid in pagination. */
2685
+ pageInfo?: Maybe<PageInfo>;
2686
+ }
2687
+
2688
+ /** An edge in a connection. */
2689
+ export interface UserIdentityEdge {
2690
+ __typename?: 'UserIdentityEdge';
2691
+ /** A cursor for use in pagination. */
2692
+ cursor?: Maybe<Scalars['String']['output']>;
2693
+ /** The item at the end of the edge. */
2694
+ node?: Maybe<UserIdentity>;
2429
2695
  }
2430
2696
 
2431
2697
  /** Represents a user session */
2432
2698
  export interface UserSession {
2433
2699
  __typename?: 'UserSession';
2434
2700
  /** Whether or not the session is active and can be used */
2435
- active: Scalars['Boolean']['output'];
2701
+ active?: Maybe<Scalars['Boolean']['output']>;
2436
2702
  /** Time when this UserSession was created */
2437
- createdAt: Scalars['Time']['output'];
2703
+ createdAt?: Maybe<Scalars['Time']['output']>;
2438
2704
  /** Global ID of this UserSession */
2439
- id: Scalars['UserSessionID']['output'];
2705
+ id?: Maybe<Scalars['UserSessionID']['output']>;
2440
2706
  /** Token belonging to the session, only present on creation */
2441
2707
  token?: Maybe<Scalars['String']['output']>;
2442
2708
  /** Time when this UserSession was last updated */
2443
- updatedAt: Scalars['Time']['output'];
2709
+ updatedAt?: Maybe<Scalars['Time']['output']>;
2444
2710
  /** User that belongs to the session */
2445
- user: User;
2711
+ user?: Maybe<User>;
2712
+ }
2713
+
2714
+ /** The connection type for UserSession. */
2715
+ export interface UserSessionConnection {
2716
+ __typename?: 'UserSessionConnection';
2717
+ /** Total count of collection. */
2718
+ count?: Maybe<Scalars['Int']['output']>;
2719
+ /** A list of edges. */
2720
+ edges?: Maybe<Array<Maybe<UserSessionEdge>>>;
2721
+ /** A list of nodes. */
2722
+ nodes?: Maybe<Array<Maybe<UserSession>>>;
2723
+ /** Information to aid in pagination. */
2724
+ pageInfo?: Maybe<PageInfo>;
2725
+ }
2726
+
2727
+ /** An edge in a connection. */
2728
+ export interface UserSessionEdge {
2729
+ __typename?: 'UserSessionEdge';
2730
+ /** A cursor for use in pagination. */
2731
+ cursor?: Maybe<Scalars['String']['output']>;
2732
+ /** The item at the end of the edge. */
2733
+ node?: Maybe<UserSession>;
2734
+ }
2735
+
2736
+ /** Autogenerated input type of UsersEmailVerification */
2737
+ export interface UsersEmailVerificationInput {
2738
+ /** A unique identifier for the client performing the mutation. */
2739
+ clientMutationId?: InputMaybe<Scalars['String']['input']>;
2740
+ /** The email verification token */
2741
+ token: Scalars['String']['input'];
2742
+ }
2743
+
2744
+ /** Autogenerated return type of UsersEmailVerification. */
2745
+ export interface UsersEmailVerificationPayload {
2746
+ __typename?: 'UsersEmailVerificationPayload';
2747
+ /** A unique identifier for the client performing the mutation. */
2748
+ clientMutationId?: Maybe<Scalars['String']['output']>;
2749
+ /** Errors encountered during execution of the mutation. */
2750
+ errors?: Maybe<Array<Error>>;
2751
+ /** The user whose email was verified */
2752
+ user?: Maybe<User>;
2446
2753
  }
2447
2754
 
2448
2755
  /** Autogenerated input type of UsersIdentityLink */
@@ -2461,7 +2768,7 @@ export interface UsersIdentityLinkPayload {
2461
2768
  /** A unique identifier for the client performing the mutation. */
2462
2769
  clientMutationId?: Maybe<Scalars['String']['output']>;
2463
2770
  /** Errors encountered during execution of the mutation. */
2464
- errors: Array<Error>;
2771
+ errors?: Maybe<Array<Error>>;
2465
2772
  /** The created user identity */
2466
2773
  userIdentity?: Maybe<UserIdentity>;
2467
2774
  }
@@ -2482,7 +2789,7 @@ export interface UsersIdentityLoginPayload {
2482
2789
  /** A unique identifier for the client performing the mutation. */
2483
2790
  clientMutationId?: Maybe<Scalars['String']['output']>;
2484
2791
  /** Errors encountered during execution of the mutation. */
2485
- errors: Array<Error>;
2792
+ errors?: Maybe<Array<Error>>;
2486
2793
  /** The created user session */
2487
2794
  userSession?: Maybe<UserSession>;
2488
2795
  }
@@ -2503,7 +2810,7 @@ export interface UsersIdentityRegisterPayload {
2503
2810
  /** A unique identifier for the client performing the mutation. */
2504
2811
  clientMutationId?: Maybe<Scalars['String']['output']>;
2505
2812
  /** Errors encountered during execution of the mutation. */
2506
- errors: Array<Error>;
2813
+ errors?: Maybe<Array<Error>>;
2507
2814
  /** The created users session */
2508
2815
  userSession?: Maybe<UserSession>;
2509
2816
  }
@@ -2522,7 +2829,7 @@ export interface UsersIdentityUnlinkPayload {
2522
2829
  /** A unique identifier for the client performing the mutation. */
2523
2830
  clientMutationId?: Maybe<Scalars['String']['output']>;
2524
2831
  /** Errors encountered during execution of the mutation. */
2525
- errors: Array<Error>;
2832
+ errors?: Maybe<Array<Error>>;
2526
2833
  /** The removed identity */
2527
2834
  userIdentity?: Maybe<UserIdentity>;
2528
2835
  }
@@ -2547,7 +2854,7 @@ export interface UsersLoginPayload {
2547
2854
  /** A unique identifier for the client performing the mutation. */
2548
2855
  clientMutationId?: Maybe<Scalars['String']['output']>;
2549
2856
  /** Errors encountered during execution of the mutation. */
2550
- errors: Array<Error>;
2857
+ errors?: Maybe<Array<Error>>;
2551
2858
  /** The created user session */
2552
2859
  userSession?: Maybe<UserSession>;
2553
2860
  }
@@ -2566,7 +2873,7 @@ export interface UsersLogoutPayload {
2566
2873
  /** A unique identifier for the client performing the mutation. */
2567
2874
  clientMutationId?: Maybe<Scalars['String']['output']>;
2568
2875
  /** Errors encountered during execution of the mutation. */
2569
- errors: Array<Error>;
2876
+ errors?: Maybe<Array<Error>>;
2570
2877
  /** The logged out user session */
2571
2878
  userSession?: Maybe<UserSession>;
2572
2879
  }
@@ -2585,7 +2892,7 @@ export interface UsersMfaBackupCodesRotatePayload {
2585
2892
  /** The newly rotated backup codes. */
2586
2893
  codes?: Maybe<Array<Scalars['String']['output']>>;
2587
2894
  /** Errors encountered during execution of the mutation. */
2588
- errors: Array<Error>;
2895
+ errors?: Maybe<Array<Error>>;
2589
2896
  }
2590
2897
 
2591
2898
  /** Autogenerated input type of UsersMfaTotpGenerateSecret */
@@ -2600,7 +2907,7 @@ export interface UsersMfaTotpGenerateSecretPayload {
2600
2907
  /** A unique identifier for the client performing the mutation. */
2601
2908
  clientMutationId?: Maybe<Scalars['String']['output']>;
2602
2909
  /** Errors encountered during execution of the mutation. */
2603
- errors: Array<Error>;
2910
+ errors?: Maybe<Array<Error>>;
2604
2911
  /** The created and signed secret */
2605
2912
  secret?: Maybe<Scalars['String']['output']>;
2606
2913
  }
@@ -2624,11 +2931,53 @@ export interface UsersMfaTotpValidateSecretPayload {
2624
2931
  /** A unique identifier for the client performing the mutation. */
2625
2932
  clientMutationId?: Maybe<Scalars['String']['output']>;
2626
2933
  /** Errors encountered during execution of the mutation. */
2627
- errors: Array<Error>;
2934
+ errors?: Maybe<Array<Error>>;
2628
2935
  /** The modified user */
2629
2936
  user?: Maybe<User>;
2630
2937
  }
2631
2938
 
2939
+ /** Autogenerated input type of UsersPasswordReset */
2940
+ export interface UsersPasswordResetInput {
2941
+ /** A unique identifier for the client performing the mutation. */
2942
+ clientMutationId?: InputMaybe<Scalars['String']['input']>;
2943
+ /** The new password to set for the user */
2944
+ newPassword: Scalars['String']['input'];
2945
+ /** The confirmation of the new password to set for the user needs to be the same as the new password */
2946
+ newPasswordConfirmation: Scalars['String']['input'];
2947
+ /** The password reset token sent to the user email */
2948
+ resetToken: Scalars['String']['input'];
2949
+ }
2950
+
2951
+ /** Autogenerated return type of UsersPasswordReset. */
2952
+ export interface UsersPasswordResetPayload {
2953
+ __typename?: 'UsersPasswordResetPayload';
2954
+ /** A unique identifier for the client performing the mutation. */
2955
+ clientMutationId?: Maybe<Scalars['String']['output']>;
2956
+ /** Errors encountered during execution of the mutation. */
2957
+ errors?: Maybe<Array<Error>>;
2958
+ /** A message indicating the result of the password reset request */
2959
+ message?: Maybe<Scalars['String']['output']>;
2960
+ }
2961
+
2962
+ /** Autogenerated input type of UsersPasswordResetRequest */
2963
+ export interface UsersPasswordResetRequestInput {
2964
+ /** A unique identifier for the client performing the mutation. */
2965
+ clientMutationId?: InputMaybe<Scalars['String']['input']>;
2966
+ /** Email of the user to reset the password */
2967
+ email: Scalars['String']['input'];
2968
+ }
2969
+
2970
+ /** Autogenerated return type of UsersPasswordResetRequest. */
2971
+ export interface UsersPasswordResetRequestPayload {
2972
+ __typename?: 'UsersPasswordResetRequestPayload';
2973
+ /** A unique identifier for the client performing the mutation. */
2974
+ clientMutationId?: Maybe<Scalars['String']['output']>;
2975
+ /** Errors encountered during execution of the mutation. */
2976
+ errors?: Maybe<Array<Error>>;
2977
+ /** A message indicating the result of the password reset request */
2978
+ message?: Maybe<Scalars['String']['output']>;
2979
+ }
2980
+
2632
2981
  /** Autogenerated input type of UsersRegister */
2633
2982
  export interface UsersRegisterInput {
2634
2983
  /** A unique identifier for the client performing the mutation. */
@@ -2649,7 +2998,7 @@ export interface UsersRegisterPayload {
2649
2998
  /** A unique identifier for the client performing the mutation. */
2650
2999
  clientMutationId?: Maybe<Scalars['String']['output']>;
2651
3000
  /** Errors encountered during execution of the mutation. */
2652
- errors: Array<Error>;
3001
+ errors?: Maybe<Array<Error>>;
2653
3002
  /** The created users session */
2654
3003
  userSession?: Maybe<UserSession>;
2655
3004
  }
@@ -2684,7 +3033,7 @@ export interface UsersUpdatePayload {
2684
3033
  /** A unique identifier for the client performing the mutation. */
2685
3034
  clientMutationId?: Maybe<Scalars['String']['output']>;
2686
3035
  /** Errors encountered during execution of the mutation. */
2687
- errors: Array<Error>;
3036
+ errors?: Maybe<Array<Error>>;
2688
3037
  /** The updated user. */
2689
3038
  user?: Maybe<User>;
2690
3039
  }