@code0-tech/sagittarius-graphql-types 0.0.0-6f0b32a0eb18c9c3569a090f089c6adf1b4d666c → 0.0.0-755f9382e6589ede0182dace55452703bcd6e85b

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 +1930 -178
  2. package/package.json +5 -6
  3. package/index.js +0 -0
package/index.d.ts CHANGED
@@ -1,65 +1,67 @@
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
- ID: { input: string; output: string; }
10
+ ID: { input: `gid://sagittarius//${number}`; output: `gid://sagittarius//${number}`; }
11
11
  String: { input: string; output: string; }
12
12
  Boolean: { input: boolean; output: boolean; }
13
13
  Int: { input: number; output: number; }
14
14
  Float: { input: number; output: number; }
15
- /** A unique identifier for all DataType entities of the application */
16
- DataTypeID: { input: any; output: any; }
17
- /** A unique identifier for all Namespace entities of the application */
18
- NamespaceID: { input: any; output: any; }
19
- /** A unique identifier for all NamespaceLicense entities of the application */
20
- NamespaceLicenseID: { input: any; output: any; }
21
- /** A unique identifier for all NamespaceMember entities of the application */
22
- NamespaceMemberID: { input: any; output: any; }
23
- /** A unique identifier for all NamespaceMemberRole entities of the application */
24
- NamespaceMemberRoleID: { input: any; output: any; }
25
- /** A unique identifier for all NamespaceProject entities of the application */
26
- NamespaceProjectID: { input: any; output: any; }
27
- /** A unique identifier for all NamespaceRole entities of the application */
28
- NamespaceRoleID: { input: any; output: any; }
29
- /** A unique identifier for all Organization entities of the application */
30
- OrganizationID: { input: any; output: any; }
31
- /** A unique identifier for all Runtime entities of the application */
32
- RuntimeID: { input: any; output: any; }
33
- /**
34
- * Time represented in ISO 8601.
35
- *
36
- * For example: "2023-12-15T17:31:00Z".
37
- */
38
- Time: { input: any; output: any; }
39
- /** A unique identifier for all User entities of the application */
40
- UserID: { input: any; output: any; }
41
- /** A unique identifier for all UserIdentity entities of the application */
42
- UserIdentityID: { input: any; output: any; }
43
- /** A unique identifier for all UserSession entities of the application */
44
- UserSessionID: { input: any; output: any; }
15
+ DataTypeID: { input: `gid://sagittarius/DataType/${number}`; output: `gid://sagittarius/DataType/${number}`; }
16
+ DataTypeIdentifierID: { input: `gid://sagittarius/DataTypeIdentifier/${number}`; output: `gid://sagittarius/DataTypeIdentifier/${number}`; }
17
+ DataTypeRuleID: { input: `gid://sagittarius/DataTypeRule/${number}`; output: `gid://sagittarius/DataTypeRule/${number}`; }
18
+ FlowID: { input: `gid://sagittarius/Flow/${number}`; output: `gid://sagittarius/Flow/${number}`; }
19
+ FlowSettingID: { input: `gid://sagittarius/FlowSetting/${number}`; output: `gid://sagittarius/FlowSetting/${number}`; }
20
+ FlowTypeID: { input: `gid://sagittarius/FlowType/${number}`; output: `gid://sagittarius/FlowType/${number}`; }
21
+ FlowTypeSettingID: { input: `gid://sagittarius/FlowTypeSetting/${number}`; output: `gid://sagittarius/FlowTypeSetting/${number}`; }
22
+ FunctionDefinitionID: { input: `gid://sagittarius/FunctionDefinition/${number}`; output: `gid://sagittarius/FunctionDefinition/${number}`; }
23
+ GenericCombinationStrategyID: { input: `gid://sagittarius/GenericCombinationStrategy/${number}`; output: `gid://sagittarius/GenericCombinationStrategy/${number}`; }
24
+ GenericMapperID: { input: `gid://sagittarius/GenericMapper/${number}`; output: `gid://sagittarius/GenericMapper/${number}`; }
25
+ GenericTypeID: { input: `gid://sagittarius/GenericType/${number}`; output: `gid://sagittarius/GenericType/${number}`; }
26
+ JSON: { input: any; output: any; }
27
+ NamespaceID: { input: `gid://sagittarius/Namespace/${number}`; output: `gid://sagittarius/Namespace/${number}`; }
28
+ NamespaceLicenseID: { input: `gid://sagittarius/NamespaceLicense/${number}`; output: `gid://sagittarius/NamespaceLicense/${number}`; }
29
+ NamespaceMemberID: { input: `gid://sagittarius/NamespaceMember/${number}`; output: `gid://sagittarius/NamespaceMember/${number}`; }
30
+ NamespaceMemberRoleID: { input: `gid://sagittarius/NamespaceMemberRole/${number}`; output: `gid://sagittarius/NamespaceMemberRole/${number}`; }
31
+ NamespaceProjectID: { input: `gid://sagittarius/NamespaceProject/${number}`; output: `gid://sagittarius/NamespaceProject/${number}`; }
32
+ NamespaceRoleID: { input: `gid://sagittarius/NamespaceRole/${number}`; output: `gid://sagittarius/NamespaceRole/${number}`; }
33
+ NodeFunctionID: { input: `gid://sagittarius/NodeFunction/${number}`; output: `gid://sagittarius/NodeFunction/${number}`; }
34
+ NodeParameterID: { input: `gid://sagittarius/NodeParameter/${number}`; output: `gid://sagittarius/NodeParameter/${number}`; }
35
+ OrganizationID: { input: `gid://sagittarius/Organization/${number}`; output: `gid://sagittarius/Organization/${number}`; }
36
+ ParameterDefinitionID: { input: `gid://sagittarius/ParameterDefinition/${number}`; output: `gid://sagittarius/ParameterDefinition/${number}`; }
37
+ ReferencePathID: { input: `gid://sagittarius/ReferencePath/${number}`; output: `gid://sagittarius/ReferencePath/${number}`; }
38
+ ReferenceValueID: { input: `gid://sagittarius/ReferenceValue/${number}`; output: `gid://sagittarius/ReferenceValue/${number}`; }
39
+ RuntimeFunctionDefinitionID: { input: `gid://sagittarius/RuntimeFunctionDefinition/${number}`; output: `gid://sagittarius/RuntimeFunctionDefinition/${number}`; }
40
+ RuntimeID: { input: `gid://sagittarius/Runtime/${number}`; output: `gid://sagittarius/Runtime/${number}`; }
41
+ RuntimeParameterDefinitionID: { input: `gid://sagittarius/RuntimeParameterDefinition/${number}`; output: `gid://sagittarius/RuntimeParameterDefinition/${number}`; }
42
+ Time: { input: string; output: string; }
43
+ TypesFlowTypeID: { input: `gid://sagittarius/TypesFlowType/${number}`; output: `gid://sagittarius/TypesFlowType/${number}`; }
44
+ UserID: { input: `gid://sagittarius/User/${number}`; output: `gid://sagittarius/User/${number}`; }
45
+ UserIdentityID: { input: `gid://sagittarius/UserIdentity/${number}`; output: `gid://sagittarius/UserIdentity/${number}`; }
46
+ UserSessionID: { input: `gid://sagittarius/UserSession/${number}`; output: `gid://sagittarius/UserSession/${number}`; }
45
47
  }
46
48
 
47
49
  /** Represents an active model error */
48
50
  export interface ActiveModelError {
49
51
  __typename?: 'ActiveModelError';
50
52
  /** The affected attribute on the model */
51
- attribute: Scalars['String']['output'];
53
+ attribute?: Maybe<Scalars['String']['output']>;
52
54
  /** The validation type that failed for the attribute */
53
- type: Scalars['String']['output'];
55
+ type?: Maybe<Scalars['String']['output']>;
54
56
  }
55
57
 
56
58
  /** Represents the application settings */
57
59
  export interface ApplicationSettings {
58
60
  __typename?: 'ApplicationSettings';
59
61
  /** Shows if organization creation is restricted to administrators */
60
- organizationCreationRestricted: Scalars['Boolean']['output'];
62
+ organizationCreationRestricted?: Maybe<Scalars['Boolean']['output']>;
61
63
  /** Shows if user registration is enabled */
62
- userRegistrationEnabled: Scalars['Boolean']['output'];
64
+ userRegistrationEnabled?: Maybe<Scalars['Boolean']['output']>;
63
65
  }
64
66
 
65
67
  /** Autogenerated input type of ApplicationSettingsUpdate */
@@ -80,7 +82,7 @@ export interface ApplicationSettingsUpdatePayload {
80
82
  /** A unique identifier for the client performing the mutation. */
81
83
  clientMutationId?: Maybe<Scalars['String']['output']>;
82
84
  /** Errors encountered during execution of the mutation. */
83
- errors: Array<Error>;
85
+ errors?: Maybe<Array<Error>>;
84
86
  }
85
87
 
86
88
  /** Objects that can present an authentication */
@@ -90,47 +92,233 @@ export type Authentication = UserSession;
90
92
  export interface DataType {
91
93
  __typename?: 'DataType';
92
94
  /** Time when this DataType was created */
93
- createdAt: Scalars['Time']['output'];
95
+ createdAt?: Maybe<Scalars['Time']['output']>;
96
+ /** Generic keys of the datatype */
97
+ genericKeys?: Maybe<Array<Scalars['String']['output']>>;
94
98
  /** Global ID of this DataType */
95
- id: Scalars['DataTypeID']['output'];
99
+ id?: Maybe<Scalars['DataTypeID']['output']>;
96
100
  /** The identifier scoped to the namespace */
97
- identifier: Scalars['String']['output'];
98
- /** The namespace where this datatype belongs to */
99
- namespace?: Maybe<Namespace>;
101
+ identifier?: Maybe<Scalars['String']['output']>;
102
+ /** Names of the flow type setting */
103
+ name?: Maybe<TranslationConnection>;
104
+ /** Rules of the datatype */
105
+ rules?: Maybe<DataTypeRuleConnection>;
106
+ /** The runtime where this datatype belongs to */
107
+ runtime?: Maybe<Runtime>;
100
108
  /** Time when this DataType was last updated */
101
- updatedAt: Scalars['Time']['output'];
109
+ updatedAt?: Maybe<Scalars['Time']['output']>;
102
110
  /** The type of the datatype */
103
- variant: DataTypeVariant;
111
+ variant?: Maybe<DataTypeVariant>;
112
+ }
113
+
114
+
115
+ /** Represents a DataType */
116
+ export interface DataTypeNameArgs {
117
+ after?: InputMaybe<Scalars['String']['input']>;
118
+ before?: InputMaybe<Scalars['String']['input']>;
119
+ first?: InputMaybe<Scalars['Int']['input']>;
120
+ last?: InputMaybe<Scalars['Int']['input']>;
121
+ }
122
+
123
+
124
+ /** Represents a DataType */
125
+ export interface DataTypeRulesArgs {
126
+ after?: InputMaybe<Scalars['String']['input']>;
127
+ before?: InputMaybe<Scalars['String']['input']>;
128
+ first?: InputMaybe<Scalars['Int']['input']>;
129
+ last?: InputMaybe<Scalars['Int']['input']>;
104
130
  }
105
131
 
106
132
  /** The connection type for DataType. */
107
133
  export interface DataTypeConnection {
108
134
  __typename?: 'DataTypeConnection';
109
135
  /** Total count of collection. */
110
- count: Scalars['Int']['output'];
136
+ count?: Maybe<Scalars['Int']['output']>;
111
137
  /** A list of edges. */
112
138
  edges?: Maybe<Array<Maybe<DataTypeEdge>>>;
113
139
  /** A list of nodes. */
114
140
  nodes?: Maybe<Array<Maybe<DataType>>>;
115
141
  /** Information to aid in pagination. */
116
- pageInfo: PageInfo;
142
+ pageInfo?: Maybe<PageInfo>;
117
143
  }
118
144
 
119
145
  /** An edge in a connection. */
120
146
  export interface DataTypeEdge {
121
147
  __typename?: 'DataTypeEdge';
122
148
  /** A cursor for use in pagination. */
123
- cursor: Scalars['String']['output'];
149
+ cursor?: Maybe<Scalars['String']['output']>;
124
150
  /** The item at the end of the edge. */
125
151
  node?: Maybe<DataType>;
126
152
  }
127
153
 
154
+ /** Represents a data type identifier. */
155
+ export interface DataTypeIdentifier {
156
+ __typename?: 'DataTypeIdentifier';
157
+ /** Time when this DataTypeIdentifier was created */
158
+ createdAt?: Maybe<Scalars['Time']['output']>;
159
+ /** The data type of the data type identifier. */
160
+ dataType?: Maybe<DataType>;
161
+ /** The generic key of the data type identifier. */
162
+ genericKey?: Maybe<Scalars['String']['output']>;
163
+ /** The generic type of the data type identifier. */
164
+ genericType?: Maybe<GenericType>;
165
+ /** Global ID of this DataTypeIdentifier */
166
+ id?: Maybe<Scalars['DataTypeIdentifierID']['output']>;
167
+ /** Time when this DataTypeIdentifier was last updated */
168
+ updatedAt?: Maybe<Scalars['Time']['output']>;
169
+ }
170
+
171
+ /** Input type for data type identifier */
172
+ export interface DataTypeIdentifierInput {
173
+ /** Data type ID */
174
+ dataTypeId?: InputMaybe<Scalars['DataTypeID']['input']>;
175
+ /** Generic key value */
176
+ genericKey?: InputMaybe<Scalars['String']['input']>;
177
+ /** Generic type information */
178
+ genericType?: InputMaybe<GenericTypeInput>;
179
+ }
180
+
181
+ /** Represents a rule that can be applied to a data type. */
182
+ export interface DataTypeRule {
183
+ __typename?: 'DataTypeRule';
184
+ /** The configuration of the rule */
185
+ config?: Maybe<DataTypeRulesConfig>;
186
+ /** Time when this DataTypeRule was created */
187
+ createdAt?: Maybe<Scalars['Time']['output']>;
188
+ /** Global ID of this DataTypeRule */
189
+ id?: Maybe<Scalars['DataTypeRuleID']['output']>;
190
+ /** Time when this DataTypeRule was last updated */
191
+ updatedAt?: Maybe<Scalars['Time']['output']>;
192
+ /** The type of the rule */
193
+ variant?: Maybe<DataTypeRulesVariant>;
194
+ }
195
+
196
+ /** The connection type for DataTypeRule. */
197
+ export interface DataTypeRuleConnection {
198
+ __typename?: 'DataTypeRuleConnection';
199
+ /** Total count of collection. */
200
+ count?: Maybe<Scalars['Int']['output']>;
201
+ /** A list of edges. */
202
+ edges?: Maybe<Array<Maybe<DataTypeRuleEdge>>>;
203
+ /** A list of nodes. */
204
+ nodes?: Maybe<Array<Maybe<DataTypeRule>>>;
205
+ /** Information to aid in pagination. */
206
+ pageInfo?: Maybe<PageInfo>;
207
+ }
208
+
209
+ /** An edge in a connection. */
210
+ export interface DataTypeRuleEdge {
211
+ __typename?: 'DataTypeRuleEdge';
212
+ /** A cursor for use in pagination. */
213
+ cursor?: Maybe<Scalars['String']['output']>;
214
+ /** The item at the end of the edge. */
215
+ node?: Maybe<DataTypeRule>;
216
+ }
217
+
218
+ /** Represents a rule that can be applied to a data type. */
219
+ export type DataTypeRulesConfig = DataTypeRulesContainsKeyConfig | DataTypeRulesContainsTypeConfig | DataTypeRulesInputTypesConfig | DataTypeRulesItemOfCollectionConfig | DataTypeRulesNumberRangeConfig | DataTypeRulesParentTypeConfig | DataTypeRulesRegexConfig | DataTypeRulesReturnTypeConfig;
220
+
221
+ /** Represents a rule that can be applied to a data type. */
222
+ export interface DataTypeRulesContainsKeyConfig {
223
+ __typename?: 'DataTypeRulesContainsKeyConfig';
224
+ /** The identifier of the data type this rule belongs to */
225
+ dataTypeIdentifier?: Maybe<DataTypeIdentifier>;
226
+ /** The key of the rule */
227
+ key?: Maybe<Scalars['String']['output']>;
228
+ }
229
+
230
+ /** Represents a rule that can be applied to a data type. */
231
+ export interface DataTypeRulesContainsTypeConfig {
232
+ __typename?: 'DataTypeRulesContainsTypeConfig';
233
+ /** The identifier of the data type this rule belongs to */
234
+ dataTypeIdentifier?: Maybe<DataTypeIdentifier>;
235
+ }
236
+
237
+ /** Represents a subtype of input type configuration for a input data type. */
238
+ export interface DataTypeRulesInputTypeConfig {
239
+ __typename?: 'DataTypeRulesInputTypeConfig';
240
+ /** The identifier of the data type this input type belongs to */
241
+ dataTypeIdentifier?: Maybe<DataTypeIdentifier>;
242
+ /** The input identifier that this configuration applies to */
243
+ inputIdentifier?: Maybe<Scalars['String']['output']>;
244
+ }
245
+
246
+ /** Represents a rule that can be applied to a data type. */
247
+ export interface DataTypeRulesInputTypesConfig {
248
+ __typename?: 'DataTypeRulesInputTypesConfig';
249
+ /** The input types that can be used in this data type rule */
250
+ inputTypes?: Maybe<Array<DataTypeRulesInputTypeConfig>>;
251
+ }
252
+
253
+ /** Represents a rule that can be applied to a data type. */
254
+ export interface DataTypeRulesItemOfCollectionConfig {
255
+ __typename?: 'DataTypeRulesItemOfCollectionConfig';
256
+ /** The items that can be configured for this rule. */
257
+ items?: Maybe<Array<Scalars['JSON']['output']>>;
258
+ }
259
+
260
+ /** Represents a rule that can be applied to a data type. */
261
+ export interface DataTypeRulesNumberRangeConfig {
262
+ __typename?: 'DataTypeRulesNumberRangeConfig';
263
+ /** The minimum value of the range */
264
+ from?: Maybe<Scalars['Int']['output']>;
265
+ /** The step value for the range, if applicable */
266
+ steps?: Maybe<Scalars['Int']['output']>;
267
+ /** The maximum value of the range */
268
+ to?: Maybe<Scalars['Int']['output']>;
269
+ }
270
+
271
+ /** Represents a rule that can be applied to a data type. */
272
+ export interface DataTypeRulesParentTypeConfig {
273
+ __typename?: 'DataTypeRulesParentTypeConfig';
274
+ /** The data type identifier for the parent type. */
275
+ dataTypeIdentifier?: Maybe<DataTypeIdentifier>;
276
+ }
277
+
278
+ /** Represents a rule that can be applied to a data type. */
279
+ export interface DataTypeRulesRegexConfig {
280
+ __typename?: 'DataTypeRulesRegexConfig';
281
+ /** The regex pattern to match against the data type value. */
282
+ pattern?: Maybe<Scalars['String']['output']>;
283
+ }
284
+
285
+ /** Represents a rule that can be applied to a data type. */
286
+ export interface DataTypeRulesReturnTypeConfig {
287
+ __typename?: 'DataTypeRulesReturnTypeConfig';
288
+ /** The data type identifier for the return type. */
289
+ dataTypeIdentifier?: Maybe<DataTypeIdentifier>;
290
+ }
291
+
292
+ /** The type of rule that can be applied to a data type. */
293
+ export const enum DataTypeRulesVariant {
294
+ /** The rule checks if a key is present in the data type. */
295
+ ContainsKey = 'CONTAINS_KEY',
296
+ /** The rule checks if a specific type is present in the data type. */
297
+ ContainsType = 'CONTAINS_TYPE',
298
+ /** The rule checks if the data type matches a specific input type. */
299
+ InputType = 'INPUT_TYPE',
300
+ /** The rule checks if an item is part of a collection in the data type. */
301
+ ItemOfCollection = 'ITEM_OF_COLLECTION',
302
+ /** The rule checks if a number falls within a specified range. */
303
+ NumberRange = 'NUMBER_RANGE',
304
+ /** The rule checks if the data type is a child of a specific parent type. */
305
+ ParentType = 'PARENT_TYPE',
306
+ /** The rule checks if a string matches a specified regular expression. */
307
+ Regex = 'REGEX',
308
+ /** The rule checks if the data type matches a specific return type. */
309
+ ReturnType = 'RETURN_TYPE'
310
+ }
311
+
128
312
  /** Represent all available types of a datatype */
129
- export enum DataTypeVariant {
313
+ export const enum DataTypeVariant {
130
314
  /** Represents an array */
131
315
  Array = 'ARRAY',
132
316
  /** Represents an data type containing a data type */
133
317
  DataType = 'DATA_TYPE',
318
+ /** Represents a error */
319
+ Error = 'ERROR',
320
+ /** Represents a node */
321
+ Node = 'NODE',
134
322
  /** Represents an object */
135
323
  Object = 'OBJECT',
136
324
  /** Represents a primitive datatype */
@@ -139,6 +327,9 @@ export enum DataTypeVariant {
139
327
  Type = 'TYPE'
140
328
  }
141
329
 
330
+ /** Represents a detailed error with either a message or an active model error */
331
+ export type DetailedError = ActiveModelError | FlowValidationError | MessageError;
332
+
142
333
  /** Autogenerated input type of Echo */
143
334
  export interface EchoInput {
144
335
  /** A unique identifier for the client performing the mutation. */
@@ -153,13 +344,602 @@ export interface EchoPayload {
153
344
  /** A unique identifier for the client performing the mutation. */
154
345
  clientMutationId?: Maybe<Scalars['String']['output']>;
155
346
  /** Errors encountered during execution of the mutation. */
156
- errors: Array<Error>;
347
+ errors?: Maybe<Array<Error>>;
157
348
  /** Message returned to the user. */
158
349
  message?: Maybe<Scalars['String']['output']>;
159
350
  }
160
351
 
161
352
  /** Objects that can present an error */
162
- 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 is invalid because of active model errors */
402
+ InvalidFlow = 'INVALID_FLOW',
403
+ /** The flow setting is invalid because of active model errors */
404
+ InvalidFlowSetting = 'INVALID_FLOW_SETTING',
405
+ /** Invalid login data provided */
406
+ InvalidLoginData = 'INVALID_LOGIN_DATA',
407
+ /** The namespace license is invalid because of active model errors */
408
+ InvalidNamespaceLicense = 'INVALID_NAMESPACE_LICENSE',
409
+ /** The namespace member is invalid because of active model errors */
410
+ InvalidNamespaceMember = 'INVALID_NAMESPACE_MEMBER',
411
+ /** The namespace project is invalid because of active model errors */
412
+ InvalidNamespaceProject = 'INVALID_NAMESPACE_PROJECT',
413
+ /** The namespace role is invalid because of active model errors */
414
+ InvalidNamespaceRole = 'INVALID_NAMESPACE_ROLE',
415
+ /** The organization is invalid because of active model errors */
416
+ InvalidOrganization = 'INVALID_ORGANIZATION',
417
+ /** The provided password repeat does not match the password */
418
+ InvalidPasswordRepeat = 'INVALID_PASSWORD_REPEAT',
419
+ /** The runtime is invalid because of active model errors */
420
+ InvalidRuntime = 'INVALID_RUNTIME',
421
+ /** Invalid setting provided */
422
+ InvalidSetting = 'INVALID_SETTING',
423
+ /** The TOTP secret is invalid or cannot be verified */
424
+ InvalidTotpSecret = 'INVALID_TOTP_SECRET',
425
+ /** The user is invalid because of active model errors */
426
+ InvalidUser = 'INVALID_USER',
427
+ /** The user identity is invalid because of active model errors */
428
+ InvalidUserIdentity = 'INVALID_USER_IDENTITY',
429
+ /** The user session is invalid because of active model errors */
430
+ InvalidUserSession = 'INVALID_USER_SESSION',
431
+ /** Invalid verification code provided */
432
+ InvalidVerificationCode = 'INVALID_VERIFICATION_CODE',
433
+ /** The namespace license with the given identifier was not found */
434
+ LicenseNotFound = 'LICENSE_NOT_FOUND',
435
+ /** Failed to load user identity from external provider */
436
+ LoadingIdentityFailed = 'LOADING_IDENTITY_FAILED',
437
+ /** Invalid MFA data provided */
438
+ MfaFailed = 'MFA_FAILED',
439
+ /** MFA is required */
440
+ MfaRequired = 'MFA_REQUIRED',
441
+ /** The primary runtime has more definitions than this one */
442
+ MissingDefinition = 'MISSING_DEFINITION',
443
+ /** This external identity is missing data */
444
+ MissingIdentityData = 'MISSING_IDENTITY_DATA',
445
+ /** Not all required parameters are present */
446
+ MissingParameter = 'MISSING_PARAMETER',
447
+ /** The user is not permitted to perform this operation */
448
+ MissingPermission = 'MISSING_PERMISSION',
449
+ /** The project is missing a primary runtime */
450
+ MissingPrimaryRuntime = 'MISSING_PRIMARY_RUNTIME',
451
+ /** The namespace member with the given identifier was not found */
452
+ NamespaceMemberNotFound = 'NAMESPACE_MEMBER_NOT_FOUND',
453
+ /** The namespace with the given identifier was not found */
454
+ NamespaceNotFound = 'NAMESPACE_NOT_FOUND',
455
+ /** The namespace project with the given identifier was not found */
456
+ NamespaceProjectNotFound = 'NAMESPACE_PROJECT_NOT_FOUND',
457
+ /** The namespace role with the given identifier was not found */
458
+ NamespaceRoleNotFound = 'NAMESPACE_ROLE_NOT_FOUND',
459
+ /** There are no free license seats to complete this operation */
460
+ NoFreeLicenseSeats = 'NO_FREE_LICENSE_SEATS',
461
+ /** The project does not have a primary runtime */
462
+ NoPrimaryRuntime = 'NO_PRIMARY_RUNTIME',
463
+ /** The organization with the given identifier was not found */
464
+ OrganizationNotFound = 'ORGANIZATION_NOT_FOUND',
465
+ /** The primary runtime has a newer definition than this one */
466
+ OutdatedDefinition = 'OUTDATED_DEFINITION',
467
+ /** @deprecated Outdated concept */
468
+ PrimaryLevelNotFound = 'PRIMARY_LEVEL_NOT_FOUND',
469
+ /** The namespace project with the given identifier was not found */
470
+ ProjectNotFound = 'PROJECT_NOT_FOUND',
471
+ /** Self-registration is disabled */
472
+ RegistrationDisabled = 'REGISTRATION_DISABLED',
473
+ /** Resources are from different runtimes */
474
+ RuntimeMismatch = 'RUNTIME_MISMATCH',
475
+ /** The runtime with the given identifier was not found */
476
+ RuntimeNotFound = 'RUNTIME_NOT_FOUND',
477
+ /** @deprecated Outdated concept */
478
+ SecondaryLevelNotFound = 'SECONDARY_LEVEL_NOT_FOUND',
479
+ /** @deprecated Outdated concept */
480
+ TertiaryLevelExceedsParameters = 'TERTIARY_LEVEL_EXCEEDS_PARAMETERS',
481
+ /** This user already has TOTP set up */
482
+ TotpSecretAlreadySet = 'TOTP_SECRET_ALREADY_SET',
483
+ /** The user is not permitted to modify this field */
484
+ UnmodifiableField = 'UNMODIFIABLE_FIELD',
485
+ /** The user with the given identifier was not found */
486
+ UserNotFound = 'USER_NOT_FOUND',
487
+ /** The user session with the given identifier was not found */
488
+ UserSessionNotFound = 'USER_SESSION_NOT_FOUND',
489
+ /** Invalid TOTP code provided */
490
+ WrongTotp = 'WRONG_TOTP'
491
+ }
492
+
493
+ /** Represents a flow */
494
+ export interface Flow {
495
+ __typename?: 'Flow';
496
+ /** Time when this Flow was created */
497
+ createdAt?: Maybe<Scalars['Time']['output']>;
498
+ /** Global ID of this Flow */
499
+ id?: Maybe<Scalars['FlowID']['output']>;
500
+ /** The input data type of the flow */
501
+ inputType?: Maybe<DataType>;
502
+ /** Name of the flow */
503
+ name?: Maybe<Scalars['String']['output']>;
504
+ /** Nodes of the flow */
505
+ nodes?: Maybe<NodeFunctionConnection>;
506
+ /** The return data type of the flow */
507
+ returnType?: Maybe<DataType>;
508
+ /** The settings of the flow */
509
+ settings?: Maybe<FlowSettingConnection>;
510
+ /** The ID of the starting node of the flow */
511
+ startingNodeId?: Maybe<Scalars['NodeFunctionID']['output']>;
512
+ /** The flow type of the flow */
513
+ type?: Maybe<FlowType>;
514
+ /** Time when this Flow was last updated */
515
+ updatedAt?: Maybe<Scalars['Time']['output']>;
516
+ /** Abilities for the current user on this Flow */
517
+ userAbilities?: Maybe<FlowUserAbilities>;
518
+ }
519
+
520
+
521
+ /** Represents a flow */
522
+ export interface FlowNodesArgs {
523
+ after?: InputMaybe<Scalars['String']['input']>;
524
+ before?: InputMaybe<Scalars['String']['input']>;
525
+ first?: InputMaybe<Scalars['Int']['input']>;
526
+ last?: InputMaybe<Scalars['Int']['input']>;
527
+ }
528
+
529
+
530
+ /** Represents a flow */
531
+ export interface FlowSettingsArgs {
532
+ after?: InputMaybe<Scalars['String']['input']>;
533
+ before?: InputMaybe<Scalars['String']['input']>;
534
+ first?: InputMaybe<Scalars['Int']['input']>;
535
+ last?: InputMaybe<Scalars['Int']['input']>;
536
+ }
537
+
538
+ /** The connection type for Flow. */
539
+ export interface FlowConnection {
540
+ __typename?: 'FlowConnection';
541
+ /** Total count of collection. */
542
+ count?: Maybe<Scalars['Int']['output']>;
543
+ /** A list of edges. */
544
+ edges?: Maybe<Array<Maybe<FlowEdge>>>;
545
+ /** A list of nodes. */
546
+ nodes?: Maybe<Array<Maybe<Flow>>>;
547
+ /** Information to aid in pagination. */
548
+ pageInfo?: Maybe<PageInfo>;
549
+ }
550
+
551
+ /** An edge in a connection. */
552
+ export interface FlowEdge {
553
+ __typename?: 'FlowEdge';
554
+ /** A cursor for use in pagination. */
555
+ cursor?: Maybe<Scalars['String']['output']>;
556
+ /** The item at the end of the edge. */
557
+ node?: Maybe<Flow>;
558
+ }
559
+
560
+ /** Input type for creating or updating a flow */
561
+ export interface FlowInput {
562
+ /** The name of the flow */
563
+ name: Scalars['String']['input'];
564
+ /** The node functions of the flow */
565
+ nodes: Array<NodeFunctionInput>;
566
+ /** The settings of the flow */
567
+ settings?: InputMaybe<Array<FlowSettingInput>>;
568
+ /** The starting node of the flow */
569
+ startingNodeId: Scalars['NodeFunctionID']['input'];
570
+ /** The identifier of the flow type */
571
+ type: Scalars['FlowTypeID']['input'];
572
+ }
573
+
574
+ /** Represents a flow setting */
575
+ export interface FlowSetting {
576
+ __typename?: 'FlowSetting';
577
+ /** Time when this FlowSetting was created */
578
+ createdAt?: Maybe<Scalars['Time']['output']>;
579
+ /** The identifier of the flow setting */
580
+ flowSettingIdentifier?: Maybe<Scalars['String']['output']>;
581
+ /** Global ID of this FlowSetting */
582
+ id?: Maybe<Scalars['FlowSettingID']['output']>;
583
+ /** Time when this FlowSetting was last updated */
584
+ updatedAt?: Maybe<Scalars['Time']['output']>;
585
+ /** The value of the flow setting */
586
+ value?: Maybe<Scalars['JSON']['output']>;
587
+ }
588
+
589
+ /** The connection type for FlowSetting. */
590
+ export interface FlowSettingConnection {
591
+ __typename?: 'FlowSettingConnection';
592
+ /** Total count of collection. */
593
+ count?: Maybe<Scalars['Int']['output']>;
594
+ /** A list of edges. */
595
+ edges?: Maybe<Array<Maybe<FlowSettingEdge>>>;
596
+ /** A list of nodes. */
597
+ nodes?: Maybe<Array<Maybe<FlowSetting>>>;
598
+ /** Information to aid in pagination. */
599
+ pageInfo?: Maybe<PageInfo>;
600
+ }
601
+
602
+ /** An edge in a connection. */
603
+ export interface FlowSettingEdge {
604
+ __typename?: 'FlowSettingEdge';
605
+ /** A cursor for use in pagination. */
606
+ cursor?: Maybe<Scalars['String']['output']>;
607
+ /** The item at the end of the edge. */
608
+ node?: Maybe<FlowSetting>;
609
+ }
610
+
611
+ /** Input type for flow settings */
612
+ export interface FlowSettingInput {
613
+ /** The identifier (not database id) of the flow setting */
614
+ flowSettingIdentifier: Scalars['String']['input'];
615
+ /** The value of the flow setting */
616
+ value: Scalars['JSON']['input'];
617
+ }
618
+
619
+ /** Represents a flow type */
620
+ export interface FlowType {
621
+ __typename?: 'FlowType';
622
+ /** Time when this FlowType was created */
623
+ createdAt?: Maybe<Scalars['Time']['output']>;
624
+ /** Descriptions of the flow type */
625
+ descriptions?: Maybe<TranslationConnection>;
626
+ /** Editable status of the flow type */
627
+ editable?: Maybe<Scalars['Boolean']['output']>;
628
+ /** Flow type settings of the flow type */
629
+ flowTypeSettings?: Maybe<Array<FlowTypeSetting>>;
630
+ /** Global ID of this FlowType */
631
+ id?: Maybe<Scalars['TypesFlowTypeID']['output']>;
632
+ /** Identifier of the flow type */
633
+ identifier?: Maybe<Scalars['String']['output']>;
634
+ /** Input type of the flow type */
635
+ inputType?: Maybe<DataType>;
636
+ /** Names of the flow type */
637
+ names?: Maybe<TranslationConnection>;
638
+ /** Return type of the flow type */
639
+ returnType?: Maybe<DataType>;
640
+ /** Time when this FlowType was last updated */
641
+ updatedAt?: Maybe<Scalars['Time']['output']>;
642
+ }
643
+
644
+
645
+ /** Represents a flow type */
646
+ export interface FlowTypeDescriptionsArgs {
647
+ after?: InputMaybe<Scalars['String']['input']>;
648
+ before?: InputMaybe<Scalars['String']['input']>;
649
+ first?: InputMaybe<Scalars['Int']['input']>;
650
+ last?: InputMaybe<Scalars['Int']['input']>;
651
+ }
652
+
653
+
654
+ /** Represents a flow type */
655
+ export interface FlowTypeNamesArgs {
656
+ after?: InputMaybe<Scalars['String']['input']>;
657
+ before?: InputMaybe<Scalars['String']['input']>;
658
+ first?: InputMaybe<Scalars['Int']['input']>;
659
+ last?: InputMaybe<Scalars['Int']['input']>;
660
+ }
661
+
662
+ /** The connection type for FlowType. */
663
+ export interface FlowTypeConnection {
664
+ __typename?: 'FlowTypeConnection';
665
+ /** Total count of collection. */
666
+ count?: Maybe<Scalars['Int']['output']>;
667
+ /** A list of edges. */
668
+ edges?: Maybe<Array<Maybe<FlowTypeEdge>>>;
669
+ /** A list of nodes. */
670
+ nodes?: Maybe<Array<Maybe<FlowType>>>;
671
+ /** Information to aid in pagination. */
672
+ pageInfo?: Maybe<PageInfo>;
673
+ }
674
+
675
+ /** An edge in a connection. */
676
+ export interface FlowTypeEdge {
677
+ __typename?: 'FlowTypeEdge';
678
+ /** A cursor for use in pagination. */
679
+ cursor?: Maybe<Scalars['String']['output']>;
680
+ /** The item at the end of the edge. */
681
+ node?: Maybe<FlowType>;
682
+ }
683
+
684
+ /** Represents a flow type setting */
685
+ export interface FlowTypeSetting {
686
+ __typename?: 'FlowTypeSetting';
687
+ /** Time when this FlowTypeSetting was created */
688
+ createdAt?: Maybe<Scalars['Time']['output']>;
689
+ /** Data type of the flow type setting */
690
+ dataType?: Maybe<DataType>;
691
+ /** Descriptions of the flow type setting */
692
+ descriptions?: Maybe<TranslationConnection>;
693
+ /** Flow type of the flow type setting */
694
+ flowType?: Maybe<FlowType>;
695
+ /** Global ID of this FlowTypeSetting */
696
+ id?: Maybe<Scalars['FlowTypeSettingID']['output']>;
697
+ /** Identifier of the flow type setting */
698
+ identifier?: Maybe<Scalars['String']['output']>;
699
+ /** Names of the flow type setting */
700
+ names?: Maybe<TranslationConnection>;
701
+ /** Unique status of the flow type setting */
702
+ unique?: Maybe<Scalars['Boolean']['output']>;
703
+ /** Time when this FlowTypeSetting was last updated */
704
+ updatedAt?: Maybe<Scalars['Time']['output']>;
705
+ }
706
+
707
+
708
+ /** Represents a flow type setting */
709
+ export interface FlowTypeSettingDescriptionsArgs {
710
+ after?: InputMaybe<Scalars['String']['input']>;
711
+ before?: InputMaybe<Scalars['String']['input']>;
712
+ first?: InputMaybe<Scalars['Int']['input']>;
713
+ last?: InputMaybe<Scalars['Int']['input']>;
714
+ }
715
+
716
+
717
+ /** Represents a flow type setting */
718
+ export interface FlowTypeSettingNamesArgs {
719
+ after?: InputMaybe<Scalars['String']['input']>;
720
+ before?: InputMaybe<Scalars['String']['input']>;
721
+ first?: InputMaybe<Scalars['Int']['input']>;
722
+ last?: InputMaybe<Scalars['Int']['input']>;
723
+ }
724
+
725
+ /** Abilities for the current user on this Flow */
726
+ export interface FlowUserAbilities {
727
+ __typename?: 'FlowUserAbilities';
728
+ /** Shows if the current user has the `delete_flow` ability on this Flow */
729
+ deleteFlow?: Maybe<Scalars['Boolean']['output']>;
730
+ }
731
+
732
+ /** Represents a flow validation error */
733
+ export interface FlowValidationError {
734
+ __typename?: 'FlowValidationError';
735
+ /** Additional details about the validation error */
736
+ details?: Maybe<ActiveModelError>;
737
+ /** The code representing the validation error type */
738
+ errorCode?: Maybe<FlowValidationErrorCodeEnum>;
739
+ /** The severity of the validation error */
740
+ severity?: Maybe<FlowValidationSeverityEnum>;
741
+ }
742
+
743
+ /** Represents the available error responses */
744
+ export const enum FlowValidationErrorCodeEnum {
745
+ /** The generic key for the data type identifier was not found. */
746
+ DataTypeIdentifierGenericKeyNotFound = 'DATA_TYPE_IDENTIFIER_GENERIC_KEY_NOT_FOUND',
747
+ /** The data type identifier runtime does not match the flow type runtime. */
748
+ DataTypeIdentifierRuntimeMismatch = 'DATA_TYPE_IDENTIFIER_RUNTIME_MISMATCH',
749
+ /** The data type rule model is invalid. */
750
+ DataTypeRuleModelInvalid = 'DATA_TYPE_RULE_MODEL_INVALID',
751
+ /** The data type runtime does not match the flow type runtime. */
752
+ DataTypeRuntimeMismatch = 'DATA_TYPE_RUNTIME_MISMATCH',
753
+ /** The flow setting model is invalid. */
754
+ FlowSettingModelInvalid = 'FLOW_SETTING_MODEL_INVALID',
755
+ /** The flow type runtime does not match the project primary runtime. */
756
+ FlowTypeRuntimeMismatch = 'FLOW_TYPE_RUNTIME_MISMATCH',
757
+ /** The node function runtime does not match the project primary runtime. */
758
+ NodeFunctionRuntimeMismatch = 'NODE_FUNCTION_RUNTIME_MISMATCH',
759
+ /** The project does not have a primary runtime set. */
760
+ NoPrimaryRuntime = 'NO_PRIMARY_RUNTIME'
761
+ }
762
+
763
+ /** Represents the severity of a flow validation error */
764
+ export const enum FlowValidationSeverityEnum {
765
+ /** A blocking validation error */
766
+ Error = 'ERROR',
767
+ /** A minor typographical issue can also be blocking */
768
+ Typo = 'TYPO',
769
+ /** A non-blocking validation warning */
770
+ Warning = 'WARNING',
771
+ /** A weak validation issue that may not need to be addressed */
772
+ Weak = 'WEAK'
773
+ }
774
+
775
+ /** Represents a function definition */
776
+ export interface FunctionDefinition {
777
+ __typename?: 'FunctionDefinition';
778
+ /** Time when this FunctionDefinition was created */
779
+ createdAt?: Maybe<Scalars['Time']['output']>;
780
+ /** Deprecation message of the function */
781
+ deprecationMessages?: Maybe<TranslationConnection>;
782
+ /** Description of the function */
783
+ descriptions?: Maybe<TranslationConnection>;
784
+ /** Documentation of the function */
785
+ documentations?: Maybe<TranslationConnection>;
786
+ /** Generic keys of the function */
787
+ genericKeys?: Maybe<Array<Scalars['String']['output']>>;
788
+ /** Global ID of this FunctionDefinition */
789
+ id?: Maybe<Scalars['FunctionDefinitionID']['output']>;
790
+ /** Identifier of the function */
791
+ identifier?: Maybe<Scalars['String']['output']>;
792
+ /** Name of the function */
793
+ names?: Maybe<TranslationConnection>;
794
+ /** Parameters of the function */
795
+ parameterDefinitions?: Maybe<ParameterDefinitionConnection>;
796
+ /** Return type of the function */
797
+ returnType?: Maybe<DataTypeIdentifier>;
798
+ /** Runtime function definition */
799
+ runtimeFunctionDefinition?: Maybe<RuntimeFunctionDefinition>;
800
+ /** Indicates if the function can throw an error */
801
+ throwsError?: Maybe<Scalars['Boolean']['output']>;
802
+ /** Time when this FunctionDefinition was last updated */
803
+ updatedAt?: Maybe<Scalars['Time']['output']>;
804
+ }
805
+
806
+
807
+ /** Represents a function definition */
808
+ export interface FunctionDefinitionDeprecationMessagesArgs {
809
+ after?: InputMaybe<Scalars['String']['input']>;
810
+ before?: InputMaybe<Scalars['String']['input']>;
811
+ first?: InputMaybe<Scalars['Int']['input']>;
812
+ last?: InputMaybe<Scalars['Int']['input']>;
813
+ }
814
+
815
+
816
+ /** Represents a function definition */
817
+ export interface FunctionDefinitionDescriptionsArgs {
818
+ after?: InputMaybe<Scalars['String']['input']>;
819
+ before?: InputMaybe<Scalars['String']['input']>;
820
+ first?: InputMaybe<Scalars['Int']['input']>;
821
+ last?: InputMaybe<Scalars['Int']['input']>;
822
+ }
823
+
824
+
825
+ /** Represents a function definition */
826
+ export interface FunctionDefinitionDocumentationsArgs {
827
+ after?: InputMaybe<Scalars['String']['input']>;
828
+ before?: InputMaybe<Scalars['String']['input']>;
829
+ first?: InputMaybe<Scalars['Int']['input']>;
830
+ last?: InputMaybe<Scalars['Int']['input']>;
831
+ }
832
+
833
+
834
+ /** Represents a function definition */
835
+ export interface FunctionDefinitionNamesArgs {
836
+ after?: InputMaybe<Scalars['String']['input']>;
837
+ before?: InputMaybe<Scalars['String']['input']>;
838
+ first?: InputMaybe<Scalars['Int']['input']>;
839
+ last?: InputMaybe<Scalars['Int']['input']>;
840
+ }
841
+
842
+
843
+ /** Represents a function definition */
844
+ export interface FunctionDefinitionParameterDefinitionsArgs {
845
+ after?: InputMaybe<Scalars['String']['input']>;
846
+ before?: InputMaybe<Scalars['String']['input']>;
847
+ first?: InputMaybe<Scalars['Int']['input']>;
848
+ last?: InputMaybe<Scalars['Int']['input']>;
849
+ }
850
+
851
+ /** The connection type for FunctionDefinition. */
852
+ export interface FunctionDefinitionConnection {
853
+ __typename?: 'FunctionDefinitionConnection';
854
+ /** Total count of collection. */
855
+ count?: Maybe<Scalars['Int']['output']>;
856
+ /** A list of edges. */
857
+ edges?: Maybe<Array<Maybe<FunctionDefinitionEdge>>>;
858
+ /** A list of nodes. */
859
+ nodes?: Maybe<Array<Maybe<FunctionDefinition>>>;
860
+ /** Information to aid in pagination. */
861
+ pageInfo?: Maybe<PageInfo>;
862
+ }
863
+
864
+ /** An edge in a connection. */
865
+ export interface FunctionDefinitionEdge {
866
+ __typename?: 'FunctionDefinitionEdge';
867
+ /** A cursor for use in pagination. */
868
+ cursor?: Maybe<Scalars['String']['output']>;
869
+ /** The item at the end of the edge. */
870
+ node?: Maybe<FunctionDefinition>;
871
+ }
872
+
873
+ /** Represents a combination strategy with AND/OR logic used by a generic mapper. */
874
+ export interface GenericCombinationStrategy {
875
+ __typename?: 'GenericCombinationStrategy';
876
+ /** Time when this GenericCombinationStrategy was created */
877
+ createdAt?: Maybe<Scalars['Time']['output']>;
878
+ /** The associated generic mapper, if any. */
879
+ genericMapper?: Maybe<GenericMapper>;
880
+ /** Global ID of this GenericCombinationStrategy */
881
+ id?: Maybe<Scalars['GenericCombinationStrategyID']['output']>;
882
+ /** The combination type ('AND' or 'OR'). */
883
+ type?: Maybe<GenericCombinationStrategyType>;
884
+ /** Time when this GenericCombinationStrategy was last updated */
885
+ updatedAt?: Maybe<Scalars['Time']['output']>;
886
+ }
887
+
888
+ /** The available combination strategy types. */
889
+ export const enum GenericCombinationStrategyType {
890
+ /** Represents a logical AND combination. */
891
+ And = 'AND',
892
+ /** Represents a logical OR combination. */
893
+ Or = 'OR'
894
+ }
895
+
896
+ /** Represents a mapping between a source data type and a target key for generic values. */
897
+ export interface GenericMapper {
898
+ __typename?: 'GenericMapper';
899
+ /** Time when this GenericMapper was created */
900
+ createdAt?: Maybe<Scalars['Time']['output']>;
901
+ /** Combination strategies associated with this generic mapper. */
902
+ genericCombinationStrategies?: Maybe<Array<GenericCombinationStrategy>>;
903
+ /** Global ID of this GenericMapper */
904
+ id?: Maybe<Scalars['GenericMapperID']['output']>;
905
+ /** The source data type identifier. */
906
+ sourceDataTypeIdentifiers?: Maybe<Array<DataTypeIdentifier>>;
907
+ /** The target key for the generic value. */
908
+ target?: Maybe<Scalars['String']['output']>;
909
+ /** Time when this GenericMapper was last updated */
910
+ updatedAt?: Maybe<Scalars['Time']['output']>;
911
+ }
912
+
913
+ /** Input type for generic mappers */
914
+ export interface GenericMapperInput {
915
+ /** The source data type identifier for the mapper */
916
+ sourceDataTypeIdentifiers: Array<DataTypeIdentifierInput>;
917
+ /** The target data type identifier for the mapper */
918
+ target: Scalars['String']['input'];
919
+ }
920
+
921
+ /** Represents a generic type that can be used in various contexts. */
922
+ export interface GenericType {
923
+ __typename?: 'GenericType';
924
+ /** Time when this GenericType was created */
925
+ createdAt?: Maybe<Scalars['Time']['output']>;
926
+ /** The data type associated with this generic type. */
927
+ dataType?: Maybe<DataType>;
928
+ /** The mappers associated with this generic type. */
929
+ genericMappers?: Maybe<Array<GenericMapper>>;
930
+ /** Global ID of this GenericType */
931
+ id?: Maybe<Scalars['GenericTypeID']['output']>;
932
+ /** Time when this GenericType was last updated */
933
+ updatedAt?: Maybe<Scalars['Time']['output']>;
934
+ }
935
+
936
+ /** Input type for generic type operations. */
937
+ export interface GenericTypeInput {
938
+ /** The data type associated with this generic type. */
939
+ dataTypeId: Scalars['DataTypeID']['input'];
940
+ /** The mappers associated with this generic type. */
941
+ genericMappers: Array<GenericMapperInput>;
942
+ }
163
943
 
164
944
  /** Represents the input for external user identity validation */
165
945
  export interface IdentityInput {
@@ -167,11 +947,48 @@ export interface IdentityInput {
167
947
  code?: InputMaybe<Scalars['String']['input']>;
168
948
  }
169
949
 
950
+ /** Abilities for the current user on this Instance */
951
+ export interface InstanceUserAbilities {
952
+ __typename?: 'InstanceUserAbilities';
953
+ /** Shows if the current user has the `create_organization` ability on this Instance */
954
+ createOrganization?: Maybe<Scalars['Boolean']['output']>;
955
+ /** Shows if the current user has the `create_runtime` ability on this Instance */
956
+ createRuntime?: Maybe<Scalars['Boolean']['output']>;
957
+ /** Shows if the current user has the `delete_runtime` ability on this Instance */
958
+ deleteRuntime?: Maybe<Scalars['Boolean']['output']>;
959
+ /** Shows if the current user has the `rotate_runtime_token` ability on this Instance */
960
+ rotateRuntimeToken?: Maybe<Scalars['Boolean']['output']>;
961
+ /** Shows if the current user has the `update_application_setting` ability on this Instance */
962
+ updateApplicationSetting?: Maybe<Scalars['Boolean']['output']>;
963
+ /** Shows if the current user has the `update_runtime` ability on this Instance */
964
+ updateRuntime?: Maybe<Scalars['Boolean']['output']>;
965
+ }
966
+
967
+ /** Represents a literal value, such as a string or number. */
968
+ export interface LiteralValue {
969
+ __typename?: 'LiteralValue';
970
+ /** Time when this LiteralValue was created */
971
+ createdAt?: Maybe<Scalars['Time']['output']>;
972
+ /** Time when this LiteralValue was last updated */
973
+ updatedAt?: Maybe<Scalars['Time']['output']>;
974
+ /** The literal value itself as JSON. */
975
+ value?: Maybe<Scalars['JSON']['output']>;
976
+ }
977
+
170
978
  /** Represents an error message */
171
979
  export interface MessageError {
172
980
  __typename?: 'MessageError';
173
981
  /** The message provided from the error */
174
- message: Scalars['String']['output'];
982
+ message?: Maybe<Scalars['String']['output']>;
983
+ }
984
+
985
+ /** Application metadata */
986
+ export interface Metadata {
987
+ __typename?: 'Metadata';
988
+ /** List of loaded extensions */
989
+ extensions?: Maybe<Array<Scalars['String']['output']>>;
990
+ /** Application version */
991
+ version?: Maybe<Scalars['String']['output']>;
175
992
  }
176
993
 
177
994
  /** Represents the input for mfa authentication */
@@ -183,7 +1000,7 @@ export interface MfaInput {
183
1000
  }
184
1001
 
185
1002
  /** Represent all available types to authenticate with mfa */
186
- export enum MfaType {
1003
+ export const enum MfaType {
187
1004
  /** Single use backup code */
188
1005
  BackupCode = 'BACKUP_CODE',
189
1006
  /** Time based onetime password */
@@ -200,11 +1017,12 @@ export interface Mutation {
200
1017
  *
201
1018
  * This is expected to be used for testing of endpoints, to verify
202
1019
  * that a user has mutation access.
1020
+ *
203
1021
  */
204
1022
  echo?: Maybe<EchoPayload>;
205
- /** Create a new namespace license. */
1023
+ /** (EE only) Create a new namespace license. */
206
1024
  namespacesLicensesCreate?: Maybe<NamespacesLicensesCreatePayload>;
207
- /** Deletes an namespace license. */
1025
+ /** (EE only) Deletes an namespace license. */
208
1026
  namespacesLicensesDelete?: Maybe<NamespacesLicensesDeletePayload>;
209
1027
  /** Update the roles a member is assigned to. */
210
1028
  namespacesMembersAssignRoles?: Maybe<NamespacesMembersAssignRolesPayload>;
@@ -212,10 +1030,16 @@ export interface Mutation {
212
1030
  namespacesMembersDelete?: Maybe<NamespacesMembersDeletePayload>;
213
1031
  /** Invite a new member to a namespace. */
214
1032
  namespacesMembersInvite?: Maybe<NamespacesMembersInvitePayload>;
1033
+ /** Assign runtimes to a project */
1034
+ namespacesProjectsAssignRuntimes?: Maybe<NamespacesProjectsAssignRuntimesPayload>;
215
1035
  /** Creates a new namespace project. */
216
1036
  namespacesProjectsCreate?: Maybe<NamespacesProjectsCreatePayload>;
217
1037
  /** Deletes a namespace project. */
218
1038
  namespacesProjectsDelete?: Maybe<NamespacesProjectsDeletePayload>;
1039
+ /** Creates a new flow. */
1040
+ namespacesProjectsFlowsCreate?: Maybe<NamespacesProjectsFlowsCreatePayload>;
1041
+ /** Deletes a namespace project. */
1042
+ namespacesProjectsFlowsDelete?: Maybe<NamespacesProjectsFlowsDeletePayload>;
219
1043
  /** Updates a namespace project. */
220
1044
  namespacesProjectsUpdate?: Maybe<NamespacesProjectsUpdatePayload>;
221
1045
  /** Update the abilities a role is granted. */
@@ -242,6 +1066,8 @@ export interface Mutation {
242
1066
  runtimesRotateToken?: Maybe<RuntimesRotateTokenPayload>;
243
1067
  /** Update an existing runtime. */
244
1068
  runtimesUpdate?: Maybe<RuntimesUpdatePayload>;
1069
+ /** Verify your email when changing it or signing up */
1070
+ usersEmailVerification?: Maybe<UsersEmailVerificationPayload>;
245
1071
  /** Links an external identity to an existing user */
246
1072
  usersIdentityLink?: Maybe<UsersIdentityLinkPayload>;
247
1073
  /** Login to an existing user via an external identity */
@@ -260,6 +1086,10 @@ export interface Mutation {
260
1086
  usersMfaTotpGenerateSecret?: Maybe<UsersMfaTotpGenerateSecretPayload>;
261
1087
  /** Validates a TOTP value for the given secret and enables TOTP MFA for the user */
262
1088
  usersMfaTotpValidateSecret?: Maybe<UsersMfaTotpValidateSecretPayload>;
1089
+ /** Reset the password using a reset token */
1090
+ usersPasswordReset?: Maybe<UsersPasswordResetPayload>;
1091
+ /** Request an password reset */
1092
+ usersPasswordResetRequest?: Maybe<UsersPasswordResetRequestPayload>;
263
1093
  /** Register a new user */
264
1094
  usersRegister?: Maybe<UsersRegisterPayload>;
265
1095
  /** Update an existing user. */
@@ -309,6 +1139,12 @@ export interface MutationNamespacesMembersInviteArgs {
309
1139
  }
310
1140
 
311
1141
 
1142
+ /** Root Mutation type */
1143
+ export interface MutationNamespacesProjectsAssignRuntimesArgs {
1144
+ input: NamespacesProjectsAssignRuntimesInput;
1145
+ }
1146
+
1147
+
312
1148
  /** Root Mutation type */
313
1149
  export interface MutationNamespacesProjectsCreateArgs {
314
1150
  input: NamespacesProjectsCreateInput;
@@ -321,6 +1157,18 @@ export interface MutationNamespacesProjectsDeleteArgs {
321
1157
  }
322
1158
 
323
1159
 
1160
+ /** Root Mutation type */
1161
+ export interface MutationNamespacesProjectsFlowsCreateArgs {
1162
+ input: NamespacesProjectsFlowsCreateInput;
1163
+ }
1164
+
1165
+
1166
+ /** Root Mutation type */
1167
+ export interface MutationNamespacesProjectsFlowsDeleteArgs {
1168
+ input: NamespacesProjectsFlowsDeleteInput;
1169
+ }
1170
+
1171
+
324
1172
  /** Root Mutation type */
325
1173
  export interface MutationNamespacesProjectsUpdateArgs {
326
1174
  input: NamespacesProjectsUpdateInput;
@@ -399,6 +1247,12 @@ export interface MutationRuntimesUpdateArgs {
399
1247
  }
400
1248
 
401
1249
 
1250
+ /** Root Mutation type */
1251
+ export interface MutationUsersEmailVerificationArgs {
1252
+ input: UsersEmailVerificationInput;
1253
+ }
1254
+
1255
+
402
1256
  /** Root Mutation type */
403
1257
  export interface MutationUsersIdentityLinkArgs {
404
1258
  input: UsersIdentityLinkInput;
@@ -453,6 +1307,18 @@ export interface MutationUsersMfaTotpValidateSecretArgs {
453
1307
  }
454
1308
 
455
1309
 
1310
+ /** Root Mutation type */
1311
+ export interface MutationUsersPasswordResetArgs {
1312
+ input: UsersPasswordResetInput;
1313
+ }
1314
+
1315
+
1316
+ /** Root Mutation type */
1317
+ export interface MutationUsersPasswordResetRequestArgs {
1318
+ input: UsersPasswordResetRequestInput;
1319
+ }
1320
+
1321
+
456
1322
  /** Root Mutation type */
457
1323
  export interface MutationUsersRegisterArgs {
458
1324
  input: UsersRegisterInput;
@@ -468,23 +1334,27 @@ export interface MutationUsersUpdateArgs {
468
1334
  export interface Namespace {
469
1335
  __typename?: 'Namespace';
470
1336
  /** Time when this Namespace was created */
471
- createdAt: Scalars['Time']['output'];
1337
+ createdAt?: Maybe<Scalars['Time']['output']>;
1338
+ /** (EE only) Currently active license of the namespace */
1339
+ currentNamespaceLicense?: Maybe<NamespaceLicense>;
472
1340
  /** Global ID of this Namespace */
473
- id: Scalars['NamespaceID']['output'];
1341
+ id?: Maybe<Scalars['NamespaceID']['output']>;
474
1342
  /** Members of the namespace */
475
- members: NamespaceMemberConnection;
476
- /** Licenses of the namespace */
477
- namespaceLicenses: NamespaceLicenseConnection;
1343
+ members?: Maybe<NamespaceMemberConnection>;
1344
+ /** (EE only) Licenses of the namespace */
1345
+ namespaceLicenses?: Maybe<NamespaceLicenseConnection>;
478
1346
  /** Parent of this namespace */
479
- parent: NamespaceParent;
1347
+ parent?: Maybe<NamespaceParent>;
480
1348
  /** Projects of the namespace */
481
- projects: NamespaceProjectConnection;
1349
+ projects?: Maybe<NamespaceProjectConnection>;
482
1350
  /** Roles of the namespace */
483
- roles: NamespaceRoleConnection;
1351
+ roles?: Maybe<NamespaceRoleConnection>;
484
1352
  /** Runtime of the namespace */
485
- runtimes: RuntimeConnection;
1353
+ runtimes?: Maybe<RuntimeConnection>;
486
1354
  /** Time when this Namespace was last updated */
487
- updatedAt: Scalars['Time']['output'];
1355
+ updatedAt?: Maybe<Scalars['Time']['output']>;
1356
+ /** Abilities for the current user on this Namespace */
1357
+ userAbilities?: Maybe<NamespaceUserAbilities>;
488
1358
  }
489
1359
 
490
1360
 
@@ -532,74 +1402,113 @@ export interface NamespaceRuntimesArgs {
532
1402
  last?: InputMaybe<Scalars['Int']['input']>;
533
1403
  }
534
1404
 
535
- /** Represents a Namespace License */
1405
+ /** (EE only) Represents a Namespace License */
536
1406
  export interface NamespaceLicense {
537
1407
  __typename?: 'NamespaceLicense';
538
1408
  /** Time when this NamespaceLicense was created */
539
- createdAt: Scalars['Time']['output'];
1409
+ createdAt?: Maybe<Scalars['Time']['output']>;
1410
+ /** The end date of the license */
1411
+ endDate?: Maybe<Scalars['Time']['output']>;
540
1412
  /** Global ID of this NamespaceLicense */
541
- id: Scalars['NamespaceLicenseID']['output'];
1413
+ id?: Maybe<Scalars['NamespaceLicenseID']['output']>;
1414
+ /** The licensee information */
1415
+ licensee?: Maybe<Scalars['JSON']['output']>;
542
1416
  /** The namespace the license belongs to */
543
- namespace: Namespace;
1417
+ namespace?: Maybe<Namespace>;
1418
+ /** The start date of the license */
1419
+ startDate?: Maybe<Scalars['Time']['output']>;
544
1420
  /** Time when this NamespaceLicense was last updated */
545
- updatedAt: Scalars['Time']['output'];
1421
+ updatedAt?: Maybe<Scalars['Time']['output']>;
1422
+ /** Abilities for the current user on this NamespaceLicense */
1423
+ userAbilities?: Maybe<NamespaceLicenseUserAbilities>;
546
1424
  }
547
1425
 
548
1426
  /** The connection type for NamespaceLicense. */
549
1427
  export interface NamespaceLicenseConnection {
550
1428
  __typename?: 'NamespaceLicenseConnection';
551
1429
  /** Total count of collection. */
552
- count: Scalars['Int']['output'];
1430
+ count?: Maybe<Scalars['Int']['output']>;
553
1431
  /** A list of edges. */
554
1432
  edges?: Maybe<Array<Maybe<NamespaceLicenseEdge>>>;
555
1433
  /** A list of nodes. */
556
1434
  nodes?: Maybe<Array<Maybe<NamespaceLicense>>>;
557
1435
  /** Information to aid in pagination. */
558
- pageInfo: PageInfo;
1436
+ pageInfo?: Maybe<PageInfo>;
559
1437
  }
560
1438
 
561
1439
  /** An edge in a connection. */
562
1440
  export interface NamespaceLicenseEdge {
563
1441
  __typename?: 'NamespaceLicenseEdge';
564
1442
  /** A cursor for use in pagination. */
565
- cursor: Scalars['String']['output'];
1443
+ cursor?: Maybe<Scalars['String']['output']>;
566
1444
  /** The item at the end of the edge. */
567
1445
  node?: Maybe<NamespaceLicense>;
568
1446
  }
569
1447
 
1448
+ /** Abilities for the current user on this NamespaceLicense */
1449
+ export interface NamespaceLicenseUserAbilities {
1450
+ __typename?: 'NamespaceLicenseUserAbilities';
1451
+ /** Shows if the current user has the `delete_namespace_license` ability on this NamespaceLicense */
1452
+ deleteNamespaceLicense?: Maybe<Scalars['Boolean']['output']>;
1453
+ }
1454
+
570
1455
  /** Represents a namespace member */
571
1456
  export interface NamespaceMember {
572
1457
  __typename?: 'NamespaceMember';
573
1458
  /** Time when this NamespaceMember was created */
574
- createdAt: Scalars['Time']['output'];
1459
+ createdAt?: Maybe<Scalars['Time']['output']>;
575
1460
  /** Global ID of this NamespaceMember */
576
- id: Scalars['NamespaceMemberID']['output'];
1461
+ id?: Maybe<Scalars['NamespaceMemberID']['output']>;
1462
+ /** Memberroles of the member */
1463
+ memberRoles?: Maybe<NamespaceMemberRoleConnection>;
577
1464
  /** Namespace this member belongs to */
578
- namespace: Namespace;
1465
+ namespace?: Maybe<Namespace>;
1466
+ /** Roles of the member */
1467
+ roles?: Maybe<NamespaceRoleConnection>;
579
1468
  /** Time when this NamespaceMember was last updated */
580
- updatedAt: Scalars['Time']['output'];
1469
+ updatedAt?: Maybe<Scalars['Time']['output']>;
581
1470
  /** User this member belongs to */
582
- user: User;
1471
+ user?: Maybe<User>;
1472
+ /** Abilities for the current user on this NamespaceMember */
1473
+ userAbilities?: Maybe<NamespaceMemberUserAbilities>;
1474
+ }
1475
+
1476
+
1477
+ /** Represents a namespace member */
1478
+ export interface NamespaceMemberMemberRolesArgs {
1479
+ after?: InputMaybe<Scalars['String']['input']>;
1480
+ before?: InputMaybe<Scalars['String']['input']>;
1481
+ first?: InputMaybe<Scalars['Int']['input']>;
1482
+ last?: InputMaybe<Scalars['Int']['input']>;
1483
+ }
1484
+
1485
+
1486
+ /** Represents a namespace member */
1487
+ export interface NamespaceMemberRolesArgs {
1488
+ after?: InputMaybe<Scalars['String']['input']>;
1489
+ before?: InputMaybe<Scalars['String']['input']>;
1490
+ first?: InputMaybe<Scalars['Int']['input']>;
1491
+ last?: InputMaybe<Scalars['Int']['input']>;
583
1492
  }
584
1493
 
585
1494
  /** The connection type for NamespaceMember. */
586
1495
  export interface NamespaceMemberConnection {
587
1496
  __typename?: 'NamespaceMemberConnection';
588
1497
  /** Total count of collection. */
589
- count: Scalars['Int']['output'];
1498
+ count?: Maybe<Scalars['Int']['output']>;
590
1499
  /** A list of edges. */
591
1500
  edges?: Maybe<Array<Maybe<NamespaceMemberEdge>>>;
592
1501
  /** A list of nodes. */
593
1502
  nodes?: Maybe<Array<Maybe<NamespaceMember>>>;
594
1503
  /** Information to aid in pagination. */
595
- pageInfo: PageInfo;
1504
+ pageInfo?: Maybe<PageInfo>;
596
1505
  }
597
1506
 
598
1507
  /** An edge in a connection. */
599
1508
  export interface NamespaceMemberEdge {
600
1509
  __typename?: 'NamespaceMemberEdge';
601
1510
  /** A cursor for use in pagination. */
602
- cursor: Scalars['String']['output'];
1511
+ cursor?: Maybe<Scalars['String']['output']>;
603
1512
  /** The item at the end of the edge. */
604
1513
  node?: Maybe<NamespaceMember>;
605
1514
  }
@@ -608,76 +1517,169 @@ export interface NamespaceMemberEdge {
608
1517
  export interface NamespaceMemberRole {
609
1518
  __typename?: 'NamespaceMemberRole';
610
1519
  /** Time when this NamespaceMemberRole was created */
611
- createdAt: Scalars['Time']['output'];
1520
+ createdAt?: Maybe<Scalars['Time']['output']>;
612
1521
  /** Global ID of this NamespaceMemberRole */
613
- id: Scalars['NamespaceMemberRoleID']['output'];
1522
+ id?: Maybe<Scalars['NamespaceMemberRoleID']['output']>;
614
1523
  /** The member the role is assigned to */
615
1524
  member?: Maybe<NamespaceMember>;
616
1525
  /** The assigned role */
617
1526
  role?: Maybe<NamespaceRole>;
618
1527
  /** Time when this NamespaceMemberRole was last updated */
619
- updatedAt: Scalars['Time']['output'];
1528
+ updatedAt?: Maybe<Scalars['Time']['output']>;
1529
+ }
1530
+
1531
+ /** The connection type for NamespaceMemberRole. */
1532
+ export interface NamespaceMemberRoleConnection {
1533
+ __typename?: 'NamespaceMemberRoleConnection';
1534
+ /** Total count of collection. */
1535
+ count?: Maybe<Scalars['Int']['output']>;
1536
+ /** A list of edges. */
1537
+ edges?: Maybe<Array<Maybe<NamespaceMemberRoleEdge>>>;
1538
+ /** A list of nodes. */
1539
+ nodes?: Maybe<Array<Maybe<NamespaceMemberRole>>>;
1540
+ /** Information to aid in pagination. */
1541
+ pageInfo?: Maybe<PageInfo>;
1542
+ }
1543
+
1544
+ /** An edge in a connection. */
1545
+ export interface NamespaceMemberRoleEdge {
1546
+ __typename?: 'NamespaceMemberRoleEdge';
1547
+ /** A cursor for use in pagination. */
1548
+ cursor?: Maybe<Scalars['String']['output']>;
1549
+ /** The item at the end of the edge. */
1550
+ node?: Maybe<NamespaceMemberRole>;
1551
+ }
1552
+
1553
+ /** Abilities for the current user on this NamespaceMember */
1554
+ export interface NamespaceMemberUserAbilities {
1555
+ __typename?: 'NamespaceMemberUserAbilities';
1556
+ /** Shows if the current user has the `assign_member_roles` ability on this NamespaceMember */
1557
+ assignMemberRoles?: Maybe<Scalars['Boolean']['output']>;
1558
+ /** Shows if the current user has the `delete_member` ability on this NamespaceMember */
1559
+ deleteMember?: Maybe<Scalars['Boolean']['output']>;
620
1560
  }
621
1561
 
622
1562
  /** Objects that can present a namespace */
623
- export type NamespaceParent = Organization;
1563
+ export type NamespaceParent = Organization | User;
624
1564
 
625
1565
  /** Represents a namespace project */
626
1566
  export interface NamespaceProject {
627
1567
  __typename?: 'NamespaceProject';
628
1568
  /** Time when this NamespaceProject was created */
629
- createdAt: Scalars['Time']['output'];
1569
+ createdAt?: Maybe<Scalars['Time']['output']>;
630
1570
  /** Description of the project */
631
- description: Scalars['String']['output'];
1571
+ description?: Maybe<Scalars['String']['output']>;
1572
+ /** Fetches an flow given by its ID */
1573
+ flow?: Maybe<Flow>;
1574
+ /** Fetches all flows in this project */
1575
+ flows?: Maybe<FlowConnection>;
632
1576
  /** Global ID of this NamespaceProject */
633
- id: Scalars['NamespaceProjectID']['output'];
1577
+ id?: Maybe<Scalars['NamespaceProjectID']['output']>;
634
1578
  /** Name of the project */
635
- name: Scalars['String']['output'];
1579
+ name?: Maybe<Scalars['String']['output']>;
636
1580
  /** The namespace where this project belongs to */
637
- namespace: Namespace;
1581
+ namespace?: Maybe<Namespace>;
1582
+ /** The primary runtime for the project */
1583
+ primaryRuntime?: Maybe<Runtime>;
1584
+ /** Roles assigned to this project */
1585
+ roles?: Maybe<NamespaceRoleConnection>;
1586
+ /** Runtimes assigned to this project */
1587
+ runtimes?: Maybe<RuntimeConnection>;
638
1588
  /** Time when this NamespaceProject was last updated */
639
- updatedAt: Scalars['Time']['output'];
1589
+ updatedAt?: Maybe<Scalars['Time']['output']>;
1590
+ /** Abilities for the current user on this NamespaceProject */
1591
+ userAbilities?: Maybe<NamespaceProjectUserAbilities>;
1592
+ }
1593
+
1594
+
1595
+ /** Represents a namespace project */
1596
+ export interface NamespaceProjectFlowArgs {
1597
+ id: Scalars['FlowID']['input'];
1598
+ }
1599
+
1600
+
1601
+ /** Represents a namespace project */
1602
+ export interface NamespaceProjectFlowsArgs {
1603
+ after?: InputMaybe<Scalars['String']['input']>;
1604
+ before?: InputMaybe<Scalars['String']['input']>;
1605
+ first?: InputMaybe<Scalars['Int']['input']>;
1606
+ last?: InputMaybe<Scalars['Int']['input']>;
1607
+ }
1608
+
1609
+
1610
+ /** Represents a namespace project */
1611
+ export interface NamespaceProjectRolesArgs {
1612
+ after?: InputMaybe<Scalars['String']['input']>;
1613
+ before?: InputMaybe<Scalars['String']['input']>;
1614
+ first?: InputMaybe<Scalars['Int']['input']>;
1615
+ last?: InputMaybe<Scalars['Int']['input']>;
1616
+ }
1617
+
1618
+
1619
+ /** Represents a namespace project */
1620
+ export interface NamespaceProjectRuntimesArgs {
1621
+ after?: InputMaybe<Scalars['String']['input']>;
1622
+ before?: InputMaybe<Scalars['String']['input']>;
1623
+ first?: InputMaybe<Scalars['Int']['input']>;
1624
+ last?: InputMaybe<Scalars['Int']['input']>;
640
1625
  }
641
1626
 
642
1627
  /** The connection type for NamespaceProject. */
643
1628
  export interface NamespaceProjectConnection {
644
1629
  __typename?: 'NamespaceProjectConnection';
645
1630
  /** Total count of collection. */
646
- count: Scalars['Int']['output'];
1631
+ count?: Maybe<Scalars['Int']['output']>;
647
1632
  /** A list of edges. */
648
1633
  edges?: Maybe<Array<Maybe<NamespaceProjectEdge>>>;
649
1634
  /** A list of nodes. */
650
1635
  nodes?: Maybe<Array<Maybe<NamespaceProject>>>;
651
1636
  /** Information to aid in pagination. */
652
- pageInfo: PageInfo;
1637
+ pageInfo?: Maybe<PageInfo>;
653
1638
  }
654
1639
 
655
1640
  /** An edge in a connection. */
656
1641
  export interface NamespaceProjectEdge {
657
1642
  __typename?: 'NamespaceProjectEdge';
658
1643
  /** A cursor for use in pagination. */
659
- cursor: Scalars['String']['output'];
1644
+ cursor?: Maybe<Scalars['String']['output']>;
660
1645
  /** The item at the end of the edge. */
661
1646
  node?: Maybe<NamespaceProject>;
662
1647
  }
663
1648
 
1649
+ /** Abilities for the current user on this NamespaceProject */
1650
+ export interface NamespaceProjectUserAbilities {
1651
+ __typename?: 'NamespaceProjectUserAbilities';
1652
+ /** Shows if the current user has the `assign_project_runtimes` ability on this NamespaceProject */
1653
+ assignProjectRuntimes?: Maybe<Scalars['Boolean']['output']>;
1654
+ /** Shows if the current user has the `create_flow` ability on this NamespaceProject */
1655
+ createFlow?: Maybe<Scalars['Boolean']['output']>;
1656
+ /** Shows if the current user has the `delete_namespace_project` ability on this NamespaceProject */
1657
+ deleteNamespaceProject?: Maybe<Scalars['Boolean']['output']>;
1658
+ /** Shows if the current user has the `update_namespace_project` ability on this NamespaceProject */
1659
+ updateNamespaceProject?: Maybe<Scalars['Boolean']['output']>;
1660
+ }
1661
+
664
1662
  /** Represents a namespace role. */
665
1663
  export interface NamespaceRole {
666
1664
  __typename?: 'NamespaceRole';
667
1665
  /** The abilities the role is granted */
668
- abilities: Array<NamespaceRoleAbility>;
1666
+ abilities?: Maybe<Array<NamespaceRoleAbility>>;
669
1667
  /** The projects this role is assigned to */
670
1668
  assignedProjects?: Maybe<NamespaceProjectConnection>;
671
1669
  /** Time when this NamespaceRole was created */
672
- createdAt: Scalars['Time']['output'];
1670
+ createdAt?: Maybe<Scalars['Time']['output']>;
673
1671
  /** Global ID of this NamespaceRole */
674
- id: Scalars['NamespaceRoleID']['output'];
1672
+ id?: Maybe<Scalars['NamespaceRoleID']['output']>;
1673
+ /** The members this role is assigned to */
1674
+ members?: Maybe<NamespaceMemberConnection>;
675
1675
  /** The name of this role */
676
- name: Scalars['String']['output'];
1676
+ name?: Maybe<Scalars['String']['output']>;
677
1677
  /** The namespace where this role belongs to */
678
1678
  namespace?: Maybe<Namespace>;
679
1679
  /** Time when this NamespaceRole was last updated */
680
- updatedAt: Scalars['Time']['output'];
1680
+ updatedAt?: Maybe<Scalars['Time']['output']>;
1681
+ /** Abilities for the current user on this NamespaceRole */
1682
+ userAbilities?: Maybe<NamespaceRoleUserAbilities>;
681
1683
  }
682
1684
 
683
1685
 
@@ -689,14 +1691,27 @@ export interface NamespaceRoleAssignedProjectsArgs {
689
1691
  last?: InputMaybe<Scalars['Int']['input']>;
690
1692
  }
691
1693
 
1694
+
1695
+ /** Represents a namespace role. */
1696
+ export interface NamespaceRoleMembersArgs {
1697
+ after?: InputMaybe<Scalars['String']['input']>;
1698
+ before?: InputMaybe<Scalars['String']['input']>;
1699
+ first?: InputMaybe<Scalars['Int']['input']>;
1700
+ last?: InputMaybe<Scalars['Int']['input']>;
1701
+ }
1702
+
692
1703
  /** Represents abilities that can be granted to roles in namespaces. */
693
- export enum NamespaceRoleAbility {
1704
+ export const enum NamespaceRoleAbility {
694
1705
  /** Allows to change the roles of a namespace member */
695
1706
  AssignMemberRoles = 'ASSIGN_MEMBER_ROLES',
1707
+ /** Allows to assign runtimes to a project in the namespace */
1708
+ AssignProjectRuntimes = 'ASSIGN_PROJECT_RUNTIMES',
696
1709
  /** Allows to change the abilities of a namespace role */
697
1710
  AssignRoleAbilities = 'ASSIGN_ROLE_ABILITIES',
698
1711
  /** Allows to change the assigned projects of a namespace role */
699
1712
  AssignRoleProjects = 'ASSIGN_ROLE_PROJECTS',
1713
+ /** Allows to create flows in a namespace project */
1714
+ CreateFlow = 'CREATE_FLOW',
700
1715
  /** Allows to create a license for the namespace */
701
1716
  CreateNamespaceLicense = 'CREATE_NAMESPACE_LICENSE',
702
1717
  /** Allows to create a project in the namespace */
@@ -705,6 +1720,8 @@ export enum NamespaceRoleAbility {
705
1720
  CreateNamespaceRole = 'CREATE_NAMESPACE_ROLE',
706
1721
  /** Allows to create a runtime globally or for the namespace */
707
1722
  CreateRuntime = 'CREATE_RUNTIME',
1723
+ /** Allows to delete flows in a namespace project */
1724
+ DeleteFlow = 'DELETE_FLOW',
708
1725
  /** Allows to remove members of a namespace */
709
1726
  DeleteMember = 'DELETE_MEMBER',
710
1727
  /** Allows to delete the license of the namespace */
@@ -727,6 +1744,8 @@ export enum NamespaceRoleAbility {
727
1744
  ReadNamespaceProject = 'READ_NAMESPACE_PROJECT',
728
1745
  /** Allows to regenerate a runtime token */
729
1746
  RotateRuntimeToken = 'ROTATE_RUNTIME_TOKEN',
1747
+ /** Allows to update flows in the project */
1748
+ UpdateFlow = 'UPDATE_FLOW',
730
1749
  /** Allows to update the project of the namespace */
731
1750
  UpdateNamespaceProject = 'UPDATE_NAMESPACE_PROJECT',
732
1751
  /** Allows to update the namespace role */
@@ -741,24 +1760,52 @@ export enum NamespaceRoleAbility {
741
1760
  export interface NamespaceRoleConnection {
742
1761
  __typename?: 'NamespaceRoleConnection';
743
1762
  /** Total count of collection. */
744
- count: Scalars['Int']['output'];
1763
+ count?: Maybe<Scalars['Int']['output']>;
745
1764
  /** A list of edges. */
746
1765
  edges?: Maybe<Array<Maybe<NamespaceRoleEdge>>>;
747
1766
  /** A list of nodes. */
748
1767
  nodes?: Maybe<Array<Maybe<NamespaceRole>>>;
749
1768
  /** Information to aid in pagination. */
750
- pageInfo: PageInfo;
1769
+ pageInfo?: Maybe<PageInfo>;
751
1770
  }
752
1771
 
753
1772
  /** An edge in a connection. */
754
1773
  export interface NamespaceRoleEdge {
755
1774
  __typename?: 'NamespaceRoleEdge';
756
1775
  /** A cursor for use in pagination. */
757
- cursor: Scalars['String']['output'];
1776
+ cursor?: Maybe<Scalars['String']['output']>;
758
1777
  /** The item at the end of the edge. */
759
1778
  node?: Maybe<NamespaceRole>;
760
1779
  }
761
1780
 
1781
+ /** Abilities for the current user on this NamespaceRole */
1782
+ export interface NamespaceRoleUserAbilities {
1783
+ __typename?: 'NamespaceRoleUserAbilities';
1784
+ /** Shows if the current user has the `assign_role_abilities` ability on this NamespaceRole */
1785
+ assignRoleAbilities?: Maybe<Scalars['Boolean']['output']>;
1786
+ /** Shows if the current user has the `assign_role_projects` ability on this NamespaceRole */
1787
+ assignRoleProjects?: Maybe<Scalars['Boolean']['output']>;
1788
+ /** Shows if the current user has the `delete_namespace_role` ability on this NamespaceRole */
1789
+ deleteNamespaceRole?: Maybe<Scalars['Boolean']['output']>;
1790
+ /** Shows if the current user has the `update_namespace_role` ability on this NamespaceRole */
1791
+ updateNamespaceRole?: Maybe<Scalars['Boolean']['output']>;
1792
+ }
1793
+
1794
+ /** Abilities for the current user on this Namespace */
1795
+ export interface NamespaceUserAbilities {
1796
+ __typename?: 'NamespaceUserAbilities';
1797
+ /** Shows if the current user has the `create_namespace_license` ability on this Namespace */
1798
+ createNamespaceLicense?: Maybe<Scalars['Boolean']['output']>;
1799
+ /** Shows if the current user has the `create_namespace_project` ability on this Namespace */
1800
+ createNamespaceProject?: Maybe<Scalars['Boolean']['output']>;
1801
+ /** Shows if the current user has the `create_namespace_role` ability on this Namespace */
1802
+ createNamespaceRole?: Maybe<Scalars['Boolean']['output']>;
1803
+ /** Shows if the current user has the `create_runtime` ability on this Namespace */
1804
+ createRuntime?: Maybe<Scalars['Boolean']['output']>;
1805
+ /** Shows if the current user has the `invite_member` ability on this Namespace */
1806
+ inviteMember?: Maybe<Scalars['Boolean']['output']>;
1807
+ }
1808
+
762
1809
  /** Autogenerated input type of NamespacesLicensesCreate */
763
1810
  export interface NamespacesLicensesCreateInput {
764
1811
  /** A unique identifier for the client performing the mutation. */
@@ -775,7 +1822,7 @@ export interface NamespacesLicensesCreatePayload {
775
1822
  /** A unique identifier for the client performing the mutation. */
776
1823
  clientMutationId?: Maybe<Scalars['String']['output']>;
777
1824
  /** Errors encountered during execution of the mutation. */
778
- errors: Array<Error>;
1825
+ errors?: Maybe<Array<Error>>;
779
1826
  /** The newly created license. */
780
1827
  namespaceLicense?: Maybe<NamespaceLicense>;
781
1828
  }
@@ -794,7 +1841,7 @@ export interface NamespacesLicensesDeletePayload {
794
1841
  /** A unique identifier for the client performing the mutation. */
795
1842
  clientMutationId?: Maybe<Scalars['String']['output']>;
796
1843
  /** Errors encountered during execution of the mutation. */
797
- errors: Array<Error>;
1844
+ errors?: Maybe<Array<Error>>;
798
1845
  /** The deleted namespace license. */
799
1846
  namespaceLicense?: Maybe<NamespaceLicense>;
800
1847
  }
@@ -815,7 +1862,7 @@ export interface NamespacesMembersAssignRolesPayload {
815
1862
  /** A unique identifier for the client performing the mutation. */
816
1863
  clientMutationId?: Maybe<Scalars['String']['output']>;
817
1864
  /** Errors encountered during execution of the mutation. */
818
- errors: Array<Error>;
1865
+ errors?: Maybe<Array<Error>>;
819
1866
  /** The roles the member is now assigned to */
820
1867
  namespaceMemberRoles?: Maybe<Array<NamespaceMemberRole>>;
821
1868
  }
@@ -834,7 +1881,7 @@ export interface NamespacesMembersDeletePayload {
834
1881
  /** A unique identifier for the client performing the mutation. */
835
1882
  clientMutationId?: Maybe<Scalars['String']['output']>;
836
1883
  /** Errors encountered during execution of the mutation. */
837
- errors: Array<Error>;
1884
+ errors?: Maybe<Array<Error>>;
838
1885
  /** The removed namespace member */
839
1886
  namespaceMember?: Maybe<NamespaceMember>;
840
1887
  }
@@ -855,13 +1902,34 @@ export interface NamespacesMembersInvitePayload {
855
1902
  /** A unique identifier for the client performing the mutation. */
856
1903
  clientMutationId?: Maybe<Scalars['String']['output']>;
857
1904
  /** Errors encountered during execution of the mutation. */
858
- errors: Array<Error>;
1905
+ errors?: Maybe<Array<Error>>;
859
1906
  /** The newly created namespace member */
860
1907
  namespaceMember?: Maybe<NamespaceMember>;
861
1908
  }
862
1909
 
863
- /** Autogenerated input type of NamespacesProjectsCreate */
864
- export interface NamespacesProjectsCreateInput {
1910
+ /** Autogenerated input type of NamespacesProjectsAssignRuntimes */
1911
+ export interface NamespacesProjectsAssignRuntimesInput {
1912
+ /** A unique identifier for the client performing the mutation. */
1913
+ clientMutationId?: InputMaybe<Scalars['String']['input']>;
1914
+ /** ID of the project to assign runtimes to */
1915
+ namespaceProjectId: Scalars['NamespaceProjectID']['input'];
1916
+ /** The new runtimes assigned to the project */
1917
+ runtimeIds: Array<Scalars['RuntimeID']['input']>;
1918
+ }
1919
+
1920
+ /** Autogenerated return type of NamespacesProjectsAssignRuntimes. */
1921
+ export interface NamespacesProjectsAssignRuntimesPayload {
1922
+ __typename?: 'NamespacesProjectsAssignRuntimesPayload';
1923
+ /** A unique identifier for the client performing the mutation. */
1924
+ clientMutationId?: Maybe<Scalars['String']['output']>;
1925
+ /** Errors encountered during execution of the mutation. */
1926
+ errors?: Maybe<Array<Error>>;
1927
+ /** The updated project with assigned runtimes */
1928
+ namespaceProject?: Maybe<NamespaceProject>;
1929
+ }
1930
+
1931
+ /** Autogenerated input type of NamespacesProjectsCreate */
1932
+ export interface NamespacesProjectsCreateInput {
865
1933
  /** A unique identifier for the client performing the mutation. */
866
1934
  clientMutationId?: InputMaybe<Scalars['String']['input']>;
867
1935
  /** Description for the new project. */
@@ -878,7 +1946,7 @@ export interface NamespacesProjectsCreatePayload {
878
1946
  /** A unique identifier for the client performing the mutation. */
879
1947
  clientMutationId?: Maybe<Scalars['String']['output']>;
880
1948
  /** Errors encountered during execution of the mutation. */
881
- errors: Array<Error>;
1949
+ errors?: Maybe<Array<Error>>;
882
1950
  /** The newly created project. */
883
1951
  namespaceProject?: Maybe<NamespaceProject>;
884
1952
  }
@@ -897,11 +1965,51 @@ export interface NamespacesProjectsDeletePayload {
897
1965
  /** A unique identifier for the client performing the mutation. */
898
1966
  clientMutationId?: Maybe<Scalars['String']['output']>;
899
1967
  /** Errors encountered during execution of the mutation. */
900
- errors: Array<Error>;
1968
+ errors?: Maybe<Array<Error>>;
901
1969
  /** The deleted project. */
902
1970
  namespaceProject?: Maybe<NamespaceProject>;
903
1971
  }
904
1972
 
1973
+ /** Autogenerated input type of NamespacesProjectsFlowsCreate */
1974
+ export interface NamespacesProjectsFlowsCreateInput {
1975
+ /** A unique identifier for the client performing the mutation. */
1976
+ clientMutationId?: InputMaybe<Scalars['String']['input']>;
1977
+ /** The flow to create */
1978
+ flow: FlowInput;
1979
+ /** The ID of the project to which the flow belongs to */
1980
+ projectId: Scalars['NamespaceProjectID']['input'];
1981
+ }
1982
+
1983
+ /** Autogenerated return type of NamespacesProjectsFlowsCreate. */
1984
+ export interface NamespacesProjectsFlowsCreatePayload {
1985
+ __typename?: 'NamespacesProjectsFlowsCreatePayload';
1986
+ /** A unique identifier for the client performing the mutation. */
1987
+ clientMutationId?: Maybe<Scalars['String']['output']>;
1988
+ /** Errors encountered during execution of the mutation. */
1989
+ errors?: Maybe<Array<Error>>;
1990
+ /** The newly created flow. */
1991
+ flow?: Maybe<Flow>;
1992
+ }
1993
+
1994
+ /** Autogenerated input type of NamespacesProjectsFlowsDelete */
1995
+ export interface NamespacesProjectsFlowsDeleteInput {
1996
+ /** A unique identifier for the client performing the mutation. */
1997
+ clientMutationId?: InputMaybe<Scalars['String']['input']>;
1998
+ /** The id of the flow which will be deleted */
1999
+ flowId: Scalars['FlowID']['input'];
2000
+ }
2001
+
2002
+ /** Autogenerated return type of NamespacesProjectsFlowsDelete. */
2003
+ export interface NamespacesProjectsFlowsDeletePayload {
2004
+ __typename?: 'NamespacesProjectsFlowsDeletePayload';
2005
+ /** A unique identifier for the client performing the mutation. */
2006
+ clientMutationId?: Maybe<Scalars['String']['output']>;
2007
+ /** Errors encountered during execution of the mutation. */
2008
+ errors?: Maybe<Array<Error>>;
2009
+ /** The deleted flow. */
2010
+ flow?: Maybe<Flow>;
2011
+ }
2012
+
905
2013
  /** Autogenerated input type of NamespacesProjectsUpdate */
906
2014
  export interface NamespacesProjectsUpdateInput {
907
2015
  /** A unique identifier for the client performing the mutation. */
@@ -912,6 +2020,8 @@ export interface NamespacesProjectsUpdateInput {
912
2020
  name?: InputMaybe<Scalars['String']['input']>;
913
2021
  /** The id of the namespace project which will be updated */
914
2022
  namespaceProjectId: Scalars['NamespaceProjectID']['input'];
2023
+ /** The primary runtime for the updated project. */
2024
+ primaryRuntimeId?: InputMaybe<Scalars['RuntimeID']['input']>;
915
2025
  }
916
2026
 
917
2027
  /** Autogenerated return type of NamespacesProjectsUpdate. */
@@ -920,7 +2030,7 @@ export interface NamespacesProjectsUpdatePayload {
920
2030
  /** A unique identifier for the client performing the mutation. */
921
2031
  clientMutationId?: Maybe<Scalars['String']['output']>;
922
2032
  /** Errors encountered during execution of the mutation. */
923
- errors: Array<Error>;
2033
+ errors?: Maybe<Array<Error>>;
924
2034
  /** The updated project. */
925
2035
  namespaceProject?: Maybe<NamespaceProject>;
926
2036
  }
@@ -943,7 +2053,7 @@ export interface NamespacesRolesAssignAbilitiesPayload {
943
2053
  /** A unique identifier for the client performing the mutation. */
944
2054
  clientMutationId?: Maybe<Scalars['String']['output']>;
945
2055
  /** Errors encountered during execution of the mutation. */
946
- errors: Array<Error>;
2056
+ errors?: Maybe<Array<Error>>;
947
2057
  }
948
2058
 
949
2059
  /** Autogenerated input type of NamespacesRolesAssignProjects */
@@ -962,7 +2072,7 @@ export interface NamespacesRolesAssignProjectsPayload {
962
2072
  /** A unique identifier for the client performing the mutation. */
963
2073
  clientMutationId?: Maybe<Scalars['String']['output']>;
964
2074
  /** Errors encountered during execution of the mutation. */
965
- errors: Array<Error>;
2075
+ errors?: Maybe<Array<Error>>;
966
2076
  /** The now assigned projects */
967
2077
  projects?: Maybe<Array<NamespaceProject>>;
968
2078
  }
@@ -983,7 +2093,7 @@ export interface NamespacesRolesCreatePayload {
983
2093
  /** A unique identifier for the client performing the mutation. */
984
2094
  clientMutationId?: Maybe<Scalars['String']['output']>;
985
2095
  /** Errors encountered during execution of the mutation. */
986
- errors: Array<Error>;
2096
+ errors?: Maybe<Array<Error>>;
987
2097
  /** The newly created namespace role */
988
2098
  namespaceRole?: Maybe<NamespaceRole>;
989
2099
  }
@@ -1002,7 +2112,7 @@ export interface NamespacesRolesDeletePayload {
1002
2112
  /** A unique identifier for the client performing the mutation. */
1003
2113
  clientMutationId?: Maybe<Scalars['String']['output']>;
1004
2114
  /** Errors encountered during execution of the mutation. */
1005
- errors: Array<Error>;
2115
+ errors?: Maybe<Array<Error>>;
1006
2116
  /** The deleted namespace role */
1007
2117
  namespaceRole?: Maybe<NamespaceRole>;
1008
2118
  }
@@ -1023,7 +2133,7 @@ export interface NamespacesRolesUpdatePayload {
1023
2133
  /** A unique identifier for the client performing the mutation. */
1024
2134
  clientMutationId?: Maybe<Scalars['String']['output']>;
1025
2135
  /** Errors encountered during execution of the mutation. */
1026
- errors: Array<Error>;
2136
+ errors?: Maybe<Array<Error>>;
1027
2137
  /** The updated namespace role. */
1028
2138
  namespaceRole?: Maybe<NamespaceRole>;
1029
2139
  }
@@ -1031,22 +2141,173 @@ export interface NamespacesRolesUpdatePayload {
1031
2141
  /** An object with an ID. */
1032
2142
  export interface Node {
1033
2143
  /** ID of the object. */
1034
- id: Scalars['ID']['output'];
2144
+ id?: Maybe<Scalars['ID']['output']>;
2145
+ }
2146
+
2147
+ /** Represents a Node Function */
2148
+ export interface NodeFunction {
2149
+ __typename?: 'NodeFunction';
2150
+ /** Time when this NodeFunction was created */
2151
+ createdAt?: Maybe<Scalars['Time']['output']>;
2152
+ /** The definition of the Node Function */
2153
+ functionDefinition?: Maybe<FunctionDefinition>;
2154
+ /** Global ID of this NodeFunction */
2155
+ id?: Maybe<Scalars['NodeFunctionID']['output']>;
2156
+ /** The ID of the next Node Function in the flow */
2157
+ nextNodeId?: Maybe<Scalars['NodeFunctionID']['output']>;
2158
+ /** The parameters of the Node Function */
2159
+ parameters?: Maybe<NodeParameterConnection>;
2160
+ /** Time when this NodeFunction was last updated */
2161
+ updatedAt?: Maybe<Scalars['Time']['output']>;
2162
+ }
2163
+
2164
+
2165
+ /** Represents a Node Function */
2166
+ export interface NodeFunctionParametersArgs {
2167
+ after?: InputMaybe<Scalars['String']['input']>;
2168
+ before?: InputMaybe<Scalars['String']['input']>;
2169
+ first?: InputMaybe<Scalars['Int']['input']>;
2170
+ last?: InputMaybe<Scalars['Int']['input']>;
2171
+ }
2172
+
2173
+ /** The connection type for NodeFunction. */
2174
+ export interface NodeFunctionConnection {
2175
+ __typename?: 'NodeFunctionConnection';
2176
+ /** Total count of collection. */
2177
+ count?: Maybe<Scalars['Int']['output']>;
2178
+ /** A list of edges. */
2179
+ edges?: Maybe<Array<Maybe<NodeFunctionEdge>>>;
2180
+ /** A list of nodes. */
2181
+ nodes?: Maybe<Array<Maybe<NodeFunction>>>;
2182
+ /** Information to aid in pagination. */
2183
+ pageInfo?: Maybe<PageInfo>;
2184
+ }
2185
+
2186
+ /** An edge in a connection. */
2187
+ export interface NodeFunctionEdge {
2188
+ __typename?: 'NodeFunctionEdge';
2189
+ /** A cursor for use in pagination. */
2190
+ cursor?: Maybe<Scalars['String']['output']>;
2191
+ /** The item at the end of the edge. */
2192
+ node?: Maybe<NodeFunction>;
2193
+ }
2194
+
2195
+ /** Input type for a Node Function */
2196
+ export interface NodeFunctionInput {
2197
+ /** The identifier of the Node Function used to create/update the flow */
2198
+ id: Scalars['NodeFunctionID']['input'];
2199
+ /** The next Node Function in the flow */
2200
+ nextNodeId?: InputMaybe<Scalars['NodeFunctionID']['input']>;
2201
+ /** The parameters of the Node Function */
2202
+ parameters: Array<NodeParameterInput>;
2203
+ /** The identifier of the Runtime Function Definition */
2204
+ runtimeFunctionId: Scalars['RuntimeFunctionDefinitionID']['input'];
2205
+ }
2206
+
2207
+ /** Represents a Node parameter */
2208
+ export interface NodeParameter {
2209
+ __typename?: 'NodeParameter';
2210
+ /** Time when this NodeParameter was created */
2211
+ createdAt?: Maybe<Scalars['Time']['output']>;
2212
+ /** Global ID of this NodeParameter */
2213
+ id?: Maybe<Scalars['NodeParameterID']['output']>;
2214
+ /** The definition of the parameter */
2215
+ runtimeParameter?: Maybe<RuntimeParameterDefinition>;
2216
+ /** Time when this NodeParameter was last updated */
2217
+ updatedAt?: Maybe<Scalars['Time']['output']>;
2218
+ /** The value of the parameter */
2219
+ value?: Maybe<NodeParameterValue>;
2220
+ }
2221
+
2222
+ /** The connection type for NodeParameter. */
2223
+ export interface NodeParameterConnection {
2224
+ __typename?: 'NodeParameterConnection';
2225
+ /** Total count of collection. */
2226
+ count?: Maybe<Scalars['Int']['output']>;
2227
+ /** A list of edges. */
2228
+ edges?: Maybe<Array<Maybe<NodeParameterEdge>>>;
2229
+ /** A list of nodes. */
2230
+ nodes?: Maybe<Array<Maybe<NodeParameter>>>;
2231
+ /** Information to aid in pagination. */
2232
+ pageInfo?: Maybe<PageInfo>;
2233
+ }
2234
+
2235
+ /** An edge in a connection. */
2236
+ export interface NodeParameterEdge {
2237
+ __typename?: 'NodeParameterEdge';
2238
+ /** A cursor for use in pagination. */
2239
+ cursor?: Maybe<Scalars['String']['output']>;
2240
+ /** The item at the end of the edge. */
2241
+ node?: Maybe<NodeParameter>;
2242
+ }
2243
+
2244
+ /** Input type for Node parameter */
2245
+ export interface NodeParameterInput {
2246
+ /** The identifier of the Runtime Parameter Definition */
2247
+ runtimeParameterDefinitionId: Scalars['RuntimeParameterDefinitionID']['input'];
2248
+ /** The value of the parameter */
2249
+ value?: InputMaybe<NodeParameterValueInput>;
2250
+ }
2251
+
2252
+ /** Represents a parameter value for a node. */
2253
+ export type NodeParameterValue = LiteralValue | NodeFunction | ReferenceValue;
2254
+
2255
+ /** Input type for parameter value */
2256
+ export interface NodeParameterValueInput {
2257
+ /** The function value of the parameter */
2258
+ functionValue?: InputMaybe<NodeFunctionInput>;
2259
+ /** The literal value of the parameter */
2260
+ literalValue?: InputMaybe<Scalars['JSON']['input']>;
2261
+ /** The reference value of the parameter */
2262
+ referenceValue?: InputMaybe<ReferenceValueInput>;
1035
2263
  }
1036
2264
 
1037
2265
  /** Represents a Organization */
1038
2266
  export interface Organization {
1039
2267
  __typename?: 'Organization';
1040
2268
  /** Time when this Organization was created */
1041
- createdAt: Scalars['Time']['output'];
2269
+ createdAt?: Maybe<Scalars['Time']['output']>;
1042
2270
  /** Global ID of this Organization */
1043
- id: Scalars['OrganizationID']['output'];
2271
+ id?: Maybe<Scalars['OrganizationID']['output']>;
1044
2272
  /** Name of the organization */
1045
- name: Scalars['String']['output'];
2273
+ name?: Maybe<Scalars['String']['output']>;
1046
2274
  /** Namespace of this organization */
1047
- namespace: Namespace;
2275
+ namespace?: Maybe<Namespace>;
1048
2276
  /** Time when this Organization was last updated */
1049
- updatedAt: Scalars['Time']['output'];
2277
+ updatedAt?: Maybe<Scalars['Time']['output']>;
2278
+ /** Abilities for the current user on this Organization */
2279
+ userAbilities?: Maybe<OrganizationUserAbilities>;
2280
+ }
2281
+
2282
+ /** The connection type for Organization. */
2283
+ export interface OrganizationConnection {
2284
+ __typename?: 'OrganizationConnection';
2285
+ /** Total count of collection. */
2286
+ count?: Maybe<Scalars['Int']['output']>;
2287
+ /** A list of edges. */
2288
+ edges?: Maybe<Array<Maybe<OrganizationEdge>>>;
2289
+ /** A list of nodes. */
2290
+ nodes?: Maybe<Array<Maybe<Organization>>>;
2291
+ /** Information to aid in pagination. */
2292
+ pageInfo?: Maybe<PageInfo>;
2293
+ }
2294
+
2295
+ /** An edge in a connection. */
2296
+ export interface OrganizationEdge {
2297
+ __typename?: 'OrganizationEdge';
2298
+ /** A cursor for use in pagination. */
2299
+ cursor?: Maybe<Scalars['String']['output']>;
2300
+ /** The item at the end of the edge. */
2301
+ node?: Maybe<Organization>;
2302
+ }
2303
+
2304
+ /** Abilities for the current user on this Organization */
2305
+ export interface OrganizationUserAbilities {
2306
+ __typename?: 'OrganizationUserAbilities';
2307
+ /** Shows if the current user has the `delete_organization` ability on this Organization */
2308
+ deleteOrganization?: Maybe<Scalars['Boolean']['output']>;
2309
+ /** Shows if the current user has the `update_organization` ability on this Organization */
2310
+ updateOrganization?: Maybe<Scalars['Boolean']['output']>;
1050
2311
  }
1051
2312
 
1052
2313
  /** Autogenerated input type of OrganizationsCreate */
@@ -1063,7 +2324,7 @@ export interface OrganizationsCreatePayload {
1063
2324
  /** A unique identifier for the client performing the mutation. */
1064
2325
  clientMutationId?: Maybe<Scalars['String']['output']>;
1065
2326
  /** Errors encountered during execution of the mutation. */
1066
- errors: Array<Error>;
2327
+ errors?: Maybe<Array<Error>>;
1067
2328
  /** The newly created organization. */
1068
2329
  organization?: Maybe<Organization>;
1069
2330
  }
@@ -1082,7 +2343,7 @@ export interface OrganizationsDeletePayload {
1082
2343
  /** A unique identifier for the client performing the mutation. */
1083
2344
  clientMutationId?: Maybe<Scalars['String']['output']>;
1084
2345
  /** Errors encountered during execution of the mutation. */
1085
- errors: Array<Error>;
2346
+ errors?: Maybe<Array<Error>>;
1086
2347
  /** The deleted organization. */
1087
2348
  organization?: Maybe<Organization>;
1088
2349
  }
@@ -1103,7 +2364,7 @@ export interface OrganizationsUpdatePayload {
1103
2364
  /** A unique identifier for the client performing the mutation. */
1104
2365
  clientMutationId?: Maybe<Scalars['String']['output']>;
1105
2366
  /** Errors encountered during execution of the mutation. */
1106
- errors: Array<Error>;
2367
+ errors?: Maybe<Array<Error>>;
1107
2368
  /** The updated organization. */
1108
2369
  organization?: Maybe<Organization>;
1109
2370
  }
@@ -1114,13 +2375,83 @@ export interface PageInfo {
1114
2375
  /** When paginating forwards, the cursor to continue. */
1115
2376
  endCursor?: Maybe<Scalars['String']['output']>;
1116
2377
  /** When paginating forwards, are there more items? */
1117
- hasNextPage: Scalars['Boolean']['output'];
2378
+ hasNextPage?: Maybe<Scalars['Boolean']['output']>;
1118
2379
  /** When paginating backwards, are there more items? */
1119
- hasPreviousPage: Scalars['Boolean']['output'];
2380
+ hasPreviousPage?: Maybe<Scalars['Boolean']['output']>;
1120
2381
  /** When paginating backwards, the cursor to continue. */
1121
2382
  startCursor?: Maybe<Scalars['String']['output']>;
1122
2383
  }
1123
2384
 
2385
+ /** Represents a parameter definition */
2386
+ export interface ParameterDefinition {
2387
+ __typename?: 'ParameterDefinition';
2388
+ /** Time when this ParameterDefinition was created */
2389
+ createdAt?: Maybe<Scalars['Time']['output']>;
2390
+ /** Data type of the parameter */
2391
+ dataTypeIdentifier?: Maybe<DataTypeIdentifier>;
2392
+ /** Description of the parameter */
2393
+ descriptions?: Maybe<TranslationConnection>;
2394
+ /** Documentation of the parameter */
2395
+ documentations?: Maybe<TranslationConnection>;
2396
+ /** Global ID of this ParameterDefinition */
2397
+ id?: Maybe<Scalars['ParameterDefinitionID']['output']>;
2398
+ /** Identifier of the parameter */
2399
+ identifier?: Maybe<Scalars['String']['output']>;
2400
+ /** Name of the parameter */
2401
+ names?: Maybe<TranslationConnection>;
2402
+ /** Time when this ParameterDefinition was last updated */
2403
+ updatedAt?: Maybe<Scalars['Time']['output']>;
2404
+ }
2405
+
2406
+
2407
+ /** Represents a parameter definition */
2408
+ export interface ParameterDefinitionDescriptionsArgs {
2409
+ after?: InputMaybe<Scalars['String']['input']>;
2410
+ before?: InputMaybe<Scalars['String']['input']>;
2411
+ first?: InputMaybe<Scalars['Int']['input']>;
2412
+ last?: InputMaybe<Scalars['Int']['input']>;
2413
+ }
2414
+
2415
+
2416
+ /** Represents a parameter definition */
2417
+ export interface ParameterDefinitionDocumentationsArgs {
2418
+ after?: InputMaybe<Scalars['String']['input']>;
2419
+ before?: InputMaybe<Scalars['String']['input']>;
2420
+ first?: InputMaybe<Scalars['Int']['input']>;
2421
+ last?: InputMaybe<Scalars['Int']['input']>;
2422
+ }
2423
+
2424
+
2425
+ /** Represents a parameter definition */
2426
+ export interface ParameterDefinitionNamesArgs {
2427
+ after?: InputMaybe<Scalars['String']['input']>;
2428
+ before?: InputMaybe<Scalars['String']['input']>;
2429
+ first?: InputMaybe<Scalars['Int']['input']>;
2430
+ last?: InputMaybe<Scalars['Int']['input']>;
2431
+ }
2432
+
2433
+ /** The connection type for ParameterDefinition. */
2434
+ export interface ParameterDefinitionConnection {
2435
+ __typename?: 'ParameterDefinitionConnection';
2436
+ /** Total count of collection. */
2437
+ count?: Maybe<Scalars['Int']['output']>;
2438
+ /** A list of edges. */
2439
+ edges?: Maybe<Array<Maybe<ParameterDefinitionEdge>>>;
2440
+ /** A list of nodes. */
2441
+ nodes?: Maybe<Array<Maybe<ParameterDefinition>>>;
2442
+ /** Information to aid in pagination. */
2443
+ pageInfo?: Maybe<PageInfo>;
2444
+ }
2445
+
2446
+ /** An edge in a connection. */
2447
+ export interface ParameterDefinitionEdge {
2448
+ __typename?: 'ParameterDefinitionEdge';
2449
+ /** A cursor for use in pagination. */
2450
+ cursor?: Maybe<Scalars['String']['output']>;
2451
+ /** The item at the end of the edge. */
2452
+ node?: Maybe<ParameterDefinition>;
2453
+ }
2454
+
1124
2455
  /** Root Query type */
1125
2456
  export interface Query {
1126
2457
  __typename?: 'Query';
@@ -1131,9 +2462,11 @@ export interface Query {
1131
2462
  /** Get the currently logged in user */
1132
2463
  currentUser?: Maybe<User>;
1133
2464
  /** Field available for use to test API access */
1134
- echo: Scalars['String']['output'];
2465
+ echo?: Maybe<Scalars['String']['output']>;
1135
2466
  /** Find runtimes */
1136
- globalRuntimes: RuntimeConnection;
2467
+ globalRuntimes?: Maybe<RuntimeConnection>;
2468
+ /** Get application metadata */
2469
+ metadata?: Maybe<Metadata>;
1137
2470
  /** Find a namespace */
1138
2471
  namespace?: Maybe<Namespace>;
1139
2472
  /** Fetches an object given its ID */
@@ -1142,6 +2475,14 @@ export interface Query {
1142
2475
  nodes?: Maybe<Array<Maybe<Node>>>;
1143
2476
  /** Find a organization */
1144
2477
  organization?: Maybe<Organization>;
2478
+ /** Find organizations */
2479
+ organizations?: Maybe<OrganizationConnection>;
2480
+ /** Find a user */
2481
+ user?: Maybe<User>;
2482
+ /** Abilities for the current user on this Instance */
2483
+ userAbilities?: Maybe<InstanceUserAbilities>;
2484
+ /** Find users */
2485
+ users?: Maybe<UserConnection>;
1145
2486
  }
1146
2487
 
1147
2488
 
@@ -1184,25 +2525,119 @@ export interface QueryOrganizationArgs {
1184
2525
  name?: InputMaybe<Scalars['String']['input']>;
1185
2526
  }
1186
2527
 
2528
+
2529
+ /** Root Query type */
2530
+ export interface QueryOrganizationsArgs {
2531
+ after?: InputMaybe<Scalars['String']['input']>;
2532
+ before?: InputMaybe<Scalars['String']['input']>;
2533
+ first?: InputMaybe<Scalars['Int']['input']>;
2534
+ last?: InputMaybe<Scalars['Int']['input']>;
2535
+ }
2536
+
2537
+
2538
+ /** Root Query type */
2539
+ export interface QueryUserArgs {
2540
+ id: Scalars['UserID']['input'];
2541
+ }
2542
+
2543
+
2544
+ /** Root Query type */
2545
+ export interface QueryUsersArgs {
2546
+ after?: InputMaybe<Scalars['String']['input']>;
2547
+ before?: InputMaybe<Scalars['String']['input']>;
2548
+ first?: InputMaybe<Scalars['Int']['input']>;
2549
+ last?: InputMaybe<Scalars['Int']['input']>;
2550
+ }
2551
+
2552
+ /** Represents a reference path in a flow */
2553
+ export interface ReferencePath {
2554
+ __typename?: 'ReferencePath';
2555
+ /** The array index of the referenced data by the path */
2556
+ arrayIndex?: Maybe<Scalars['Int']['output']>;
2557
+ /** Time when this ReferencePath was created */
2558
+ createdAt?: Maybe<Scalars['Time']['output']>;
2559
+ /** Global ID of this ReferencePath */
2560
+ id?: Maybe<Scalars['ReferencePathID']['output']>;
2561
+ /** The path to the reference in the flow */
2562
+ path?: Maybe<Scalars['String']['output']>;
2563
+ /** Time when this ReferencePath was last updated */
2564
+ updatedAt?: Maybe<Scalars['Time']['output']>;
2565
+ }
2566
+
2567
+ /** Input type for reference path */
2568
+ export interface ReferencePathInput {
2569
+ /** Array index if applicable */
2570
+ arrayIndex?: InputMaybe<Scalars['Int']['input']>;
2571
+ /** The path to the reference in the flow */
2572
+ path?: InputMaybe<Scalars['String']['input']>;
2573
+ }
2574
+
2575
+ /** Represents a reference value in the system. */
2576
+ export interface ReferenceValue {
2577
+ __typename?: 'ReferenceValue';
2578
+ /** Time when this ReferenceValue was created */
2579
+ createdAt?: Maybe<Scalars['Time']['output']>;
2580
+ /** The identifier of the data type this reference value belongs to. */
2581
+ dataTypeIdentifier?: Maybe<DataTypeIdentifier>;
2582
+ /** The depth of the reference value. */
2583
+ depth?: Maybe<Scalars['Int']['output']>;
2584
+ /** Global ID of this ReferenceValue */
2585
+ id?: Maybe<Scalars['ReferenceValueID']['output']>;
2586
+ /** The node of the reference value. */
2587
+ node?: Maybe<Scalars['Int']['output']>;
2588
+ /** The referenced value. */
2589
+ nodeFunctionId?: Maybe<Scalars['NodeFunctionID']['output']>;
2590
+ /** The paths associated with this reference value. */
2591
+ referencePath?: Maybe<Array<ReferencePath>>;
2592
+ /** The scope of the reference value. */
2593
+ scope?: Maybe<Array<Scalars['Int']['output']>>;
2594
+ /** Time when this ReferenceValue was last updated */
2595
+ updatedAt?: Maybe<Scalars['Time']['output']>;
2596
+ }
2597
+
2598
+ /** Input type for reference value */
2599
+ export interface ReferenceValueInput {
2600
+ /** The identifier of the data type this reference value belongs to */
2601
+ dataTypeIdentifier: DataTypeIdentifierInput;
2602
+ /** The depth of the reference value */
2603
+ depth: Scalars['Int']['input'];
2604
+ /** The node of the reference */
2605
+ node: Scalars['Int']['input'];
2606
+ /** The referenced value */
2607
+ nodeFunctionId: Scalars['NodeFunctionID']['input'];
2608
+ /** The paths associated with this reference value */
2609
+ referencePath: Array<ReferencePathInput>;
2610
+ /** The scope of the reference value */
2611
+ scope: Array<Scalars['Int']['input']>;
2612
+ }
2613
+
1187
2614
  /** Represents a runtime */
1188
2615
  export interface Runtime {
1189
2616
  __typename?: 'Runtime';
1190
2617
  /** Time when this Runtime was created */
1191
- createdAt: Scalars['Time']['output'];
2618
+ createdAt?: Maybe<Scalars['Time']['output']>;
1192
2619
  /** DataTypes of the runtime */
1193
- dataTypes: DataTypeConnection;
2620
+ dataTypes?: Maybe<DataTypeConnection>;
1194
2621
  /** The description for the runtime if present */
1195
- description: Scalars['String']['output'];
2622
+ description?: Maybe<Scalars['String']['output']>;
2623
+ /** FlowTypes of the runtime */
2624
+ flowTypes?: Maybe<FlowTypeConnection>;
1196
2625
  /** Global ID of this Runtime */
1197
- id: Scalars['RuntimeID']['output'];
2626
+ id?: Maybe<Scalars['RuntimeID']['output']>;
1198
2627
  /** The name for the runtime */
1199
- name: Scalars['String']['output'];
2628
+ name?: Maybe<Scalars['String']['output']>;
1200
2629
  /** The parent namespace for the runtime */
1201
2630
  namespace?: Maybe<Namespace>;
2631
+ /** Projects associated with the runtime */
2632
+ projects?: Maybe<NamespaceProjectConnection>;
2633
+ /** The status of the runtime */
2634
+ status?: Maybe<RuntimeStatusType>;
1202
2635
  /** Token belonging to the runtime, only present on creation */
1203
2636
  token?: Maybe<Scalars['String']['output']>;
1204
2637
  /** Time when this Runtime was last updated */
1205
- updatedAt: Scalars['Time']['output'];
2638
+ updatedAt?: Maybe<Scalars['Time']['output']>;
2639
+ /** Abilities for the current user on this Runtime */
2640
+ userAbilities?: Maybe<RuntimeUserAbilities>;
1206
2641
  }
1207
2642
 
1208
2643
 
@@ -1214,28 +2649,135 @@ export interface RuntimeDataTypesArgs {
1214
2649
  last?: InputMaybe<Scalars['Int']['input']>;
1215
2650
  }
1216
2651
 
2652
+
2653
+ /** Represents a runtime */
2654
+ export interface RuntimeFlowTypesArgs {
2655
+ after?: InputMaybe<Scalars['String']['input']>;
2656
+ before?: InputMaybe<Scalars['String']['input']>;
2657
+ first?: InputMaybe<Scalars['Int']['input']>;
2658
+ last?: InputMaybe<Scalars['Int']['input']>;
2659
+ }
2660
+
2661
+
2662
+ /** Represents a runtime */
2663
+ export interface RuntimeProjectsArgs {
2664
+ after?: InputMaybe<Scalars['String']['input']>;
2665
+ before?: InputMaybe<Scalars['String']['input']>;
2666
+ first?: InputMaybe<Scalars['Int']['input']>;
2667
+ last?: InputMaybe<Scalars['Int']['input']>;
2668
+ }
2669
+
1217
2670
  /** The connection type for Runtime. */
1218
2671
  export interface RuntimeConnection {
1219
2672
  __typename?: 'RuntimeConnection';
1220
2673
  /** Total count of collection. */
1221
- count: Scalars['Int']['output'];
2674
+ count?: Maybe<Scalars['Int']['output']>;
1222
2675
  /** A list of edges. */
1223
2676
  edges?: Maybe<Array<Maybe<RuntimeEdge>>>;
1224
2677
  /** A list of nodes. */
1225
2678
  nodes?: Maybe<Array<Maybe<Runtime>>>;
1226
2679
  /** Information to aid in pagination. */
1227
- pageInfo: PageInfo;
2680
+ pageInfo?: Maybe<PageInfo>;
1228
2681
  }
1229
2682
 
1230
2683
  /** An edge in a connection. */
1231
2684
  export interface RuntimeEdge {
1232
2685
  __typename?: 'RuntimeEdge';
1233
2686
  /** A cursor for use in pagination. */
1234
- cursor: Scalars['String']['output'];
2687
+ cursor?: Maybe<Scalars['String']['output']>;
1235
2688
  /** The item at the end of the edge. */
1236
2689
  node?: Maybe<Runtime>;
1237
2690
  }
1238
2691
 
2692
+ /** Represents a runtime function definition */
2693
+ export interface RuntimeFunctionDefinition {
2694
+ __typename?: 'RuntimeFunctionDefinition';
2695
+ /** Time when this RuntimeFunctionDefinition was created */
2696
+ createdAt?: Maybe<Scalars['Time']['output']>;
2697
+ /** Function definitions of the runtime function definition */
2698
+ functionDefinitions?: Maybe<FunctionDefinitionConnection>;
2699
+ /** Global ID of this RuntimeFunctionDefinition */
2700
+ id?: Maybe<Scalars['RuntimeFunctionDefinitionID']['output']>;
2701
+ /** Identifier of the runtime function definition */
2702
+ identifier?: Maybe<Scalars['String']['output']>;
2703
+ /** The runtime this runtime function definition belongs to */
2704
+ runtime?: Maybe<Runtime>;
2705
+ /** Parameter definitions of the runtime function definition */
2706
+ runtimeParameterDefinitions?: Maybe<RuntimeParameterDefinitionConnection>;
2707
+ /** Time when this RuntimeFunctionDefinition was last updated */
2708
+ updatedAt?: Maybe<Scalars['Time']['output']>;
2709
+ }
2710
+
2711
+
2712
+ /** Represents a runtime function definition */
2713
+ export interface RuntimeFunctionDefinitionFunctionDefinitionsArgs {
2714
+ after?: InputMaybe<Scalars['String']['input']>;
2715
+ before?: InputMaybe<Scalars['String']['input']>;
2716
+ first?: InputMaybe<Scalars['Int']['input']>;
2717
+ last?: InputMaybe<Scalars['Int']['input']>;
2718
+ }
2719
+
2720
+
2721
+ /** Represents a runtime function definition */
2722
+ export interface RuntimeFunctionDefinitionRuntimeParameterDefinitionsArgs {
2723
+ after?: InputMaybe<Scalars['String']['input']>;
2724
+ before?: InputMaybe<Scalars['String']['input']>;
2725
+ first?: InputMaybe<Scalars['Int']['input']>;
2726
+ last?: InputMaybe<Scalars['Int']['input']>;
2727
+ }
2728
+
2729
+ /** Represents a runtime parameter definition */
2730
+ export interface RuntimeParameterDefinition {
2731
+ __typename?: 'RuntimeParameterDefinition';
2732
+ /** Time when this RuntimeParameterDefinition was created */
2733
+ createdAt?: Maybe<Scalars['Time']['output']>;
2734
+ /** Global ID of this RuntimeParameterDefinition */
2735
+ id?: Maybe<Scalars['RuntimeParameterDefinitionID']['output']>;
2736
+ /** Time when this RuntimeParameterDefinition was last updated */
2737
+ updatedAt?: Maybe<Scalars['Time']['output']>;
2738
+ }
2739
+
2740
+ /** The connection type for RuntimeParameterDefinition. */
2741
+ export interface RuntimeParameterDefinitionConnection {
2742
+ __typename?: 'RuntimeParameterDefinitionConnection';
2743
+ /** Total count of collection. */
2744
+ count?: Maybe<Scalars['Int']['output']>;
2745
+ /** A list of edges. */
2746
+ edges?: Maybe<Array<Maybe<RuntimeParameterDefinitionEdge>>>;
2747
+ /** A list of nodes. */
2748
+ nodes?: Maybe<Array<Maybe<RuntimeParameterDefinition>>>;
2749
+ /** Information to aid in pagination. */
2750
+ pageInfo?: Maybe<PageInfo>;
2751
+ }
2752
+
2753
+ /** An edge in a connection. */
2754
+ export interface RuntimeParameterDefinitionEdge {
2755
+ __typename?: 'RuntimeParameterDefinitionEdge';
2756
+ /** A cursor for use in pagination. */
2757
+ cursor?: Maybe<Scalars['String']['output']>;
2758
+ /** The item at the end of the edge. */
2759
+ node?: Maybe<RuntimeParameterDefinition>;
2760
+ }
2761
+
2762
+ /** Represent all available types of statuses of a runtime */
2763
+ export const enum RuntimeStatusType {
2764
+ /** No problem with connection, everything works as expected */
2765
+ Connected = 'CONNECTED',
2766
+ /** The runtime is disconnected, cause unknown */
2767
+ Disconnected = 'DISCONNECTED'
2768
+ }
2769
+
2770
+ /** Abilities for the current user on this Runtime */
2771
+ export interface RuntimeUserAbilities {
2772
+ __typename?: 'RuntimeUserAbilities';
2773
+ /** Shows if the current user has the `delete_runtime` ability on this Runtime */
2774
+ deleteRuntime?: Maybe<Scalars['Boolean']['output']>;
2775
+ /** Shows if the current user has the `rotate_runtime_token` ability on this Runtime */
2776
+ rotateRuntimeToken?: Maybe<Scalars['Boolean']['output']>;
2777
+ /** Shows if the current user has the `update_runtime` ability on this Runtime */
2778
+ updateRuntime?: Maybe<Scalars['Boolean']['output']>;
2779
+ }
2780
+
1239
2781
  /** Autogenerated input type of RuntimesCreate */
1240
2782
  export interface RuntimesCreateInput {
1241
2783
  /** A unique identifier for the client performing the mutation. */
@@ -1254,7 +2796,7 @@ export interface RuntimesCreatePayload {
1254
2796
  /** A unique identifier for the client performing the mutation. */
1255
2797
  clientMutationId?: Maybe<Scalars['String']['output']>;
1256
2798
  /** Errors encountered during execution of the mutation. */
1257
- errors: Array<Error>;
2799
+ errors?: Maybe<Array<Error>>;
1258
2800
  /** The newly created runtime. */
1259
2801
  runtime?: Maybe<Runtime>;
1260
2802
  }
@@ -1273,7 +2815,7 @@ export interface RuntimesDeletePayload {
1273
2815
  /** A unique identifier for the client performing the mutation. */
1274
2816
  clientMutationId?: Maybe<Scalars['String']['output']>;
1275
2817
  /** Errors encountered during execution of the mutation. */
1276
- errors: Array<Error>;
2818
+ errors?: Maybe<Array<Error>>;
1277
2819
  /** The updated organization. */
1278
2820
  runtime?: Maybe<Runtime>;
1279
2821
  }
@@ -1292,7 +2834,7 @@ export interface RuntimesRotateTokenPayload {
1292
2834
  /** A unique identifier for the client performing the mutation. */
1293
2835
  clientMutationId?: Maybe<Scalars['String']['output']>;
1294
2836
  /** Errors encountered during execution of the mutation. */
1295
- errors: Array<Error>;
2837
+ errors?: Maybe<Array<Error>>;
1296
2838
  /** The updated runtime. */
1297
2839
  runtime?: Maybe<Runtime>;
1298
2840
  }
@@ -1315,36 +2857,84 @@ export interface RuntimesUpdatePayload {
1315
2857
  /** A unique identifier for the client performing the mutation. */
1316
2858
  clientMutationId?: Maybe<Scalars['String']['output']>;
1317
2859
  /** Errors encountered during execution of the mutation. */
1318
- errors: Array<Error>;
2860
+ errors?: Maybe<Array<Error>>;
1319
2861
  /** The updated runtime. */
1320
2862
  runtime?: Maybe<Runtime>;
1321
2863
  }
1322
2864
 
2865
+ /** Represents a translation */
2866
+ export interface Translation {
2867
+ __typename?: 'Translation';
2868
+ /** Code of the translation */
2869
+ code?: Maybe<Scalars['String']['output']>;
2870
+ /** Content of the translation */
2871
+ content?: Maybe<Scalars['String']['output']>;
2872
+ }
2873
+
2874
+ /** The connection type for Translation. */
2875
+ export interface TranslationConnection {
2876
+ __typename?: 'TranslationConnection';
2877
+ /** Total count of collection. */
2878
+ count?: Maybe<Scalars['Int']['output']>;
2879
+ /** A list of edges. */
2880
+ edges?: Maybe<Array<Maybe<TranslationEdge>>>;
2881
+ /** A list of nodes. */
2882
+ nodes?: Maybe<Array<Maybe<Translation>>>;
2883
+ /** Information to aid in pagination. */
2884
+ pageInfo?: Maybe<PageInfo>;
2885
+ }
2886
+
2887
+ /** An edge in a connection. */
2888
+ export interface TranslationEdge {
2889
+ __typename?: 'TranslationEdge';
2890
+ /** A cursor for use in pagination. */
2891
+ cursor?: Maybe<Scalars['String']['output']>;
2892
+ /** The item at the end of the edge. */
2893
+ node?: Maybe<Translation>;
2894
+ }
2895
+
1323
2896
  /** Represents a user */
1324
2897
  export interface User {
1325
2898
  __typename?: 'User';
1326
2899
  /** Global admin status of the user */
1327
- admin: Scalars['Boolean']['output'];
2900
+ admin?: Maybe<Scalars['Boolean']['output']>;
1328
2901
  /** The avatar if present of the user */
1329
2902
  avatarPath?: Maybe<Scalars['String']['output']>;
1330
2903
  /** Time when this User was created */
1331
- createdAt: Scalars['Time']['output'];
2904
+ createdAt?: Maybe<Scalars['Time']['output']>;
1332
2905
  /** Email of the user */
1333
- email: Scalars['String']['output'];
2906
+ email?: Maybe<Scalars['String']['output']>;
2907
+ /** Email verification date of the user if present */
2908
+ emailVerifiedAt?: Maybe<Scalars['Time']['output']>;
1334
2909
  /** Firstname of the user */
1335
- firstname: Scalars['String']['output'];
2910
+ firstname?: Maybe<Scalars['String']['output']>;
1336
2911
  /** Global ID of this User */
1337
- id: Scalars['UserID']['output'];
2912
+ id?: Maybe<Scalars['UserID']['output']>;
2913
+ /** Identities of this user */
2914
+ identities?: Maybe<UserIdentityConnection>;
1338
2915
  /** Lastname of the user */
1339
- lastname: Scalars['String']['output'];
2916
+ lastname?: Maybe<Scalars['String']['output']>;
1340
2917
  /** Namespace of this user */
1341
2918
  namespace?: Maybe<Namespace>;
1342
2919
  /** Namespace Memberships of this user */
1343
- namespaceMemberships: NamespaceMemberConnection;
2920
+ namespaceMemberships?: Maybe<NamespaceMemberConnection>;
2921
+ /** Sessions of this user */
2922
+ sessions?: Maybe<UserSessionConnection>;
1344
2923
  /** Time when this User was last updated */
1345
- updatedAt: Scalars['Time']['output'];
2924
+ updatedAt?: Maybe<Scalars['Time']['output']>;
2925
+ /** Abilities for the current user on this User */
2926
+ userAbilities?: Maybe<UserUserAbilities>;
1346
2927
  /** Username of the user */
1347
- username: Scalars['String']['output'];
2928
+ username?: Maybe<Scalars['String']['output']>;
2929
+ }
2930
+
2931
+
2932
+ /** Represents a user */
2933
+ export interface UserIdentitiesArgs {
2934
+ after?: InputMaybe<Scalars['String']['input']>;
2935
+ before?: InputMaybe<Scalars['String']['input']>;
2936
+ first?: InputMaybe<Scalars['Int']['input']>;
2937
+ last?: InputMaybe<Scalars['Int']['input']>;
1348
2938
  }
1349
2939
 
1350
2940
 
@@ -1356,38 +2946,150 @@ export interface UserNamespaceMembershipsArgs {
1356
2946
  last?: InputMaybe<Scalars['Int']['input']>;
1357
2947
  }
1358
2948
 
2949
+
2950
+ /** Represents a user */
2951
+ export interface UserSessionsArgs {
2952
+ after?: InputMaybe<Scalars['String']['input']>;
2953
+ before?: InputMaybe<Scalars['String']['input']>;
2954
+ first?: InputMaybe<Scalars['Int']['input']>;
2955
+ last?: InputMaybe<Scalars['Int']['input']>;
2956
+ }
2957
+
2958
+ /** The connection type for User. */
2959
+ export interface UserConnection {
2960
+ __typename?: 'UserConnection';
2961
+ /** Total count of collection. */
2962
+ count?: Maybe<Scalars['Int']['output']>;
2963
+ /** A list of edges. */
2964
+ edges?: Maybe<Array<Maybe<UserEdge>>>;
2965
+ /** A list of nodes. */
2966
+ nodes?: Maybe<Array<Maybe<User>>>;
2967
+ /** Information to aid in pagination. */
2968
+ pageInfo?: Maybe<PageInfo>;
2969
+ }
2970
+
2971
+ /** An edge in a connection. */
2972
+ export interface UserEdge {
2973
+ __typename?: 'UserEdge';
2974
+ /** A cursor for use in pagination. */
2975
+ cursor?: Maybe<Scalars['String']['output']>;
2976
+ /** The item at the end of the edge. */
2977
+ node?: Maybe<User>;
2978
+ }
2979
+
1359
2980
  /** Represents an external user identity */
1360
2981
  export interface UserIdentity {
1361
2982
  __typename?: 'UserIdentity';
1362
2983
  /** Time when this UserIdentity was created */
1363
- createdAt: Scalars['Time']['output'];
2984
+ createdAt?: Maybe<Scalars['Time']['output']>;
1364
2985
  /** Global ID of this UserIdentity */
1365
- id: Scalars['UserIdentityID']['output'];
2986
+ id?: Maybe<Scalars['UserIdentityID']['output']>;
1366
2987
  /** The description for the runtime if present */
1367
- identifier: Scalars['String']['output'];
2988
+ identifier?: Maybe<Scalars['String']['output']>;
1368
2989
  /** The name for the runtime */
1369
- providerId: Scalars['String']['output'];
2990
+ providerId?: Maybe<Scalars['String']['output']>;
1370
2991
  /** Time when this UserIdentity was last updated */
1371
- updatedAt: Scalars['Time']['output'];
2992
+ updatedAt?: Maybe<Scalars['Time']['output']>;
1372
2993
  /** The correlating user of the identity */
1373
- user: User;
2994
+ user?: Maybe<User>;
2995
+ }
2996
+
2997
+ /** The connection type for UserIdentity. */
2998
+ export interface UserIdentityConnection {
2999
+ __typename?: 'UserIdentityConnection';
3000
+ /** Total count of collection. */
3001
+ count?: Maybe<Scalars['Int']['output']>;
3002
+ /** A list of edges. */
3003
+ edges?: Maybe<Array<Maybe<UserIdentityEdge>>>;
3004
+ /** A list of nodes. */
3005
+ nodes?: Maybe<Array<Maybe<UserIdentity>>>;
3006
+ /** Information to aid in pagination. */
3007
+ pageInfo?: Maybe<PageInfo>;
3008
+ }
3009
+
3010
+ /** An edge in a connection. */
3011
+ export interface UserIdentityEdge {
3012
+ __typename?: 'UserIdentityEdge';
3013
+ /** A cursor for use in pagination. */
3014
+ cursor?: Maybe<Scalars['String']['output']>;
3015
+ /** The item at the end of the edge. */
3016
+ node?: Maybe<UserIdentity>;
1374
3017
  }
1375
3018
 
1376
3019
  /** Represents a user session */
1377
3020
  export interface UserSession {
1378
3021
  __typename?: 'UserSession';
1379
3022
  /** Whether or not the session is active and can be used */
1380
- active: Scalars['Boolean']['output'];
3023
+ active?: Maybe<Scalars['Boolean']['output']>;
1381
3024
  /** Time when this UserSession was created */
1382
- createdAt: Scalars['Time']['output'];
3025
+ createdAt?: Maybe<Scalars['Time']['output']>;
1383
3026
  /** Global ID of this UserSession */
1384
- id: Scalars['UserSessionID']['output'];
3027
+ id?: Maybe<Scalars['UserSessionID']['output']>;
1385
3028
  /** Token belonging to the session, only present on creation */
1386
3029
  token?: Maybe<Scalars['String']['output']>;
1387
3030
  /** Time when this UserSession was last updated */
1388
- updatedAt: Scalars['Time']['output'];
3031
+ updatedAt?: Maybe<Scalars['Time']['output']>;
1389
3032
  /** User that belongs to the session */
1390
- user: User;
3033
+ user?: Maybe<User>;
3034
+ /** Abilities for the current user on this UserSession */
3035
+ userAbilities?: Maybe<UserSessionUserAbilities>;
3036
+ }
3037
+
3038
+ /** The connection type for UserSession. */
3039
+ export interface UserSessionConnection {
3040
+ __typename?: 'UserSessionConnection';
3041
+ /** Total count of collection. */
3042
+ count?: Maybe<Scalars['Int']['output']>;
3043
+ /** A list of edges. */
3044
+ edges?: Maybe<Array<Maybe<UserSessionEdge>>>;
3045
+ /** A list of nodes. */
3046
+ nodes?: Maybe<Array<Maybe<UserSession>>>;
3047
+ /** Information to aid in pagination. */
3048
+ pageInfo?: Maybe<PageInfo>;
3049
+ }
3050
+
3051
+ /** An edge in a connection. */
3052
+ export interface UserSessionEdge {
3053
+ __typename?: 'UserSessionEdge';
3054
+ /** A cursor for use in pagination. */
3055
+ cursor?: Maybe<Scalars['String']['output']>;
3056
+ /** The item at the end of the edge. */
3057
+ node?: Maybe<UserSession>;
3058
+ }
3059
+
3060
+ /** Abilities for the current user on this UserSession */
3061
+ export interface UserSessionUserAbilities {
3062
+ __typename?: 'UserSessionUserAbilities';
3063
+ /** Shows if the current user has the `logout_session` ability on this UserSession */
3064
+ logoutSession?: Maybe<Scalars['Boolean']['output']>;
3065
+ }
3066
+
3067
+ /** Abilities for the current user on this User */
3068
+ export interface UserUserAbilities {
3069
+ __typename?: 'UserUserAbilities';
3070
+ /** Shows if the current user has the `manage_mfa` ability on this User */
3071
+ manageMfa?: Maybe<Scalars['Boolean']['output']>;
3072
+ /** Shows if the current user has the `update_user` ability on this User */
3073
+ updateUser?: Maybe<Scalars['Boolean']['output']>;
3074
+ }
3075
+
3076
+ /** Autogenerated input type of UsersEmailVerification */
3077
+ export interface UsersEmailVerificationInput {
3078
+ /** A unique identifier for the client performing the mutation. */
3079
+ clientMutationId?: InputMaybe<Scalars['String']['input']>;
3080
+ /** The email verification token */
3081
+ token: Scalars['String']['input'];
3082
+ }
3083
+
3084
+ /** Autogenerated return type of UsersEmailVerification. */
3085
+ export interface UsersEmailVerificationPayload {
3086
+ __typename?: 'UsersEmailVerificationPayload';
3087
+ /** A unique identifier for the client performing the mutation. */
3088
+ clientMutationId?: Maybe<Scalars['String']['output']>;
3089
+ /** Errors encountered during execution of the mutation. */
3090
+ errors?: Maybe<Array<Error>>;
3091
+ /** The user whose email was verified */
3092
+ user?: Maybe<User>;
1391
3093
  }
1392
3094
 
1393
3095
  /** Autogenerated input type of UsersIdentityLink */
@@ -1406,7 +3108,7 @@ export interface UsersIdentityLinkPayload {
1406
3108
  /** A unique identifier for the client performing the mutation. */
1407
3109
  clientMutationId?: Maybe<Scalars['String']['output']>;
1408
3110
  /** Errors encountered during execution of the mutation. */
1409
- errors: Array<Error>;
3111
+ errors?: Maybe<Array<Error>>;
1410
3112
  /** The created user identity */
1411
3113
  userIdentity?: Maybe<UserIdentity>;
1412
3114
  }
@@ -1427,7 +3129,7 @@ export interface UsersIdentityLoginPayload {
1427
3129
  /** A unique identifier for the client performing the mutation. */
1428
3130
  clientMutationId?: Maybe<Scalars['String']['output']>;
1429
3131
  /** Errors encountered during execution of the mutation. */
1430
- errors: Array<Error>;
3132
+ errors?: Maybe<Array<Error>>;
1431
3133
  /** The created user session */
1432
3134
  userSession?: Maybe<UserSession>;
1433
3135
  }
@@ -1448,7 +3150,7 @@ export interface UsersIdentityRegisterPayload {
1448
3150
  /** A unique identifier for the client performing the mutation. */
1449
3151
  clientMutationId?: Maybe<Scalars['String']['output']>;
1450
3152
  /** Errors encountered during execution of the mutation. */
1451
- errors: Array<Error>;
3153
+ errors?: Maybe<Array<Error>>;
1452
3154
  /** The created users session */
1453
3155
  userSession?: Maybe<UserSession>;
1454
3156
  }
@@ -1467,7 +3169,7 @@ export interface UsersIdentityUnlinkPayload {
1467
3169
  /** A unique identifier for the client performing the mutation. */
1468
3170
  clientMutationId?: Maybe<Scalars['String']['output']>;
1469
3171
  /** Errors encountered during execution of the mutation. */
1470
- errors: Array<Error>;
3172
+ errors?: Maybe<Array<Error>>;
1471
3173
  /** The removed identity */
1472
3174
  userIdentity?: Maybe<UserIdentity>;
1473
3175
  }
@@ -1492,7 +3194,7 @@ export interface UsersLoginPayload {
1492
3194
  /** A unique identifier for the client performing the mutation. */
1493
3195
  clientMutationId?: Maybe<Scalars['String']['output']>;
1494
3196
  /** Errors encountered during execution of the mutation. */
1495
- errors: Array<Error>;
3197
+ errors?: Maybe<Array<Error>>;
1496
3198
  /** The created user session */
1497
3199
  userSession?: Maybe<UserSession>;
1498
3200
  }
@@ -1511,7 +3213,7 @@ export interface UsersLogoutPayload {
1511
3213
  /** A unique identifier for the client performing the mutation. */
1512
3214
  clientMutationId?: Maybe<Scalars['String']['output']>;
1513
3215
  /** Errors encountered during execution of the mutation. */
1514
- errors: Array<Error>;
3216
+ errors?: Maybe<Array<Error>>;
1515
3217
  /** The logged out user session */
1516
3218
  userSession?: Maybe<UserSession>;
1517
3219
  }
@@ -1530,7 +3232,7 @@ export interface UsersMfaBackupCodesRotatePayload {
1530
3232
  /** The newly rotated backup codes. */
1531
3233
  codes?: Maybe<Array<Scalars['String']['output']>>;
1532
3234
  /** Errors encountered during execution of the mutation. */
1533
- errors: Array<Error>;
3235
+ errors?: Maybe<Array<Error>>;
1534
3236
  }
1535
3237
 
1536
3238
  /** Autogenerated input type of UsersMfaTotpGenerateSecret */
@@ -1545,7 +3247,7 @@ export interface UsersMfaTotpGenerateSecretPayload {
1545
3247
  /** A unique identifier for the client performing the mutation. */
1546
3248
  clientMutationId?: Maybe<Scalars['String']['output']>;
1547
3249
  /** Errors encountered during execution of the mutation. */
1548
- errors: Array<Error>;
3250
+ errors?: Maybe<Array<Error>>;
1549
3251
  /** The created and signed secret */
1550
3252
  secret?: Maybe<Scalars['String']['output']>;
1551
3253
  }
@@ -1569,11 +3271,53 @@ export interface UsersMfaTotpValidateSecretPayload {
1569
3271
  /** A unique identifier for the client performing the mutation. */
1570
3272
  clientMutationId?: Maybe<Scalars['String']['output']>;
1571
3273
  /** Errors encountered during execution of the mutation. */
1572
- errors: Array<Error>;
3274
+ errors?: Maybe<Array<Error>>;
1573
3275
  /** The modified user */
1574
3276
  user?: Maybe<User>;
1575
3277
  }
1576
3278
 
3279
+ /** Autogenerated input type of UsersPasswordReset */
3280
+ export interface UsersPasswordResetInput {
3281
+ /** A unique identifier for the client performing the mutation. */
3282
+ clientMutationId?: InputMaybe<Scalars['String']['input']>;
3283
+ /** The new password to set for the user */
3284
+ newPassword: Scalars['String']['input'];
3285
+ /** The confirmation of the new password to set for the user needs to be the same as the new password */
3286
+ newPasswordConfirmation: Scalars['String']['input'];
3287
+ /** The password reset token sent to the user email */
3288
+ resetToken: Scalars['String']['input'];
3289
+ }
3290
+
3291
+ /** Autogenerated return type of UsersPasswordReset. */
3292
+ export interface UsersPasswordResetPayload {
3293
+ __typename?: 'UsersPasswordResetPayload';
3294
+ /** A unique identifier for the client performing the mutation. */
3295
+ clientMutationId?: Maybe<Scalars['String']['output']>;
3296
+ /** Errors encountered during execution of the mutation. */
3297
+ errors?: Maybe<Array<Error>>;
3298
+ /** A message indicating the result of the password reset request */
3299
+ message?: Maybe<Scalars['String']['output']>;
3300
+ }
3301
+
3302
+ /** Autogenerated input type of UsersPasswordResetRequest */
3303
+ export interface UsersPasswordResetRequestInput {
3304
+ /** A unique identifier for the client performing the mutation. */
3305
+ clientMutationId?: InputMaybe<Scalars['String']['input']>;
3306
+ /** Email of the user to reset the password */
3307
+ email: Scalars['String']['input'];
3308
+ }
3309
+
3310
+ /** Autogenerated return type of UsersPasswordResetRequest. */
3311
+ export interface UsersPasswordResetRequestPayload {
3312
+ __typename?: 'UsersPasswordResetRequestPayload';
3313
+ /** A unique identifier for the client performing the mutation. */
3314
+ clientMutationId?: Maybe<Scalars['String']['output']>;
3315
+ /** Errors encountered during execution of the mutation. */
3316
+ errors?: Maybe<Array<Error>>;
3317
+ /** A message indicating the result of the password reset request */
3318
+ message?: Maybe<Scalars['String']['output']>;
3319
+ }
3320
+
1577
3321
  /** Autogenerated input type of UsersRegister */
1578
3322
  export interface UsersRegisterInput {
1579
3323
  /** A unique identifier for the client performing the mutation. */
@@ -1582,6 +3326,8 @@ export interface UsersRegisterInput {
1582
3326
  email: Scalars['String']['input'];
1583
3327
  /** Password of the user */
1584
3328
  password: Scalars['String']['input'];
3329
+ /** The repeated password of the user to check for typos */
3330
+ passwordRepeat: Scalars['String']['input'];
1585
3331
  /** Username of the user */
1586
3332
  username: Scalars['String']['input'];
1587
3333
  }
@@ -1592,7 +3338,7 @@ export interface UsersRegisterPayload {
1592
3338
  /** A unique identifier for the client performing the mutation. */
1593
3339
  clientMutationId?: Maybe<Scalars['String']['output']>;
1594
3340
  /** Errors encountered during execution of the mutation. */
1595
- errors: Array<Error>;
3341
+ errors?: Maybe<Array<Error>>;
1596
3342
  /** The created users session */
1597
3343
  userSession?: Maybe<UserSession>;
1598
3344
  }
@@ -1609,6 +3355,12 @@ export interface UsersUpdateInput {
1609
3355
  firstname?: InputMaybe<Scalars['String']['input']>;
1610
3356
  /** New lastname for the user. */
1611
3357
  lastname?: InputMaybe<Scalars['String']['input']>;
3358
+ /** The data of the mfa validation */
3359
+ mfa?: InputMaybe<MfaInput>;
3360
+ /** New password for the user. */
3361
+ password?: InputMaybe<Scalars['String']['input']>;
3362
+ /** New password repeat for the user to check for typos, required if password is set. */
3363
+ passwordRepeat?: InputMaybe<Scalars['String']['input']>;
1612
3364
  /** ID of the user to update. */
1613
3365
  userId: Scalars['UserID']['input'];
1614
3366
  /** New username for the user. */
@@ -1621,7 +3373,7 @@ export interface UsersUpdatePayload {
1621
3373
  /** A unique identifier for the client performing the mutation. */
1622
3374
  clientMutationId?: Maybe<Scalars['String']['output']>;
1623
3375
  /** Errors encountered during execution of the mutation. */
1624
- errors: Array<Error>;
3376
+ errors?: Maybe<Array<Error>>;
1625
3377
  /** The updated user. */
1626
3378
  user?: Maybe<User>;
1627
3379
  }