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

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 +981 -341
  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 */
@@ -356,6 +327,9 @@ export enum DataTypeVariant {
356
327
  Type = 'TYPE'
357
328
  }
358
329
 
330
+ /** Represents a detailed error with either a message or an active model error */
331
+ export type DetailedError = ActiveModelError | FlowValidationError | MessageError;
332
+
359
333
  /** Autogenerated input type of Echo */
360
334
  export interface EchoInput {
361
335
  /** A unique identifier for the client performing the mutation. */
@@ -370,63 +344,221 @@ export interface EchoPayload {
370
344
  /** A unique identifier for the client performing the mutation. */
371
345
  clientMutationId?: Maybe<Scalars['String']['output']>;
372
346
  /** Errors encountered during execution of the mutation. */
373
- errors: Array<Error>;
347
+ errors?: Maybe<Array<Error>>;
374
348
  /** Message returned to the user. */
375
349
  message?: Maybe<Scalars['String']['output']>;
376
350
  }
377
351
 
378
352
  /** Objects that can present an error */
379
- export type Error = ActiveModelError | MessageError;
353
+ export interface Error {
354
+ __typename?: 'Error';
355
+ /** Detailed validation errors if applicable */
356
+ details?: Maybe<Array<DetailedError>>;
357
+ /** The code representing the error type */
358
+ errorCode?: Maybe<ErrorCodeEnum>;
359
+ }
360
+
361
+ /** Represents the available error responses */
362
+ export const enum ErrorCodeEnum {
363
+ /** This action would remove the last administrative role */
364
+ CannotDeleteLastAdminRole = 'CANNOT_DELETE_LAST_ADMIN_ROLE',
365
+ /** Only administrators can modify admin status of users */
366
+ CannotModifyAdmin = 'CANNOT_MODIFY_ADMIN',
367
+ /** Users cannot modify their own admin status */
368
+ CannotModifyOwnAdmin = 'CANNOT_MODIFY_OWN_ADMIN',
369
+ /** This action would remove the last administrator */
370
+ CannotRemoveLastAdministrator = 'CANNOT_REMOVE_LAST_ADMINISTRATOR',
371
+ /** This action would remove the last administrative ability */
372
+ CannotRemoveLastAdminAbility = 'CANNOT_REMOVE_LAST_ADMIN_ABILITY',
373
+ /** Failed to send the email verification */
374
+ EmailVerificationSendFailed = 'EMAIL_VERIFICATION_SEND_FAILED',
375
+ /** This external identity does not exist */
376
+ ExternalIdentityDoesNotExist = 'EXTERNAL_IDENTITY_DOES_NOT_EXIST',
377
+ /** The old backup codes could not be deleted */
378
+ FailedToInvalidateOldBackupCodes = 'FAILED_TO_INVALIDATE_OLD_BACKUP_CODES',
379
+ /** Failed to reset the user password */
380
+ FailedToResetPassword = 'FAILED_TO_RESET_PASSWORD',
381
+ /** The new backup codes could not be saved */
382
+ FailedToSaveValidBackupCode = 'FAILED_TO_SAVE_VALID_BACKUP_CODE',
383
+ /** The flow with the given identifier was not found */
384
+ FlowNotFound = 'FLOW_NOT_FOUND',
385
+ /** The flow type with the given identifier was not found */
386
+ FlowTypeNotFound = 'FLOW_TYPE_NOT_FOUND',
387
+ /** The flow validation has failed */
388
+ FlowValidationFailed = 'FLOW_VALIDATION_FAILED',
389
+ /** The given key was not found in the data type */
390
+ GenericKeyNotFound = 'GENERIC_KEY_NOT_FOUND',
391
+ /** The external identity with the given identifier was not found */
392
+ IdentityNotFound = 'IDENTITY_NOT_FOUND',
393
+ /** Failed to validate the external identity */
394
+ IdentityValidationFailed = 'IDENTITY_VALIDATION_FAILED',
395
+ /** Resources are from different namespaces */
396
+ InconsistentNamespace = 'INCONSISTENT_NAMESPACE',
397
+ /** The attachment is invalid because of active model errors */
398
+ InvalidAttachment = 'INVALID_ATTACHMENT',
399
+ /** This external identity is invalid */
400
+ InvalidExternalIdentity = 'INVALID_EXTERNAL_IDENTITY',
401
+ /** The flow setting is invalid because of active model errors */
402
+ InvalidFlowSetting = 'INVALID_FLOW_SETTING',
403
+ /** Invalid login data provided */
404
+ InvalidLoginData = 'INVALID_LOGIN_DATA',
405
+ /** The namespace license is invalid because of active model errors */
406
+ InvalidNamespaceLicense = 'INVALID_NAMESPACE_LICENSE',
407
+ /** The namespace member is invalid because of active model errors */
408
+ InvalidNamespaceMember = 'INVALID_NAMESPACE_MEMBER',
409
+ /** The namespace project is invalid because of active model errors */
410
+ InvalidNamespaceProject = 'INVALID_NAMESPACE_PROJECT',
411
+ /** The namespace role is invalid because of active model errors */
412
+ InvalidNamespaceRole = 'INVALID_NAMESPACE_ROLE',
413
+ /** The organization is invalid because of active model errors */
414
+ InvalidOrganization = 'INVALID_ORGANIZATION',
415
+ /** The provided password repeat does not match the password */
416
+ InvalidPasswordRepeat = 'INVALID_PASSWORD_REPEAT',
417
+ /** The runtime is invalid because of active model errors */
418
+ InvalidRuntime = 'INVALID_RUNTIME',
419
+ /** Invalid setting provided */
420
+ InvalidSetting = 'INVALID_SETTING',
421
+ /** The TOTP secret is invalid or cannot be verified */
422
+ InvalidTotpSecret = 'INVALID_TOTP_SECRET',
423
+ /** The user is invalid because of active model errors */
424
+ InvalidUser = 'INVALID_USER',
425
+ /** The user identity is invalid because of active model errors */
426
+ InvalidUserIdentity = 'INVALID_USER_IDENTITY',
427
+ /** The user session is invalid because of active model errors */
428
+ InvalidUserSession = 'INVALID_USER_SESSION',
429
+ /** Invalid verification code provided */
430
+ InvalidVerificationCode = 'INVALID_VERIFICATION_CODE',
431
+ /** The namespace license with the given identifier was not found */
432
+ LicenseNotFound = 'LICENSE_NOT_FOUND',
433
+ /** Failed to load user identity from external provider */
434
+ LoadingIdentityFailed = 'LOADING_IDENTITY_FAILED',
435
+ /** Invalid MFA data provided */
436
+ MfaFailed = 'MFA_FAILED',
437
+ /** MFA is required */
438
+ MfaRequired = 'MFA_REQUIRED',
439
+ /** This external identity is missing data */
440
+ MissingIdentityData = 'MISSING_IDENTITY_DATA',
441
+ /** Not all required parameters are present */
442
+ MissingParameter = 'MISSING_PARAMETER',
443
+ /** The user is not permitted to perform this operation */
444
+ MissingPermission = 'MISSING_PERMISSION',
445
+ /** The namespace member with the given identifier was not found */
446
+ NamespaceMemberNotFound = 'NAMESPACE_MEMBER_NOT_FOUND',
447
+ /** The namespace with the given identifier was not found */
448
+ NamespaceNotFound = 'NAMESPACE_NOT_FOUND',
449
+ /** The namespace project with the given identifier was not found */
450
+ NamespaceProjectNotFound = 'NAMESPACE_PROJECT_NOT_FOUND',
451
+ /** The namespace role with the given identifier was not found */
452
+ NamespaceRoleNotFound = 'NAMESPACE_ROLE_NOT_FOUND',
453
+ /** There are no free license seats to complete this operation */
454
+ NoFreeLicenseSeats = 'NO_FREE_LICENSE_SEATS',
455
+ /** The project does not have a primary runtime */
456
+ NoPrimaryRuntime = 'NO_PRIMARY_RUNTIME',
457
+ /** The organization with the given identifier was not found */
458
+ OrganizationNotFound = 'ORGANIZATION_NOT_FOUND',
459
+ /** @deprecated Outdated concept */
460
+ PrimaryLevelNotFound = 'PRIMARY_LEVEL_NOT_FOUND',
461
+ /** The namespace project with the given identifier was not found */
462
+ ProjectNotFound = 'PROJECT_NOT_FOUND',
463
+ /** Self-registration is disabled */
464
+ RegistrationDisabled = 'REGISTRATION_DISABLED',
465
+ /** Resources are from different runtimes */
466
+ RuntimeMismatch = 'RUNTIME_MISMATCH',
467
+ /** The runtime with the given identifier was not found */
468
+ RuntimeNotFound = 'RUNTIME_NOT_FOUND',
469
+ /** @deprecated Outdated concept */
470
+ SecondaryLevelNotFound = 'SECONDARY_LEVEL_NOT_FOUND',
471
+ /** @deprecated Outdated concept */
472
+ TertiaryLevelExceedsParameters = 'TERTIARY_LEVEL_EXCEEDS_PARAMETERS',
473
+ /** This user already has TOTP set up */
474
+ TotpSecretAlreadySet = 'TOTP_SECRET_ALREADY_SET',
475
+ /** The user is not permitted to modify this field */
476
+ UnmodifiableField = 'UNMODIFIABLE_FIELD',
477
+ /** The user with the given identifier was not found */
478
+ UserNotFound = 'USER_NOT_FOUND',
479
+ /** The user session with the given identifier was not found */
480
+ UserSessionNotFound = 'USER_SESSION_NOT_FOUND',
481
+ /** Invalid TOTP code provided */
482
+ WrongTotp = 'WRONG_TOTP'
483
+ }
380
484
 
381
485
  /** Represents a flow */
382
486
  export interface Flow {
383
487
  __typename?: 'Flow';
384
488
  /** Time when this Flow was created */
385
- createdAt: Scalars['Time']['output'];
489
+ createdAt?: Maybe<Scalars['Time']['output']>;
386
490
  /** Global ID of this Flow */
387
- id: Scalars['FlowID']['output'];
491
+ id?: Maybe<Scalars['FlowID']['output']>;
388
492
  /** The input data type of the flow */
389
493
  inputType?: Maybe<DataType>;
494
+ /** Name of the flow */
495
+ name?: Maybe<Scalars['String']['output']>;
496
+ /** Nodes of the flow */
497
+ nodes?: Maybe<NodeFunctionConnection>;
390
498
  /** The return data type of the flow */
391
499
  returnType?: Maybe<DataType>;
392
500
  /** The settings of the flow */
393
- settings?: Maybe<Array<FlowSetting>>;
394
- /** The starting node of the flow */
395
- startingNode: NodeFunction;
501
+ settings?: Maybe<FlowSettingConnection>;
502
+ /** The ID of the starting node of the flow */
503
+ startingNodeId?: Maybe<Scalars['NodeFunctionID']['output']>;
396
504
  /** The flow type of the flow */
397
- type: FlowType;
505
+ type?: Maybe<FlowType>;
398
506
  /** Time when this Flow was last updated */
399
- updatedAt: Scalars['Time']['output'];
507
+ updatedAt?: Maybe<Scalars['Time']['output']>;
508
+ /** Abilities for the current user on this Flow */
509
+ userAbilities?: Maybe<FlowUserAbilities>;
510
+ }
511
+
512
+
513
+ /** Represents a flow */
514
+ export interface FlowNodesArgs {
515
+ after?: InputMaybe<Scalars['String']['input']>;
516
+ before?: InputMaybe<Scalars['String']['input']>;
517
+ first?: InputMaybe<Scalars['Int']['input']>;
518
+ last?: InputMaybe<Scalars['Int']['input']>;
519
+ }
520
+
521
+
522
+ /** Represents a flow */
523
+ export interface FlowSettingsArgs {
524
+ after?: InputMaybe<Scalars['String']['input']>;
525
+ before?: InputMaybe<Scalars['String']['input']>;
526
+ first?: InputMaybe<Scalars['Int']['input']>;
527
+ last?: InputMaybe<Scalars['Int']['input']>;
400
528
  }
401
529
 
402
530
  /** The connection type for Flow. */
403
531
  export interface FlowConnection {
404
532
  __typename?: 'FlowConnection';
405
533
  /** Total count of collection. */
406
- count: Scalars['Int']['output'];
534
+ count?: Maybe<Scalars['Int']['output']>;
407
535
  /** A list of edges. */
408
536
  edges?: Maybe<Array<Maybe<FlowEdge>>>;
409
537
  /** A list of nodes. */
410
538
  nodes?: Maybe<Array<Maybe<Flow>>>;
411
539
  /** Information to aid in pagination. */
412
- pageInfo: PageInfo;
540
+ pageInfo?: Maybe<PageInfo>;
413
541
  }
414
542
 
415
543
  /** An edge in a connection. */
416
544
  export interface FlowEdge {
417
545
  __typename?: 'FlowEdge';
418
546
  /** A cursor for use in pagination. */
419
- cursor: Scalars['String']['output'];
547
+ cursor?: Maybe<Scalars['String']['output']>;
420
548
  /** The item at the end of the edge. */
421
549
  node?: Maybe<Flow>;
422
550
  }
423
551
 
424
552
  /** Input type for creating or updating a flow */
425
553
  export interface FlowInput {
554
+ /** The name of the flow */
555
+ name: Scalars['String']['input'];
556
+ /** The node functions of the flow */
557
+ nodes: Array<NodeFunctionInput>;
426
558
  /** The settings of the flow */
427
559
  settings?: InputMaybe<Array<FlowSettingInput>>;
428
560
  /** The starting node of the flow */
429
- startingNode: NodeFunctionInput;
561
+ startingNodeId: Scalars['NodeFunctionID']['input'];
430
562
  /** The identifier of the flow type */
431
563
  type: Scalars['FlowTypeID']['input'];
432
564
  }
@@ -435,15 +567,37 @@ export interface FlowInput {
435
567
  export interface FlowSetting {
436
568
  __typename?: 'FlowSetting';
437
569
  /** Time when this FlowSetting was created */
438
- createdAt: Scalars['Time']['output'];
570
+ createdAt?: Maybe<Scalars['Time']['output']>;
439
571
  /** The identifier of the flow setting */
440
- flowSettingId: Scalars['String']['output'];
572
+ flowSettingIdentifier?: Maybe<Scalars['String']['output']>;
441
573
  /** Global ID of this FlowSetting */
442
- id: Scalars['FlowSettingID']['output'];
574
+ id?: Maybe<Scalars['FlowSettingID']['output']>;
443
575
  /** Time when this FlowSetting was last updated */
444
- updatedAt: Scalars['Time']['output'];
576
+ updatedAt?: Maybe<Scalars['Time']['output']>;
445
577
  /** The value of the flow setting */
446
- value: Scalars['JSON']['output'];
578
+ value?: Maybe<Scalars['JSON']['output']>;
579
+ }
580
+
581
+ /** The connection type for FlowSetting. */
582
+ export interface FlowSettingConnection {
583
+ __typename?: 'FlowSettingConnection';
584
+ /** Total count of collection. */
585
+ count?: Maybe<Scalars['Int']['output']>;
586
+ /** A list of edges. */
587
+ edges?: Maybe<Array<Maybe<FlowSettingEdge>>>;
588
+ /** A list of nodes. */
589
+ nodes?: Maybe<Array<Maybe<FlowSetting>>>;
590
+ /** Information to aid in pagination. */
591
+ pageInfo?: Maybe<PageInfo>;
592
+ }
593
+
594
+ /** An edge in a connection. */
595
+ export interface FlowSettingEdge {
596
+ __typename?: 'FlowSettingEdge';
597
+ /** A cursor for use in pagination. */
598
+ cursor?: Maybe<Scalars['String']['output']>;
599
+ /** The item at the end of the edge. */
600
+ node?: Maybe<FlowSetting>;
447
601
  }
448
602
 
449
603
  /** Input type for flow settings */
@@ -458,17 +612,17 @@ export interface FlowSettingInput {
458
612
  export interface FlowType {
459
613
  __typename?: 'FlowType';
460
614
  /** Time when this FlowType was created */
461
- createdAt: Scalars['Time']['output'];
615
+ createdAt?: Maybe<Scalars['Time']['output']>;
462
616
  /** Descriptions of the flow type */
463
617
  descriptions?: Maybe<TranslationConnection>;
464
618
  /** Editable status of the flow type */
465
- editable: Scalars['Boolean']['output'];
619
+ editable?: Maybe<Scalars['Boolean']['output']>;
466
620
  /** Flow type settings of the flow type */
467
- flowTypeSettings: Array<FlowTypeSetting>;
621
+ flowTypeSettings?: Maybe<Array<FlowTypeSetting>>;
468
622
  /** Global ID of this FlowType */
469
- id: Scalars['TypesFlowTypeID']['output'];
623
+ id?: Maybe<Scalars['TypesFlowTypeID']['output']>;
470
624
  /** Identifier of the flow type */
471
- identifier: Scalars['String']['output'];
625
+ identifier?: Maybe<Scalars['String']['output']>;
472
626
  /** Input type of the flow type */
473
627
  inputType?: Maybe<DataType>;
474
628
  /** Names of the flow type */
@@ -476,7 +630,7 @@ export interface FlowType {
476
630
  /** Return type of the flow type */
477
631
  returnType?: Maybe<DataType>;
478
632
  /** Time when this FlowType was last updated */
479
- updatedAt: Scalars['Time']['output'];
633
+ updatedAt?: Maybe<Scalars['Time']['output']>;
480
634
  }
481
635
 
482
636
 
@@ -501,20 +655,20 @@ export interface FlowTypeNamesArgs {
501
655
  export interface FlowTypeConnection {
502
656
  __typename?: 'FlowTypeConnection';
503
657
  /** Total count of collection. */
504
- count: Scalars['Int']['output'];
658
+ count?: Maybe<Scalars['Int']['output']>;
505
659
  /** A list of edges. */
506
660
  edges?: Maybe<Array<Maybe<FlowTypeEdge>>>;
507
661
  /** A list of nodes. */
508
662
  nodes?: Maybe<Array<Maybe<FlowType>>>;
509
663
  /** Information to aid in pagination. */
510
- pageInfo: PageInfo;
664
+ pageInfo?: Maybe<PageInfo>;
511
665
  }
512
666
 
513
667
  /** An edge in a connection. */
514
668
  export interface FlowTypeEdge {
515
669
  __typename?: 'FlowTypeEdge';
516
670
  /** A cursor for use in pagination. */
517
- cursor: Scalars['String']['output'];
671
+ cursor?: Maybe<Scalars['String']['output']>;
518
672
  /** The item at the end of the edge. */
519
673
  node?: Maybe<FlowType>;
520
674
  }
@@ -523,23 +677,23 @@ export interface FlowTypeEdge {
523
677
  export interface FlowTypeSetting {
524
678
  __typename?: 'FlowTypeSetting';
525
679
  /** Time when this FlowTypeSetting was created */
526
- createdAt: Scalars['Time']['output'];
680
+ createdAt?: Maybe<Scalars['Time']['output']>;
527
681
  /** Data type of the flow type setting */
528
682
  dataType?: Maybe<DataType>;
529
683
  /** Descriptions of the flow type setting */
530
- descriptions: TranslationConnection;
684
+ descriptions?: Maybe<TranslationConnection>;
531
685
  /** Flow type of the flow type setting */
532
686
  flowType?: Maybe<FlowType>;
533
687
  /** Global ID of this FlowTypeSetting */
534
- id: Scalars['FlowTypeSettingID']['output'];
688
+ id?: Maybe<Scalars['FlowTypeSettingID']['output']>;
535
689
  /** Identifier of the flow type setting */
536
- identifier: Scalars['String']['output'];
690
+ identifier?: Maybe<Scalars['String']['output']>;
537
691
  /** Names of the flow type setting */
538
- names: TranslationConnection;
692
+ names?: Maybe<TranslationConnection>;
539
693
  /** Unique status of the flow type setting */
540
- unique: Scalars['Boolean']['output'];
694
+ unique?: Maybe<Scalars['Boolean']['output']>;
541
695
  /** Time when this FlowTypeSetting was last updated */
542
- updatedAt: Scalars['Time']['output'];
696
+ updatedAt?: Maybe<Scalars['Time']['output']>;
543
697
  }
544
698
 
545
699
 
@@ -560,11 +714,61 @@ export interface FlowTypeSettingNamesArgs {
560
714
  last?: InputMaybe<Scalars['Int']['input']>;
561
715
  }
562
716
 
717
+ /** Abilities for the current user on this Flow */
718
+ export interface FlowUserAbilities {
719
+ __typename?: 'FlowUserAbilities';
720
+ /** Shows if the current user has the `delete_flow` ability on this Flow */
721
+ deleteFlow?: Maybe<Scalars['Boolean']['output']>;
722
+ }
723
+
724
+ /** Represents a flow validation error */
725
+ export interface FlowValidationError {
726
+ __typename?: 'FlowValidationError';
727
+ /** Additional details about the validation error */
728
+ details?: Maybe<ActiveModelError>;
729
+ /** The code representing the validation error type */
730
+ errorCode?: Maybe<FlowValidationErrorCodeEnum>;
731
+ /** The severity of the validation error */
732
+ severity?: Maybe<FlowValidationSeverityEnum>;
733
+ }
734
+
735
+ /** Represents the available error responses */
736
+ export const enum FlowValidationErrorCodeEnum {
737
+ /** The generic key for the data type identifier was not found. */
738
+ DataTypeIdentifierGenericKeyNotFound = 'DATA_TYPE_IDENTIFIER_GENERIC_KEY_NOT_FOUND',
739
+ /** The data type identifier runtime does not match the flow type runtime. */
740
+ DataTypeIdentifierRuntimeMismatch = 'DATA_TYPE_IDENTIFIER_RUNTIME_MISMATCH',
741
+ /** The data type rule model is invalid. */
742
+ DataTypeRuleModelInvalid = 'DATA_TYPE_RULE_MODEL_INVALID',
743
+ /** The data type runtime does not match the flow type runtime. */
744
+ DataTypeRuntimeMismatch = 'DATA_TYPE_RUNTIME_MISMATCH',
745
+ /** The flow setting model is invalid. */
746
+ FlowSettingModelInvalid = 'FLOW_SETTING_MODEL_INVALID',
747
+ /** The flow type runtime does not match the project primary runtime. */
748
+ FlowTypeRuntimeMismatch = 'FLOW_TYPE_RUNTIME_MISMATCH',
749
+ /** The node function runtime does not match the project primary runtime. */
750
+ NodeFunctionRuntimeMismatch = 'NODE_FUNCTION_RUNTIME_MISMATCH',
751
+ /** The project does not have a primary runtime set. */
752
+ NoPrimaryRuntime = 'NO_PRIMARY_RUNTIME'
753
+ }
754
+
755
+ /** Represents the severity of a flow validation error */
756
+ export const enum FlowValidationSeverityEnum {
757
+ /** A blocking validation error */
758
+ Error = 'ERROR',
759
+ /** A minor typographical issue can also be blocking */
760
+ Typo = 'TYPO',
761
+ /** A non-blocking validation warning */
762
+ Warning = 'WARNING',
763
+ /** A weak validation issue that may not need to be addressed */
764
+ Weak = 'WEAK'
765
+ }
766
+
563
767
  /** Represents a function definition */
564
768
  export interface FunctionDefinition {
565
769
  __typename?: 'FunctionDefinition';
566
770
  /** Time when this FunctionDefinition was created */
567
- createdAt: Scalars['Time']['output'];
771
+ createdAt?: Maybe<Scalars['Time']['output']>;
568
772
  /** Deprecation message of the function */
569
773
  deprecationMessages?: Maybe<TranslationConnection>;
570
774
  /** Description of the function */
@@ -574,7 +778,9 @@ export interface FunctionDefinition {
574
778
  /** Generic keys of the function */
575
779
  genericKeys?: Maybe<Array<Scalars['String']['output']>>;
576
780
  /** Global ID of this FunctionDefinition */
577
- id: Scalars['FunctionDefinitionID']['output'];
781
+ id?: Maybe<Scalars['FunctionDefinitionID']['output']>;
782
+ /** Identifier of the function */
783
+ identifier?: Maybe<Scalars['String']['output']>;
578
784
  /** Name of the function */
579
785
  names?: Maybe<TranslationConnection>;
580
786
  /** Parameters of the function */
@@ -584,9 +790,9 @@ export interface FunctionDefinition {
584
790
  /** Runtime function definition */
585
791
  runtimeFunctionDefinition?: Maybe<RuntimeFunctionDefinition>;
586
792
  /** Indicates if the function can throw an error */
587
- throwsError: Scalars['Boolean']['output'];
793
+ throwsError?: Maybe<Scalars['Boolean']['output']>;
588
794
  /** Time when this FunctionDefinition was last updated */
589
- updatedAt: Scalars['Time']['output'];
795
+ updatedAt?: Maybe<Scalars['Time']['output']>;
590
796
  }
591
797
 
592
798
 
@@ -638,20 +844,20 @@ export interface FunctionDefinitionParameterDefinitionsArgs {
638
844
  export interface FunctionDefinitionConnection {
639
845
  __typename?: 'FunctionDefinitionConnection';
640
846
  /** Total count of collection. */
641
- count: Scalars['Int']['output'];
847
+ count?: Maybe<Scalars['Int']['output']>;
642
848
  /** A list of edges. */
643
849
  edges?: Maybe<Array<Maybe<FunctionDefinitionEdge>>>;
644
850
  /** A list of nodes. */
645
851
  nodes?: Maybe<Array<Maybe<FunctionDefinition>>>;
646
852
  /** Information to aid in pagination. */
647
- pageInfo: PageInfo;
853
+ pageInfo?: Maybe<PageInfo>;
648
854
  }
649
855
 
650
856
  /** An edge in a connection. */
651
857
  export interface FunctionDefinitionEdge {
652
858
  __typename?: 'FunctionDefinitionEdge';
653
859
  /** A cursor for use in pagination. */
654
- cursor: Scalars['String']['output'];
860
+ cursor?: Maybe<Scalars['String']['output']>;
655
861
  /** The item at the end of the edge. */
656
862
  node?: Maybe<FunctionDefinition>;
657
863
  }
@@ -660,19 +866,19 @@ export interface FunctionDefinitionEdge {
660
866
  export interface GenericCombinationStrategy {
661
867
  __typename?: 'GenericCombinationStrategy';
662
868
  /** Time when this GenericCombinationStrategy was created */
663
- createdAt: Scalars['Time']['output'];
869
+ createdAt?: Maybe<Scalars['Time']['output']>;
664
870
  /** The associated generic mapper, if any. */
665
871
  genericMapper?: Maybe<GenericMapper>;
666
872
  /** Global ID of this GenericCombinationStrategy */
667
- id: Scalars['GenericCombinationStrategyID']['output'];
873
+ id?: Maybe<Scalars['GenericCombinationStrategyID']['output']>;
668
874
  /** The combination type ('AND' or 'OR'). */
669
- type: GenericCombinationStrategyType;
875
+ type?: Maybe<GenericCombinationStrategyType>;
670
876
  /** Time when this GenericCombinationStrategy was last updated */
671
- updatedAt: Scalars['Time']['output'];
877
+ updatedAt?: Maybe<Scalars['Time']['output']>;
672
878
  }
673
879
 
674
880
  /** The available combination strategy types. */
675
- export enum GenericCombinationStrategyType {
881
+ export const enum GenericCombinationStrategyType {
676
882
  /** Represents a logical AND combination. */
677
883
  And = 'AND',
678
884
  /** Represents a logical OR combination. */
@@ -683,17 +889,17 @@ export enum GenericCombinationStrategyType {
683
889
  export interface GenericMapper {
684
890
  __typename?: 'GenericMapper';
685
891
  /** Time when this GenericMapper was created */
686
- createdAt: Scalars['Time']['output'];
892
+ createdAt?: Maybe<Scalars['Time']['output']>;
687
893
  /** Combination strategies associated with this generic mapper. */
688
894
  genericCombinationStrategies?: Maybe<Array<GenericCombinationStrategy>>;
689
895
  /** Global ID of this GenericMapper */
690
- id: Scalars['GenericMapperID']['output'];
896
+ id?: Maybe<Scalars['GenericMapperID']['output']>;
691
897
  /** The source data type identifier. */
692
- sources: Array<DataTypeIdentifier>;
898
+ sourceDataTypeIdentifiers?: Maybe<Array<DataTypeIdentifier>>;
693
899
  /** The target key for the generic value. */
694
- target: Scalars['String']['output'];
900
+ target?: Maybe<Scalars['String']['output']>;
695
901
  /** Time when this GenericMapper was last updated */
696
- updatedAt: Scalars['Time']['output'];
902
+ updatedAt?: Maybe<Scalars['Time']['output']>;
697
903
  }
698
904
 
699
905
  /** Input type for generic mappers */
@@ -708,15 +914,15 @@ export interface GenericMapperInput {
708
914
  export interface GenericType {
709
915
  __typename?: 'GenericType';
710
916
  /** Time when this GenericType was created */
711
- createdAt: Scalars['Time']['output'];
917
+ createdAt?: Maybe<Scalars['Time']['output']>;
712
918
  /** The data type associated with this generic type. */
713
- dataType: DataType;
919
+ dataType?: Maybe<DataType>;
714
920
  /** The mappers associated with this generic type. */
715
- genericMappers: Array<GenericMapper>;
921
+ genericMappers?: Maybe<Array<GenericMapper>>;
716
922
  /** Global ID of this GenericType */
717
- id: Scalars['GenericTypeID']['output'];
923
+ id?: Maybe<Scalars['GenericTypeID']['output']>;
718
924
  /** Time when this GenericType was last updated */
719
- updatedAt: Scalars['Time']['output'];
925
+ updatedAt?: Maybe<Scalars['Time']['output']>;
720
926
  }
721
927
 
722
928
  /** Input type for generic type operations. */
@@ -733,22 +939,39 @@ export interface IdentityInput {
733
939
  code?: InputMaybe<Scalars['String']['input']>;
734
940
  }
735
941
 
942
+ /** Abilities for the current user on this Instance */
943
+ export interface InstanceUserAbilities {
944
+ __typename?: 'InstanceUserAbilities';
945
+ /** Shows if the current user has the `create_organization` ability on this Instance */
946
+ createOrganization?: Maybe<Scalars['Boolean']['output']>;
947
+ /** Shows if the current user has the `create_runtime` ability on this Instance */
948
+ createRuntime?: Maybe<Scalars['Boolean']['output']>;
949
+ /** Shows if the current user has the `delete_runtime` ability on this Instance */
950
+ deleteRuntime?: Maybe<Scalars['Boolean']['output']>;
951
+ /** Shows if the current user has the `rotate_runtime_token` ability on this Instance */
952
+ rotateRuntimeToken?: Maybe<Scalars['Boolean']['output']>;
953
+ /** Shows if the current user has the `update_application_setting` ability on this Instance */
954
+ updateApplicationSetting?: Maybe<Scalars['Boolean']['output']>;
955
+ /** Shows if the current user has the `update_runtime` ability on this Instance */
956
+ updateRuntime?: Maybe<Scalars['Boolean']['output']>;
957
+ }
958
+
736
959
  /** Represents a literal value, such as a string or number. */
737
960
  export interface LiteralValue {
738
961
  __typename?: 'LiteralValue';
739
962
  /** Time when this LiteralValue was created */
740
- createdAt: Scalars['Time']['output'];
963
+ createdAt?: Maybe<Scalars['Time']['output']>;
741
964
  /** Time when this LiteralValue was last updated */
742
- updatedAt: Scalars['Time']['output'];
965
+ updatedAt?: Maybe<Scalars['Time']['output']>;
743
966
  /** The literal value itself as JSON. */
744
- value: Scalars['JSON']['output'];
967
+ value?: Maybe<Scalars['JSON']['output']>;
745
968
  }
746
969
 
747
970
  /** Represents an error message */
748
971
  export interface MessageError {
749
972
  __typename?: 'MessageError';
750
973
  /** The message provided from the error */
751
- message: Scalars['String']['output'];
974
+ message?: Maybe<Scalars['String']['output']>;
752
975
  }
753
976
 
754
977
  /** Represents the input for mfa authentication */
@@ -760,7 +983,7 @@ export interface MfaInput {
760
983
  }
761
984
 
762
985
  /** Represent all available types to authenticate with mfa */
763
- export enum MfaType {
986
+ export const enum MfaType {
764
987
  /** Single use backup code */
765
988
  BackupCode = 'BACKUP_CODE',
766
989
  /** Time based onetime password */
@@ -777,11 +1000,12 @@ export interface Mutation {
777
1000
  *
778
1001
  * This is expected to be used for testing of endpoints, to verify
779
1002
  * that a user has mutation access.
1003
+ *
780
1004
  */
781
1005
  echo?: Maybe<EchoPayload>;
782
- /** Create a new namespace license. */
1006
+ /** (EE only) Create a new namespace license. */
783
1007
  namespacesLicensesCreate?: Maybe<NamespacesLicensesCreatePayload>;
784
- /** Deletes an namespace license. */
1008
+ /** (EE only) Deletes an namespace license. */
785
1009
  namespacesLicensesDelete?: Maybe<NamespacesLicensesDeletePayload>;
786
1010
  /** Update the roles a member is assigned to. */
787
1011
  namespacesMembersAssignRoles?: Maybe<NamespacesMembersAssignRolesPayload>;
@@ -825,6 +1049,8 @@ export interface Mutation {
825
1049
  runtimesRotateToken?: Maybe<RuntimesRotateTokenPayload>;
826
1050
  /** Update an existing runtime. */
827
1051
  runtimesUpdate?: Maybe<RuntimesUpdatePayload>;
1052
+ /** Verify your email when changing it or signing up */
1053
+ usersEmailVerification?: Maybe<UsersEmailVerificationPayload>;
828
1054
  /** Links an external identity to an existing user */
829
1055
  usersIdentityLink?: Maybe<UsersIdentityLinkPayload>;
830
1056
  /** Login to an existing user via an external identity */
@@ -843,6 +1069,10 @@ export interface Mutation {
843
1069
  usersMfaTotpGenerateSecret?: Maybe<UsersMfaTotpGenerateSecretPayload>;
844
1070
  /** Validates a TOTP value for the given secret and enables TOTP MFA for the user */
845
1071
  usersMfaTotpValidateSecret?: Maybe<UsersMfaTotpValidateSecretPayload>;
1072
+ /** Reset the password using a reset token */
1073
+ usersPasswordReset?: Maybe<UsersPasswordResetPayload>;
1074
+ /** Request an password reset */
1075
+ usersPasswordResetRequest?: Maybe<UsersPasswordResetRequestPayload>;
846
1076
  /** Register a new user */
847
1077
  usersRegister?: Maybe<UsersRegisterPayload>;
848
1078
  /** Update an existing user. */
@@ -1000,6 +1230,12 @@ export interface MutationRuntimesUpdateArgs {
1000
1230
  }
1001
1231
 
1002
1232
 
1233
+ /** Root Mutation type */
1234
+ export interface MutationUsersEmailVerificationArgs {
1235
+ input: UsersEmailVerificationInput;
1236
+ }
1237
+
1238
+
1003
1239
  /** Root Mutation type */
1004
1240
  export interface MutationUsersIdentityLinkArgs {
1005
1241
  input: UsersIdentityLinkInput;
@@ -1054,6 +1290,18 @@ export interface MutationUsersMfaTotpValidateSecretArgs {
1054
1290
  }
1055
1291
 
1056
1292
 
1293
+ /** Root Mutation type */
1294
+ export interface MutationUsersPasswordResetArgs {
1295
+ input: UsersPasswordResetInput;
1296
+ }
1297
+
1298
+
1299
+ /** Root Mutation type */
1300
+ export interface MutationUsersPasswordResetRequestArgs {
1301
+ input: UsersPasswordResetRequestInput;
1302
+ }
1303
+
1304
+
1057
1305
  /** Root Mutation type */
1058
1306
  export interface MutationUsersRegisterArgs {
1059
1307
  input: UsersRegisterInput;
@@ -1069,23 +1317,27 @@ export interface MutationUsersUpdateArgs {
1069
1317
  export interface Namespace {
1070
1318
  __typename?: 'Namespace';
1071
1319
  /** Time when this Namespace was created */
1072
- createdAt: Scalars['Time']['output'];
1320
+ createdAt?: Maybe<Scalars['Time']['output']>;
1321
+ /** (EE only) Currently active license of the namespace */
1322
+ currentNamespaceLicense?: Maybe<NamespaceLicense>;
1073
1323
  /** Global ID of this Namespace */
1074
- id: Scalars['NamespaceID']['output'];
1324
+ id?: Maybe<Scalars['NamespaceID']['output']>;
1075
1325
  /** Members of the namespace */
1076
- members: NamespaceMemberConnection;
1077
- /** Licenses of the namespace */
1078
- namespaceLicenses: NamespaceLicenseConnection;
1326
+ members?: Maybe<NamespaceMemberConnection>;
1327
+ /** (EE only) Licenses of the namespace */
1328
+ namespaceLicenses?: Maybe<NamespaceLicenseConnection>;
1079
1329
  /** Parent of this namespace */
1080
- parent: NamespaceParent;
1330
+ parent?: Maybe<NamespaceParent>;
1081
1331
  /** Projects of the namespace */
1082
- projects: NamespaceProjectConnection;
1332
+ projects?: Maybe<NamespaceProjectConnection>;
1083
1333
  /** Roles of the namespace */
1084
- roles: NamespaceRoleConnection;
1334
+ roles?: Maybe<NamespaceRoleConnection>;
1085
1335
  /** Runtime of the namespace */
1086
- runtimes: RuntimeConnection;
1336
+ runtimes?: Maybe<RuntimeConnection>;
1087
1337
  /** Time when this Namespace was last updated */
1088
- updatedAt: Scalars['Time']['output'];
1338
+ updatedAt?: Maybe<Scalars['Time']['output']>;
1339
+ /** Abilities for the current user on this Namespace */
1340
+ userAbilities?: Maybe<NamespaceUserAbilities>;
1089
1341
  }
1090
1342
 
1091
1343
 
@@ -1133,74 +1385,113 @@ export interface NamespaceRuntimesArgs {
1133
1385
  last?: InputMaybe<Scalars['Int']['input']>;
1134
1386
  }
1135
1387
 
1136
- /** Represents a Namespace License */
1388
+ /** (EE only) Represents a Namespace License */
1137
1389
  export interface NamespaceLicense {
1138
1390
  __typename?: 'NamespaceLicense';
1139
1391
  /** Time when this NamespaceLicense was created */
1140
- createdAt: Scalars['Time']['output'];
1392
+ createdAt?: Maybe<Scalars['Time']['output']>;
1393
+ /** The end date of the license */
1394
+ endDate?: Maybe<Scalars['Time']['output']>;
1141
1395
  /** Global ID of this NamespaceLicense */
1142
- id: Scalars['NamespaceLicenseID']['output'];
1396
+ id?: Maybe<Scalars['NamespaceLicenseID']['output']>;
1397
+ /** The licensee information */
1398
+ licensee?: Maybe<Scalars['JSON']['output']>;
1143
1399
  /** The namespace the license belongs to */
1144
- namespace: Namespace;
1400
+ namespace?: Maybe<Namespace>;
1401
+ /** The start date of the license */
1402
+ startDate?: Maybe<Scalars['Time']['output']>;
1145
1403
  /** Time when this NamespaceLicense was last updated */
1146
- updatedAt: Scalars['Time']['output'];
1404
+ updatedAt?: Maybe<Scalars['Time']['output']>;
1405
+ /** Abilities for the current user on this NamespaceLicense */
1406
+ userAbilities?: Maybe<NamespaceLicenseUserAbilities>;
1147
1407
  }
1148
1408
 
1149
1409
  /** The connection type for NamespaceLicense. */
1150
1410
  export interface NamespaceLicenseConnection {
1151
1411
  __typename?: 'NamespaceLicenseConnection';
1152
1412
  /** Total count of collection. */
1153
- count: Scalars['Int']['output'];
1413
+ count?: Maybe<Scalars['Int']['output']>;
1154
1414
  /** A list of edges. */
1155
1415
  edges?: Maybe<Array<Maybe<NamespaceLicenseEdge>>>;
1156
1416
  /** A list of nodes. */
1157
1417
  nodes?: Maybe<Array<Maybe<NamespaceLicense>>>;
1158
1418
  /** Information to aid in pagination. */
1159
- pageInfo: PageInfo;
1419
+ pageInfo?: Maybe<PageInfo>;
1160
1420
  }
1161
1421
 
1162
1422
  /** An edge in a connection. */
1163
1423
  export interface NamespaceLicenseEdge {
1164
1424
  __typename?: 'NamespaceLicenseEdge';
1165
1425
  /** A cursor for use in pagination. */
1166
- cursor: Scalars['String']['output'];
1426
+ cursor?: Maybe<Scalars['String']['output']>;
1167
1427
  /** The item at the end of the edge. */
1168
1428
  node?: Maybe<NamespaceLicense>;
1169
1429
  }
1170
1430
 
1431
+ /** Abilities for the current user on this NamespaceLicense */
1432
+ export interface NamespaceLicenseUserAbilities {
1433
+ __typename?: 'NamespaceLicenseUserAbilities';
1434
+ /** Shows if the current user has the `delete_namespace_license` ability on this NamespaceLicense */
1435
+ deleteNamespaceLicense?: Maybe<Scalars['Boolean']['output']>;
1436
+ }
1437
+
1171
1438
  /** Represents a namespace member */
1172
1439
  export interface NamespaceMember {
1173
1440
  __typename?: 'NamespaceMember';
1174
1441
  /** Time when this NamespaceMember was created */
1175
- createdAt: Scalars['Time']['output'];
1442
+ createdAt?: Maybe<Scalars['Time']['output']>;
1176
1443
  /** Global ID of this NamespaceMember */
1177
- id: Scalars['NamespaceMemberID']['output'];
1444
+ id?: Maybe<Scalars['NamespaceMemberID']['output']>;
1445
+ /** Memberroles of the member */
1446
+ memberRoles?: Maybe<NamespaceMemberRoleConnection>;
1178
1447
  /** Namespace this member belongs to */
1179
- namespace: Namespace;
1448
+ namespace?: Maybe<Namespace>;
1449
+ /** Roles of the member */
1450
+ roles?: Maybe<NamespaceRoleConnection>;
1180
1451
  /** Time when this NamespaceMember was last updated */
1181
- updatedAt: Scalars['Time']['output'];
1452
+ updatedAt?: Maybe<Scalars['Time']['output']>;
1182
1453
  /** User this member belongs to */
1183
- user: User;
1454
+ user?: Maybe<User>;
1455
+ /** Abilities for the current user on this NamespaceMember */
1456
+ userAbilities?: Maybe<NamespaceMemberUserAbilities>;
1457
+ }
1458
+
1459
+
1460
+ /** Represents a namespace member */
1461
+ export interface NamespaceMemberMemberRolesArgs {
1462
+ after?: InputMaybe<Scalars['String']['input']>;
1463
+ before?: InputMaybe<Scalars['String']['input']>;
1464
+ first?: InputMaybe<Scalars['Int']['input']>;
1465
+ last?: InputMaybe<Scalars['Int']['input']>;
1466
+ }
1467
+
1468
+
1469
+ /** Represents a namespace member */
1470
+ export interface NamespaceMemberRolesArgs {
1471
+ after?: InputMaybe<Scalars['String']['input']>;
1472
+ before?: InputMaybe<Scalars['String']['input']>;
1473
+ first?: InputMaybe<Scalars['Int']['input']>;
1474
+ last?: InputMaybe<Scalars['Int']['input']>;
1184
1475
  }
1185
1476
 
1186
1477
  /** The connection type for NamespaceMember. */
1187
1478
  export interface NamespaceMemberConnection {
1188
1479
  __typename?: 'NamespaceMemberConnection';
1189
1480
  /** Total count of collection. */
1190
- count: Scalars['Int']['output'];
1481
+ count?: Maybe<Scalars['Int']['output']>;
1191
1482
  /** A list of edges. */
1192
1483
  edges?: Maybe<Array<Maybe<NamespaceMemberEdge>>>;
1193
1484
  /** A list of nodes. */
1194
1485
  nodes?: Maybe<Array<Maybe<NamespaceMember>>>;
1195
1486
  /** Information to aid in pagination. */
1196
- pageInfo: PageInfo;
1487
+ pageInfo?: Maybe<PageInfo>;
1197
1488
  }
1198
1489
 
1199
1490
  /** An edge in a connection. */
1200
1491
  export interface NamespaceMemberEdge {
1201
1492
  __typename?: 'NamespaceMemberEdge';
1202
1493
  /** A cursor for use in pagination. */
1203
- cursor: Scalars['String']['output'];
1494
+ cursor?: Maybe<Scalars['String']['output']>;
1204
1495
  /** The item at the end of the edge. */
1205
1496
  node?: Maybe<NamespaceMember>;
1206
1497
  }
@@ -1209,43 +1500,76 @@ export interface NamespaceMemberEdge {
1209
1500
  export interface NamespaceMemberRole {
1210
1501
  __typename?: 'NamespaceMemberRole';
1211
1502
  /** Time when this NamespaceMemberRole was created */
1212
- createdAt: Scalars['Time']['output'];
1503
+ createdAt?: Maybe<Scalars['Time']['output']>;
1213
1504
  /** Global ID of this NamespaceMemberRole */
1214
- id: Scalars['NamespaceMemberRoleID']['output'];
1505
+ id?: Maybe<Scalars['NamespaceMemberRoleID']['output']>;
1215
1506
  /** The member the role is assigned to */
1216
1507
  member?: Maybe<NamespaceMember>;
1217
1508
  /** The assigned role */
1218
1509
  role?: Maybe<NamespaceRole>;
1219
1510
  /** Time when this NamespaceMemberRole was last updated */
1220
- updatedAt: Scalars['Time']['output'];
1511
+ updatedAt?: Maybe<Scalars['Time']['output']>;
1512
+ }
1513
+
1514
+ /** The connection type for NamespaceMemberRole. */
1515
+ export interface NamespaceMemberRoleConnection {
1516
+ __typename?: 'NamespaceMemberRoleConnection';
1517
+ /** Total count of collection. */
1518
+ count?: Maybe<Scalars['Int']['output']>;
1519
+ /** A list of edges. */
1520
+ edges?: Maybe<Array<Maybe<NamespaceMemberRoleEdge>>>;
1521
+ /** A list of nodes. */
1522
+ nodes?: Maybe<Array<Maybe<NamespaceMemberRole>>>;
1523
+ /** Information to aid in pagination. */
1524
+ pageInfo?: Maybe<PageInfo>;
1525
+ }
1526
+
1527
+ /** An edge in a connection. */
1528
+ export interface NamespaceMemberRoleEdge {
1529
+ __typename?: 'NamespaceMemberRoleEdge';
1530
+ /** A cursor for use in pagination. */
1531
+ cursor?: Maybe<Scalars['String']['output']>;
1532
+ /** The item at the end of the edge. */
1533
+ node?: Maybe<NamespaceMemberRole>;
1534
+ }
1535
+
1536
+ /** Abilities for the current user on this NamespaceMember */
1537
+ export interface NamespaceMemberUserAbilities {
1538
+ __typename?: 'NamespaceMemberUserAbilities';
1539
+ /** Shows if the current user has the `assign_member_roles` ability on this NamespaceMember */
1540
+ assignMemberRoles?: Maybe<Scalars['Boolean']['output']>;
1541
+ /** Shows if the current user has the `delete_member` ability on this NamespaceMember */
1542
+ deleteMember?: Maybe<Scalars['Boolean']['output']>;
1221
1543
  }
1222
1544
 
1223
1545
  /** Objects that can present a namespace */
1224
- export type NamespaceParent = Organization;
1546
+ export type NamespaceParent = Organization | User;
1225
1547
 
1226
1548
  /** Represents a namespace project */
1227
1549
  export interface NamespaceProject {
1228
1550
  __typename?: 'NamespaceProject';
1229
1551
  /** Time when this NamespaceProject was created */
1230
- createdAt: Scalars['Time']['output'];
1552
+ createdAt?: Maybe<Scalars['Time']['output']>;
1231
1553
  /** Description of the project */
1232
- description: Scalars['String']['output'];
1554
+ description?: Maybe<Scalars['String']['output']>;
1233
1555
  /** Fetches an flow given by its ID */
1234
1556
  flow?: Maybe<Flow>;
1235
1557
  /** Fetches all flows in this project */
1236
1558
  flows?: Maybe<FlowConnection>;
1237
1559
  /** Global ID of this NamespaceProject */
1238
- id: Scalars['NamespaceProjectID']['output'];
1560
+ id?: Maybe<Scalars['NamespaceProjectID']['output']>;
1239
1561
  /** Name of the project */
1240
- name: Scalars['String']['output'];
1562
+ name?: Maybe<Scalars['String']['output']>;
1241
1563
  /** The namespace where this project belongs to */
1242
- namespace: Namespace;
1564
+ namespace?: Maybe<Namespace>;
1243
1565
  /** The primary runtime for the project */
1244
1566
  primaryRuntime?: Maybe<Runtime>;
1245
1567
  /** Runtimes assigned to this project */
1246
- runtimes: RuntimeConnection;
1568
+ runtimes?: Maybe<RuntimeConnection>;
1247
1569
  /** Time when this NamespaceProject was last updated */
1248
- updatedAt: Scalars['Time']['output'];
1570
+ updatedAt?: Maybe<Scalars['Time']['output']>;
1571
+ /** Abilities for the current user on this NamespaceProject */
1572
+ userAbilities?: Maybe<NamespaceProjectUserAbilities>;
1249
1573
  }
1250
1574
 
1251
1575
 
@@ -1276,41 +1600,56 @@ export interface NamespaceProjectRuntimesArgs {
1276
1600
  export interface NamespaceProjectConnection {
1277
1601
  __typename?: 'NamespaceProjectConnection';
1278
1602
  /** Total count of collection. */
1279
- count: Scalars['Int']['output'];
1603
+ count?: Maybe<Scalars['Int']['output']>;
1280
1604
  /** A list of edges. */
1281
1605
  edges?: Maybe<Array<Maybe<NamespaceProjectEdge>>>;
1282
1606
  /** A list of nodes. */
1283
1607
  nodes?: Maybe<Array<Maybe<NamespaceProject>>>;
1284
1608
  /** Information to aid in pagination. */
1285
- pageInfo: PageInfo;
1609
+ pageInfo?: Maybe<PageInfo>;
1286
1610
  }
1287
1611
 
1288
1612
  /** An edge in a connection. */
1289
1613
  export interface NamespaceProjectEdge {
1290
1614
  __typename?: 'NamespaceProjectEdge';
1291
1615
  /** A cursor for use in pagination. */
1292
- cursor: Scalars['String']['output'];
1616
+ cursor?: Maybe<Scalars['String']['output']>;
1293
1617
  /** The item at the end of the edge. */
1294
1618
  node?: Maybe<NamespaceProject>;
1295
1619
  }
1296
1620
 
1621
+ /** Abilities for the current user on this NamespaceProject */
1622
+ export interface NamespaceProjectUserAbilities {
1623
+ __typename?: 'NamespaceProjectUserAbilities';
1624
+ /** Shows if the current user has the `assign_project_runtimes` ability on this NamespaceProject */
1625
+ assignProjectRuntimes?: Maybe<Scalars['Boolean']['output']>;
1626
+ /** Shows if the current user has the `create_flow` ability on this NamespaceProject */
1627
+ createFlow?: Maybe<Scalars['Boolean']['output']>;
1628
+ /** Shows if the current user has the `delete_namespace_project` ability on this NamespaceProject */
1629
+ deleteNamespaceProject?: Maybe<Scalars['Boolean']['output']>;
1630
+ /** Shows if the current user has the `update_namespace_project` ability on this NamespaceProject */
1631
+ updateNamespaceProject?: Maybe<Scalars['Boolean']['output']>;
1632
+ }
1633
+
1297
1634
  /** Represents a namespace role. */
1298
1635
  export interface NamespaceRole {
1299
1636
  __typename?: 'NamespaceRole';
1300
1637
  /** The abilities the role is granted */
1301
- abilities: Array<NamespaceRoleAbility>;
1638
+ abilities?: Maybe<Array<NamespaceRoleAbility>>;
1302
1639
  /** The projects this role is assigned to */
1303
1640
  assignedProjects?: Maybe<NamespaceProjectConnection>;
1304
1641
  /** Time when this NamespaceRole was created */
1305
- createdAt: Scalars['Time']['output'];
1642
+ createdAt?: Maybe<Scalars['Time']['output']>;
1306
1643
  /** Global ID of this NamespaceRole */
1307
- id: Scalars['NamespaceRoleID']['output'];
1644
+ id?: Maybe<Scalars['NamespaceRoleID']['output']>;
1308
1645
  /** The name of this role */
1309
- name: Scalars['String']['output'];
1646
+ name?: Maybe<Scalars['String']['output']>;
1310
1647
  /** The namespace where this role belongs to */
1311
1648
  namespace?: Maybe<Namespace>;
1312
1649
  /** Time when this NamespaceRole was last updated */
1313
- updatedAt: Scalars['Time']['output'];
1650
+ updatedAt?: Maybe<Scalars['Time']['output']>;
1651
+ /** Abilities for the current user on this NamespaceRole */
1652
+ userAbilities?: Maybe<NamespaceRoleUserAbilities>;
1314
1653
  }
1315
1654
 
1316
1655
 
@@ -1323,7 +1662,7 @@ export interface NamespaceRoleAssignedProjectsArgs {
1323
1662
  }
1324
1663
 
1325
1664
  /** Represents abilities that can be granted to roles in namespaces. */
1326
- export enum NamespaceRoleAbility {
1665
+ export const enum NamespaceRoleAbility {
1327
1666
  /** Allows to change the roles of a namespace member */
1328
1667
  AssignMemberRoles = 'ASSIGN_MEMBER_ROLES',
1329
1668
  /** Allows to assign runtimes to a project in the namespace */
@@ -1333,7 +1672,7 @@ export enum NamespaceRoleAbility {
1333
1672
  /** Allows to change the assigned projects of a namespace role */
1334
1673
  AssignRoleProjects = 'ASSIGN_ROLE_PROJECTS',
1335
1674
  /** Allows to create flows in a namespace project */
1336
- CreateFlows = 'CREATE_FLOWS',
1675
+ CreateFlow = 'CREATE_FLOW',
1337
1676
  /** Allows to create a license for the namespace */
1338
1677
  CreateNamespaceLicense = 'CREATE_NAMESPACE_LICENSE',
1339
1678
  /** Allows to create a project in the namespace */
@@ -1343,7 +1682,7 @@ export enum NamespaceRoleAbility {
1343
1682
  /** Allows to create a runtime globally or for the namespace */
1344
1683
  CreateRuntime = 'CREATE_RUNTIME',
1345
1684
  /** Allows to delete flows in a namespace project */
1346
- DeleteFlows = 'DELETE_FLOWS',
1685
+ DeleteFlow = 'DELETE_FLOW',
1347
1686
  /** Allows to remove members of a namespace */
1348
1687
  DeleteMember = 'DELETE_MEMBER',
1349
1688
  /** Allows to delete the license of the namespace */
@@ -1367,7 +1706,7 @@ export enum NamespaceRoleAbility {
1367
1706
  /** Allows to regenerate a runtime token */
1368
1707
  RotateRuntimeToken = 'ROTATE_RUNTIME_TOKEN',
1369
1708
  /** Allows to update flows in the project */
1370
- UpdateFlows = 'UPDATE_FLOWS',
1709
+ UpdateFlow = 'UPDATE_FLOW',
1371
1710
  /** Allows to update the project of the namespace */
1372
1711
  UpdateNamespaceProject = 'UPDATE_NAMESPACE_PROJECT',
1373
1712
  /** Allows to update the namespace role */
@@ -1382,24 +1721,52 @@ export enum NamespaceRoleAbility {
1382
1721
  export interface NamespaceRoleConnection {
1383
1722
  __typename?: 'NamespaceRoleConnection';
1384
1723
  /** Total count of collection. */
1385
- count: Scalars['Int']['output'];
1724
+ count?: Maybe<Scalars['Int']['output']>;
1386
1725
  /** A list of edges. */
1387
1726
  edges?: Maybe<Array<Maybe<NamespaceRoleEdge>>>;
1388
1727
  /** A list of nodes. */
1389
1728
  nodes?: Maybe<Array<Maybe<NamespaceRole>>>;
1390
1729
  /** Information to aid in pagination. */
1391
- pageInfo: PageInfo;
1730
+ pageInfo?: Maybe<PageInfo>;
1392
1731
  }
1393
1732
 
1394
1733
  /** An edge in a connection. */
1395
1734
  export interface NamespaceRoleEdge {
1396
1735
  __typename?: 'NamespaceRoleEdge';
1397
1736
  /** A cursor for use in pagination. */
1398
- cursor: Scalars['String']['output'];
1737
+ cursor?: Maybe<Scalars['String']['output']>;
1399
1738
  /** The item at the end of the edge. */
1400
1739
  node?: Maybe<NamespaceRole>;
1401
1740
  }
1402
1741
 
1742
+ /** Abilities for the current user on this NamespaceRole */
1743
+ export interface NamespaceRoleUserAbilities {
1744
+ __typename?: 'NamespaceRoleUserAbilities';
1745
+ /** Shows if the current user has the `assign_role_abilities` ability on this NamespaceRole */
1746
+ assignRoleAbilities?: Maybe<Scalars['Boolean']['output']>;
1747
+ /** Shows if the current user has the `assign_role_projects` ability on this NamespaceRole */
1748
+ assignRoleProjects?: Maybe<Scalars['Boolean']['output']>;
1749
+ /** Shows if the current user has the `delete_namespace_role` ability on this NamespaceRole */
1750
+ deleteNamespaceRole?: Maybe<Scalars['Boolean']['output']>;
1751
+ /** Shows if the current user has the `update_namespace_role` ability on this NamespaceRole */
1752
+ updateNamespaceRole?: Maybe<Scalars['Boolean']['output']>;
1753
+ }
1754
+
1755
+ /** Abilities for the current user on this Namespace */
1756
+ export interface NamespaceUserAbilities {
1757
+ __typename?: 'NamespaceUserAbilities';
1758
+ /** Shows if the current user has the `create_namespace_license` ability on this Namespace */
1759
+ createNamespaceLicense?: Maybe<Scalars['Boolean']['output']>;
1760
+ /** Shows if the current user has the `create_namespace_project` ability on this Namespace */
1761
+ createNamespaceProject?: Maybe<Scalars['Boolean']['output']>;
1762
+ /** Shows if the current user has the `create_namespace_role` ability on this Namespace */
1763
+ createNamespaceRole?: Maybe<Scalars['Boolean']['output']>;
1764
+ /** Shows if the current user has the `create_runtime` ability on this Namespace */
1765
+ createRuntime?: Maybe<Scalars['Boolean']['output']>;
1766
+ /** Shows if the current user has the `invite_member` ability on this Namespace */
1767
+ inviteMember?: Maybe<Scalars['Boolean']['output']>;
1768
+ }
1769
+
1403
1770
  /** Autogenerated input type of NamespacesLicensesCreate */
1404
1771
  export interface NamespacesLicensesCreateInput {
1405
1772
  /** A unique identifier for the client performing the mutation. */
@@ -1416,7 +1783,7 @@ export interface NamespacesLicensesCreatePayload {
1416
1783
  /** A unique identifier for the client performing the mutation. */
1417
1784
  clientMutationId?: Maybe<Scalars['String']['output']>;
1418
1785
  /** Errors encountered during execution of the mutation. */
1419
- errors: Array<Error>;
1786
+ errors?: Maybe<Array<Error>>;
1420
1787
  /** The newly created license. */
1421
1788
  namespaceLicense?: Maybe<NamespaceLicense>;
1422
1789
  }
@@ -1435,7 +1802,7 @@ export interface NamespacesLicensesDeletePayload {
1435
1802
  /** A unique identifier for the client performing the mutation. */
1436
1803
  clientMutationId?: Maybe<Scalars['String']['output']>;
1437
1804
  /** Errors encountered during execution of the mutation. */
1438
- errors: Array<Error>;
1805
+ errors?: Maybe<Array<Error>>;
1439
1806
  /** The deleted namespace license. */
1440
1807
  namespaceLicense?: Maybe<NamespaceLicense>;
1441
1808
  }
@@ -1456,7 +1823,7 @@ export interface NamespacesMembersAssignRolesPayload {
1456
1823
  /** A unique identifier for the client performing the mutation. */
1457
1824
  clientMutationId?: Maybe<Scalars['String']['output']>;
1458
1825
  /** Errors encountered during execution of the mutation. */
1459
- errors: Array<Error>;
1826
+ errors?: Maybe<Array<Error>>;
1460
1827
  /** The roles the member is now assigned to */
1461
1828
  namespaceMemberRoles?: Maybe<Array<NamespaceMemberRole>>;
1462
1829
  }
@@ -1475,7 +1842,7 @@ export interface NamespacesMembersDeletePayload {
1475
1842
  /** A unique identifier for the client performing the mutation. */
1476
1843
  clientMutationId?: Maybe<Scalars['String']['output']>;
1477
1844
  /** Errors encountered during execution of the mutation. */
1478
- errors: Array<Error>;
1845
+ errors?: Maybe<Array<Error>>;
1479
1846
  /** The removed namespace member */
1480
1847
  namespaceMember?: Maybe<NamespaceMember>;
1481
1848
  }
@@ -1496,7 +1863,7 @@ export interface NamespacesMembersInvitePayload {
1496
1863
  /** A unique identifier for the client performing the mutation. */
1497
1864
  clientMutationId?: Maybe<Scalars['String']['output']>;
1498
1865
  /** Errors encountered during execution of the mutation. */
1499
- errors: Array<Error>;
1866
+ errors?: Maybe<Array<Error>>;
1500
1867
  /** The newly created namespace member */
1501
1868
  namespaceMember?: Maybe<NamespaceMember>;
1502
1869
  }
@@ -1517,7 +1884,7 @@ export interface NamespacesProjectsAssignRuntimesPayload {
1517
1884
  /** A unique identifier for the client performing the mutation. */
1518
1885
  clientMutationId?: Maybe<Scalars['String']['output']>;
1519
1886
  /** Errors encountered during execution of the mutation. */
1520
- errors: Array<Error>;
1887
+ errors?: Maybe<Array<Error>>;
1521
1888
  /** The updated project with assigned runtimes */
1522
1889
  namespaceProject?: Maybe<NamespaceProject>;
1523
1890
  }
@@ -1540,7 +1907,7 @@ export interface NamespacesProjectsCreatePayload {
1540
1907
  /** A unique identifier for the client performing the mutation. */
1541
1908
  clientMutationId?: Maybe<Scalars['String']['output']>;
1542
1909
  /** Errors encountered during execution of the mutation. */
1543
- errors: Array<Error>;
1910
+ errors?: Maybe<Array<Error>>;
1544
1911
  /** The newly created project. */
1545
1912
  namespaceProject?: Maybe<NamespaceProject>;
1546
1913
  }
@@ -1559,7 +1926,7 @@ export interface NamespacesProjectsDeletePayload {
1559
1926
  /** A unique identifier for the client performing the mutation. */
1560
1927
  clientMutationId?: Maybe<Scalars['String']['output']>;
1561
1928
  /** Errors encountered during execution of the mutation. */
1562
- errors: Array<Error>;
1929
+ errors?: Maybe<Array<Error>>;
1563
1930
  /** The deleted project. */
1564
1931
  namespaceProject?: Maybe<NamespaceProject>;
1565
1932
  }
@@ -1580,7 +1947,7 @@ export interface NamespacesProjectsFlowsCreatePayload {
1580
1947
  /** A unique identifier for the client performing the mutation. */
1581
1948
  clientMutationId?: Maybe<Scalars['String']['output']>;
1582
1949
  /** Errors encountered during execution of the mutation. */
1583
- errors: Array<Error>;
1950
+ errors?: Maybe<Array<Error>>;
1584
1951
  /** The newly created flow. */
1585
1952
  flow?: Maybe<Flow>;
1586
1953
  }
@@ -1599,7 +1966,7 @@ export interface NamespacesProjectsFlowsDeletePayload {
1599
1966
  /** A unique identifier for the client performing the mutation. */
1600
1967
  clientMutationId?: Maybe<Scalars['String']['output']>;
1601
1968
  /** Errors encountered during execution of the mutation. */
1602
- errors: Array<Error>;
1969
+ errors?: Maybe<Array<Error>>;
1603
1970
  /** The deleted flow. */
1604
1971
  flow?: Maybe<Flow>;
1605
1972
  }
@@ -1624,7 +1991,7 @@ export interface NamespacesProjectsUpdatePayload {
1624
1991
  /** A unique identifier for the client performing the mutation. */
1625
1992
  clientMutationId?: Maybe<Scalars['String']['output']>;
1626
1993
  /** Errors encountered during execution of the mutation. */
1627
- errors: Array<Error>;
1994
+ errors?: Maybe<Array<Error>>;
1628
1995
  /** The updated project. */
1629
1996
  namespaceProject?: Maybe<NamespaceProject>;
1630
1997
  }
@@ -1647,7 +2014,7 @@ export interface NamespacesRolesAssignAbilitiesPayload {
1647
2014
  /** A unique identifier for the client performing the mutation. */
1648
2015
  clientMutationId?: Maybe<Scalars['String']['output']>;
1649
2016
  /** Errors encountered during execution of the mutation. */
1650
- errors: Array<Error>;
2017
+ errors?: Maybe<Array<Error>>;
1651
2018
  }
1652
2019
 
1653
2020
  /** Autogenerated input type of NamespacesRolesAssignProjects */
@@ -1666,7 +2033,7 @@ export interface NamespacesRolesAssignProjectsPayload {
1666
2033
  /** A unique identifier for the client performing the mutation. */
1667
2034
  clientMutationId?: Maybe<Scalars['String']['output']>;
1668
2035
  /** Errors encountered during execution of the mutation. */
1669
- errors: Array<Error>;
2036
+ errors?: Maybe<Array<Error>>;
1670
2037
  /** The now assigned projects */
1671
2038
  projects?: Maybe<Array<NamespaceProject>>;
1672
2039
  }
@@ -1687,7 +2054,7 @@ export interface NamespacesRolesCreatePayload {
1687
2054
  /** A unique identifier for the client performing the mutation. */
1688
2055
  clientMutationId?: Maybe<Scalars['String']['output']>;
1689
2056
  /** Errors encountered during execution of the mutation. */
1690
- errors: Array<Error>;
2057
+ errors?: Maybe<Array<Error>>;
1691
2058
  /** The newly created namespace role */
1692
2059
  namespaceRole?: Maybe<NamespaceRole>;
1693
2060
  }
@@ -1706,7 +2073,7 @@ export interface NamespacesRolesDeletePayload {
1706
2073
  /** A unique identifier for the client performing the mutation. */
1707
2074
  clientMutationId?: Maybe<Scalars['String']['output']>;
1708
2075
  /** Errors encountered during execution of the mutation. */
1709
- errors: Array<Error>;
2076
+ errors?: Maybe<Array<Error>>;
1710
2077
  /** The deleted namespace role */
1711
2078
  namespaceRole?: Maybe<NamespaceRole>;
1712
2079
  }
@@ -1727,7 +2094,7 @@ export interface NamespacesRolesUpdatePayload {
1727
2094
  /** A unique identifier for the client performing the mutation. */
1728
2095
  clientMutationId?: Maybe<Scalars['String']['output']>;
1729
2096
  /** Errors encountered during execution of the mutation. */
1730
- errors: Array<Error>;
2097
+ errors?: Maybe<Array<Error>>;
1731
2098
  /** The updated namespace role. */
1732
2099
  namespaceRole?: Maybe<NamespaceRole>;
1733
2100
  }
@@ -1735,24 +2102,24 @@ export interface NamespacesRolesUpdatePayload {
1735
2102
  /** An object with an ID. */
1736
2103
  export interface Node {
1737
2104
  /** ID of the object. */
1738
- id: Scalars['ID']['output'];
2105
+ id?: Maybe<Scalars['ID']['output']>;
1739
2106
  }
1740
2107
 
1741
2108
  /** Represents a Node Function */
1742
2109
  export interface NodeFunction {
1743
2110
  __typename?: 'NodeFunction';
1744
2111
  /** Time when this NodeFunction was created */
1745
- createdAt: Scalars['Time']['output'];
2112
+ createdAt?: Maybe<Scalars['Time']['output']>;
2113
+ /** The definition of the Node Function */
2114
+ functionDefinition?: Maybe<FunctionDefinition>;
1746
2115
  /** Global ID of this NodeFunction */
1747
- id: Scalars['NodeFunctionID']['output'];
1748
- /** The next Node Function in the flow */
1749
- nextNode?: Maybe<NodeFunction>;
2116
+ id?: Maybe<Scalars['NodeFunctionID']['output']>;
2117
+ /** The ID of the next Node Function in the flow */
2118
+ nextNodeId?: Maybe<Scalars['NodeFunctionID']['output']>;
1750
2119
  /** The parameters of the Node Function */
1751
- parameters: NodeParameterConnection;
1752
- /** The definition of the Node Function */
1753
- runtimeFunction: RuntimeFunctionDefinition;
2120
+ parameters?: Maybe<NodeParameterConnection>;
1754
2121
  /** Time when this NodeFunction was last updated */
1755
- updatedAt: Scalars['Time']['output'];
2122
+ updatedAt?: Maybe<Scalars['Time']['output']>;
1756
2123
  }
1757
2124
 
1758
2125
 
@@ -1764,10 +2131,34 @@ export interface NodeFunctionParametersArgs {
1764
2131
  last?: InputMaybe<Scalars['Int']['input']>;
1765
2132
  }
1766
2133
 
2134
+ /** The connection type for NodeFunction. */
2135
+ export interface NodeFunctionConnection {
2136
+ __typename?: 'NodeFunctionConnection';
2137
+ /** Total count of collection. */
2138
+ count?: Maybe<Scalars['Int']['output']>;
2139
+ /** A list of edges. */
2140
+ edges?: Maybe<Array<Maybe<NodeFunctionEdge>>>;
2141
+ /** A list of nodes. */
2142
+ nodes?: Maybe<Array<Maybe<NodeFunction>>>;
2143
+ /** Information to aid in pagination. */
2144
+ pageInfo?: Maybe<PageInfo>;
2145
+ }
2146
+
2147
+ /** An edge in a connection. */
2148
+ export interface NodeFunctionEdge {
2149
+ __typename?: 'NodeFunctionEdge';
2150
+ /** A cursor for use in pagination. */
2151
+ cursor?: Maybe<Scalars['String']['output']>;
2152
+ /** The item at the end of the edge. */
2153
+ node?: Maybe<NodeFunction>;
2154
+ }
2155
+
1767
2156
  /** Input type for a Node Function */
1768
2157
  export interface NodeFunctionInput {
2158
+ /** The identifier of the Node Function used to create/update the flow */
2159
+ id: Scalars['NodeFunctionID']['input'];
1769
2160
  /** The next Node Function in the flow */
1770
- nextNode?: InputMaybe<NodeFunctionInput>;
2161
+ nextNodeId?: InputMaybe<Scalars['NodeFunctionID']['input']>;
1771
2162
  /** The parameters of the Node Function */
1772
2163
  parameters: Array<NodeParameterInput>;
1773
2164
  /** The identifier of the Runtime Function Definition */
@@ -1778,13 +2169,13 @@ export interface NodeFunctionInput {
1778
2169
  export interface NodeParameter {
1779
2170
  __typename?: 'NodeParameter';
1780
2171
  /** Time when this NodeParameter was created */
1781
- createdAt: Scalars['Time']['output'];
2172
+ createdAt?: Maybe<Scalars['Time']['output']>;
1782
2173
  /** Global ID of this NodeParameter */
1783
- id: Scalars['NodeParameterID']['output'];
2174
+ id?: Maybe<Scalars['NodeParameterID']['output']>;
1784
2175
  /** The definition of the parameter */
1785
- runtimeParameter: RuntimeParameterDefinition;
2176
+ runtimeParameter?: Maybe<RuntimeParameterDefinition>;
1786
2177
  /** Time when this NodeParameter was last updated */
1787
- updatedAt: Scalars['Time']['output'];
2178
+ updatedAt?: Maybe<Scalars['Time']['output']>;
1788
2179
  /** The value of the parameter */
1789
2180
  value?: Maybe<NodeParameterValue>;
1790
2181
  }
@@ -1793,20 +2184,20 @@ export interface NodeParameter {
1793
2184
  export interface NodeParameterConnection {
1794
2185
  __typename?: 'NodeParameterConnection';
1795
2186
  /** Total count of collection. */
1796
- count: Scalars['Int']['output'];
2187
+ count?: Maybe<Scalars['Int']['output']>;
1797
2188
  /** A list of edges. */
1798
2189
  edges?: Maybe<Array<Maybe<NodeParameterEdge>>>;
1799
2190
  /** A list of nodes. */
1800
2191
  nodes?: Maybe<Array<Maybe<NodeParameter>>>;
1801
2192
  /** Information to aid in pagination. */
1802
- pageInfo: PageInfo;
2193
+ pageInfo?: Maybe<PageInfo>;
1803
2194
  }
1804
2195
 
1805
2196
  /** An edge in a connection. */
1806
2197
  export interface NodeParameterEdge {
1807
2198
  __typename?: 'NodeParameterEdge';
1808
2199
  /** A cursor for use in pagination. */
1809
- cursor: Scalars['String']['output'];
2200
+ cursor?: Maybe<Scalars['String']['output']>;
1810
2201
  /** The item at the end of the edge. */
1811
2202
  node?: Maybe<NodeParameter>;
1812
2203
  }
@@ -1836,15 +2227,48 @@ export interface NodeParameterValueInput {
1836
2227
  export interface Organization {
1837
2228
  __typename?: 'Organization';
1838
2229
  /** Time when this Organization was created */
1839
- createdAt: Scalars['Time']['output'];
2230
+ createdAt?: Maybe<Scalars['Time']['output']>;
1840
2231
  /** Global ID of this Organization */
1841
- id: Scalars['OrganizationID']['output'];
2232
+ id?: Maybe<Scalars['OrganizationID']['output']>;
1842
2233
  /** Name of the organization */
1843
- name: Scalars['String']['output'];
2234
+ name?: Maybe<Scalars['String']['output']>;
1844
2235
  /** Namespace of this organization */
1845
- namespace: Namespace;
2236
+ namespace?: Maybe<Namespace>;
1846
2237
  /** Time when this Organization was last updated */
1847
- updatedAt: Scalars['Time']['output'];
2238
+ updatedAt?: Maybe<Scalars['Time']['output']>;
2239
+ /** Abilities for the current user on this Organization */
2240
+ userAbilities?: Maybe<OrganizationUserAbilities>;
2241
+ }
2242
+
2243
+ /** The connection type for Organization. */
2244
+ export interface OrganizationConnection {
2245
+ __typename?: 'OrganizationConnection';
2246
+ /** Total count of collection. */
2247
+ count?: Maybe<Scalars['Int']['output']>;
2248
+ /** A list of edges. */
2249
+ edges?: Maybe<Array<Maybe<OrganizationEdge>>>;
2250
+ /** A list of nodes. */
2251
+ nodes?: Maybe<Array<Maybe<Organization>>>;
2252
+ /** Information to aid in pagination. */
2253
+ pageInfo?: Maybe<PageInfo>;
2254
+ }
2255
+
2256
+ /** An edge in a connection. */
2257
+ export interface OrganizationEdge {
2258
+ __typename?: 'OrganizationEdge';
2259
+ /** A cursor for use in pagination. */
2260
+ cursor?: Maybe<Scalars['String']['output']>;
2261
+ /** The item at the end of the edge. */
2262
+ node?: Maybe<Organization>;
2263
+ }
2264
+
2265
+ /** Abilities for the current user on this Organization */
2266
+ export interface OrganizationUserAbilities {
2267
+ __typename?: 'OrganizationUserAbilities';
2268
+ /** Shows if the current user has the `delete_organization` ability on this Organization */
2269
+ deleteOrganization?: Maybe<Scalars['Boolean']['output']>;
2270
+ /** Shows if the current user has the `update_organization` ability on this Organization */
2271
+ updateOrganization?: Maybe<Scalars['Boolean']['output']>;
1848
2272
  }
1849
2273
 
1850
2274
  /** Autogenerated input type of OrganizationsCreate */
@@ -1861,7 +2285,7 @@ export interface OrganizationsCreatePayload {
1861
2285
  /** A unique identifier for the client performing the mutation. */
1862
2286
  clientMutationId?: Maybe<Scalars['String']['output']>;
1863
2287
  /** Errors encountered during execution of the mutation. */
1864
- errors: Array<Error>;
2288
+ errors?: Maybe<Array<Error>>;
1865
2289
  /** The newly created organization. */
1866
2290
  organization?: Maybe<Organization>;
1867
2291
  }
@@ -1880,7 +2304,7 @@ export interface OrganizationsDeletePayload {
1880
2304
  /** A unique identifier for the client performing the mutation. */
1881
2305
  clientMutationId?: Maybe<Scalars['String']['output']>;
1882
2306
  /** Errors encountered during execution of the mutation. */
1883
- errors: Array<Error>;
2307
+ errors?: Maybe<Array<Error>>;
1884
2308
  /** The deleted organization. */
1885
2309
  organization?: Maybe<Organization>;
1886
2310
  }
@@ -1901,7 +2325,7 @@ export interface OrganizationsUpdatePayload {
1901
2325
  /** A unique identifier for the client performing the mutation. */
1902
2326
  clientMutationId?: Maybe<Scalars['String']['output']>;
1903
2327
  /** Errors encountered during execution of the mutation. */
1904
- errors: Array<Error>;
2328
+ errors?: Maybe<Array<Error>>;
1905
2329
  /** The updated organization. */
1906
2330
  organization?: Maybe<Organization>;
1907
2331
  }
@@ -1912,9 +2336,9 @@ export interface PageInfo {
1912
2336
  /** When paginating forwards, the cursor to continue. */
1913
2337
  endCursor?: Maybe<Scalars['String']['output']>;
1914
2338
  /** When paginating forwards, are there more items? */
1915
- hasNextPage: Scalars['Boolean']['output'];
2339
+ hasNextPage?: Maybe<Scalars['Boolean']['output']>;
1916
2340
  /** When paginating backwards, are there more items? */
1917
- hasPreviousPage: Scalars['Boolean']['output'];
2341
+ hasPreviousPage?: Maybe<Scalars['Boolean']['output']>;
1918
2342
  /** When paginating backwards, the cursor to continue. */
1919
2343
  startCursor?: Maybe<Scalars['String']['output']>;
1920
2344
  }
@@ -1923,19 +2347,21 @@ export interface PageInfo {
1923
2347
  export interface ParameterDefinition {
1924
2348
  __typename?: 'ParameterDefinition';
1925
2349
  /** Time when this ParameterDefinition was created */
1926
- createdAt: Scalars['Time']['output'];
2350
+ createdAt?: Maybe<Scalars['Time']['output']>;
1927
2351
  /** Data type of the parameter */
1928
- dataType?: Maybe<DataTypeIdentifier>;
2352
+ dataTypeIdentifier?: Maybe<DataTypeIdentifier>;
1929
2353
  /** Description of the parameter */
1930
2354
  descriptions?: Maybe<TranslationConnection>;
1931
2355
  /** Documentation of the parameter */
1932
2356
  documentations?: Maybe<TranslationConnection>;
1933
2357
  /** Global ID of this ParameterDefinition */
1934
- id: Scalars['ParameterDefinitionID']['output'];
2358
+ id?: Maybe<Scalars['ParameterDefinitionID']['output']>;
2359
+ /** Identifier of the parameter */
2360
+ identifier?: Maybe<Scalars['String']['output']>;
1935
2361
  /** Name of the parameter */
1936
2362
  names?: Maybe<TranslationConnection>;
1937
2363
  /** Time when this ParameterDefinition was last updated */
1938
- updatedAt: Scalars['Time']['output'];
2364
+ updatedAt?: Maybe<Scalars['Time']['output']>;
1939
2365
  }
1940
2366
 
1941
2367
 
@@ -1969,20 +2395,20 @@ export interface ParameterDefinitionNamesArgs {
1969
2395
  export interface ParameterDefinitionConnection {
1970
2396
  __typename?: 'ParameterDefinitionConnection';
1971
2397
  /** Total count of collection. */
1972
- count: Scalars['Int']['output'];
2398
+ count?: Maybe<Scalars['Int']['output']>;
1973
2399
  /** A list of edges. */
1974
2400
  edges?: Maybe<Array<Maybe<ParameterDefinitionEdge>>>;
1975
2401
  /** A list of nodes. */
1976
2402
  nodes?: Maybe<Array<Maybe<ParameterDefinition>>>;
1977
2403
  /** Information to aid in pagination. */
1978
- pageInfo: PageInfo;
2404
+ pageInfo?: Maybe<PageInfo>;
1979
2405
  }
1980
2406
 
1981
2407
  /** An edge in a connection. */
1982
2408
  export interface ParameterDefinitionEdge {
1983
2409
  __typename?: 'ParameterDefinitionEdge';
1984
2410
  /** A cursor for use in pagination. */
1985
- cursor: Scalars['String']['output'];
2411
+ cursor?: Maybe<Scalars['String']['output']>;
1986
2412
  /** The item at the end of the edge. */
1987
2413
  node?: Maybe<ParameterDefinition>;
1988
2414
  }
@@ -1997,9 +2423,9 @@ export interface Query {
1997
2423
  /** Get the currently logged in user */
1998
2424
  currentUser?: Maybe<User>;
1999
2425
  /** Field available for use to test API access */
2000
- echo: Scalars['String']['output'];
2426
+ echo?: Maybe<Scalars['String']['output']>;
2001
2427
  /** Find runtimes */
2002
- globalRuntimes: RuntimeConnection;
2428
+ globalRuntimes?: Maybe<RuntimeConnection>;
2003
2429
  /** Find a namespace */
2004
2430
  namespace?: Maybe<Namespace>;
2005
2431
  /** Fetches an object given its ID */
@@ -2008,8 +2434,12 @@ export interface Query {
2008
2434
  nodes?: Maybe<Array<Maybe<Node>>>;
2009
2435
  /** Find a organization */
2010
2436
  organization?: Maybe<Organization>;
2437
+ /** Find organizations */
2438
+ organizations?: Maybe<OrganizationConnection>;
2439
+ /** Abilities for the current user on this Instance */
2440
+ userAbilities?: Maybe<InstanceUserAbilities>;
2011
2441
  /** Find users */
2012
- users: UserConnection;
2442
+ users?: Maybe<UserConnection>;
2013
2443
  }
2014
2444
 
2015
2445
 
@@ -2053,6 +2483,15 @@ export interface QueryOrganizationArgs {
2053
2483
  }
2054
2484
 
2055
2485
 
2486
+ /** Root Query type */
2487
+ export interface QueryOrganizationsArgs {
2488
+ after?: InputMaybe<Scalars['String']['input']>;
2489
+ before?: InputMaybe<Scalars['String']['input']>;
2490
+ first?: InputMaybe<Scalars['Int']['input']>;
2491
+ last?: InputMaybe<Scalars['Int']['input']>;
2492
+ }
2493
+
2494
+
2056
2495
  /** Root Query type */
2057
2496
  export interface QueryUsersArgs {
2058
2497
  after?: InputMaybe<Scalars['String']['input']>;
@@ -2067,13 +2506,13 @@ export interface ReferencePath {
2067
2506
  /** The array index of the referenced data by the path */
2068
2507
  arrayIndex?: Maybe<Scalars['Int']['output']>;
2069
2508
  /** Time when this ReferencePath was created */
2070
- createdAt: Scalars['Time']['output'];
2509
+ createdAt?: Maybe<Scalars['Time']['output']>;
2071
2510
  /** Global ID of this ReferencePath */
2072
- id: Scalars['ReferencePathID']['output'];
2511
+ id?: Maybe<Scalars['ReferencePathID']['output']>;
2073
2512
  /** The path to the reference in the flow */
2074
2513
  path?: Maybe<Scalars['String']['output']>;
2075
2514
  /** Time when this ReferencePath was last updated */
2076
- updatedAt: Scalars['Time']['output'];
2515
+ updatedAt?: Maybe<Scalars['Time']['output']>;
2077
2516
  }
2078
2517
 
2079
2518
  /** Input type for reference path */
@@ -2088,62 +2527,68 @@ export interface ReferencePathInput {
2088
2527
  export interface ReferenceValue {
2089
2528
  __typename?: 'ReferenceValue';
2090
2529
  /** Time when this ReferenceValue was created */
2091
- createdAt: Scalars['Time']['output'];
2530
+ createdAt?: Maybe<Scalars['Time']['output']>;
2092
2531
  /** The identifier of the data type this reference value belongs to. */
2093
- dataTypeIdentifier: DataTypeIdentifier;
2532
+ dataTypeIdentifier?: Maybe<DataTypeIdentifier>;
2533
+ /** The depth of the reference value. */
2534
+ depth?: Maybe<Scalars['Int']['output']>;
2094
2535
  /** Global ID of this ReferenceValue */
2095
- id: Scalars['ReferenceValueID']['output'];
2096
- /** The primary level of the reference value. */
2097
- primaryLevel: Scalars['Int']['output'];
2536
+ id?: Maybe<Scalars['ReferenceValueID']['output']>;
2537
+ /** The node of the reference value. */
2538
+ node?: Maybe<Scalars['Int']['output']>;
2539
+ /** The referenced value. */
2540
+ nodeFunctionId?: Maybe<Scalars['NodeFunctionID']['output']>;
2098
2541
  /** 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']>;
2542
+ referencePath?: Maybe<Array<ReferencePath>>;
2543
+ /** The scope of the reference value. */
2544
+ scope?: Maybe<Array<Scalars['Int']['output']>>;
2104
2545
  /** Time when this ReferenceValue was last updated */
2105
- updatedAt: Scalars['Time']['output'];
2546
+ updatedAt?: Maybe<Scalars['Time']['output']>;
2106
2547
  }
2107
2548
 
2108
2549
  /** Input type for reference value */
2109
2550
  export interface ReferenceValueInput {
2110
2551
  /** The identifier of the data type this reference value belongs to */
2111
2552
  dataTypeIdentifier: DataTypeIdentifierInput;
2112
- /** The primary level of the reference value */
2113
- primaryLevel: Scalars['Int']['input'];
2553
+ /** The depth of the reference value */
2554
+ depth: Scalars['Int']['input'];
2555
+ /** The node of the reference */
2556
+ node: Scalars['Int']['input'];
2557
+ /** The referenced value */
2558
+ nodeFunctionId: Scalars['NodeFunctionID']['input'];
2114
2559
  /** The paths associated with this reference value */
2115
2560
  referencePath: Array<ReferencePathInput>;
2116
- /** The secondary level of the reference value */
2117
- secondaryLevel: Scalars['Int']['input'];
2118
- /** The tertiary level of the reference value */
2119
- tertiaryLevel?: InputMaybe<Scalars['Int']['input']>;
2561
+ /** The scope of the reference value */
2562
+ scope: Array<Scalars['Int']['input']>;
2120
2563
  }
2121
2564
 
2122
2565
  /** Represents a runtime */
2123
2566
  export interface Runtime {
2124
2567
  __typename?: 'Runtime';
2125
2568
  /** Time when this Runtime was created */
2126
- createdAt: Scalars['Time']['output'];
2569
+ createdAt?: Maybe<Scalars['Time']['output']>;
2127
2570
  /** DataTypes of the runtime */
2128
- dataTypes: DataTypeConnection;
2571
+ dataTypes?: Maybe<DataTypeConnection>;
2129
2572
  /** The description for the runtime if present */
2130
- description: Scalars['String']['output'];
2573
+ description?: Maybe<Scalars['String']['output']>;
2131
2574
  /** FlowTypes of the runtime */
2132
- flowTypes: FlowTypeConnection;
2575
+ flowTypes?: Maybe<FlowTypeConnection>;
2133
2576
  /** Global ID of this Runtime */
2134
- id: Scalars['RuntimeID']['output'];
2577
+ id?: Maybe<Scalars['RuntimeID']['output']>;
2135
2578
  /** The name for the runtime */
2136
- name: Scalars['String']['output'];
2579
+ name?: Maybe<Scalars['String']['output']>;
2137
2580
  /** The parent namespace for the runtime */
2138
2581
  namespace?: Maybe<Namespace>;
2139
2582
  /** Projects associated with the runtime */
2140
- projects: NamespaceProjectConnection;
2583
+ projects?: Maybe<NamespaceProjectConnection>;
2141
2584
  /** The status of the runtime */
2142
- status: RuntimeStatusType;
2585
+ status?: Maybe<RuntimeStatusType>;
2143
2586
  /** Token belonging to the runtime, only present on creation */
2144
2587
  token?: Maybe<Scalars['String']['output']>;
2145
2588
  /** Time when this Runtime was last updated */
2146
- updatedAt: Scalars['Time']['output'];
2589
+ updatedAt?: Maybe<Scalars['Time']['output']>;
2590
+ /** Abilities for the current user on this Runtime */
2591
+ userAbilities?: Maybe<RuntimeUserAbilities>;
2147
2592
  }
2148
2593
 
2149
2594
 
@@ -2177,41 +2622,45 @@ export interface RuntimeProjectsArgs {
2177
2622
  export interface RuntimeConnection {
2178
2623
  __typename?: 'RuntimeConnection';
2179
2624
  /** Total count of collection. */
2180
- count: Scalars['Int']['output'];
2625
+ count?: Maybe<Scalars['Int']['output']>;
2181
2626
  /** A list of edges. */
2182
2627
  edges?: Maybe<Array<Maybe<RuntimeEdge>>>;
2183
2628
  /** A list of nodes. */
2184
2629
  nodes?: Maybe<Array<Maybe<Runtime>>>;
2185
2630
  /** Information to aid in pagination. */
2186
- pageInfo: PageInfo;
2631
+ pageInfo?: Maybe<PageInfo>;
2187
2632
  }
2188
2633
 
2189
2634
  /** An edge in a connection. */
2190
2635
  export interface RuntimeEdge {
2191
2636
  __typename?: 'RuntimeEdge';
2192
2637
  /** A cursor for use in pagination. */
2193
- cursor: Scalars['String']['output'];
2638
+ cursor?: Maybe<Scalars['String']['output']>;
2194
2639
  /** The item at the end of the edge. */
2195
2640
  node?: Maybe<Runtime>;
2196
2641
  }
2197
2642
 
2198
- /** Represents a Node Function definition */
2643
+ /** Represents a runtime function definition */
2199
2644
  export interface RuntimeFunctionDefinition {
2200
2645
  __typename?: 'RuntimeFunctionDefinition';
2201
2646
  /** Time when this RuntimeFunctionDefinition was created */
2202
- createdAt: Scalars['Time']['output'];
2203
- /** Function definitions of the Node Function */
2647
+ createdAt?: Maybe<Scalars['Time']['output']>;
2648
+ /** Function definitions of the runtime function definition */
2204
2649
  functionDefinitions?: Maybe<FunctionDefinitionConnection>;
2205
2650
  /** Global ID of this RuntimeFunctionDefinition */
2206
- id: Scalars['RuntimeParameterDefinitionID']['output'];
2207
- /** The runtime this Node Function belongs to */
2208
- runtime: Runtime;
2651
+ id?: Maybe<Scalars['RuntimeFunctionDefinitionID']['output']>;
2652
+ /** Identifier of the runtime function definition */
2653
+ identifier?: Maybe<Scalars['String']['output']>;
2654
+ /** The runtime this runtime function definition belongs to */
2655
+ runtime?: Maybe<Runtime>;
2656
+ /** Parameter definitions of the runtime function definition */
2657
+ runtimeParameterDefinitions?: Maybe<RuntimeParameterDefinitionConnection>;
2209
2658
  /** Time when this RuntimeFunctionDefinition was last updated */
2210
- updatedAt: Scalars['Time']['output'];
2659
+ updatedAt?: Maybe<Scalars['Time']['output']>;
2211
2660
  }
2212
2661
 
2213
2662
 
2214
- /** Represents a Node Function definition */
2663
+ /** Represents a runtime function definition */
2215
2664
  export interface RuntimeFunctionDefinitionFunctionDefinitionsArgs {
2216
2665
  after?: InputMaybe<Scalars['String']['input']>;
2217
2666
  before?: InputMaybe<Scalars['String']['input']>;
@@ -2219,25 +2668,67 @@ export interface RuntimeFunctionDefinitionFunctionDefinitionsArgs {
2219
2668
  last?: InputMaybe<Scalars['Int']['input']>;
2220
2669
  }
2221
2670
 
2222
- /** Represents a Node parameter definition */
2671
+
2672
+ /** Represents a runtime function definition */
2673
+ export interface RuntimeFunctionDefinitionRuntimeParameterDefinitionsArgs {
2674
+ after?: InputMaybe<Scalars['String']['input']>;
2675
+ before?: InputMaybe<Scalars['String']['input']>;
2676
+ first?: InputMaybe<Scalars['Int']['input']>;
2677
+ last?: InputMaybe<Scalars['Int']['input']>;
2678
+ }
2679
+
2680
+ /** Represents a runtime parameter definition */
2223
2681
  export interface RuntimeParameterDefinition {
2224
2682
  __typename?: 'RuntimeParameterDefinition';
2225
2683
  /** Time when this RuntimeParameterDefinition was created */
2226
- createdAt: Scalars['Time']['output'];
2684
+ createdAt?: Maybe<Scalars['Time']['output']>;
2227
2685
  /** Global ID of this RuntimeParameterDefinition */
2228
- id: Scalars['RuntimeParameterDefinitionID']['output'];
2686
+ id?: Maybe<Scalars['RuntimeParameterDefinitionID']['output']>;
2229
2687
  /** Time when this RuntimeParameterDefinition was last updated */
2230
- updatedAt: Scalars['Time']['output'];
2688
+ updatedAt?: Maybe<Scalars['Time']['output']>;
2689
+ }
2690
+
2691
+ /** The connection type for RuntimeParameterDefinition. */
2692
+ export interface RuntimeParameterDefinitionConnection {
2693
+ __typename?: 'RuntimeParameterDefinitionConnection';
2694
+ /** Total count of collection. */
2695
+ count?: Maybe<Scalars['Int']['output']>;
2696
+ /** A list of edges. */
2697
+ edges?: Maybe<Array<Maybe<RuntimeParameterDefinitionEdge>>>;
2698
+ /** A list of nodes. */
2699
+ nodes?: Maybe<Array<Maybe<RuntimeParameterDefinition>>>;
2700
+ /** Information to aid in pagination. */
2701
+ pageInfo?: Maybe<PageInfo>;
2702
+ }
2703
+
2704
+ /** An edge in a connection. */
2705
+ export interface RuntimeParameterDefinitionEdge {
2706
+ __typename?: 'RuntimeParameterDefinitionEdge';
2707
+ /** A cursor for use in pagination. */
2708
+ cursor?: Maybe<Scalars['String']['output']>;
2709
+ /** The item at the end of the edge. */
2710
+ node?: Maybe<RuntimeParameterDefinition>;
2231
2711
  }
2232
2712
 
2233
2713
  /** Represent all available types of statuses of a runtime */
2234
- export enum RuntimeStatusType {
2714
+ export const enum RuntimeStatusType {
2235
2715
  /** No problem with connection, everything works as expected */
2236
2716
  Connected = 'CONNECTED',
2237
2717
  /** The runtime is disconnected, cause unknown */
2238
2718
  Disconnected = 'DISCONNECTED'
2239
2719
  }
2240
2720
 
2721
+ /** Abilities for the current user on this Runtime */
2722
+ export interface RuntimeUserAbilities {
2723
+ __typename?: 'RuntimeUserAbilities';
2724
+ /** Shows if the current user has the `delete_runtime` ability on this Runtime */
2725
+ deleteRuntime?: Maybe<Scalars['Boolean']['output']>;
2726
+ /** Shows if the current user has the `rotate_runtime_token` ability on this Runtime */
2727
+ rotateRuntimeToken?: Maybe<Scalars['Boolean']['output']>;
2728
+ /** Shows if the current user has the `update_runtime` ability on this Runtime */
2729
+ updateRuntime?: Maybe<Scalars['Boolean']['output']>;
2730
+ }
2731
+
2241
2732
  /** Autogenerated input type of RuntimesCreate */
2242
2733
  export interface RuntimesCreateInput {
2243
2734
  /** A unique identifier for the client performing the mutation. */
@@ -2256,7 +2747,7 @@ export interface RuntimesCreatePayload {
2256
2747
  /** A unique identifier for the client performing the mutation. */
2257
2748
  clientMutationId?: Maybe<Scalars['String']['output']>;
2258
2749
  /** Errors encountered during execution of the mutation. */
2259
- errors: Array<Error>;
2750
+ errors?: Maybe<Array<Error>>;
2260
2751
  /** The newly created runtime. */
2261
2752
  runtime?: Maybe<Runtime>;
2262
2753
  }
@@ -2275,7 +2766,7 @@ export interface RuntimesDeletePayload {
2275
2766
  /** A unique identifier for the client performing the mutation. */
2276
2767
  clientMutationId?: Maybe<Scalars['String']['output']>;
2277
2768
  /** Errors encountered during execution of the mutation. */
2278
- errors: Array<Error>;
2769
+ errors?: Maybe<Array<Error>>;
2279
2770
  /** The updated organization. */
2280
2771
  runtime?: Maybe<Runtime>;
2281
2772
  }
@@ -2294,7 +2785,7 @@ export interface RuntimesRotateTokenPayload {
2294
2785
  /** A unique identifier for the client performing the mutation. */
2295
2786
  clientMutationId?: Maybe<Scalars['String']['output']>;
2296
2787
  /** Errors encountered during execution of the mutation. */
2297
- errors: Array<Error>;
2788
+ errors?: Maybe<Array<Error>>;
2298
2789
  /** The updated runtime. */
2299
2790
  runtime?: Maybe<Runtime>;
2300
2791
  }
@@ -2317,7 +2808,7 @@ export interface RuntimesUpdatePayload {
2317
2808
  /** A unique identifier for the client performing the mutation. */
2318
2809
  clientMutationId?: Maybe<Scalars['String']['output']>;
2319
2810
  /** Errors encountered during execution of the mutation. */
2320
- errors: Array<Error>;
2811
+ errors?: Maybe<Array<Error>>;
2321
2812
  /** The updated runtime. */
2322
2813
  runtime?: Maybe<Runtime>;
2323
2814
  }
@@ -2326,29 +2817,29 @@ export interface RuntimesUpdatePayload {
2326
2817
  export interface Translation {
2327
2818
  __typename?: 'Translation';
2328
2819
  /** Code of the translation */
2329
- code: Scalars['String']['output'];
2820
+ code?: Maybe<Scalars['String']['output']>;
2330
2821
  /** Content of the translation */
2331
- content: Scalars['String']['output'];
2822
+ content?: Maybe<Scalars['String']['output']>;
2332
2823
  }
2333
2824
 
2334
2825
  /** The connection type for Translation. */
2335
2826
  export interface TranslationConnection {
2336
2827
  __typename?: 'TranslationConnection';
2337
2828
  /** Total count of collection. */
2338
- count: Scalars['Int']['output'];
2829
+ count?: Maybe<Scalars['Int']['output']>;
2339
2830
  /** A list of edges. */
2340
2831
  edges?: Maybe<Array<Maybe<TranslationEdge>>>;
2341
2832
  /** A list of nodes. */
2342
2833
  nodes?: Maybe<Array<Maybe<Translation>>>;
2343
2834
  /** Information to aid in pagination. */
2344
- pageInfo: PageInfo;
2835
+ pageInfo?: Maybe<PageInfo>;
2345
2836
  }
2346
2837
 
2347
2838
  /** An edge in a connection. */
2348
2839
  export interface TranslationEdge {
2349
2840
  __typename?: 'TranslationEdge';
2350
2841
  /** A cursor for use in pagination. */
2351
- cursor: Scalars['String']['output'];
2842
+ cursor?: Maybe<Scalars['String']['output']>;
2352
2843
  /** The item at the end of the edge. */
2353
2844
  node?: Maybe<Translation>;
2354
2845
  }
@@ -2357,27 +2848,44 @@ export interface TranslationEdge {
2357
2848
  export interface User {
2358
2849
  __typename?: 'User';
2359
2850
  /** Global admin status of the user */
2360
- admin: Scalars['Boolean']['output'];
2851
+ admin?: Maybe<Scalars['Boolean']['output']>;
2361
2852
  /** The avatar if present of the user */
2362
2853
  avatarPath?: Maybe<Scalars['String']['output']>;
2363
2854
  /** Time when this User was created */
2364
- createdAt: Scalars['Time']['output'];
2855
+ createdAt?: Maybe<Scalars['Time']['output']>;
2365
2856
  /** Email of the user */
2366
- email: Scalars['String']['output'];
2857
+ email?: Maybe<Scalars['String']['output']>;
2858
+ /** Email verification date of the user if present */
2859
+ emailVerifiedAt?: Maybe<Scalars['Time']['output']>;
2367
2860
  /** Firstname of the user */
2368
- firstname: Scalars['String']['output'];
2861
+ firstname?: Maybe<Scalars['String']['output']>;
2369
2862
  /** Global ID of this User */
2370
- id: Scalars['UserID']['output'];
2863
+ id?: Maybe<Scalars['UserID']['output']>;
2864
+ /** Identities of this user */
2865
+ identities?: Maybe<UserIdentityConnection>;
2371
2866
  /** Lastname of the user */
2372
- lastname: Scalars['String']['output'];
2867
+ lastname?: Maybe<Scalars['String']['output']>;
2373
2868
  /** Namespace of this user */
2374
2869
  namespace?: Maybe<Namespace>;
2375
2870
  /** Namespace Memberships of this user */
2376
- namespaceMemberships: NamespaceMemberConnection;
2871
+ namespaceMemberships?: Maybe<NamespaceMemberConnection>;
2872
+ /** Sessions of this user */
2873
+ sessions?: Maybe<UserSessionConnection>;
2377
2874
  /** Time when this User was last updated */
2378
- updatedAt: Scalars['Time']['output'];
2875
+ updatedAt?: Maybe<Scalars['Time']['output']>;
2876
+ /** Abilities for the current user on this User */
2877
+ userAbilities?: Maybe<UserUserAbilities>;
2379
2878
  /** Username of the user */
2380
- username: Scalars['String']['output'];
2879
+ username?: Maybe<Scalars['String']['output']>;
2880
+ }
2881
+
2882
+
2883
+ /** Represents a user */
2884
+ export interface UserIdentitiesArgs {
2885
+ after?: InputMaybe<Scalars['String']['input']>;
2886
+ before?: InputMaybe<Scalars['String']['input']>;
2887
+ first?: InputMaybe<Scalars['Int']['input']>;
2888
+ last?: InputMaybe<Scalars['Int']['input']>;
2381
2889
  }
2382
2890
 
2383
2891
 
@@ -2389,24 +2897,33 @@ export interface UserNamespaceMembershipsArgs {
2389
2897
  last?: InputMaybe<Scalars['Int']['input']>;
2390
2898
  }
2391
2899
 
2900
+
2901
+ /** Represents a user */
2902
+ export interface UserSessionsArgs {
2903
+ after?: InputMaybe<Scalars['String']['input']>;
2904
+ before?: InputMaybe<Scalars['String']['input']>;
2905
+ first?: InputMaybe<Scalars['Int']['input']>;
2906
+ last?: InputMaybe<Scalars['Int']['input']>;
2907
+ }
2908
+
2392
2909
  /** The connection type for User. */
2393
2910
  export interface UserConnection {
2394
2911
  __typename?: 'UserConnection';
2395
2912
  /** Total count of collection. */
2396
- count: Scalars['Int']['output'];
2913
+ count?: Maybe<Scalars['Int']['output']>;
2397
2914
  /** A list of edges. */
2398
2915
  edges?: Maybe<Array<Maybe<UserEdge>>>;
2399
2916
  /** A list of nodes. */
2400
2917
  nodes?: Maybe<Array<Maybe<User>>>;
2401
2918
  /** Information to aid in pagination. */
2402
- pageInfo: PageInfo;
2919
+ pageInfo?: Maybe<PageInfo>;
2403
2920
  }
2404
2921
 
2405
2922
  /** An edge in a connection. */
2406
2923
  export interface UserEdge {
2407
2924
  __typename?: 'UserEdge';
2408
2925
  /** A cursor for use in pagination. */
2409
- cursor: Scalars['String']['output'];
2926
+ cursor?: Maybe<Scalars['String']['output']>;
2410
2927
  /** The item at the end of the edge. */
2411
2928
  node?: Maybe<User>;
2412
2929
  }
@@ -2415,34 +2932,115 @@ export interface UserEdge {
2415
2932
  export interface UserIdentity {
2416
2933
  __typename?: 'UserIdentity';
2417
2934
  /** Time when this UserIdentity was created */
2418
- createdAt: Scalars['Time']['output'];
2935
+ createdAt?: Maybe<Scalars['Time']['output']>;
2419
2936
  /** Global ID of this UserIdentity */
2420
- id: Scalars['UserIdentityID']['output'];
2937
+ id?: Maybe<Scalars['UserIdentityID']['output']>;
2421
2938
  /** The description for the runtime if present */
2422
- identifier: Scalars['String']['output'];
2939
+ identifier?: Maybe<Scalars['String']['output']>;
2423
2940
  /** The name for the runtime */
2424
- providerId: Scalars['String']['output'];
2941
+ providerId?: Maybe<Scalars['String']['output']>;
2425
2942
  /** Time when this UserIdentity was last updated */
2426
- updatedAt: Scalars['Time']['output'];
2943
+ updatedAt?: Maybe<Scalars['Time']['output']>;
2427
2944
  /** The correlating user of the identity */
2428
- user: User;
2945
+ user?: Maybe<User>;
2946
+ }
2947
+
2948
+ /** The connection type for UserIdentity. */
2949
+ export interface UserIdentityConnection {
2950
+ __typename?: 'UserIdentityConnection';
2951
+ /** Total count of collection. */
2952
+ count?: Maybe<Scalars['Int']['output']>;
2953
+ /** A list of edges. */
2954
+ edges?: Maybe<Array<Maybe<UserIdentityEdge>>>;
2955
+ /** A list of nodes. */
2956
+ nodes?: Maybe<Array<Maybe<UserIdentity>>>;
2957
+ /** Information to aid in pagination. */
2958
+ pageInfo?: Maybe<PageInfo>;
2959
+ }
2960
+
2961
+ /** An edge in a connection. */
2962
+ export interface UserIdentityEdge {
2963
+ __typename?: 'UserIdentityEdge';
2964
+ /** A cursor for use in pagination. */
2965
+ cursor?: Maybe<Scalars['String']['output']>;
2966
+ /** The item at the end of the edge. */
2967
+ node?: Maybe<UserIdentity>;
2429
2968
  }
2430
2969
 
2431
2970
  /** Represents a user session */
2432
2971
  export interface UserSession {
2433
2972
  __typename?: 'UserSession';
2434
2973
  /** Whether or not the session is active and can be used */
2435
- active: Scalars['Boolean']['output'];
2974
+ active?: Maybe<Scalars['Boolean']['output']>;
2436
2975
  /** Time when this UserSession was created */
2437
- createdAt: Scalars['Time']['output'];
2976
+ createdAt?: Maybe<Scalars['Time']['output']>;
2438
2977
  /** Global ID of this UserSession */
2439
- id: Scalars['UserSessionID']['output'];
2978
+ id?: Maybe<Scalars['UserSessionID']['output']>;
2440
2979
  /** Token belonging to the session, only present on creation */
2441
2980
  token?: Maybe<Scalars['String']['output']>;
2442
2981
  /** Time when this UserSession was last updated */
2443
- updatedAt: Scalars['Time']['output'];
2982
+ updatedAt?: Maybe<Scalars['Time']['output']>;
2444
2983
  /** User that belongs to the session */
2445
- user: User;
2984
+ user?: Maybe<User>;
2985
+ /** Abilities for the current user on this UserSession */
2986
+ userAbilities?: Maybe<UserSessionUserAbilities>;
2987
+ }
2988
+
2989
+ /** The connection type for UserSession. */
2990
+ export interface UserSessionConnection {
2991
+ __typename?: 'UserSessionConnection';
2992
+ /** Total count of collection. */
2993
+ count?: Maybe<Scalars['Int']['output']>;
2994
+ /** A list of edges. */
2995
+ edges?: Maybe<Array<Maybe<UserSessionEdge>>>;
2996
+ /** A list of nodes. */
2997
+ nodes?: Maybe<Array<Maybe<UserSession>>>;
2998
+ /** Information to aid in pagination. */
2999
+ pageInfo?: Maybe<PageInfo>;
3000
+ }
3001
+
3002
+ /** An edge in a connection. */
3003
+ export interface UserSessionEdge {
3004
+ __typename?: 'UserSessionEdge';
3005
+ /** A cursor for use in pagination. */
3006
+ cursor?: Maybe<Scalars['String']['output']>;
3007
+ /** The item at the end of the edge. */
3008
+ node?: Maybe<UserSession>;
3009
+ }
3010
+
3011
+ /** Abilities for the current user on this UserSession */
3012
+ export interface UserSessionUserAbilities {
3013
+ __typename?: 'UserSessionUserAbilities';
3014
+ /** Shows if the current user has the `logout_session` ability on this UserSession */
3015
+ logoutSession?: Maybe<Scalars['Boolean']['output']>;
3016
+ }
3017
+
3018
+ /** Abilities for the current user on this User */
3019
+ export interface UserUserAbilities {
3020
+ __typename?: 'UserUserAbilities';
3021
+ /** Shows if the current user has the `manage_mfa` ability on this User */
3022
+ manageMfa?: Maybe<Scalars['Boolean']['output']>;
3023
+ /** Shows if the current user has the `update_user` ability on this User */
3024
+ updateUser?: Maybe<Scalars['Boolean']['output']>;
3025
+ }
3026
+
3027
+ /** Autogenerated input type of UsersEmailVerification */
3028
+ export interface UsersEmailVerificationInput {
3029
+ /** A unique identifier for the client performing the mutation. */
3030
+ clientMutationId?: InputMaybe<Scalars['String']['input']>;
3031
+ /** The email verification token */
3032
+ token: Scalars['String']['input'];
3033
+ }
3034
+
3035
+ /** Autogenerated return type of UsersEmailVerification. */
3036
+ export interface UsersEmailVerificationPayload {
3037
+ __typename?: 'UsersEmailVerificationPayload';
3038
+ /** A unique identifier for the client performing the mutation. */
3039
+ clientMutationId?: Maybe<Scalars['String']['output']>;
3040
+ /** Errors encountered during execution of the mutation. */
3041
+ errors?: Maybe<Array<Error>>;
3042
+ /** The user whose email was verified */
3043
+ user?: Maybe<User>;
2446
3044
  }
2447
3045
 
2448
3046
  /** Autogenerated input type of UsersIdentityLink */
@@ -2461,7 +3059,7 @@ export interface UsersIdentityLinkPayload {
2461
3059
  /** A unique identifier for the client performing the mutation. */
2462
3060
  clientMutationId?: Maybe<Scalars['String']['output']>;
2463
3061
  /** Errors encountered during execution of the mutation. */
2464
- errors: Array<Error>;
3062
+ errors?: Maybe<Array<Error>>;
2465
3063
  /** The created user identity */
2466
3064
  userIdentity?: Maybe<UserIdentity>;
2467
3065
  }
@@ -2482,7 +3080,7 @@ export interface UsersIdentityLoginPayload {
2482
3080
  /** A unique identifier for the client performing the mutation. */
2483
3081
  clientMutationId?: Maybe<Scalars['String']['output']>;
2484
3082
  /** Errors encountered during execution of the mutation. */
2485
- errors: Array<Error>;
3083
+ errors?: Maybe<Array<Error>>;
2486
3084
  /** The created user session */
2487
3085
  userSession?: Maybe<UserSession>;
2488
3086
  }
@@ -2503,7 +3101,7 @@ export interface UsersIdentityRegisterPayload {
2503
3101
  /** A unique identifier for the client performing the mutation. */
2504
3102
  clientMutationId?: Maybe<Scalars['String']['output']>;
2505
3103
  /** Errors encountered during execution of the mutation. */
2506
- errors: Array<Error>;
3104
+ errors?: Maybe<Array<Error>>;
2507
3105
  /** The created users session */
2508
3106
  userSession?: Maybe<UserSession>;
2509
3107
  }
@@ -2522,7 +3120,7 @@ export interface UsersIdentityUnlinkPayload {
2522
3120
  /** A unique identifier for the client performing the mutation. */
2523
3121
  clientMutationId?: Maybe<Scalars['String']['output']>;
2524
3122
  /** Errors encountered during execution of the mutation. */
2525
- errors: Array<Error>;
3123
+ errors?: Maybe<Array<Error>>;
2526
3124
  /** The removed identity */
2527
3125
  userIdentity?: Maybe<UserIdentity>;
2528
3126
  }
@@ -2547,7 +3145,7 @@ export interface UsersLoginPayload {
2547
3145
  /** A unique identifier for the client performing the mutation. */
2548
3146
  clientMutationId?: Maybe<Scalars['String']['output']>;
2549
3147
  /** Errors encountered during execution of the mutation. */
2550
- errors: Array<Error>;
3148
+ errors?: Maybe<Array<Error>>;
2551
3149
  /** The created user session */
2552
3150
  userSession?: Maybe<UserSession>;
2553
3151
  }
@@ -2566,7 +3164,7 @@ export interface UsersLogoutPayload {
2566
3164
  /** A unique identifier for the client performing the mutation. */
2567
3165
  clientMutationId?: Maybe<Scalars['String']['output']>;
2568
3166
  /** Errors encountered during execution of the mutation. */
2569
- errors: Array<Error>;
3167
+ errors?: Maybe<Array<Error>>;
2570
3168
  /** The logged out user session */
2571
3169
  userSession?: Maybe<UserSession>;
2572
3170
  }
@@ -2585,7 +3183,7 @@ export interface UsersMfaBackupCodesRotatePayload {
2585
3183
  /** The newly rotated backup codes. */
2586
3184
  codes?: Maybe<Array<Scalars['String']['output']>>;
2587
3185
  /** Errors encountered during execution of the mutation. */
2588
- errors: Array<Error>;
3186
+ errors?: Maybe<Array<Error>>;
2589
3187
  }
2590
3188
 
2591
3189
  /** Autogenerated input type of UsersMfaTotpGenerateSecret */
@@ -2600,7 +3198,7 @@ export interface UsersMfaTotpGenerateSecretPayload {
2600
3198
  /** A unique identifier for the client performing the mutation. */
2601
3199
  clientMutationId?: Maybe<Scalars['String']['output']>;
2602
3200
  /** Errors encountered during execution of the mutation. */
2603
- errors: Array<Error>;
3201
+ errors?: Maybe<Array<Error>>;
2604
3202
  /** The created and signed secret */
2605
3203
  secret?: Maybe<Scalars['String']['output']>;
2606
3204
  }
@@ -2624,11 +3222,53 @@ export interface UsersMfaTotpValidateSecretPayload {
2624
3222
  /** A unique identifier for the client performing the mutation. */
2625
3223
  clientMutationId?: Maybe<Scalars['String']['output']>;
2626
3224
  /** Errors encountered during execution of the mutation. */
2627
- errors: Array<Error>;
3225
+ errors?: Maybe<Array<Error>>;
2628
3226
  /** The modified user */
2629
3227
  user?: Maybe<User>;
2630
3228
  }
2631
3229
 
3230
+ /** Autogenerated input type of UsersPasswordReset */
3231
+ export interface UsersPasswordResetInput {
3232
+ /** A unique identifier for the client performing the mutation. */
3233
+ clientMutationId?: InputMaybe<Scalars['String']['input']>;
3234
+ /** The new password to set for the user */
3235
+ newPassword: Scalars['String']['input'];
3236
+ /** The confirmation of the new password to set for the user needs to be the same as the new password */
3237
+ newPasswordConfirmation: Scalars['String']['input'];
3238
+ /** The password reset token sent to the user email */
3239
+ resetToken: Scalars['String']['input'];
3240
+ }
3241
+
3242
+ /** Autogenerated return type of UsersPasswordReset. */
3243
+ export interface UsersPasswordResetPayload {
3244
+ __typename?: 'UsersPasswordResetPayload';
3245
+ /** A unique identifier for the client performing the mutation. */
3246
+ clientMutationId?: Maybe<Scalars['String']['output']>;
3247
+ /** Errors encountered during execution of the mutation. */
3248
+ errors?: Maybe<Array<Error>>;
3249
+ /** A message indicating the result of the password reset request */
3250
+ message?: Maybe<Scalars['String']['output']>;
3251
+ }
3252
+
3253
+ /** Autogenerated input type of UsersPasswordResetRequest */
3254
+ export interface UsersPasswordResetRequestInput {
3255
+ /** A unique identifier for the client performing the mutation. */
3256
+ clientMutationId?: InputMaybe<Scalars['String']['input']>;
3257
+ /** Email of the user to reset the password */
3258
+ email: Scalars['String']['input'];
3259
+ }
3260
+
3261
+ /** Autogenerated return type of UsersPasswordResetRequest. */
3262
+ export interface UsersPasswordResetRequestPayload {
3263
+ __typename?: 'UsersPasswordResetRequestPayload';
3264
+ /** A unique identifier for the client performing the mutation. */
3265
+ clientMutationId?: Maybe<Scalars['String']['output']>;
3266
+ /** Errors encountered during execution of the mutation. */
3267
+ errors?: Maybe<Array<Error>>;
3268
+ /** A message indicating the result of the password reset request */
3269
+ message?: Maybe<Scalars['String']['output']>;
3270
+ }
3271
+
2632
3272
  /** Autogenerated input type of UsersRegister */
2633
3273
  export interface UsersRegisterInput {
2634
3274
  /** A unique identifier for the client performing the mutation. */
@@ -2649,7 +3289,7 @@ export interface UsersRegisterPayload {
2649
3289
  /** A unique identifier for the client performing the mutation. */
2650
3290
  clientMutationId?: Maybe<Scalars['String']['output']>;
2651
3291
  /** Errors encountered during execution of the mutation. */
2652
- errors: Array<Error>;
3292
+ errors?: Maybe<Array<Error>>;
2653
3293
  /** The created users session */
2654
3294
  userSession?: Maybe<UserSession>;
2655
3295
  }
@@ -2684,7 +3324,7 @@ export interface UsersUpdatePayload {
2684
3324
  /** A unique identifier for the client performing the mutation. */
2685
3325
  clientMutationId?: Maybe<Scalars['String']['output']>;
2686
3326
  /** Errors encountered during execution of the mutation. */
2687
- errors: Array<Error>;
3327
+ errors?: Maybe<Array<Error>>;
2688
3328
  /** The updated user. */
2689
3329
  user?: Maybe<User>;
2690
3330
  }