@code0-tech/sagittarius-graphql-types 0.0.0-4b2e73eae302fe499001bf42fdb3a6bcc5be78aa → 0.0.0-56198dce107a9c09cc5eca0773f239d9c3eba598

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 +675 -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,53 +341,140 @@ 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
+ /** Nodes of the flow */
429
+ nodes?: Maybe<NodeFunctionConnection>;
390
430
  /** The return data type of the flow */
391
431
  returnType?: Maybe<DataType>;
392
432
  /** The settings of the flow */
393
- settings?: Maybe<Array<FlowSetting>>;
394
- /** The starting node of the flow */
395
- startingNode: NodeFunction;
433
+ settings?: Maybe<FlowSettingConnection>;
434
+ /** The ID of the starting node of the flow */
435
+ startingNodeId?: Maybe<Scalars['NodeFunctionID']['output']>;
396
436
  /** The flow type of the flow */
397
- type: FlowType;
437
+ type?: Maybe<FlowType>;
398
438
  /** Time when this Flow was last updated */
399
- updatedAt: Scalars['Time']['output'];
439
+ updatedAt?: Maybe<Scalars['Time']['output']>;
440
+ }
441
+
442
+
443
+ /** Represents a flow */
444
+ export interface FlowNodesArgs {
445
+ after?: InputMaybe<Scalars['String']['input']>;
446
+ before?: InputMaybe<Scalars['String']['input']>;
447
+ first?: InputMaybe<Scalars['Int']['input']>;
448
+ last?: InputMaybe<Scalars['Int']['input']>;
449
+ }
450
+
451
+
452
+ /** Represents a flow */
453
+ export interface FlowSettingsArgs {
454
+ after?: InputMaybe<Scalars['String']['input']>;
455
+ before?: InputMaybe<Scalars['String']['input']>;
456
+ first?: InputMaybe<Scalars['Int']['input']>;
457
+ last?: InputMaybe<Scalars['Int']['input']>;
400
458
  }
401
459
 
402
460
  /** The connection type for Flow. */
403
461
  export interface FlowConnection {
404
462
  __typename?: 'FlowConnection';
405
463
  /** Total count of collection. */
406
- count: Scalars['Int']['output'];
464
+ count?: Maybe<Scalars['Int']['output']>;
407
465
  /** A list of edges. */
408
466
  edges?: Maybe<Array<Maybe<FlowEdge>>>;
409
467
  /** A list of nodes. */
410
468
  nodes?: Maybe<Array<Maybe<Flow>>>;
411
469
  /** Information to aid in pagination. */
412
- pageInfo: PageInfo;
470
+ pageInfo?: Maybe<PageInfo>;
413
471
  }
414
472
 
415
473
  /** An edge in a connection. */
416
474
  export interface FlowEdge {
417
475
  __typename?: 'FlowEdge';
418
476
  /** A cursor for use in pagination. */
419
- cursor: Scalars['String']['output'];
477
+ cursor?: Maybe<Scalars['String']['output']>;
420
478
  /** The item at the end of the edge. */
421
479
  node?: Maybe<Flow>;
422
480
  }
@@ -435,15 +493,37 @@ export interface FlowInput {
435
493
  export interface FlowSetting {
436
494
  __typename?: 'FlowSetting';
437
495
  /** Time when this FlowSetting was created */
438
- createdAt: Scalars['Time']['output'];
496
+ createdAt?: Maybe<Scalars['Time']['output']>;
439
497
  /** The identifier of the flow setting */
440
- flowSettingId: Scalars['String']['output'];
498
+ flowSettingIdentifier?: Maybe<Scalars['String']['output']>;
441
499
  /** Global ID of this FlowSetting */
442
- id: Scalars['FlowSettingID']['output'];
500
+ id?: Maybe<Scalars['FlowSettingID']['output']>;
443
501
  /** Time when this FlowSetting was last updated */
444
- updatedAt: Scalars['Time']['output'];
502
+ updatedAt?: Maybe<Scalars['Time']['output']>;
445
503
  /** The value of the flow setting */
446
- value: Scalars['JSON']['output'];
504
+ value?: Maybe<Scalars['JSON']['output']>;
505
+ }
506
+
507
+ /** The connection type for FlowSetting. */
508
+ export interface FlowSettingConnection {
509
+ __typename?: 'FlowSettingConnection';
510
+ /** Total count of collection. */
511
+ count?: Maybe<Scalars['Int']['output']>;
512
+ /** A list of edges. */
513
+ edges?: Maybe<Array<Maybe<FlowSettingEdge>>>;
514
+ /** A list of nodes. */
515
+ nodes?: Maybe<Array<Maybe<FlowSetting>>>;
516
+ /** Information to aid in pagination. */
517
+ pageInfo?: Maybe<PageInfo>;
518
+ }
519
+
520
+ /** An edge in a connection. */
521
+ export interface FlowSettingEdge {
522
+ __typename?: 'FlowSettingEdge';
523
+ /** A cursor for use in pagination. */
524
+ cursor?: Maybe<Scalars['String']['output']>;
525
+ /** The item at the end of the edge. */
526
+ node?: Maybe<FlowSetting>;
447
527
  }
448
528
 
449
529
  /** Input type for flow settings */
@@ -458,17 +538,17 @@ export interface FlowSettingInput {
458
538
  export interface FlowType {
459
539
  __typename?: 'FlowType';
460
540
  /** Time when this FlowType was created */
461
- createdAt: Scalars['Time']['output'];
541
+ createdAt?: Maybe<Scalars['Time']['output']>;
462
542
  /** Descriptions of the flow type */
463
543
  descriptions?: Maybe<TranslationConnection>;
464
544
  /** Editable status of the flow type */
465
- editable: Scalars['Boolean']['output'];
545
+ editable?: Maybe<Scalars['Boolean']['output']>;
466
546
  /** Flow type settings of the flow type */
467
- flowTypeSettings: Array<FlowTypeSetting>;
547
+ flowTypeSettings?: Maybe<Array<FlowTypeSetting>>;
468
548
  /** Global ID of this FlowType */
469
- id: Scalars['TypesFlowTypeID']['output'];
549
+ id?: Maybe<Scalars['TypesFlowTypeID']['output']>;
470
550
  /** Identifier of the flow type */
471
- identifier: Scalars['String']['output'];
551
+ identifier?: Maybe<Scalars['String']['output']>;
472
552
  /** Input type of the flow type */
473
553
  inputType?: Maybe<DataType>;
474
554
  /** Names of the flow type */
@@ -476,7 +556,7 @@ export interface FlowType {
476
556
  /** Return type of the flow type */
477
557
  returnType?: Maybe<DataType>;
478
558
  /** Time when this FlowType was last updated */
479
- updatedAt: Scalars['Time']['output'];
559
+ updatedAt?: Maybe<Scalars['Time']['output']>;
480
560
  }
481
561
 
482
562
 
@@ -501,20 +581,20 @@ export interface FlowTypeNamesArgs {
501
581
  export interface FlowTypeConnection {
502
582
  __typename?: 'FlowTypeConnection';
503
583
  /** Total count of collection. */
504
- count: Scalars['Int']['output'];
584
+ count?: Maybe<Scalars['Int']['output']>;
505
585
  /** A list of edges. */
506
586
  edges?: Maybe<Array<Maybe<FlowTypeEdge>>>;
507
587
  /** A list of nodes. */
508
588
  nodes?: Maybe<Array<Maybe<FlowType>>>;
509
589
  /** Information to aid in pagination. */
510
- pageInfo: PageInfo;
590
+ pageInfo?: Maybe<PageInfo>;
511
591
  }
512
592
 
513
593
  /** An edge in a connection. */
514
594
  export interface FlowTypeEdge {
515
595
  __typename?: 'FlowTypeEdge';
516
596
  /** A cursor for use in pagination. */
517
- cursor: Scalars['String']['output'];
597
+ cursor?: Maybe<Scalars['String']['output']>;
518
598
  /** The item at the end of the edge. */
519
599
  node?: Maybe<FlowType>;
520
600
  }
@@ -523,23 +603,23 @@ export interface FlowTypeEdge {
523
603
  export interface FlowTypeSetting {
524
604
  __typename?: 'FlowTypeSetting';
525
605
  /** Time when this FlowTypeSetting was created */
526
- createdAt: Scalars['Time']['output'];
606
+ createdAt?: Maybe<Scalars['Time']['output']>;
527
607
  /** Data type of the flow type setting */
528
608
  dataType?: Maybe<DataType>;
529
609
  /** Descriptions of the flow type setting */
530
- descriptions: TranslationConnection;
610
+ descriptions?: Maybe<TranslationConnection>;
531
611
  /** Flow type of the flow type setting */
532
612
  flowType?: Maybe<FlowType>;
533
613
  /** Global ID of this FlowTypeSetting */
534
- id: Scalars['FlowTypeSettingID']['output'];
614
+ id?: Maybe<Scalars['FlowTypeSettingID']['output']>;
535
615
  /** Identifier of the flow type setting */
536
- identifier: Scalars['String']['output'];
616
+ identifier?: Maybe<Scalars['String']['output']>;
537
617
  /** Names of the flow type setting */
538
- names: TranslationConnection;
618
+ names?: Maybe<TranslationConnection>;
539
619
  /** Unique status of the flow type setting */
540
- unique: Scalars['Boolean']['output'];
620
+ unique?: Maybe<Scalars['Boolean']['output']>;
541
621
  /** Time when this FlowTypeSetting was last updated */
542
- updatedAt: Scalars['Time']['output'];
622
+ updatedAt?: Maybe<Scalars['Time']['output']>;
543
623
  }
544
624
 
545
625
 
@@ -564,7 +644,7 @@ export interface FlowTypeSettingNamesArgs {
564
644
  export interface FunctionDefinition {
565
645
  __typename?: 'FunctionDefinition';
566
646
  /** Time when this FunctionDefinition was created */
567
- createdAt: Scalars['Time']['output'];
647
+ createdAt?: Maybe<Scalars['Time']['output']>;
568
648
  /** Deprecation message of the function */
569
649
  deprecationMessages?: Maybe<TranslationConnection>;
570
650
  /** Description of the function */
@@ -574,7 +654,9 @@ export interface FunctionDefinition {
574
654
  /** Generic keys of the function */
575
655
  genericKeys?: Maybe<Array<Scalars['String']['output']>>;
576
656
  /** Global ID of this FunctionDefinition */
577
- id: Scalars['FunctionDefinitionID']['output'];
657
+ id?: Maybe<Scalars['FunctionDefinitionID']['output']>;
658
+ /** Identifier of the function */
659
+ identifier?: Maybe<Scalars['String']['output']>;
578
660
  /** Name of the function */
579
661
  names?: Maybe<TranslationConnection>;
580
662
  /** Parameters of the function */
@@ -584,9 +666,9 @@ export interface FunctionDefinition {
584
666
  /** Runtime function definition */
585
667
  runtimeFunctionDefinition?: Maybe<RuntimeFunctionDefinition>;
586
668
  /** Indicates if the function can throw an error */
587
- throwsError: Scalars['Boolean']['output'];
669
+ throwsError?: Maybe<Scalars['Boolean']['output']>;
588
670
  /** Time when this FunctionDefinition was last updated */
589
- updatedAt: Scalars['Time']['output'];
671
+ updatedAt?: Maybe<Scalars['Time']['output']>;
590
672
  }
591
673
 
592
674
 
@@ -638,20 +720,20 @@ export interface FunctionDefinitionParameterDefinitionsArgs {
638
720
  export interface FunctionDefinitionConnection {
639
721
  __typename?: 'FunctionDefinitionConnection';
640
722
  /** Total count of collection. */
641
- count: Scalars['Int']['output'];
723
+ count?: Maybe<Scalars['Int']['output']>;
642
724
  /** A list of edges. */
643
725
  edges?: Maybe<Array<Maybe<FunctionDefinitionEdge>>>;
644
726
  /** A list of nodes. */
645
727
  nodes?: Maybe<Array<Maybe<FunctionDefinition>>>;
646
728
  /** Information to aid in pagination. */
647
- pageInfo: PageInfo;
729
+ pageInfo?: Maybe<PageInfo>;
648
730
  }
649
731
 
650
732
  /** An edge in a connection. */
651
733
  export interface FunctionDefinitionEdge {
652
734
  __typename?: 'FunctionDefinitionEdge';
653
735
  /** A cursor for use in pagination. */
654
- cursor: Scalars['String']['output'];
736
+ cursor?: Maybe<Scalars['String']['output']>;
655
737
  /** The item at the end of the edge. */
656
738
  node?: Maybe<FunctionDefinition>;
657
739
  }
@@ -660,19 +742,19 @@ export interface FunctionDefinitionEdge {
660
742
  export interface GenericCombinationStrategy {
661
743
  __typename?: 'GenericCombinationStrategy';
662
744
  /** Time when this GenericCombinationStrategy was created */
663
- createdAt: Scalars['Time']['output'];
745
+ createdAt?: Maybe<Scalars['Time']['output']>;
664
746
  /** The associated generic mapper, if any. */
665
747
  genericMapper?: Maybe<GenericMapper>;
666
748
  /** Global ID of this GenericCombinationStrategy */
667
- id: Scalars['GenericCombinationStrategyID']['output'];
749
+ id?: Maybe<Scalars['GenericCombinationStrategyID']['output']>;
668
750
  /** The combination type ('AND' or 'OR'). */
669
- type: GenericCombinationStrategyType;
751
+ type?: Maybe<GenericCombinationStrategyType>;
670
752
  /** Time when this GenericCombinationStrategy was last updated */
671
- updatedAt: Scalars['Time']['output'];
753
+ updatedAt?: Maybe<Scalars['Time']['output']>;
672
754
  }
673
755
 
674
756
  /** The available combination strategy types. */
675
- export enum GenericCombinationStrategyType {
757
+ export const enum GenericCombinationStrategyType {
676
758
  /** Represents a logical AND combination. */
677
759
  And = 'AND',
678
760
  /** Represents a logical OR combination. */
@@ -683,17 +765,17 @@ export enum GenericCombinationStrategyType {
683
765
  export interface GenericMapper {
684
766
  __typename?: 'GenericMapper';
685
767
  /** Time when this GenericMapper was created */
686
- createdAt: Scalars['Time']['output'];
768
+ createdAt?: Maybe<Scalars['Time']['output']>;
687
769
  /** Combination strategies associated with this generic mapper. */
688
770
  genericCombinationStrategies?: Maybe<Array<GenericCombinationStrategy>>;
689
771
  /** Global ID of this GenericMapper */
690
- id: Scalars['GenericMapperID']['output'];
772
+ id?: Maybe<Scalars['GenericMapperID']['output']>;
691
773
  /** The source data type identifier. */
692
- sources: Array<DataTypeIdentifier>;
774
+ sourceDataTypeIdentifiers?: Maybe<Array<DataTypeIdentifier>>;
693
775
  /** The target key for the generic value. */
694
- target: Scalars['String']['output'];
776
+ target?: Maybe<Scalars['String']['output']>;
695
777
  /** Time when this GenericMapper was last updated */
696
- updatedAt: Scalars['Time']['output'];
778
+ updatedAt?: Maybe<Scalars['Time']['output']>;
697
779
  }
698
780
 
699
781
  /** Input type for generic mappers */
@@ -708,15 +790,15 @@ export interface GenericMapperInput {
708
790
  export interface GenericType {
709
791
  __typename?: 'GenericType';
710
792
  /** Time when this GenericType was created */
711
- createdAt: Scalars['Time']['output'];
793
+ createdAt?: Maybe<Scalars['Time']['output']>;
712
794
  /** The data type associated with this generic type. */
713
- dataType: DataType;
795
+ dataType?: Maybe<DataType>;
714
796
  /** The mappers associated with this generic type. */
715
- genericMappers: Array<GenericMapper>;
797
+ genericMappers?: Maybe<Array<GenericMapper>>;
716
798
  /** Global ID of this GenericType */
717
- id: Scalars['GenericTypeID']['output'];
799
+ id?: Maybe<Scalars['GenericTypeID']['output']>;
718
800
  /** Time when this GenericType was last updated */
719
- updatedAt: Scalars['Time']['output'];
801
+ updatedAt?: Maybe<Scalars['Time']['output']>;
720
802
  }
721
803
 
722
804
  /** Input type for generic type operations. */
@@ -737,18 +819,18 @@ export interface IdentityInput {
737
819
  export interface LiteralValue {
738
820
  __typename?: 'LiteralValue';
739
821
  /** Time when this LiteralValue was created */
740
- createdAt: Scalars['Time']['output'];
822
+ createdAt?: Maybe<Scalars['Time']['output']>;
741
823
  /** Time when this LiteralValue was last updated */
742
- updatedAt: Scalars['Time']['output'];
824
+ updatedAt?: Maybe<Scalars['Time']['output']>;
743
825
  /** The literal value itself as JSON. */
744
- value: Scalars['JSON']['output'];
826
+ value?: Maybe<Scalars['JSON']['output']>;
745
827
  }
746
828
 
747
829
  /** Represents an error message */
748
830
  export interface MessageError {
749
831
  __typename?: 'MessageError';
750
832
  /** The message provided from the error */
751
- message: Scalars['String']['output'];
833
+ message?: Maybe<Scalars['String']['output']>;
752
834
  }
753
835
 
754
836
  /** Represents the input for mfa authentication */
@@ -760,7 +842,7 @@ export interface MfaInput {
760
842
  }
761
843
 
762
844
  /** Represent all available types to authenticate with mfa */
763
- export enum MfaType {
845
+ export const enum MfaType {
764
846
  /** Single use backup code */
765
847
  BackupCode = 'BACKUP_CODE',
766
848
  /** Time based onetime password */
@@ -777,11 +859,12 @@ export interface Mutation {
777
859
  *
778
860
  * This is expected to be used for testing of endpoints, to verify
779
861
  * that a user has mutation access.
862
+ *
780
863
  */
781
864
  echo?: Maybe<EchoPayload>;
782
- /** Create a new namespace license. */
865
+ /** (EE only) Create a new namespace license. */
783
866
  namespacesLicensesCreate?: Maybe<NamespacesLicensesCreatePayload>;
784
- /** Deletes an namespace license. */
867
+ /** (EE only) Deletes an namespace license. */
785
868
  namespacesLicensesDelete?: Maybe<NamespacesLicensesDeletePayload>;
786
869
  /** Update the roles a member is assigned to. */
787
870
  namespacesMembersAssignRoles?: Maybe<NamespacesMembersAssignRolesPayload>;
@@ -825,6 +908,8 @@ export interface Mutation {
825
908
  runtimesRotateToken?: Maybe<RuntimesRotateTokenPayload>;
826
909
  /** Update an existing runtime. */
827
910
  runtimesUpdate?: Maybe<RuntimesUpdatePayload>;
911
+ /** Verify your email when changing it or signing up */
912
+ usersEmailVerification?: Maybe<UsersEmailVerificationPayload>;
828
913
  /** Links an external identity to an existing user */
829
914
  usersIdentityLink?: Maybe<UsersIdentityLinkPayload>;
830
915
  /** Login to an existing user via an external identity */
@@ -843,6 +928,10 @@ export interface Mutation {
843
928
  usersMfaTotpGenerateSecret?: Maybe<UsersMfaTotpGenerateSecretPayload>;
844
929
  /** Validates a TOTP value for the given secret and enables TOTP MFA for the user */
845
930
  usersMfaTotpValidateSecret?: Maybe<UsersMfaTotpValidateSecretPayload>;
931
+ /** Reset the password using a reset token */
932
+ usersPasswordReset?: Maybe<UsersPasswordResetPayload>;
933
+ /** Request an password reset */
934
+ usersPasswordResetRequest?: Maybe<UsersPasswordResetRequestPayload>;
846
935
  /** Register a new user */
847
936
  usersRegister?: Maybe<UsersRegisterPayload>;
848
937
  /** Update an existing user. */
@@ -1000,6 +1089,12 @@ export interface MutationRuntimesUpdateArgs {
1000
1089
  }
1001
1090
 
1002
1091
 
1092
+ /** Root Mutation type */
1093
+ export interface MutationUsersEmailVerificationArgs {
1094
+ input: UsersEmailVerificationInput;
1095
+ }
1096
+
1097
+
1003
1098
  /** Root Mutation type */
1004
1099
  export interface MutationUsersIdentityLinkArgs {
1005
1100
  input: UsersIdentityLinkInput;
@@ -1054,6 +1149,18 @@ export interface MutationUsersMfaTotpValidateSecretArgs {
1054
1149
  }
1055
1150
 
1056
1151
 
1152
+ /** Root Mutation type */
1153
+ export interface MutationUsersPasswordResetArgs {
1154
+ input: UsersPasswordResetInput;
1155
+ }
1156
+
1157
+
1158
+ /** Root Mutation type */
1159
+ export interface MutationUsersPasswordResetRequestArgs {
1160
+ input: UsersPasswordResetRequestInput;
1161
+ }
1162
+
1163
+
1057
1164
  /** Root Mutation type */
1058
1165
  export interface MutationUsersRegisterArgs {
1059
1166
  input: UsersRegisterInput;
@@ -1069,23 +1176,23 @@ export interface MutationUsersUpdateArgs {
1069
1176
  export interface Namespace {
1070
1177
  __typename?: 'Namespace';
1071
1178
  /** Time when this Namespace was created */
1072
- createdAt: Scalars['Time']['output'];
1179
+ createdAt?: Maybe<Scalars['Time']['output']>;
1073
1180
  /** Global ID of this Namespace */
1074
- id: Scalars['NamespaceID']['output'];
1181
+ id?: Maybe<Scalars['NamespaceID']['output']>;
1075
1182
  /** Members of the namespace */
1076
- members: NamespaceMemberConnection;
1077
- /** Licenses of the namespace */
1078
- namespaceLicenses: NamespaceLicenseConnection;
1183
+ members?: Maybe<NamespaceMemberConnection>;
1184
+ /** (EE only) Licenses of the namespace */
1185
+ namespaceLicenses?: Maybe<NamespaceLicenseConnection>;
1079
1186
  /** Parent of this namespace */
1080
- parent: NamespaceParent;
1187
+ parent?: Maybe<NamespaceParent>;
1081
1188
  /** Projects of the namespace */
1082
- projects: NamespaceProjectConnection;
1189
+ projects?: Maybe<NamespaceProjectConnection>;
1083
1190
  /** Roles of the namespace */
1084
- roles: NamespaceRoleConnection;
1191
+ roles?: Maybe<NamespaceRoleConnection>;
1085
1192
  /** Runtime of the namespace */
1086
- runtimes: RuntimeConnection;
1193
+ runtimes?: Maybe<RuntimeConnection>;
1087
1194
  /** Time when this Namespace was last updated */
1088
- updatedAt: Scalars['Time']['output'];
1195
+ updatedAt?: Maybe<Scalars['Time']['output']>;
1089
1196
  }
1090
1197
 
1091
1198
 
@@ -1133,37 +1240,43 @@ export interface NamespaceRuntimesArgs {
1133
1240
  last?: InputMaybe<Scalars['Int']['input']>;
1134
1241
  }
1135
1242
 
1136
- /** Represents a Namespace License */
1243
+ /** (EE only) Represents a Namespace License */
1137
1244
  export interface NamespaceLicense {
1138
1245
  __typename?: 'NamespaceLicense';
1139
1246
  /** Time when this NamespaceLicense was created */
1140
- createdAt: Scalars['Time']['output'];
1247
+ createdAt?: Maybe<Scalars['Time']['output']>;
1248
+ /** The end date of the license */
1249
+ endDate?: Maybe<Scalars['Time']['output']>;
1141
1250
  /** Global ID of this NamespaceLicense */
1142
- id: Scalars['NamespaceLicenseID']['output'];
1251
+ id?: Maybe<Scalars['NamespaceLicenseID']['output']>;
1252
+ /** The licensee information */
1253
+ licensee?: Maybe<Scalars['JSON']['output']>;
1143
1254
  /** The namespace the license belongs to */
1144
- namespace: Namespace;
1255
+ namespace?: Maybe<Namespace>;
1256
+ /** The start date of the license */
1257
+ startDate?: Maybe<Scalars['Time']['output']>;
1145
1258
  /** Time when this NamespaceLicense was last updated */
1146
- updatedAt: Scalars['Time']['output'];
1259
+ updatedAt?: Maybe<Scalars['Time']['output']>;
1147
1260
  }
1148
1261
 
1149
1262
  /** The connection type for NamespaceLicense. */
1150
1263
  export interface NamespaceLicenseConnection {
1151
1264
  __typename?: 'NamespaceLicenseConnection';
1152
1265
  /** Total count of collection. */
1153
- count: Scalars['Int']['output'];
1266
+ count?: Maybe<Scalars['Int']['output']>;
1154
1267
  /** A list of edges. */
1155
1268
  edges?: Maybe<Array<Maybe<NamespaceLicenseEdge>>>;
1156
1269
  /** A list of nodes. */
1157
1270
  nodes?: Maybe<Array<Maybe<NamespaceLicense>>>;
1158
1271
  /** Information to aid in pagination. */
1159
- pageInfo: PageInfo;
1272
+ pageInfo?: Maybe<PageInfo>;
1160
1273
  }
1161
1274
 
1162
1275
  /** An edge in a connection. */
1163
1276
  export interface NamespaceLicenseEdge {
1164
1277
  __typename?: 'NamespaceLicenseEdge';
1165
1278
  /** A cursor for use in pagination. */
1166
- cursor: Scalars['String']['output'];
1279
+ cursor?: Maybe<Scalars['String']['output']>;
1167
1280
  /** The item at the end of the edge. */
1168
1281
  node?: Maybe<NamespaceLicense>;
1169
1282
  }
@@ -1172,35 +1285,57 @@ export interface NamespaceLicenseEdge {
1172
1285
  export interface NamespaceMember {
1173
1286
  __typename?: 'NamespaceMember';
1174
1287
  /** Time when this NamespaceMember was created */
1175
- createdAt: Scalars['Time']['output'];
1288
+ createdAt?: Maybe<Scalars['Time']['output']>;
1176
1289
  /** Global ID of this NamespaceMember */
1177
- id: Scalars['NamespaceMemberID']['output'];
1290
+ id?: Maybe<Scalars['NamespaceMemberID']['output']>;
1291
+ /** Memberroles of the member */
1292
+ memberRoles?: Maybe<NamespaceMemberRoleConnection>;
1178
1293
  /** Namespace this member belongs to */
1179
- namespace: Namespace;
1294
+ namespace?: Maybe<Namespace>;
1295
+ /** Roles of the member */
1296
+ roles?: Maybe<NamespaceRoleConnection>;
1180
1297
  /** Time when this NamespaceMember was last updated */
1181
- updatedAt: Scalars['Time']['output'];
1298
+ updatedAt?: Maybe<Scalars['Time']['output']>;
1182
1299
  /** User this member belongs to */
1183
- user: User;
1300
+ user?: Maybe<User>;
1301
+ }
1302
+
1303
+
1304
+ /** Represents a namespace member */
1305
+ export interface NamespaceMemberMemberRolesArgs {
1306
+ after?: InputMaybe<Scalars['String']['input']>;
1307
+ before?: InputMaybe<Scalars['String']['input']>;
1308
+ first?: InputMaybe<Scalars['Int']['input']>;
1309
+ last?: InputMaybe<Scalars['Int']['input']>;
1310
+ }
1311
+
1312
+
1313
+ /** Represents a namespace member */
1314
+ export interface NamespaceMemberRolesArgs {
1315
+ after?: InputMaybe<Scalars['String']['input']>;
1316
+ before?: InputMaybe<Scalars['String']['input']>;
1317
+ first?: InputMaybe<Scalars['Int']['input']>;
1318
+ last?: InputMaybe<Scalars['Int']['input']>;
1184
1319
  }
1185
1320
 
1186
1321
  /** The connection type for NamespaceMember. */
1187
1322
  export interface NamespaceMemberConnection {
1188
1323
  __typename?: 'NamespaceMemberConnection';
1189
1324
  /** Total count of collection. */
1190
- count: Scalars['Int']['output'];
1325
+ count?: Maybe<Scalars['Int']['output']>;
1191
1326
  /** A list of edges. */
1192
1327
  edges?: Maybe<Array<Maybe<NamespaceMemberEdge>>>;
1193
1328
  /** A list of nodes. */
1194
1329
  nodes?: Maybe<Array<Maybe<NamespaceMember>>>;
1195
1330
  /** Information to aid in pagination. */
1196
- pageInfo: PageInfo;
1331
+ pageInfo?: Maybe<PageInfo>;
1197
1332
  }
1198
1333
 
1199
1334
  /** An edge in a connection. */
1200
1335
  export interface NamespaceMemberEdge {
1201
1336
  __typename?: 'NamespaceMemberEdge';
1202
1337
  /** A cursor for use in pagination. */
1203
- cursor: Scalars['String']['output'];
1338
+ cursor?: Maybe<Scalars['String']['output']>;
1204
1339
  /** The item at the end of the edge. */
1205
1340
  node?: Maybe<NamespaceMember>;
1206
1341
  }
@@ -1209,43 +1344,65 @@ export interface NamespaceMemberEdge {
1209
1344
  export interface NamespaceMemberRole {
1210
1345
  __typename?: 'NamespaceMemberRole';
1211
1346
  /** Time when this NamespaceMemberRole was created */
1212
- createdAt: Scalars['Time']['output'];
1347
+ createdAt?: Maybe<Scalars['Time']['output']>;
1213
1348
  /** Global ID of this NamespaceMemberRole */
1214
- id: Scalars['NamespaceMemberRoleID']['output'];
1349
+ id?: Maybe<Scalars['NamespaceMemberRoleID']['output']>;
1215
1350
  /** The member the role is assigned to */
1216
1351
  member?: Maybe<NamespaceMember>;
1217
1352
  /** The assigned role */
1218
1353
  role?: Maybe<NamespaceRole>;
1219
1354
  /** Time when this NamespaceMemberRole was last updated */
1220
- updatedAt: Scalars['Time']['output'];
1355
+ updatedAt?: Maybe<Scalars['Time']['output']>;
1356
+ }
1357
+
1358
+ /** The connection type for NamespaceMemberRole. */
1359
+ export interface NamespaceMemberRoleConnection {
1360
+ __typename?: 'NamespaceMemberRoleConnection';
1361
+ /** Total count of collection. */
1362
+ count?: Maybe<Scalars['Int']['output']>;
1363
+ /** A list of edges. */
1364
+ edges?: Maybe<Array<Maybe<NamespaceMemberRoleEdge>>>;
1365
+ /** A list of nodes. */
1366
+ nodes?: Maybe<Array<Maybe<NamespaceMemberRole>>>;
1367
+ /** Information to aid in pagination. */
1368
+ pageInfo?: Maybe<PageInfo>;
1369
+ }
1370
+
1371
+ /** An edge in a connection. */
1372
+ export interface NamespaceMemberRoleEdge {
1373
+ __typename?: 'NamespaceMemberRoleEdge';
1374
+ /** A cursor for use in pagination. */
1375
+ cursor?: Maybe<Scalars['String']['output']>;
1376
+ /** The item at the end of the edge. */
1377
+ node?: Maybe<NamespaceMemberRole>;
1221
1378
  }
1222
1379
 
1223
1380
  /** Objects that can present a namespace */
1224
- export type NamespaceParent = Organization;
1381
+ export type NamespaceParent = Organization | User;
1225
1382
 
1226
1383
  /** Represents a namespace project */
1227
1384
  export interface NamespaceProject {
1228
1385
  __typename?: 'NamespaceProject';
1229
1386
  /** Time when this NamespaceProject was created */
1230
- createdAt: Scalars['Time']['output'];
1387
+ createdAt?: Maybe<Scalars['Time']['output']>;
1231
1388
  /** Description of the project */
1232
- description: Scalars['String']['output'];
1389
+ description?: Maybe<Scalars['String']['output']>;
1233
1390
  /** Fetches an flow given by its ID */
1234
1391
  flow?: Maybe<Flow>;
1235
1392
  /** Fetches all flows in this project */
1236
1393
  flows?: Maybe<FlowConnection>;
1237
1394
  /** Global ID of this NamespaceProject */
1238
- id: Scalars['NamespaceProjectID']['output'];
1395
+ id?: Maybe<Scalars['NamespaceProjectID']['output']>;
1239
1396
  /** Name of the project */
1240
- name: Scalars['String']['output'];
1397
+ name?: Maybe<Scalars['String']['output']>;
1241
1398
  /** The namespace where this project belongs to */
1242
- namespace: Namespace;
1399
+ namespace?: Maybe<Namespace>;
1243
1400
  /** The primary runtime for the project */
1244
1401
  primaryRuntime?: Maybe<Runtime>;
1245
1402
  /** Runtimes assigned to this project */
1246
- runtimes: RuntimeConnection;
1403
+ runtimes?: Maybe<RuntimeConnection>;
1247
1404
  /** Time when this NamespaceProject was last updated */
1248
- updatedAt: Scalars['Time']['output'];
1405
+ updatedAt?: Maybe<Scalars['Time']['output']>;
1249
1406
  }
1250
1407
 
1251
1408
 
@@ -1276,20 +1433,20 @@ export interface NamespaceProjectRuntimesArgs {
1276
1433
  export interface NamespaceProjectConnection {
1277
1434
  __typename?: 'NamespaceProjectConnection';
1278
1435
  /** Total count of collection. */
1279
- count: Scalars['Int']['output'];
1436
+ count?: Maybe<Scalars['Int']['output']>;
1280
1437
  /** A list of edges. */
1281
1438
  edges?: Maybe<Array<Maybe<NamespaceProjectEdge>>>;
1282
1439
  /** A list of nodes. */
1283
1440
  nodes?: Maybe<Array<Maybe<NamespaceProject>>>;
1284
1441
  /** Information to aid in pagination. */
1285
- pageInfo: PageInfo;
1442
+ pageInfo?: Maybe<PageInfo>;
1286
1443
  }
1287
1444
 
1288
1445
  /** An edge in a connection. */
1289
1446
  export interface NamespaceProjectEdge {
1290
1447
  __typename?: 'NamespaceProjectEdge';
1291
1448
  /** A cursor for use in pagination. */
1292
- cursor: Scalars['String']['output'];
1449
+ cursor?: Maybe<Scalars['String']['output']>;
1293
1450
  /** The item at the end of the edge. */
1294
1451
  node?: Maybe<NamespaceProject>;
1295
1452
  }
@@ -1298,19 +1455,19 @@ export interface NamespaceProjectEdge {
1298
1455
  export interface NamespaceRole {
1299
1456
  __typename?: 'NamespaceRole';
1300
1457
  /** The abilities the role is granted */
1301
- abilities: Array<NamespaceRoleAbility>;
1458
+ abilities?: Maybe<Array<NamespaceRoleAbility>>;
1302
1459
  /** The projects this role is assigned to */
1303
1460
  assignedProjects?: Maybe<NamespaceProjectConnection>;
1304
1461
  /** Time when this NamespaceRole was created */
1305
- createdAt: Scalars['Time']['output'];
1462
+ createdAt?: Maybe<Scalars['Time']['output']>;
1306
1463
  /** Global ID of this NamespaceRole */
1307
- id: Scalars['NamespaceRoleID']['output'];
1464
+ id?: Maybe<Scalars['NamespaceRoleID']['output']>;
1308
1465
  /** The name of this role */
1309
- name: Scalars['String']['output'];
1466
+ name?: Maybe<Scalars['String']['output']>;
1310
1467
  /** The namespace where this role belongs to */
1311
1468
  namespace?: Maybe<Namespace>;
1312
1469
  /** Time when this NamespaceRole was last updated */
1313
- updatedAt: Scalars['Time']['output'];
1470
+ updatedAt?: Maybe<Scalars['Time']['output']>;
1314
1471
  }
1315
1472
 
1316
1473
 
@@ -1323,7 +1480,7 @@ export interface NamespaceRoleAssignedProjectsArgs {
1323
1480
  }
1324
1481
 
1325
1482
  /** Represents abilities that can be granted to roles in namespaces. */
1326
- export enum NamespaceRoleAbility {
1483
+ export const enum NamespaceRoleAbility {
1327
1484
  /** Allows to change the roles of a namespace member */
1328
1485
  AssignMemberRoles = 'ASSIGN_MEMBER_ROLES',
1329
1486
  /** Allows to assign runtimes to a project in the namespace */
@@ -1382,20 +1539,20 @@ export enum NamespaceRoleAbility {
1382
1539
  export interface NamespaceRoleConnection {
1383
1540
  __typename?: 'NamespaceRoleConnection';
1384
1541
  /** Total count of collection. */
1385
- count: Scalars['Int']['output'];
1542
+ count?: Maybe<Scalars['Int']['output']>;
1386
1543
  /** A list of edges. */
1387
1544
  edges?: Maybe<Array<Maybe<NamespaceRoleEdge>>>;
1388
1545
  /** A list of nodes. */
1389
1546
  nodes?: Maybe<Array<Maybe<NamespaceRole>>>;
1390
1547
  /** Information to aid in pagination. */
1391
- pageInfo: PageInfo;
1548
+ pageInfo?: Maybe<PageInfo>;
1392
1549
  }
1393
1550
 
1394
1551
  /** An edge in a connection. */
1395
1552
  export interface NamespaceRoleEdge {
1396
1553
  __typename?: 'NamespaceRoleEdge';
1397
1554
  /** A cursor for use in pagination. */
1398
- cursor: Scalars['String']['output'];
1555
+ cursor?: Maybe<Scalars['String']['output']>;
1399
1556
  /** The item at the end of the edge. */
1400
1557
  node?: Maybe<NamespaceRole>;
1401
1558
  }
@@ -1416,7 +1573,7 @@ export interface NamespacesLicensesCreatePayload {
1416
1573
  /** A unique identifier for the client performing the mutation. */
1417
1574
  clientMutationId?: Maybe<Scalars['String']['output']>;
1418
1575
  /** Errors encountered during execution of the mutation. */
1419
- errors: Array<Error>;
1576
+ errors?: Maybe<Array<Error>>;
1420
1577
  /** The newly created license. */
1421
1578
  namespaceLicense?: Maybe<NamespaceLicense>;
1422
1579
  }
@@ -1435,7 +1592,7 @@ export interface NamespacesLicensesDeletePayload {
1435
1592
  /** A unique identifier for the client performing the mutation. */
1436
1593
  clientMutationId?: Maybe<Scalars['String']['output']>;
1437
1594
  /** Errors encountered during execution of the mutation. */
1438
- errors: Array<Error>;
1595
+ errors?: Maybe<Array<Error>>;
1439
1596
  /** The deleted namespace license. */
1440
1597
  namespaceLicense?: Maybe<NamespaceLicense>;
1441
1598
  }
@@ -1456,7 +1613,7 @@ export interface NamespacesMembersAssignRolesPayload {
1456
1613
  /** A unique identifier for the client performing the mutation. */
1457
1614
  clientMutationId?: Maybe<Scalars['String']['output']>;
1458
1615
  /** Errors encountered during execution of the mutation. */
1459
- errors: Array<Error>;
1616
+ errors?: Maybe<Array<Error>>;
1460
1617
  /** The roles the member is now assigned to */
1461
1618
  namespaceMemberRoles?: Maybe<Array<NamespaceMemberRole>>;
1462
1619
  }
@@ -1475,7 +1632,7 @@ export interface NamespacesMembersDeletePayload {
1475
1632
  /** A unique identifier for the client performing the mutation. */
1476
1633
  clientMutationId?: Maybe<Scalars['String']['output']>;
1477
1634
  /** Errors encountered during execution of the mutation. */
1478
- errors: Array<Error>;
1635
+ errors?: Maybe<Array<Error>>;
1479
1636
  /** The removed namespace member */
1480
1637
  namespaceMember?: Maybe<NamespaceMember>;
1481
1638
  }
@@ -1496,7 +1653,7 @@ export interface NamespacesMembersInvitePayload {
1496
1653
  /** A unique identifier for the client performing the mutation. */
1497
1654
  clientMutationId?: Maybe<Scalars['String']['output']>;
1498
1655
  /** Errors encountered during execution of the mutation. */
1499
- errors: Array<Error>;
1656
+ errors?: Maybe<Array<Error>>;
1500
1657
  /** The newly created namespace member */
1501
1658
  namespaceMember?: Maybe<NamespaceMember>;
1502
1659
  }
@@ -1517,7 +1674,7 @@ export interface NamespacesProjectsAssignRuntimesPayload {
1517
1674
  /** A unique identifier for the client performing the mutation. */
1518
1675
  clientMutationId?: Maybe<Scalars['String']['output']>;
1519
1676
  /** Errors encountered during execution of the mutation. */
1520
- errors: Array<Error>;
1677
+ errors?: Maybe<Array<Error>>;
1521
1678
  /** The updated project with assigned runtimes */
1522
1679
  namespaceProject?: Maybe<NamespaceProject>;
1523
1680
  }
@@ -1540,7 +1697,7 @@ export interface NamespacesProjectsCreatePayload {
1540
1697
  /** A unique identifier for the client performing the mutation. */
1541
1698
  clientMutationId?: Maybe<Scalars['String']['output']>;
1542
1699
  /** Errors encountered during execution of the mutation. */
1543
- errors: Array<Error>;
1700
+ errors?: Maybe<Array<Error>>;
1544
1701
  /** The newly created project. */
1545
1702
  namespaceProject?: Maybe<NamespaceProject>;
1546
1703
  }
@@ -1559,7 +1716,7 @@ export interface NamespacesProjectsDeletePayload {
1559
1716
  /** A unique identifier for the client performing the mutation. */
1560
1717
  clientMutationId?: Maybe<Scalars['String']['output']>;
1561
1718
  /** Errors encountered during execution of the mutation. */
1562
- errors: Array<Error>;
1719
+ errors?: Maybe<Array<Error>>;
1563
1720
  /** The deleted project. */
1564
1721
  namespaceProject?: Maybe<NamespaceProject>;
1565
1722
  }
@@ -1580,7 +1737,7 @@ export interface NamespacesProjectsFlowsCreatePayload {
1580
1737
  /** A unique identifier for the client performing the mutation. */
1581
1738
  clientMutationId?: Maybe<Scalars['String']['output']>;
1582
1739
  /** Errors encountered during execution of the mutation. */
1583
- errors: Array<Error>;
1740
+ errors?: Maybe<Array<Error>>;
1584
1741
  /** The newly created flow. */
1585
1742
  flow?: Maybe<Flow>;
1586
1743
  }
@@ -1599,7 +1756,7 @@ export interface NamespacesProjectsFlowsDeletePayload {
1599
1756
  /** A unique identifier for the client performing the mutation. */
1600
1757
  clientMutationId?: Maybe<Scalars['String']['output']>;
1601
1758
  /** Errors encountered during execution of the mutation. */
1602
- errors: Array<Error>;
1759
+ errors?: Maybe<Array<Error>>;
1603
1760
  /** The deleted flow. */
1604
1761
  flow?: Maybe<Flow>;
1605
1762
  }
@@ -1624,7 +1781,7 @@ export interface NamespacesProjectsUpdatePayload {
1624
1781
  /** A unique identifier for the client performing the mutation. */
1625
1782
  clientMutationId?: Maybe<Scalars['String']['output']>;
1626
1783
  /** Errors encountered during execution of the mutation. */
1627
- errors: Array<Error>;
1784
+ errors?: Maybe<Array<Error>>;
1628
1785
  /** The updated project. */
1629
1786
  namespaceProject?: Maybe<NamespaceProject>;
1630
1787
  }
@@ -1647,7 +1804,7 @@ export interface NamespacesRolesAssignAbilitiesPayload {
1647
1804
  /** A unique identifier for the client performing the mutation. */
1648
1805
  clientMutationId?: Maybe<Scalars['String']['output']>;
1649
1806
  /** Errors encountered during execution of the mutation. */
1650
- errors: Array<Error>;
1807
+ errors?: Maybe<Array<Error>>;
1651
1808
  }
1652
1809
 
1653
1810
  /** Autogenerated input type of NamespacesRolesAssignProjects */
@@ -1666,7 +1823,7 @@ export interface NamespacesRolesAssignProjectsPayload {
1666
1823
  /** A unique identifier for the client performing the mutation. */
1667
1824
  clientMutationId?: Maybe<Scalars['String']['output']>;
1668
1825
  /** Errors encountered during execution of the mutation. */
1669
- errors: Array<Error>;
1826
+ errors?: Maybe<Array<Error>>;
1670
1827
  /** The now assigned projects */
1671
1828
  projects?: Maybe<Array<NamespaceProject>>;
1672
1829
  }
@@ -1687,7 +1844,7 @@ export interface NamespacesRolesCreatePayload {
1687
1844
  /** A unique identifier for the client performing the mutation. */
1688
1845
  clientMutationId?: Maybe<Scalars['String']['output']>;
1689
1846
  /** Errors encountered during execution of the mutation. */
1690
- errors: Array<Error>;
1847
+ errors?: Maybe<Array<Error>>;
1691
1848
  /** The newly created namespace role */
1692
1849
  namespaceRole?: Maybe<NamespaceRole>;
1693
1850
  }
@@ -1706,7 +1863,7 @@ export interface NamespacesRolesDeletePayload {
1706
1863
  /** A unique identifier for the client performing the mutation. */
1707
1864
  clientMutationId?: Maybe<Scalars['String']['output']>;
1708
1865
  /** Errors encountered during execution of the mutation. */
1709
- errors: Array<Error>;
1866
+ errors?: Maybe<Array<Error>>;
1710
1867
  /** The deleted namespace role */
1711
1868
  namespaceRole?: Maybe<NamespaceRole>;
1712
1869
  }
@@ -1727,7 +1884,7 @@ export interface NamespacesRolesUpdatePayload {
1727
1884
  /** A unique identifier for the client performing the mutation. */
1728
1885
  clientMutationId?: Maybe<Scalars['String']['output']>;
1729
1886
  /** Errors encountered during execution of the mutation. */
1730
- errors: Array<Error>;
1887
+ errors?: Maybe<Array<Error>>;
1731
1888
  /** The updated namespace role. */
1732
1889
  namespaceRole?: Maybe<NamespaceRole>;
1733
1890
  }
@@ -1735,24 +1892,24 @@ export interface NamespacesRolesUpdatePayload {
1735
1892
  /** An object with an ID. */
1736
1893
  export interface Node {
1737
1894
  /** ID of the object. */
1738
- id: Scalars['ID']['output'];
1895
+ id?: Maybe<Scalars['ID']['output']>;
1739
1896
  }
1740
1897
 
1741
1898
  /** Represents a Node Function */
1742
1899
  export interface NodeFunction {
1743
1900
  __typename?: 'NodeFunction';
1744
1901
  /** Time when this NodeFunction was created */
1745
- createdAt: Scalars['Time']['output'];
1902
+ createdAt?: Maybe<Scalars['Time']['output']>;
1903
+ /** The definition of the Node Function */
1904
+ functionDefinition?: Maybe<FunctionDefinition>;
1746
1905
  /** Global ID of this NodeFunction */
1747
- id: Scalars['NodeFunctionID']['output'];
1748
- /** The next Node Function in the flow */
1749
- nextNode?: Maybe<NodeFunction>;
1906
+ id?: Maybe<Scalars['NodeFunctionID']['output']>;
1907
+ /** The ID of the next Node Function in the flow */
1908
+ nextNodeId?: Maybe<Scalars['NodeFunctionID']['output']>;
1750
1909
  /** The parameters of the Node Function */
1751
- parameters: NodeParameterConnection;
1752
- /** The definition of the Node Function */
1753
- runtimeFunction: RuntimeFunctionDefinition;
1910
+ parameters?: Maybe<NodeParameterConnection>;
1754
1911
  /** Time when this NodeFunction was last updated */
1755
- updatedAt: Scalars['Time']['output'];
1912
+ updatedAt?: Maybe<Scalars['Time']['output']>;
1756
1913
  }
1757
1914
 
1758
1915
 
@@ -1764,6 +1921,28 @@ export interface NodeFunctionParametersArgs {
1764
1921
  last?: InputMaybe<Scalars['Int']['input']>;
1765
1922
  }
1766
1923
 
1924
+ /** The connection type for NodeFunction. */
1925
+ export interface NodeFunctionConnection {
1926
+ __typename?: 'NodeFunctionConnection';
1927
+ /** Total count of collection. */
1928
+ count?: Maybe<Scalars['Int']['output']>;
1929
+ /** A list of edges. */
1930
+ edges?: Maybe<Array<Maybe<NodeFunctionEdge>>>;
1931
+ /** A list of nodes. */
1932
+ nodes?: Maybe<Array<Maybe<NodeFunction>>>;
1933
+ /** Information to aid in pagination. */
1934
+ pageInfo?: Maybe<PageInfo>;
1935
+ }
1936
+
1937
+ /** An edge in a connection. */
1938
+ export interface NodeFunctionEdge {
1939
+ __typename?: 'NodeFunctionEdge';
1940
+ /** A cursor for use in pagination. */
1941
+ cursor?: Maybe<Scalars['String']['output']>;
1942
+ /** The item at the end of the edge. */
1943
+ node?: Maybe<NodeFunction>;
1944
+ }
1945
+
1767
1946
  /** Input type for a Node Function */
1768
1947
  export interface NodeFunctionInput {
1769
1948
  /** The next Node Function in the flow */
@@ -1778,13 +1957,13 @@ export interface NodeFunctionInput {
1778
1957
  export interface NodeParameter {
1779
1958
  __typename?: 'NodeParameter';
1780
1959
  /** Time when this NodeParameter was created */
1781
- createdAt: Scalars['Time']['output'];
1960
+ createdAt?: Maybe<Scalars['Time']['output']>;
1782
1961
  /** Global ID of this NodeParameter */
1783
- id: Scalars['NodeParameterID']['output'];
1962
+ id?: Maybe<Scalars['NodeParameterID']['output']>;
1784
1963
  /** The definition of the parameter */
1785
- runtimeParameter: RuntimeParameterDefinition;
1964
+ runtimeParameter?: Maybe<RuntimeParameterDefinition>;
1786
1965
  /** Time when this NodeParameter was last updated */
1787
- updatedAt: Scalars['Time']['output'];
1966
+ updatedAt?: Maybe<Scalars['Time']['output']>;
1788
1967
  /** The value of the parameter */
1789
1968
  value?: Maybe<NodeParameterValue>;
1790
1969
  }
@@ -1793,20 +1972,20 @@ export interface NodeParameter {
1793
1972
  export interface NodeParameterConnection {
1794
1973
  __typename?: 'NodeParameterConnection';
1795
1974
  /** Total count of collection. */
1796
- count: Scalars['Int']['output'];
1975
+ count?: Maybe<Scalars['Int']['output']>;
1797
1976
  /** A list of edges. */
1798
1977
  edges?: Maybe<Array<Maybe<NodeParameterEdge>>>;
1799
1978
  /** A list of nodes. */
1800
1979
  nodes?: Maybe<Array<Maybe<NodeParameter>>>;
1801
1980
  /** Information to aid in pagination. */
1802
- pageInfo: PageInfo;
1981
+ pageInfo?: Maybe<PageInfo>;
1803
1982
  }
1804
1983
 
1805
1984
  /** An edge in a connection. */
1806
1985
  export interface NodeParameterEdge {
1807
1986
  __typename?: 'NodeParameterEdge';
1808
1987
  /** A cursor for use in pagination. */
1809
- cursor: Scalars['String']['output'];
1988
+ cursor?: Maybe<Scalars['String']['output']>;
1810
1989
  /** The item at the end of the edge. */
1811
1990
  node?: Maybe<NodeParameter>;
1812
1991
  }
@@ -1836,15 +2015,15 @@ export interface NodeParameterValueInput {
1836
2015
  export interface Organization {
1837
2016
  __typename?: 'Organization';
1838
2017
  /** Time when this Organization was created */
1839
- createdAt: Scalars['Time']['output'];
2018
+ createdAt?: Maybe<Scalars['Time']['output']>;
1840
2019
  /** Global ID of this Organization */
1841
- id: Scalars['OrganizationID']['output'];
2020
+ id?: Maybe<Scalars['OrganizationID']['output']>;
1842
2021
  /** Name of the organization */
1843
- name: Scalars['String']['output'];
2022
+ name?: Maybe<Scalars['String']['output']>;
1844
2023
  /** Namespace of this organization */
1845
- namespace: Namespace;
2024
+ namespace?: Maybe<Namespace>;
1846
2025
  /** Time when this Organization was last updated */
1847
- updatedAt: Scalars['Time']['output'];
2026
+ updatedAt?: Maybe<Scalars['Time']['output']>;
1848
2027
  }
1849
2028
 
1850
2029
  /** Autogenerated input type of OrganizationsCreate */
@@ -1861,7 +2040,7 @@ export interface OrganizationsCreatePayload {
1861
2040
  /** A unique identifier for the client performing the mutation. */
1862
2041
  clientMutationId?: Maybe<Scalars['String']['output']>;
1863
2042
  /** Errors encountered during execution of the mutation. */
1864
- errors: Array<Error>;
2043
+ errors?: Maybe<Array<Error>>;
1865
2044
  /** The newly created organization. */
1866
2045
  organization?: Maybe<Organization>;
1867
2046
  }
@@ -1880,7 +2059,7 @@ export interface OrganizationsDeletePayload {
1880
2059
  /** A unique identifier for the client performing the mutation. */
1881
2060
  clientMutationId?: Maybe<Scalars['String']['output']>;
1882
2061
  /** Errors encountered during execution of the mutation. */
1883
- errors: Array<Error>;
2062
+ errors?: Maybe<Array<Error>>;
1884
2063
  /** The deleted organization. */
1885
2064
  organization?: Maybe<Organization>;
1886
2065
  }
@@ -1901,7 +2080,7 @@ export interface OrganizationsUpdatePayload {
1901
2080
  /** A unique identifier for the client performing the mutation. */
1902
2081
  clientMutationId?: Maybe<Scalars['String']['output']>;
1903
2082
  /** Errors encountered during execution of the mutation. */
1904
- errors: Array<Error>;
2083
+ errors?: Maybe<Array<Error>>;
1905
2084
  /** The updated organization. */
1906
2085
  organization?: Maybe<Organization>;
1907
2086
  }
@@ -1912,9 +2091,9 @@ export interface PageInfo {
1912
2091
  /** When paginating forwards, the cursor to continue. */
1913
2092
  endCursor?: Maybe<Scalars['String']['output']>;
1914
2093
  /** When paginating forwards, are there more items? */
1915
- hasNextPage: Scalars['Boolean']['output'];
2094
+ hasNextPage?: Maybe<Scalars['Boolean']['output']>;
1916
2095
  /** When paginating backwards, are there more items? */
1917
- hasPreviousPage: Scalars['Boolean']['output'];
2096
+ hasPreviousPage?: Maybe<Scalars['Boolean']['output']>;
1918
2097
  /** When paginating backwards, the cursor to continue. */
1919
2098
  startCursor?: Maybe<Scalars['String']['output']>;
1920
2099
  }
@@ -1923,19 +2102,21 @@ export interface PageInfo {
1923
2102
  export interface ParameterDefinition {
1924
2103
  __typename?: 'ParameterDefinition';
1925
2104
  /** Time when this ParameterDefinition was created */
1926
- createdAt: Scalars['Time']['output'];
2105
+ createdAt?: Maybe<Scalars['Time']['output']>;
1927
2106
  /** Data type of the parameter */
1928
- dataType?: Maybe<DataTypeIdentifier>;
2107
+ dataTypeIdentifier?: Maybe<DataTypeIdentifier>;
1929
2108
  /** Description of the parameter */
1930
2109
  descriptions?: Maybe<TranslationConnection>;
1931
2110
  /** Documentation of the parameter */
1932
2111
  documentations?: Maybe<TranslationConnection>;
1933
2112
  /** Global ID of this ParameterDefinition */
1934
- id: Scalars['ParameterDefinitionID']['output'];
2113
+ id?: Maybe<Scalars['ParameterDefinitionID']['output']>;
2114
+ /** Identifier of the parameter */
2115
+ identifier?: Maybe<Scalars['String']['output']>;
1935
2116
  /** Name of the parameter */
1936
2117
  names?: Maybe<TranslationConnection>;
1937
2118
  /** Time when this ParameterDefinition was last updated */
1938
- updatedAt: Scalars['Time']['output'];
2119
+ updatedAt?: Maybe<Scalars['Time']['output']>;
1939
2120
  }
1940
2121
 
1941
2122
 
@@ -1969,20 +2150,20 @@ export interface ParameterDefinitionNamesArgs {
1969
2150
  export interface ParameterDefinitionConnection {
1970
2151
  __typename?: 'ParameterDefinitionConnection';
1971
2152
  /** Total count of collection. */
1972
- count: Scalars['Int']['output'];
2153
+ count?: Maybe<Scalars['Int']['output']>;
1973
2154
  /** A list of edges. */
1974
2155
  edges?: Maybe<Array<Maybe<ParameterDefinitionEdge>>>;
1975
2156
  /** A list of nodes. */
1976
2157
  nodes?: Maybe<Array<Maybe<ParameterDefinition>>>;
1977
2158
  /** Information to aid in pagination. */
1978
- pageInfo: PageInfo;
2159
+ pageInfo?: Maybe<PageInfo>;
1979
2160
  }
1980
2161
 
1981
2162
  /** An edge in a connection. */
1982
2163
  export interface ParameterDefinitionEdge {
1983
2164
  __typename?: 'ParameterDefinitionEdge';
1984
2165
  /** A cursor for use in pagination. */
1985
- cursor: Scalars['String']['output'];
2166
+ cursor?: Maybe<Scalars['String']['output']>;
1986
2167
  /** The item at the end of the edge. */
1987
2168
  node?: Maybe<ParameterDefinition>;
1988
2169
  }
@@ -1997,9 +2178,9 @@ export interface Query {
1997
2178
  /** Get the currently logged in user */
1998
2179
  currentUser?: Maybe<User>;
1999
2180
  /** Field available for use to test API access */
2000
- echo: Scalars['String']['output'];
2181
+ echo?: Maybe<Scalars['String']['output']>;
2001
2182
  /** Find runtimes */
2002
- globalRuntimes: RuntimeConnection;
2183
+ globalRuntimes?: Maybe<RuntimeConnection>;
2003
2184
  /** Find a namespace */
2004
2185
  namespace?: Maybe<Namespace>;
2005
2186
  /** Fetches an object given its ID */
@@ -2009,7 +2190,7 @@ export interface Query {
2009
2190
  /** Find a organization */
2010
2191
  organization?: Maybe<Organization>;
2011
2192
  /** Find users */
2012
- users: UserConnection;
2193
+ users?: Maybe<UserConnection>;
2013
2194
  }
2014
2195
 
2015
2196
 
@@ -2067,13 +2248,13 @@ export interface ReferencePath {
2067
2248
  /** The array index of the referenced data by the path */
2068
2249
  arrayIndex?: Maybe<Scalars['Int']['output']>;
2069
2250
  /** Time when this ReferencePath was created */
2070
- createdAt: Scalars['Time']['output'];
2251
+ createdAt?: Maybe<Scalars['Time']['output']>;
2071
2252
  /** Global ID of this ReferencePath */
2072
- id: Scalars['ReferencePathID']['output'];
2253
+ id?: Maybe<Scalars['ReferencePathID']['output']>;
2073
2254
  /** The path to the reference in the flow */
2074
2255
  path?: Maybe<Scalars['String']['output']>;
2075
2256
  /** Time when this ReferencePath was last updated */
2076
- updatedAt: Scalars['Time']['output'];
2257
+ updatedAt?: Maybe<Scalars['Time']['output']>;
2077
2258
  }
2078
2259
 
2079
2260
  /** Input type for reference path */
@@ -2088,21 +2269,21 @@ export interface ReferencePathInput {
2088
2269
  export interface ReferenceValue {
2089
2270
  __typename?: 'ReferenceValue';
2090
2271
  /** Time when this ReferenceValue was created */
2091
- createdAt: Scalars['Time']['output'];
2272
+ createdAt?: Maybe<Scalars['Time']['output']>;
2092
2273
  /** The identifier of the data type this reference value belongs to. */
2093
- dataTypeIdentifier: DataTypeIdentifier;
2274
+ dataTypeIdentifier?: Maybe<DataTypeIdentifier>;
2275
+ /** The depth of the reference value. */
2276
+ depth?: Maybe<Scalars['Int']['output']>;
2094
2277
  /** Global ID of this ReferenceValue */
2095
- id: Scalars['ReferenceValueID']['output'];
2096
- /** The primary level of the reference value. */
2097
- primaryLevel: Scalars['Int']['output'];
2278
+ id?: Maybe<Scalars['ReferenceValueID']['output']>;
2279
+ /** The node of the reference value. */
2280
+ node?: Maybe<Scalars['Int']['output']>;
2098
2281
  /** 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']>;
2282
+ referencePath?: Maybe<Array<ReferencePath>>;
2283
+ /** The scope of the reference value. */
2284
+ scope?: Maybe<Array<Scalars['Int']['output']>>;
2104
2285
  /** Time when this ReferenceValue was last updated */
2105
- updatedAt: Scalars['Time']['output'];
2286
+ updatedAt?: Maybe<Scalars['Time']['output']>;
2106
2287
  }
2107
2288
 
2108
2289
  /** Input type for reference value */
@@ -2123,27 +2304,27 @@ export interface ReferenceValueInput {
2123
2304
  export interface Runtime {
2124
2305
  __typename?: 'Runtime';
2125
2306
  /** Time when this Runtime was created */
2126
- createdAt: Scalars['Time']['output'];
2307
+ createdAt?: Maybe<Scalars['Time']['output']>;
2127
2308
  /** DataTypes of the runtime */
2128
- dataTypes: DataTypeConnection;
2309
+ dataTypes?: Maybe<DataTypeConnection>;
2129
2310
  /** The description for the runtime if present */
2130
- description: Scalars['String']['output'];
2311
+ description?: Maybe<Scalars['String']['output']>;
2131
2312
  /** FlowTypes of the runtime */
2132
- flowTypes: FlowTypeConnection;
2313
+ flowTypes?: Maybe<FlowTypeConnection>;
2133
2314
  /** Global ID of this Runtime */
2134
- id: Scalars['RuntimeID']['output'];
2315
+ id?: Maybe<Scalars['RuntimeID']['output']>;
2135
2316
  /** The name for the runtime */
2136
- name: Scalars['String']['output'];
2317
+ name?: Maybe<Scalars['String']['output']>;
2137
2318
  /** The parent namespace for the runtime */
2138
2319
  namespace?: Maybe<Namespace>;
2139
2320
  /** Projects associated with the runtime */
2140
- projects: NamespaceProjectConnection;
2321
+ projects?: Maybe<NamespaceProjectConnection>;
2141
2322
  /** The status of the runtime */
2142
- status: RuntimeStatusType;
2323
+ status?: Maybe<RuntimeStatusType>;
2143
2324
  /** Token belonging to the runtime, only present on creation */
2144
2325
  token?: Maybe<Scalars['String']['output']>;
2145
2326
  /** Time when this Runtime was last updated */
2146
- updatedAt: Scalars['Time']['output'];
2327
+ updatedAt?: Maybe<Scalars['Time']['output']>;
2147
2328
  }
2148
2329
 
2149
2330
 
@@ -2177,41 +2358,45 @@ export interface RuntimeProjectsArgs {
2177
2358
  export interface RuntimeConnection {
2178
2359
  __typename?: 'RuntimeConnection';
2179
2360
  /** Total count of collection. */
2180
- count: Scalars['Int']['output'];
2361
+ count?: Maybe<Scalars['Int']['output']>;
2181
2362
  /** A list of edges. */
2182
2363
  edges?: Maybe<Array<Maybe<RuntimeEdge>>>;
2183
2364
  /** A list of nodes. */
2184
2365
  nodes?: Maybe<Array<Maybe<Runtime>>>;
2185
2366
  /** Information to aid in pagination. */
2186
- pageInfo: PageInfo;
2367
+ pageInfo?: Maybe<PageInfo>;
2187
2368
  }
2188
2369
 
2189
2370
  /** An edge in a connection. */
2190
2371
  export interface RuntimeEdge {
2191
2372
  __typename?: 'RuntimeEdge';
2192
2373
  /** A cursor for use in pagination. */
2193
- cursor: Scalars['String']['output'];
2374
+ cursor?: Maybe<Scalars['String']['output']>;
2194
2375
  /** The item at the end of the edge. */
2195
2376
  node?: Maybe<Runtime>;
2196
2377
  }
2197
2378
 
2198
- /** Represents a Node Function definition */
2379
+ /** Represents a runtime function definition */
2199
2380
  export interface RuntimeFunctionDefinition {
2200
2381
  __typename?: 'RuntimeFunctionDefinition';
2201
2382
  /** Time when this RuntimeFunctionDefinition was created */
2202
- createdAt: Scalars['Time']['output'];
2203
- /** Function definitions of the Node Function */
2383
+ createdAt?: Maybe<Scalars['Time']['output']>;
2384
+ /** Function definitions of the runtime function definition */
2204
2385
  functionDefinitions?: Maybe<FunctionDefinitionConnection>;
2205
2386
  /** Global ID of this RuntimeFunctionDefinition */
2206
- id: Scalars['RuntimeParameterDefinitionID']['output'];
2207
- /** The runtime this Node Function belongs to */
2208
- runtime: Runtime;
2387
+ id?: Maybe<Scalars['RuntimeFunctionDefinitionID']['output']>;
2388
+ /** Identifier of the runtime function definition */
2389
+ identifier?: Maybe<Scalars['String']['output']>;
2390
+ /** The runtime this runtime function definition belongs to */
2391
+ runtime?: Maybe<Runtime>;
2392
+ /** Parameter definitions of the runtime function definition */
2393
+ runtimeParameterDefinitions?: Maybe<RuntimeParameterDefinitionConnection>;
2209
2394
  /** Time when this RuntimeFunctionDefinition was last updated */
2210
- updatedAt: Scalars['Time']['output'];
2395
+ updatedAt?: Maybe<Scalars['Time']['output']>;
2211
2396
  }
2212
2397
 
2213
2398
 
2214
- /** Represents a Node Function definition */
2399
+ /** Represents a runtime function definition */
2215
2400
  export interface RuntimeFunctionDefinitionFunctionDefinitionsArgs {
2216
2401
  after?: InputMaybe<Scalars['String']['input']>;
2217
2402
  before?: InputMaybe<Scalars['String']['input']>;
@@ -2219,19 +2404,50 @@ export interface RuntimeFunctionDefinitionFunctionDefinitionsArgs {
2219
2404
  last?: InputMaybe<Scalars['Int']['input']>;
2220
2405
  }
2221
2406
 
2222
- /** Represents a Node parameter definition */
2407
+
2408
+ /** Represents a runtime function definition */
2409
+ export interface RuntimeFunctionDefinitionRuntimeParameterDefinitionsArgs {
2410
+ after?: InputMaybe<Scalars['String']['input']>;
2411
+ before?: InputMaybe<Scalars['String']['input']>;
2412
+ first?: InputMaybe<Scalars['Int']['input']>;
2413
+ last?: InputMaybe<Scalars['Int']['input']>;
2414
+ }
2415
+
2416
+ /** Represents a runtime parameter definition */
2223
2417
  export interface RuntimeParameterDefinition {
2224
2418
  __typename?: 'RuntimeParameterDefinition';
2225
2419
  /** Time when this RuntimeParameterDefinition was created */
2226
- createdAt: Scalars['Time']['output'];
2420
+ createdAt?: Maybe<Scalars['Time']['output']>;
2227
2421
  /** Global ID of this RuntimeParameterDefinition */
2228
- id: Scalars['RuntimeParameterDefinitionID']['output'];
2422
+ id?: Maybe<Scalars['RuntimeParameterDefinitionID']['output']>;
2229
2423
  /** Time when this RuntimeParameterDefinition was last updated */
2230
- updatedAt: Scalars['Time']['output'];
2424
+ updatedAt?: Maybe<Scalars['Time']['output']>;
2425
+ }
2426
+
2427
+ /** The connection type for RuntimeParameterDefinition. */
2428
+ export interface RuntimeParameterDefinitionConnection {
2429
+ __typename?: 'RuntimeParameterDefinitionConnection';
2430
+ /** Total count of collection. */
2431
+ count?: Maybe<Scalars['Int']['output']>;
2432
+ /** A list of edges. */
2433
+ edges?: Maybe<Array<Maybe<RuntimeParameterDefinitionEdge>>>;
2434
+ /** A list of nodes. */
2435
+ nodes?: Maybe<Array<Maybe<RuntimeParameterDefinition>>>;
2436
+ /** Information to aid in pagination. */
2437
+ pageInfo?: Maybe<PageInfo>;
2438
+ }
2439
+
2440
+ /** An edge in a connection. */
2441
+ export interface RuntimeParameterDefinitionEdge {
2442
+ __typename?: 'RuntimeParameterDefinitionEdge';
2443
+ /** A cursor for use in pagination. */
2444
+ cursor?: Maybe<Scalars['String']['output']>;
2445
+ /** The item at the end of the edge. */
2446
+ node?: Maybe<RuntimeParameterDefinition>;
2231
2447
  }
2232
2448
 
2233
2449
  /** Represent all available types of statuses of a runtime */
2234
- export enum RuntimeStatusType {
2450
+ export const enum RuntimeStatusType {
2235
2451
  /** No problem with connection, everything works as expected */
2236
2452
  Connected = 'CONNECTED',
2237
2453
  /** The runtime is disconnected, cause unknown */
@@ -2256,7 +2472,7 @@ export interface RuntimesCreatePayload {
2256
2472
  /** A unique identifier for the client performing the mutation. */
2257
2473
  clientMutationId?: Maybe<Scalars['String']['output']>;
2258
2474
  /** Errors encountered during execution of the mutation. */
2259
- errors: Array<Error>;
2475
+ errors?: Maybe<Array<Error>>;
2260
2476
  /** The newly created runtime. */
2261
2477
  runtime?: Maybe<Runtime>;
2262
2478
  }
@@ -2275,7 +2491,7 @@ export interface RuntimesDeletePayload {
2275
2491
  /** A unique identifier for the client performing the mutation. */
2276
2492
  clientMutationId?: Maybe<Scalars['String']['output']>;
2277
2493
  /** Errors encountered during execution of the mutation. */
2278
- errors: Array<Error>;
2494
+ errors?: Maybe<Array<Error>>;
2279
2495
  /** The updated organization. */
2280
2496
  runtime?: Maybe<Runtime>;
2281
2497
  }
@@ -2294,7 +2510,7 @@ export interface RuntimesRotateTokenPayload {
2294
2510
  /** A unique identifier for the client performing the mutation. */
2295
2511
  clientMutationId?: Maybe<Scalars['String']['output']>;
2296
2512
  /** Errors encountered during execution of the mutation. */
2297
- errors: Array<Error>;
2513
+ errors?: Maybe<Array<Error>>;
2298
2514
  /** The updated runtime. */
2299
2515
  runtime?: Maybe<Runtime>;
2300
2516
  }
@@ -2317,7 +2533,7 @@ export interface RuntimesUpdatePayload {
2317
2533
  /** A unique identifier for the client performing the mutation. */
2318
2534
  clientMutationId?: Maybe<Scalars['String']['output']>;
2319
2535
  /** Errors encountered during execution of the mutation. */
2320
- errors: Array<Error>;
2536
+ errors?: Maybe<Array<Error>>;
2321
2537
  /** The updated runtime. */
2322
2538
  runtime?: Maybe<Runtime>;
2323
2539
  }
@@ -2326,29 +2542,29 @@ export interface RuntimesUpdatePayload {
2326
2542
  export interface Translation {
2327
2543
  __typename?: 'Translation';
2328
2544
  /** Code of the translation */
2329
- code: Scalars['String']['output'];
2545
+ code?: Maybe<Scalars['String']['output']>;
2330
2546
  /** Content of the translation */
2331
- content: Scalars['String']['output'];
2547
+ content?: Maybe<Scalars['String']['output']>;
2332
2548
  }
2333
2549
 
2334
2550
  /** The connection type for Translation. */
2335
2551
  export interface TranslationConnection {
2336
2552
  __typename?: 'TranslationConnection';
2337
2553
  /** Total count of collection. */
2338
- count: Scalars['Int']['output'];
2554
+ count?: Maybe<Scalars['Int']['output']>;
2339
2555
  /** A list of edges. */
2340
2556
  edges?: Maybe<Array<Maybe<TranslationEdge>>>;
2341
2557
  /** A list of nodes. */
2342
2558
  nodes?: Maybe<Array<Maybe<Translation>>>;
2343
2559
  /** Information to aid in pagination. */
2344
- pageInfo: PageInfo;
2560
+ pageInfo?: Maybe<PageInfo>;
2345
2561
  }
2346
2562
 
2347
2563
  /** An edge in a connection. */
2348
2564
  export interface TranslationEdge {
2349
2565
  __typename?: 'TranslationEdge';
2350
2566
  /** A cursor for use in pagination. */
2351
- cursor: Scalars['String']['output'];
2567
+ cursor?: Maybe<Scalars['String']['output']>;
2352
2568
  /** The item at the end of the edge. */
2353
2569
  node?: Maybe<Translation>;
2354
2570
  }
@@ -2357,27 +2573,42 @@ export interface TranslationEdge {
2357
2573
  export interface User {
2358
2574
  __typename?: 'User';
2359
2575
  /** Global admin status of the user */
2360
- admin: Scalars['Boolean']['output'];
2576
+ admin?: Maybe<Scalars['Boolean']['output']>;
2361
2577
  /** The avatar if present of the user */
2362
2578
  avatarPath?: Maybe<Scalars['String']['output']>;
2363
2579
  /** Time when this User was created */
2364
- createdAt: Scalars['Time']['output'];
2580
+ createdAt?: Maybe<Scalars['Time']['output']>;
2365
2581
  /** Email of the user */
2366
- email: Scalars['String']['output'];
2582
+ email?: Maybe<Scalars['String']['output']>;
2583
+ /** Email verification date of the user if present */
2584
+ emailVerifiedAt?: Maybe<Scalars['Time']['output']>;
2367
2585
  /** Firstname of the user */
2368
- firstname: Scalars['String']['output'];
2586
+ firstname?: Maybe<Scalars['String']['output']>;
2369
2587
  /** Global ID of this User */
2370
- id: Scalars['UserID']['output'];
2588
+ id?: Maybe<Scalars['UserID']['output']>;
2589
+ /** Identities of this user */
2590
+ identities?: Maybe<UserIdentityConnection>;
2371
2591
  /** Lastname of the user */
2372
- lastname: Scalars['String']['output'];
2592
+ lastname?: Maybe<Scalars['String']['output']>;
2373
2593
  /** Namespace of this user */
2374
2594
  namespace?: Maybe<Namespace>;
2375
2595
  /** Namespace Memberships of this user */
2376
- namespaceMemberships: NamespaceMemberConnection;
2596
+ namespaceMemberships?: Maybe<NamespaceMemberConnection>;
2597
+ /** Sessions of this user */
2598
+ sessions?: Maybe<UserSessionConnection>;
2377
2599
  /** Time when this User was last updated */
2378
- updatedAt: Scalars['Time']['output'];
2600
+ updatedAt?: Maybe<Scalars['Time']['output']>;
2379
2601
  /** Username of the user */
2380
- username: Scalars['String']['output'];
2602
+ username?: Maybe<Scalars['String']['output']>;
2603
+ }
2604
+
2605
+
2606
+ /** Represents a user */
2607
+ export interface UserIdentitiesArgs {
2608
+ after?: InputMaybe<Scalars['String']['input']>;
2609
+ before?: InputMaybe<Scalars['String']['input']>;
2610
+ first?: InputMaybe<Scalars['Int']['input']>;
2611
+ last?: InputMaybe<Scalars['Int']['input']>;
2381
2612
  }
2382
2613
 
2383
2614
 
@@ -2389,24 +2620,33 @@ export interface UserNamespaceMembershipsArgs {
2389
2620
  last?: InputMaybe<Scalars['Int']['input']>;
2390
2621
  }
2391
2622
 
2623
+
2624
+ /** Represents a user */
2625
+ export interface UserSessionsArgs {
2626
+ after?: InputMaybe<Scalars['String']['input']>;
2627
+ before?: InputMaybe<Scalars['String']['input']>;
2628
+ first?: InputMaybe<Scalars['Int']['input']>;
2629
+ last?: InputMaybe<Scalars['Int']['input']>;
2630
+ }
2631
+
2392
2632
  /** The connection type for User. */
2393
2633
  export interface UserConnection {
2394
2634
  __typename?: 'UserConnection';
2395
2635
  /** Total count of collection. */
2396
- count: Scalars['Int']['output'];
2636
+ count?: Maybe<Scalars['Int']['output']>;
2397
2637
  /** A list of edges. */
2398
2638
  edges?: Maybe<Array<Maybe<UserEdge>>>;
2399
2639
  /** A list of nodes. */
2400
2640
  nodes?: Maybe<Array<Maybe<User>>>;
2401
2641
  /** Information to aid in pagination. */
2402
- pageInfo: PageInfo;
2642
+ pageInfo?: Maybe<PageInfo>;
2403
2643
  }
2404
2644
 
2405
2645
  /** An edge in a connection. */
2406
2646
  export interface UserEdge {
2407
2647
  __typename?: 'UserEdge';
2408
2648
  /** A cursor for use in pagination. */
2409
- cursor: Scalars['String']['output'];
2649
+ cursor?: Maybe<Scalars['String']['output']>;
2410
2650
  /** The item at the end of the edge. */
2411
2651
  node?: Maybe<User>;
2412
2652
  }
@@ -2415,34 +2655,97 @@ export interface UserEdge {
2415
2655
  export interface UserIdentity {
2416
2656
  __typename?: 'UserIdentity';
2417
2657
  /** Time when this UserIdentity was created */
2418
- createdAt: Scalars['Time']['output'];
2658
+ createdAt?: Maybe<Scalars['Time']['output']>;
2419
2659
  /** Global ID of this UserIdentity */
2420
- id: Scalars['UserIdentityID']['output'];
2660
+ id?: Maybe<Scalars['UserIdentityID']['output']>;
2421
2661
  /** The description for the runtime if present */
2422
- identifier: Scalars['String']['output'];
2662
+ identifier?: Maybe<Scalars['String']['output']>;
2423
2663
  /** The name for the runtime */
2424
- providerId: Scalars['String']['output'];
2664
+ providerId?: Maybe<Scalars['String']['output']>;
2425
2665
  /** Time when this UserIdentity was last updated */
2426
- updatedAt: Scalars['Time']['output'];
2666
+ updatedAt?: Maybe<Scalars['Time']['output']>;
2427
2667
  /** The correlating user of the identity */
2428
- user: User;
2668
+ user?: Maybe<User>;
2669
+ }
2670
+
2671
+ /** The connection type for UserIdentity. */
2672
+ export interface UserIdentityConnection {
2673
+ __typename?: 'UserIdentityConnection';
2674
+ /** Total count of collection. */
2675
+ count?: Maybe<Scalars['Int']['output']>;
2676
+ /** A list of edges. */
2677
+ edges?: Maybe<Array<Maybe<UserIdentityEdge>>>;
2678
+ /** A list of nodes. */
2679
+ nodes?: Maybe<Array<Maybe<UserIdentity>>>;
2680
+ /** Information to aid in pagination. */
2681
+ pageInfo?: Maybe<PageInfo>;
2682
+ }
2683
+
2684
+ /** An edge in a connection. */
2685
+ export interface UserIdentityEdge {
2686
+ __typename?: 'UserIdentityEdge';
2687
+ /** A cursor for use in pagination. */
2688
+ cursor?: Maybe<Scalars['String']['output']>;
2689
+ /** The item at the end of the edge. */
2690
+ node?: Maybe<UserIdentity>;
2429
2691
  }
2430
2692
 
2431
2693
  /** Represents a user session */
2432
2694
  export interface UserSession {
2433
2695
  __typename?: 'UserSession';
2434
2696
  /** Whether or not the session is active and can be used */
2435
- active: Scalars['Boolean']['output'];
2697
+ active?: Maybe<Scalars['Boolean']['output']>;
2436
2698
  /** Time when this UserSession was created */
2437
- createdAt: Scalars['Time']['output'];
2699
+ createdAt?: Maybe<Scalars['Time']['output']>;
2438
2700
  /** Global ID of this UserSession */
2439
- id: Scalars['UserSessionID']['output'];
2701
+ id?: Maybe<Scalars['UserSessionID']['output']>;
2440
2702
  /** Token belonging to the session, only present on creation */
2441
2703
  token?: Maybe<Scalars['String']['output']>;
2442
2704
  /** Time when this UserSession was last updated */
2443
- updatedAt: Scalars['Time']['output'];
2705
+ updatedAt?: Maybe<Scalars['Time']['output']>;
2444
2706
  /** User that belongs to the session */
2445
- user: User;
2707
+ user?: Maybe<User>;
2708
+ }
2709
+
2710
+ /** The connection type for UserSession. */
2711
+ export interface UserSessionConnection {
2712
+ __typename?: 'UserSessionConnection';
2713
+ /** Total count of collection. */
2714
+ count?: Maybe<Scalars['Int']['output']>;
2715
+ /** A list of edges. */
2716
+ edges?: Maybe<Array<Maybe<UserSessionEdge>>>;
2717
+ /** A list of nodes. */
2718
+ nodes?: Maybe<Array<Maybe<UserSession>>>;
2719
+ /** Information to aid in pagination. */
2720
+ pageInfo?: Maybe<PageInfo>;
2721
+ }
2722
+
2723
+ /** An edge in a connection. */
2724
+ export interface UserSessionEdge {
2725
+ __typename?: 'UserSessionEdge';
2726
+ /** A cursor for use in pagination. */
2727
+ cursor?: Maybe<Scalars['String']['output']>;
2728
+ /** The item at the end of the edge. */
2729
+ node?: Maybe<UserSession>;
2730
+ }
2731
+
2732
+ /** Autogenerated input type of UsersEmailVerification */
2733
+ export interface UsersEmailVerificationInput {
2734
+ /** A unique identifier for the client performing the mutation. */
2735
+ clientMutationId?: InputMaybe<Scalars['String']['input']>;
2736
+ /** The email verification token */
2737
+ token: Scalars['String']['input'];
2738
+ }
2739
+
2740
+ /** Autogenerated return type of UsersEmailVerification. */
2741
+ export interface UsersEmailVerificationPayload {
2742
+ __typename?: 'UsersEmailVerificationPayload';
2743
+ /** A unique identifier for the client performing the mutation. */
2744
+ clientMutationId?: Maybe<Scalars['String']['output']>;
2745
+ /** Errors encountered during execution of the mutation. */
2746
+ errors?: Maybe<Array<Error>>;
2747
+ /** The user whose email was verified */
2748
+ user?: Maybe<User>;
2446
2749
  }
2447
2750
 
2448
2751
  /** Autogenerated input type of UsersIdentityLink */
@@ -2461,7 +2764,7 @@ export interface UsersIdentityLinkPayload {
2461
2764
  /** A unique identifier for the client performing the mutation. */
2462
2765
  clientMutationId?: Maybe<Scalars['String']['output']>;
2463
2766
  /** Errors encountered during execution of the mutation. */
2464
- errors: Array<Error>;
2767
+ errors?: Maybe<Array<Error>>;
2465
2768
  /** The created user identity */
2466
2769
  userIdentity?: Maybe<UserIdentity>;
2467
2770
  }
@@ -2482,7 +2785,7 @@ export interface UsersIdentityLoginPayload {
2482
2785
  /** A unique identifier for the client performing the mutation. */
2483
2786
  clientMutationId?: Maybe<Scalars['String']['output']>;
2484
2787
  /** Errors encountered during execution of the mutation. */
2485
- errors: Array<Error>;
2788
+ errors?: Maybe<Array<Error>>;
2486
2789
  /** The created user session */
2487
2790
  userSession?: Maybe<UserSession>;
2488
2791
  }
@@ -2503,7 +2806,7 @@ export interface UsersIdentityRegisterPayload {
2503
2806
  /** A unique identifier for the client performing the mutation. */
2504
2807
  clientMutationId?: Maybe<Scalars['String']['output']>;
2505
2808
  /** Errors encountered during execution of the mutation. */
2506
- errors: Array<Error>;
2809
+ errors?: Maybe<Array<Error>>;
2507
2810
  /** The created users session */
2508
2811
  userSession?: Maybe<UserSession>;
2509
2812
  }
@@ -2522,7 +2825,7 @@ export interface UsersIdentityUnlinkPayload {
2522
2825
  /** A unique identifier for the client performing the mutation. */
2523
2826
  clientMutationId?: Maybe<Scalars['String']['output']>;
2524
2827
  /** Errors encountered during execution of the mutation. */
2525
- errors: Array<Error>;
2828
+ errors?: Maybe<Array<Error>>;
2526
2829
  /** The removed identity */
2527
2830
  userIdentity?: Maybe<UserIdentity>;
2528
2831
  }
@@ -2547,7 +2850,7 @@ export interface UsersLoginPayload {
2547
2850
  /** A unique identifier for the client performing the mutation. */
2548
2851
  clientMutationId?: Maybe<Scalars['String']['output']>;
2549
2852
  /** Errors encountered during execution of the mutation. */
2550
- errors: Array<Error>;
2853
+ errors?: Maybe<Array<Error>>;
2551
2854
  /** The created user session */
2552
2855
  userSession?: Maybe<UserSession>;
2553
2856
  }
@@ -2566,7 +2869,7 @@ export interface UsersLogoutPayload {
2566
2869
  /** A unique identifier for the client performing the mutation. */
2567
2870
  clientMutationId?: Maybe<Scalars['String']['output']>;
2568
2871
  /** Errors encountered during execution of the mutation. */
2569
- errors: Array<Error>;
2872
+ errors?: Maybe<Array<Error>>;
2570
2873
  /** The logged out user session */
2571
2874
  userSession?: Maybe<UserSession>;
2572
2875
  }
@@ -2585,7 +2888,7 @@ export interface UsersMfaBackupCodesRotatePayload {
2585
2888
  /** The newly rotated backup codes. */
2586
2889
  codes?: Maybe<Array<Scalars['String']['output']>>;
2587
2890
  /** Errors encountered during execution of the mutation. */
2588
- errors: Array<Error>;
2891
+ errors?: Maybe<Array<Error>>;
2589
2892
  }
2590
2893
 
2591
2894
  /** Autogenerated input type of UsersMfaTotpGenerateSecret */
@@ -2600,7 +2903,7 @@ export interface UsersMfaTotpGenerateSecretPayload {
2600
2903
  /** A unique identifier for the client performing the mutation. */
2601
2904
  clientMutationId?: Maybe<Scalars['String']['output']>;
2602
2905
  /** Errors encountered during execution of the mutation. */
2603
- errors: Array<Error>;
2906
+ errors?: Maybe<Array<Error>>;
2604
2907
  /** The created and signed secret */
2605
2908
  secret?: Maybe<Scalars['String']['output']>;
2606
2909
  }
@@ -2624,11 +2927,53 @@ export interface UsersMfaTotpValidateSecretPayload {
2624
2927
  /** A unique identifier for the client performing the mutation. */
2625
2928
  clientMutationId?: Maybe<Scalars['String']['output']>;
2626
2929
  /** Errors encountered during execution of the mutation. */
2627
- errors: Array<Error>;
2930
+ errors?: Maybe<Array<Error>>;
2628
2931
  /** The modified user */
2629
2932
  user?: Maybe<User>;
2630
2933
  }
2631
2934
 
2935
+ /** Autogenerated input type of UsersPasswordReset */
2936
+ export interface UsersPasswordResetInput {
2937
+ /** A unique identifier for the client performing the mutation. */
2938
+ clientMutationId?: InputMaybe<Scalars['String']['input']>;
2939
+ /** The new password to set for the user */
2940
+ newPassword: Scalars['String']['input'];
2941
+ /** The confirmation of the new password to set for the user needs to be the same as the new password */
2942
+ newPasswordConfirmation: Scalars['String']['input'];
2943
+ /** The password reset token sent to the user email */
2944
+ resetToken: Scalars['String']['input'];
2945
+ }
2946
+
2947
+ /** Autogenerated return type of UsersPasswordReset. */
2948
+ export interface UsersPasswordResetPayload {
2949
+ __typename?: 'UsersPasswordResetPayload';
2950
+ /** A unique identifier for the client performing the mutation. */
2951
+ clientMutationId?: Maybe<Scalars['String']['output']>;
2952
+ /** Errors encountered during execution of the mutation. */
2953
+ errors?: Maybe<Array<Error>>;
2954
+ /** A message indicating the result of the password reset request */
2955
+ message?: Maybe<Scalars['String']['output']>;
2956
+ }
2957
+
2958
+ /** Autogenerated input type of UsersPasswordResetRequest */
2959
+ export interface UsersPasswordResetRequestInput {
2960
+ /** A unique identifier for the client performing the mutation. */
2961
+ clientMutationId?: InputMaybe<Scalars['String']['input']>;
2962
+ /** Email of the user to reset the password */
2963
+ email: Scalars['String']['input'];
2964
+ }
2965
+
2966
+ /** Autogenerated return type of UsersPasswordResetRequest. */
2967
+ export interface UsersPasswordResetRequestPayload {
2968
+ __typename?: 'UsersPasswordResetRequestPayload';
2969
+ /** A unique identifier for the client performing the mutation. */
2970
+ clientMutationId?: Maybe<Scalars['String']['output']>;
2971
+ /** Errors encountered during execution of the mutation. */
2972
+ errors?: Maybe<Array<Error>>;
2973
+ /** A message indicating the result of the password reset request */
2974
+ message?: Maybe<Scalars['String']['output']>;
2975
+ }
2976
+
2632
2977
  /** Autogenerated input type of UsersRegister */
2633
2978
  export interface UsersRegisterInput {
2634
2979
  /** A unique identifier for the client performing the mutation. */
@@ -2649,7 +2994,7 @@ export interface UsersRegisterPayload {
2649
2994
  /** A unique identifier for the client performing the mutation. */
2650
2995
  clientMutationId?: Maybe<Scalars['String']['output']>;
2651
2996
  /** Errors encountered during execution of the mutation. */
2652
- errors: Array<Error>;
2997
+ errors?: Maybe<Array<Error>>;
2653
2998
  /** The created users session */
2654
2999
  userSession?: Maybe<UserSession>;
2655
3000
  }
@@ -2684,7 +3029,7 @@ export interface UsersUpdatePayload {
2684
3029
  /** A unique identifier for the client performing the mutation. */
2685
3030
  clientMutationId?: Maybe<Scalars['String']['output']>;
2686
3031
  /** Errors encountered during execution of the mutation. */
2687
- errors: Array<Error>;
3032
+ errors?: Maybe<Array<Error>>;
2688
3033
  /** The updated user. */
2689
3034
  user?: Maybe<User>;
2690
3035
  }