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

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 +356 -950
  2. package/index.js +0 -0
  3. package/package.json +5 -4
package/index.d.ts CHANGED
@@ -1,10 +1,10 @@
1
1
  export type Maybe<T> = T | null;
2
2
  export type InputMaybe<T> = Maybe<T>;
3
- export type Exact<T extends { [key: string]: unknown }> = { [K in keyof T]: T[K] }
4
- export type MakeOptional<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]?: Maybe<T[SubKey]> }
5
- export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]: Maybe<T[SubKey]> }
6
- export type MakeEmpty<T extends { [key: string]: unknown }, K extends keyof T> = { [_ in K]?: never }
7
- export type Incremental<T> = T | { [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never }
3
+ export type Exact<T extends { [key: string]: unknown }> = { [K in keyof T]: T[K] };
4
+ export type MakeOptional<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]?: Maybe<T[SubKey]> };
5
+ export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]: Maybe<T[SubKey]> };
6
+ export type MakeEmpty<T extends { [key: string]: unknown }, K extends keyof T> = { [_ in K]?: never };
7
+ export type Incremental<T> = T | { [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never };
8
8
  /** All built-in and custom scalars, mapped to their actual values */
9
9
  export interface Scalars {
10
10
  ID: { input: `gid://sagittarius//${number}`; output: `gid://sagittarius//${number}`; }
@@ -12,37 +12,67 @@ export interface Scalars {
12
12
  Boolean: { input: boolean; output: boolean; }
13
13
  Int: { input: number; output: number; }
14
14
  Float: { input: number; output: number; }
15
+ /** A unique identifier for all DataType entities of the application */
15
16
  DataTypeID: { input: `gid://sagittarius/DataType/${number}`; output: `gid://sagittarius/DataType/${number}`; }
17
+ /** A unique identifier for all DataTypeIdentifier entities of the application */
16
18
  DataTypeIdentifierID: { input: `gid://sagittarius/DataTypeIdentifier/${number}`; output: `gid://sagittarius/DataTypeIdentifier/${number}`; }
19
+ /** A unique identifier for all DataTypeRule entities of the application */
17
20
  DataTypeRuleID: { input: `gid://sagittarius/DataTypeRule/${number}`; output: `gid://sagittarius/DataTypeRule/${number}`; }
21
+ /** A unique identifier for all Flow entities of the application */
18
22
  FlowID: { input: `gid://sagittarius/Flow/${number}`; output: `gid://sagittarius/Flow/${number}`; }
23
+ /** A unique identifier for all FlowSetting entities of the application */
19
24
  FlowSettingID: { input: `gid://sagittarius/FlowSetting/${number}`; output: `gid://sagittarius/FlowSetting/${number}`; }
25
+ /** A unique identifier for all FlowType entities of the application */
20
26
  FlowTypeID: { input: `gid://sagittarius/FlowType/${number}`; output: `gid://sagittarius/FlowType/${number}`; }
27
+ /** A unique identifier for all FlowTypeSetting entities of the application */
21
28
  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}`; }
29
+ /** A unique identifier for all GenericMapper entities of the application */
24
30
  GenericMapperID: { input: `gid://sagittarius/GenericMapper/${number}`; output: `gid://sagittarius/GenericMapper/${number}`; }
31
+ /** A unique identifier for all GenericType entities of the application */
25
32
  GenericTypeID: { input: `gid://sagittarius/GenericType/${number}`; output: `gid://sagittarius/GenericType/${number}`; }
33
+ /** Represents untyped JSON */
26
34
  JSON: { input: any; output: any; }
35
+ /** A unique identifier for all Namespace entities of the application */
27
36
  NamespaceID: { input: `gid://sagittarius/Namespace/${number}`; output: `gid://sagittarius/Namespace/${number}`; }
37
+ /** A unique identifier for all NamespaceLicense entities of the application */
28
38
  NamespaceLicenseID: { input: `gid://sagittarius/NamespaceLicense/${number}`; output: `gid://sagittarius/NamespaceLicense/${number}`; }
39
+ /** A unique identifier for all NamespaceMember entities of the application */
29
40
  NamespaceMemberID: { input: `gid://sagittarius/NamespaceMember/${number}`; output: `gid://sagittarius/NamespaceMember/${number}`; }
41
+ /** A unique identifier for all NamespaceMemberRole entities of the application */
30
42
  NamespaceMemberRoleID: { input: `gid://sagittarius/NamespaceMemberRole/${number}`; output: `gid://sagittarius/NamespaceMemberRole/${number}`; }
43
+ /** A unique identifier for all NamespaceProject entities of the application */
31
44
  NamespaceProjectID: { input: `gid://sagittarius/NamespaceProject/${number}`; output: `gid://sagittarius/NamespaceProject/${number}`; }
45
+ /** A unique identifier for all NamespaceRole entities of the application */
32
46
  NamespaceRoleID: { input: `gid://sagittarius/NamespaceRole/${number}`; output: `gid://sagittarius/NamespaceRole/${number}`; }
47
+ /** A unique identifier for all NodeFunction entities of the application */
33
48
  NodeFunctionID: { input: `gid://sagittarius/NodeFunction/${number}`; output: `gid://sagittarius/NodeFunction/${number}`; }
49
+ /** A unique identifier for all NodeParameter entities of the application */
34
50
  NodeParameterID: { input: `gid://sagittarius/NodeParameter/${number}`; output: `gid://sagittarius/NodeParameter/${number}`; }
51
+ /** A unique identifier for all Organization entities of the application */
35
52
  OrganizationID: { input: `gid://sagittarius/Organization/${number}`; output: `gid://sagittarius/Organization/${number}`; }
36
- ParameterDefinitionID: { input: `gid://sagittarius/ParameterDefinition/${number}`; output: `gid://sagittarius/ParameterDefinition/${number}`; }
53
+ /** A unique identifier for all ReferencePath entities of the application */
37
54
  ReferencePathID: { input: `gid://sagittarius/ReferencePath/${number}`; output: `gid://sagittarius/ReferencePath/${number}`; }
55
+ /** A unique identifier for all ReferenceValue entities of the application */
38
56
  ReferenceValueID: { input: `gid://sagittarius/ReferenceValue/${number}`; output: `gid://sagittarius/ReferenceValue/${number}`; }
57
+ /** A unique identifier for all RuntimeFunctionDefinition entities of the application */
39
58
  RuntimeFunctionDefinitionID: { input: `gid://sagittarius/RuntimeFunctionDefinition/${number}`; output: `gid://sagittarius/RuntimeFunctionDefinition/${number}`; }
59
+ /** A unique identifier for all Runtime entities of the application */
40
60
  RuntimeID: { input: `gid://sagittarius/Runtime/${number}`; output: `gid://sagittarius/Runtime/${number}`; }
61
+ /** A unique identifier for all RuntimeParameterDefinition entities of the application */
41
62
  RuntimeParameterDefinitionID: { input: `gid://sagittarius/RuntimeParameterDefinition/${number}`; output: `gid://sagittarius/RuntimeParameterDefinition/${number}`; }
63
+ /**
64
+ * Time represented in ISO 8601.
65
+ *
66
+ * For example: "2023-12-15T17:31:00Z".
67
+ */
42
68
  Time: { input: string; output: string; }
69
+ /** A unique identifier for all Types::FlowType entities of the application */
43
70
  TypesFlowTypeID: { input: `gid://sagittarius/TypesFlowType/${number}`; output: `gid://sagittarius/TypesFlowType/${number}`; }
71
+ /** A unique identifier for all User entities of the application */
44
72
  UserID: { input: `gid://sagittarius/User/${number}`; output: `gid://sagittarius/User/${number}`; }
73
+ /** A unique identifier for all UserIdentity entities of the application */
45
74
  UserIdentityID: { input: `gid://sagittarius/UserIdentity/${number}`; output: `gid://sagittarius/UserIdentity/${number}`; }
75
+ /** A unique identifier for all UserSession entities of the application */
46
76
  UserSessionID: { input: `gid://sagittarius/UserSession/${number}`; output: `gid://sagittarius/UserSession/${number}`; }
47
77
  }
48
78
 
@@ -50,18 +80,18 @@ export interface Scalars {
50
80
  export interface ActiveModelError {
51
81
  __typename?: 'ActiveModelError';
52
82
  /** The affected attribute on the model */
53
- attribute?: Maybe<Scalars['String']['output']>;
83
+ attribute: Scalars['String']['output'];
54
84
  /** The validation type that failed for the attribute */
55
- type?: Maybe<Scalars['String']['output']>;
85
+ type: Scalars['String']['output'];
56
86
  }
57
87
 
58
88
  /** Represents the application settings */
59
89
  export interface ApplicationSettings {
60
90
  __typename?: 'ApplicationSettings';
61
91
  /** Shows if organization creation is restricted to administrators */
62
- organizationCreationRestricted?: Maybe<Scalars['Boolean']['output']>;
92
+ organizationCreationRestricted: Scalars['Boolean']['output'];
63
93
  /** Shows if user registration is enabled */
64
- userRegistrationEnabled?: Maybe<Scalars['Boolean']['output']>;
94
+ userRegistrationEnabled: Scalars['Boolean']['output'];
65
95
  }
66
96
 
67
97
  /** Autogenerated input type of ApplicationSettingsUpdate */
@@ -82,33 +112,54 @@ export interface ApplicationSettingsUpdatePayload {
82
112
  /** A unique identifier for the client performing the mutation. */
83
113
  clientMutationId?: Maybe<Scalars['String']['output']>;
84
114
  /** Errors encountered during execution of the mutation. */
85
- errors?: Maybe<Array<Error>>;
115
+ errors: Array<Error>;
86
116
  }
87
117
 
88
118
  /** Objects that can present an authentication */
89
119
  export type Authentication = UserSession;
90
120
 
121
+ /** Represents a rule that can be applied to a data type. */
122
+ export type Config = ContainsKeyConfig | ContainsTypeConfig | InputTypesConfig | ItemOfCollectionConfig | NumberRangeConfig | RegexConfig | ReturnTypeConfig;
123
+
124
+ /** Represents a rule that can be applied to a data type. */
125
+ export interface ContainsKeyConfig {
126
+ __typename?: 'ContainsKeyConfig';
127
+ /** The identifier of the data type this rule belongs to */
128
+ dataTypeIdentifier: DataTypeIdentifier;
129
+ /** The key of the rule */
130
+ key: Scalars['String']['output'];
131
+ }
132
+
133
+ /** Represents a rule that can be applied to a data type. */
134
+ export interface ContainsTypeConfig {
135
+ __typename?: 'ContainsTypeConfig';
136
+ /** The identifier of the data type this rule belongs to */
137
+ dataTypeIdentifier: DataTypeIdentifier;
138
+ }
139
+
91
140
  /** Represents a DataType */
92
141
  export interface DataType {
93
142
  __typename?: 'DataType';
94
143
  /** Time when this DataType was created */
95
- createdAt?: Maybe<Scalars['Time']['output']>;
144
+ createdAt: Scalars['Time']['output'];
96
145
  /** Generic keys of the datatype */
97
146
  genericKeys?: Maybe<Array<Scalars['String']['output']>>;
98
147
  /** Global ID of this DataType */
99
- id?: Maybe<Scalars['DataTypeID']['output']>;
148
+ id: Scalars['DataTypeID']['output'];
100
149
  /** The identifier scoped to the namespace */
101
- identifier?: Maybe<Scalars['String']['output']>;
150
+ identifier: Scalars['String']['output'];
102
151
  /** Names of the flow type setting */
103
- name?: Maybe<TranslationConnection>;
152
+ name: TranslationConnection;
153
+ /** The namespace where this datatype belongs to */
154
+ namespace?: Maybe<Namespace>;
155
+ /** The parent datatype */
156
+ parent?: Maybe<DataTypeIdentifier>;
104
157
  /** Rules of the datatype */
105
- rules?: Maybe<DataTypeRuleConnection>;
106
- /** The runtime where this datatype belongs to */
107
- runtime?: Maybe<Runtime>;
158
+ rules: DataTypeRuleConnection;
108
159
  /** Time when this DataType was last updated */
109
- updatedAt?: Maybe<Scalars['Time']['output']>;
160
+ updatedAt: Scalars['Time']['output'];
110
161
  /** The type of the datatype */
111
- variant?: Maybe<DataTypeVariant>;
162
+ variant: DataTypeVariant;
112
163
  }
113
164
 
114
165
 
@@ -133,20 +184,20 @@ export interface DataTypeRulesArgs {
133
184
  export interface DataTypeConnection {
134
185
  __typename?: 'DataTypeConnection';
135
186
  /** Total count of collection. */
136
- count?: Maybe<Scalars['Int']['output']>;
187
+ count: Scalars['Int']['output'];
137
188
  /** A list of edges. */
138
189
  edges?: Maybe<Array<Maybe<DataTypeEdge>>>;
139
190
  /** A list of nodes. */
140
191
  nodes?: Maybe<Array<Maybe<DataType>>>;
141
192
  /** Information to aid in pagination. */
142
- pageInfo?: Maybe<PageInfo>;
193
+ pageInfo: PageInfo;
143
194
  }
144
195
 
145
196
  /** An edge in a connection. */
146
197
  export interface DataTypeEdge {
147
198
  __typename?: 'DataTypeEdge';
148
199
  /** A cursor for use in pagination. */
149
- cursor?: Maybe<Scalars['String']['output']>;
200
+ cursor: Scalars['String']['output'];
150
201
  /** The item at the end of the edge. */
151
202
  node?: Maybe<DataType>;
152
203
  }
@@ -155,7 +206,7 @@ export interface DataTypeEdge {
155
206
  export interface DataTypeIdentifier {
156
207
  __typename?: 'DataTypeIdentifier';
157
208
  /** Time when this DataTypeIdentifier was created */
158
- createdAt?: Maybe<Scalars['Time']['output']>;
209
+ createdAt: Scalars['Time']['output'];
159
210
  /** The data type of the data type identifier. */
160
211
  dataType?: Maybe<DataType>;
161
212
  /** The generic key of the data type identifier. */
@@ -163,9 +214,9 @@ export interface DataTypeIdentifier {
163
214
  /** The generic type of the data type identifier. */
164
215
  genericType?: Maybe<GenericType>;
165
216
  /** Global ID of this DataTypeIdentifier */
166
- id?: Maybe<Scalars['DataTypeIdentifierID']['output']>;
217
+ id: Scalars['DataTypeIdentifierID']['output'];
167
218
  /** Time when this DataTypeIdentifier was last updated */
168
- updatedAt?: Maybe<Scalars['Time']['output']>;
219
+ updatedAt: Scalars['Time']['output'];
169
220
  }
170
221
 
171
222
  /** Input type for data type identifier */
@@ -182,115 +233,41 @@ export interface DataTypeIdentifierInput {
182
233
  export interface DataTypeRule {
183
234
  __typename?: 'DataTypeRule';
184
235
  /** The configuration of the rule */
185
- config?: Maybe<DataTypeRulesConfig>;
236
+ config: Config;
186
237
  /** Time when this DataTypeRule was created */
187
- createdAt?: Maybe<Scalars['Time']['output']>;
238
+ createdAt: Scalars['Time']['output'];
188
239
  /** Global ID of this DataTypeRule */
189
- id?: Maybe<Scalars['DataTypeRuleID']['output']>;
240
+ id: Scalars['DataTypeRuleID']['output'];
190
241
  /** Time when this DataTypeRule was last updated */
191
- updatedAt?: Maybe<Scalars['Time']['output']>;
242
+ updatedAt: Scalars['Time']['output'];
192
243
  /** The type of the rule */
193
- variant?: Maybe<DataTypeRulesVariant>;
244
+ variant: DataTypeRulesDataTypeRuleVariant;
194
245
  }
195
246
 
196
247
  /** The connection type for DataTypeRule. */
197
248
  export interface DataTypeRuleConnection {
198
249
  __typename?: 'DataTypeRuleConnection';
199
250
  /** Total count of collection. */
200
- count?: Maybe<Scalars['Int']['output']>;
251
+ count: Scalars['Int']['output'];
201
252
  /** A list of edges. */
202
253
  edges?: Maybe<Array<Maybe<DataTypeRuleEdge>>>;
203
254
  /** A list of nodes. */
204
255
  nodes?: Maybe<Array<Maybe<DataTypeRule>>>;
205
256
  /** Information to aid in pagination. */
206
- pageInfo?: Maybe<PageInfo>;
257
+ pageInfo: PageInfo;
207
258
  }
208
259
 
209
260
  /** An edge in a connection. */
210
261
  export interface DataTypeRuleEdge {
211
262
  __typename?: 'DataTypeRuleEdge';
212
263
  /** A cursor for use in pagination. */
213
- cursor?: Maybe<Scalars['String']['output']>;
264
+ cursor: Scalars['String']['output'];
214
265
  /** The item at the end of the edge. */
215
266
  node?: Maybe<DataTypeRule>;
216
267
  }
217
268
 
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
269
  /** The type of rule that can be applied to a data type. */
293
- export const enum DataTypeRulesVariant {
270
+ export enum DataTypeRulesDataTypeRuleVariant {
294
271
  /** The rule checks if a key is present in the data type. */
295
272
  ContainsKey = 'CONTAINS_KEY',
296
273
  /** The rule checks if a specific type is present in the data type. */
@@ -301,8 +278,6 @@ export const enum DataTypeRulesVariant {
301
278
  ItemOfCollection = 'ITEM_OF_COLLECTION',
302
279
  /** The rule checks if a number falls within a specified range. */
303
280
  NumberRange = 'NUMBER_RANGE',
304
- /** The rule checks if the data type is a child of a specific parent type. */
305
- ParentType = 'PARENT_TYPE',
306
281
  /** The rule checks if a string matches a specified regular expression. */
307
282
  Regex = 'REGEX',
308
283
  /** The rule checks if the data type matches a specific return type. */
@@ -310,7 +285,7 @@ export const enum DataTypeRulesVariant {
310
285
  }
311
286
 
312
287
  /** Represent all available types of a datatype */
313
- export const enum DataTypeVariant {
288
+ export enum DataTypeVariant {
314
289
  /** Represents an array */
315
290
  Array = 'ARRAY',
316
291
  /** Represents an data type containing a data type */
@@ -341,142 +316,33 @@ export interface EchoPayload {
341
316
  /** A unique identifier for the client performing the mutation. */
342
317
  clientMutationId?: Maybe<Scalars['String']['output']>;
343
318
  /** Errors encountered during execution of the mutation. */
344
- errors?: Maybe<Array<Error>>;
319
+ errors: Array<Error>;
345
320
  /** Message returned to the user. */
346
321
  message?: Maybe<Scalars['String']['output']>;
347
322
  }
348
323
 
349
324
  /** Objects that can present an error */
350
- export type Error = ActiveModelError | ErrorCode | MessageError;
351
-
352
- /** Represents an error code */
353
- export interface ErrorCode {
354
- __typename?: 'ErrorCode';
355
- /** The error code */
356
- errorCode?: Maybe<ErrorCodeEnum>;
357
- }
358
-
359
- /** Represents the available error responses */
360
- export const enum ErrorCodeEnum {
361
- /** This action would remove the last administrative role */
362
- CannotDeleteLastAdminRole = 'CANNOT_DELETE_LAST_ADMIN_ROLE',
363
- /** This action would remove the last administrator */
364
- CannotRemoveLastAdministrator = 'CANNOT_REMOVE_LAST_ADMINISTRATOR',
365
- /** This action would remove the last administrative ability */
366
- CannotRemoveLastAdminAbility = 'CANNOT_REMOVE_LAST_ADMIN_ABILITY',
367
- /** This external identity does not exist */
368
- ExternalIdentityDoesNotExist = 'EXTERNAL_IDENTITY_DOES_NOT_EXIST',
369
- /** The old backup codes could not be deleted */
370
- FailedToInvalidateOldBackupCodes = 'FAILED_TO_INVALIDATE_OLD_BACKUP_CODES',
371
- /** The new backup codes could not be saved */
372
- FailedToSaveValidBackupCode = 'FAILED_TO_SAVE_VALID_BACKUP_CODE',
373
- /** The given key was not found in the data type */
374
- GenericKeyNotFound = 'GENERIC_KEY_NOT_FOUND',
375
- /** Failed to validate the external identity */
376
- IdentityValidationFailed = 'IDENTITY_VALIDATION_FAILED',
377
- /** Resources are from different namespaces */
378
- InconsistentNamespace = 'INCONSISTENT_NAMESPACE',
379
- /** This external identity is invalid */
380
- InvalidExternalIdentity = 'INVALID_EXTERNAL_IDENTITY',
381
- /** Invalid login data provided */
382
- InvalidLoginData = 'INVALID_LOGIN_DATA',
383
- /** Invalid setting provided */
384
- InvalidSetting = 'INVALID_SETTING',
385
- /** Invalid verification code provided */
386
- InvalidVerificationCode = 'INVALID_VERIFICATION_CODE',
387
- /** Invalid MFA data provided */
388
- MfaFailed = 'MFA_FAILED',
389
- /** MFA is required */
390
- MfaRequired = 'MFA_REQUIRED',
391
- /** This external identity is missing data */
392
- MissingIdentityData = 'MISSING_IDENTITY_DATA',
393
- /** Not all required parameters are present */
394
- MissingParameter = 'MISSING_PARAMETER',
395
- /** The user is not permitted to perform this operation */
396
- MissingPermission = 'MISSING_PERMISSION',
397
- /** There are no free license seats to complete this operation */
398
- NoFreeLicenseSeats = 'NO_FREE_LICENSE_SEATS',
399
- /** The project does not have a primary runtime */
400
- NoPrimaryRuntime = 'NO_PRIMARY_RUNTIME',
401
- /** @deprecated Outdated concept */
402
- PrimaryLevelNotFound = 'PRIMARY_LEVEL_NOT_FOUND',
403
- /** Self-registration is disabled */
404
- RegistrationDisabled = 'REGISTRATION_DISABLED',
405
- /** Resources are from different runtimes */
406
- RuntimeMismatch = 'RUNTIME_MISMATCH',
407
- /** @deprecated Outdated concept */
408
- SecondaryLevelNotFound = 'SECONDARY_LEVEL_NOT_FOUND',
409
- /** @deprecated Outdated concept */
410
- TertiaryLevelExceedsParameters = 'TERTIARY_LEVEL_EXCEEDS_PARAMETERS',
411
- /** This user already has TOTP set up */
412
- TotpSecretAlreadySet = 'TOTP_SECRET_ALREADY_SET',
413
- /** The user is not permitted to modify this field */
414
- UnmodifiableField = 'UNMODIFIABLE_FIELD',
415
- /** Invalid TOTP code provided */
416
- WrongTotp = 'WRONG_TOTP'
417
- }
325
+ export type Error = ActiveModelError | MessageError;
418
326
 
419
327
  /** Represents a flow */
420
328
  export interface Flow {
421
329
  __typename?: 'Flow';
422
330
  /** Time when this Flow was created */
423
- createdAt?: Maybe<Scalars['Time']['output']>;
331
+ createdAt: Scalars['Time']['output'];
424
332
  /** Global ID of this Flow */
425
- id?: Maybe<Scalars['FlowID']['output']>;
333
+ id: Scalars['FlowID']['output'];
426
334
  /** The input data type of the flow */
427
335
  inputType?: Maybe<DataType>;
428
- /** Nodes of the flow */
429
- nodes?: Maybe<NodeFunctionConnection>;
430
336
  /** The return data type of the flow */
431
337
  returnType?: Maybe<DataType>;
432
338
  /** The settings of the flow */
433
- settings?: Maybe<FlowSettingConnection>;
434
- /** The ID of the starting node of the flow */
435
- startingNodeId?: Maybe<Scalars['NodeFunctionID']['output']>;
339
+ settings?: Maybe<Array<FlowSetting>>;
340
+ /** The starting node of the flow */
341
+ startingNode: NodeFunction;
436
342
  /** The flow type of the flow */
437
- type?: Maybe<FlowType>;
343
+ type: FlowType;
438
344
  /** Time when this Flow was last updated */
439
- updatedAt?: Maybe<Scalars['Time']['output']>;
440
- }
441
-
442
-
443
- /** Represents a flow */
444
- export interface FlowNodesArgs {
445
- after?: InputMaybe<Scalars['String']['input']>;
446
- before?: InputMaybe<Scalars['String']['input']>;
447
- first?: InputMaybe<Scalars['Int']['input']>;
448
- last?: InputMaybe<Scalars['Int']['input']>;
449
- }
450
-
451
-
452
- /** Represents a flow */
453
- export interface FlowSettingsArgs {
454
- after?: InputMaybe<Scalars['String']['input']>;
455
- before?: InputMaybe<Scalars['String']['input']>;
456
- first?: InputMaybe<Scalars['Int']['input']>;
457
- last?: InputMaybe<Scalars['Int']['input']>;
458
- }
459
-
460
- /** The connection type for Flow. */
461
- export interface FlowConnection {
462
- __typename?: 'FlowConnection';
463
- /** Total count of collection. */
464
- count?: Maybe<Scalars['Int']['output']>;
465
- /** A list of edges. */
466
- edges?: Maybe<Array<Maybe<FlowEdge>>>;
467
- /** A list of nodes. */
468
- nodes?: Maybe<Array<Maybe<Flow>>>;
469
- /** Information to aid in pagination. */
470
- pageInfo?: Maybe<PageInfo>;
471
- }
472
-
473
- /** An edge in a connection. */
474
- export interface FlowEdge {
475
- __typename?: 'FlowEdge';
476
- /** A cursor for use in pagination. */
477
- cursor?: Maybe<Scalars['String']['output']>;
478
- /** The item at the end of the edge. */
479
- node?: Maybe<Flow>;
345
+ updatedAt: Scalars['Time']['output'];
480
346
  }
481
347
 
482
348
  /** Input type for creating or updating a flow */
@@ -493,37 +359,15 @@ export interface FlowInput {
493
359
  export interface FlowSetting {
494
360
  __typename?: 'FlowSetting';
495
361
  /** Time when this FlowSetting was created */
496
- createdAt?: Maybe<Scalars['Time']['output']>;
362
+ createdAt: Scalars['Time']['output'];
497
363
  /** The identifier of the flow setting */
498
- flowSettingIdentifier?: Maybe<Scalars['String']['output']>;
364
+ flowSettingId: Scalars['String']['output'];
499
365
  /** Global ID of this FlowSetting */
500
- id?: Maybe<Scalars['FlowSettingID']['output']>;
366
+ id: Scalars['FlowSettingID']['output'];
501
367
  /** Time when this FlowSetting was last updated */
502
- updatedAt?: Maybe<Scalars['Time']['output']>;
368
+ updatedAt: Scalars['Time']['output'];
503
369
  /** The value of the flow setting */
504
- value?: Maybe<Scalars['JSON']['output']>;
505
- }
506
-
507
- /** The connection type for FlowSetting. */
508
- export interface FlowSettingConnection {
509
- __typename?: 'FlowSettingConnection';
510
- /** Total count of collection. */
511
- count?: Maybe<Scalars['Int']['output']>;
512
- /** A list of edges. */
513
- edges?: Maybe<Array<Maybe<FlowSettingEdge>>>;
514
- /** A list of nodes. */
515
- nodes?: Maybe<Array<Maybe<FlowSetting>>>;
516
- /** Information to aid in pagination. */
517
- pageInfo?: Maybe<PageInfo>;
518
- }
519
-
520
- /** An edge in a connection. */
521
- export interface FlowSettingEdge {
522
- __typename?: 'FlowSettingEdge';
523
- /** A cursor for use in pagination. */
524
- cursor?: Maybe<Scalars['String']['output']>;
525
- /** The item at the end of the edge. */
526
- node?: Maybe<FlowSetting>;
370
+ value: Scalars['JSON']['output'];
527
371
  }
528
372
 
529
373
  /** Input type for flow settings */
@@ -538,17 +382,17 @@ export interface FlowSettingInput {
538
382
  export interface FlowType {
539
383
  __typename?: 'FlowType';
540
384
  /** Time when this FlowType was created */
541
- createdAt?: Maybe<Scalars['Time']['output']>;
385
+ createdAt: Scalars['Time']['output'];
542
386
  /** Descriptions of the flow type */
543
387
  descriptions?: Maybe<TranslationConnection>;
544
388
  /** Editable status of the flow type */
545
- editable?: Maybe<Scalars['Boolean']['output']>;
389
+ editable: Scalars['Boolean']['output'];
546
390
  /** Flow type settings of the flow type */
547
- flowTypeSettings?: Maybe<Array<FlowTypeSetting>>;
391
+ flowTypeSettings: Array<FlowTypeSetting>;
548
392
  /** Global ID of this FlowType */
549
- id?: Maybe<Scalars['TypesFlowTypeID']['output']>;
393
+ id: Scalars['TypesFlowTypeID']['output'];
550
394
  /** Identifier of the flow type */
551
- identifier?: Maybe<Scalars['String']['output']>;
395
+ identifier: Scalars['String']['output'];
552
396
  /** Input type of the flow type */
553
397
  inputType?: Maybe<DataType>;
554
398
  /** Names of the flow type */
@@ -556,7 +400,7 @@ export interface FlowType {
556
400
  /** Return type of the flow type */
557
401
  returnType?: Maybe<DataType>;
558
402
  /** Time when this FlowType was last updated */
559
- updatedAt?: Maybe<Scalars['Time']['output']>;
403
+ updatedAt: Scalars['Time']['output'];
560
404
  }
561
405
 
562
406
 
@@ -581,20 +425,20 @@ export interface FlowTypeNamesArgs {
581
425
  export interface FlowTypeConnection {
582
426
  __typename?: 'FlowTypeConnection';
583
427
  /** Total count of collection. */
584
- count?: Maybe<Scalars['Int']['output']>;
428
+ count: Scalars['Int']['output'];
585
429
  /** A list of edges. */
586
430
  edges?: Maybe<Array<Maybe<FlowTypeEdge>>>;
587
431
  /** A list of nodes. */
588
432
  nodes?: Maybe<Array<Maybe<FlowType>>>;
589
433
  /** Information to aid in pagination. */
590
- pageInfo?: Maybe<PageInfo>;
434
+ pageInfo: PageInfo;
591
435
  }
592
436
 
593
437
  /** An edge in a connection. */
594
438
  export interface FlowTypeEdge {
595
439
  __typename?: 'FlowTypeEdge';
596
440
  /** A cursor for use in pagination. */
597
- cursor?: Maybe<Scalars['String']['output']>;
441
+ cursor: Scalars['String']['output'];
598
442
  /** The item at the end of the edge. */
599
443
  node?: Maybe<FlowType>;
600
444
  }
@@ -603,23 +447,23 @@ export interface FlowTypeEdge {
603
447
  export interface FlowTypeSetting {
604
448
  __typename?: 'FlowTypeSetting';
605
449
  /** Time when this FlowTypeSetting was created */
606
- createdAt?: Maybe<Scalars['Time']['output']>;
450
+ createdAt: Scalars['Time']['output'];
607
451
  /** Data type of the flow type setting */
608
452
  dataType?: Maybe<DataType>;
609
453
  /** Descriptions of the flow type setting */
610
- descriptions?: Maybe<TranslationConnection>;
454
+ descriptions: TranslationConnection;
611
455
  /** Flow type of the flow type setting */
612
456
  flowType?: Maybe<FlowType>;
613
457
  /** Global ID of this FlowTypeSetting */
614
- id?: Maybe<Scalars['FlowTypeSettingID']['output']>;
458
+ id: Scalars['FlowTypeSettingID']['output'];
615
459
  /** Identifier of the flow type setting */
616
- identifier?: Maybe<Scalars['String']['output']>;
460
+ identifier: Scalars['String']['output'];
617
461
  /** Names of the flow type setting */
618
- names?: Maybe<TranslationConnection>;
462
+ names: TranslationConnection;
619
463
  /** Unique status of the flow type setting */
620
- unique?: Maybe<Scalars['Boolean']['output']>;
464
+ unique: Scalars['Boolean']['output'];
621
465
  /** Time when this FlowTypeSetting was last updated */
622
- updatedAt?: Maybe<Scalars['Time']['output']>;
466
+ updatedAt: Scalars['Time']['output'];
623
467
  }
624
468
 
625
469
 
@@ -640,142 +484,19 @@ export interface FlowTypeSettingNamesArgs {
640
484
  last?: InputMaybe<Scalars['Int']['input']>;
641
485
  }
642
486
 
643
- /** Represents a function definition */
644
- export interface FunctionDefinition {
645
- __typename?: 'FunctionDefinition';
646
- /** Time when this FunctionDefinition was created */
647
- createdAt?: Maybe<Scalars['Time']['output']>;
648
- /** Deprecation message of the function */
649
- deprecationMessages?: Maybe<TranslationConnection>;
650
- /** Description of the function */
651
- descriptions?: Maybe<TranslationConnection>;
652
- /** Documentation of the function */
653
- documentations?: Maybe<TranslationConnection>;
654
- /** Generic keys of the function */
655
- genericKeys?: Maybe<Array<Scalars['String']['output']>>;
656
- /** Global ID of this FunctionDefinition */
657
- id?: Maybe<Scalars['FunctionDefinitionID']['output']>;
658
- /** Identifier of the function */
659
- identifier?: Maybe<Scalars['String']['output']>;
660
- /** Name of the function */
661
- names?: Maybe<TranslationConnection>;
662
- /** Parameters of the function */
663
- parameterDefinitions?: Maybe<ParameterDefinitionConnection>;
664
- /** Return type of the function */
665
- returnType?: Maybe<DataTypeIdentifier>;
666
- /** Runtime function definition */
667
- runtimeFunctionDefinition?: Maybe<RuntimeFunctionDefinition>;
668
- /** Indicates if the function can throw an error */
669
- throwsError?: Maybe<Scalars['Boolean']['output']>;
670
- /** Time when this FunctionDefinition was last updated */
671
- updatedAt?: Maybe<Scalars['Time']['output']>;
672
- }
673
-
674
-
675
- /** Represents a function definition */
676
- export interface FunctionDefinitionDeprecationMessagesArgs {
677
- after?: InputMaybe<Scalars['String']['input']>;
678
- before?: InputMaybe<Scalars['String']['input']>;
679
- first?: InputMaybe<Scalars['Int']['input']>;
680
- last?: InputMaybe<Scalars['Int']['input']>;
681
- }
682
-
683
-
684
- /** Represents a function definition */
685
- export interface FunctionDefinitionDescriptionsArgs {
686
- after?: InputMaybe<Scalars['String']['input']>;
687
- before?: InputMaybe<Scalars['String']['input']>;
688
- first?: InputMaybe<Scalars['Int']['input']>;
689
- last?: InputMaybe<Scalars['Int']['input']>;
690
- }
691
-
692
-
693
- /** Represents a function definition */
694
- export interface FunctionDefinitionDocumentationsArgs {
695
- after?: InputMaybe<Scalars['String']['input']>;
696
- before?: InputMaybe<Scalars['String']['input']>;
697
- first?: InputMaybe<Scalars['Int']['input']>;
698
- last?: InputMaybe<Scalars['Int']['input']>;
699
- }
700
-
701
-
702
- /** Represents a function definition */
703
- export interface FunctionDefinitionNamesArgs {
704
- after?: InputMaybe<Scalars['String']['input']>;
705
- before?: InputMaybe<Scalars['String']['input']>;
706
- first?: InputMaybe<Scalars['Int']['input']>;
707
- last?: InputMaybe<Scalars['Int']['input']>;
708
- }
709
-
710
-
711
- /** Represents a function definition */
712
- export interface FunctionDefinitionParameterDefinitionsArgs {
713
- after?: InputMaybe<Scalars['String']['input']>;
714
- before?: InputMaybe<Scalars['String']['input']>;
715
- first?: InputMaybe<Scalars['Int']['input']>;
716
- last?: InputMaybe<Scalars['Int']['input']>;
717
- }
718
-
719
- /** The connection type for FunctionDefinition. */
720
- export interface FunctionDefinitionConnection {
721
- __typename?: 'FunctionDefinitionConnection';
722
- /** Total count of collection. */
723
- count?: Maybe<Scalars['Int']['output']>;
724
- /** A list of edges. */
725
- edges?: Maybe<Array<Maybe<FunctionDefinitionEdge>>>;
726
- /** A list of nodes. */
727
- nodes?: Maybe<Array<Maybe<FunctionDefinition>>>;
728
- /** Information to aid in pagination. */
729
- pageInfo?: Maybe<PageInfo>;
730
- }
731
-
732
- /** An edge in a connection. */
733
- export interface FunctionDefinitionEdge {
734
- __typename?: 'FunctionDefinitionEdge';
735
- /** A cursor for use in pagination. */
736
- cursor?: Maybe<Scalars['String']['output']>;
737
- /** The item at the end of the edge. */
738
- node?: Maybe<FunctionDefinition>;
739
- }
740
-
741
- /** Represents a combination strategy with AND/OR logic used by a generic mapper. */
742
- export interface GenericCombinationStrategy {
743
- __typename?: 'GenericCombinationStrategy';
744
- /** Time when this GenericCombinationStrategy was created */
745
- createdAt?: Maybe<Scalars['Time']['output']>;
746
- /** The associated generic mapper, if any. */
747
- genericMapper?: Maybe<GenericMapper>;
748
- /** Global ID of this GenericCombinationStrategy */
749
- id?: Maybe<Scalars['GenericCombinationStrategyID']['output']>;
750
- /** The combination type ('AND' or 'OR'). */
751
- type?: Maybe<GenericCombinationStrategyType>;
752
- /** Time when this GenericCombinationStrategy was last updated */
753
- updatedAt?: Maybe<Scalars['Time']['output']>;
754
- }
755
-
756
- /** The available combination strategy types. */
757
- export const enum GenericCombinationStrategyType {
758
- /** Represents a logical AND combination. */
759
- And = 'AND',
760
- /** Represents a logical OR combination. */
761
- Or = 'OR'
762
- }
763
-
764
487
  /** Represents a mapping between a source data type and a target key for generic values. */
765
488
  export interface GenericMapper {
766
489
  __typename?: 'GenericMapper';
767
490
  /** Time when this GenericMapper was created */
768
- createdAt?: Maybe<Scalars['Time']['output']>;
769
- /** Combination strategies associated with this generic mapper. */
770
- genericCombinationStrategies?: Maybe<Array<GenericCombinationStrategy>>;
491
+ createdAt: Scalars['Time']['output'];
771
492
  /** Global ID of this GenericMapper */
772
- id?: Maybe<Scalars['GenericMapperID']['output']>;
493
+ id: Scalars['GenericMapperID']['output'];
773
494
  /** The source data type identifier. */
774
- sourceDataTypeIdentifiers?: Maybe<Array<DataTypeIdentifier>>;
495
+ source: DataTypeIdentifier;
775
496
  /** The target key for the generic value. */
776
- target?: Maybe<Scalars['String']['output']>;
497
+ target: Scalars['String']['output'];
777
498
  /** Time when this GenericMapper was last updated */
778
- updatedAt?: Maybe<Scalars['Time']['output']>;
499
+ updatedAt: Scalars['Time']['output'];
779
500
  }
780
501
 
781
502
  /** Input type for generic mappers */
@@ -790,15 +511,15 @@ export interface GenericMapperInput {
790
511
  export interface GenericType {
791
512
  __typename?: 'GenericType';
792
513
  /** Time when this GenericType was created */
793
- createdAt?: Maybe<Scalars['Time']['output']>;
514
+ createdAt: Scalars['Time']['output'];
794
515
  /** The data type associated with this generic type. */
795
- dataType?: Maybe<DataType>;
516
+ dataType: DataType;
796
517
  /** The mappers associated with this generic type. */
797
- genericMappers?: Maybe<Array<GenericMapper>>;
518
+ genericMappers: Array<GenericMapper>;
798
519
  /** Global ID of this GenericType */
799
- id?: Maybe<Scalars['GenericTypeID']['output']>;
520
+ id: Scalars['GenericTypeID']['output'];
800
521
  /** Time when this GenericType was last updated */
801
- updatedAt?: Maybe<Scalars['Time']['output']>;
522
+ updatedAt: Scalars['Time']['output'];
802
523
  }
803
524
 
804
525
  /** Input type for generic type operations. */
@@ -815,22 +536,45 @@ export interface IdentityInput {
815
536
  code?: InputMaybe<Scalars['String']['input']>;
816
537
  }
817
538
 
539
+ /** Represents a subtype of input type configuration for a input data type. */
540
+ export interface InputTypeConfig {
541
+ __typename?: 'InputTypeConfig';
542
+ /** The identifier of the data type this input type belongs to */
543
+ dataTypeIdentifier: DataTypeIdentifier;
544
+ /** The input data type that this configuration applies to */
545
+ inputType: DataType;
546
+ }
547
+
548
+ /** Represents a rule that can be applied to a data type. */
549
+ export interface InputTypesConfig {
550
+ __typename?: 'InputTypesConfig';
551
+ /** The input types that can be used in this data type rule */
552
+ inputTypes: Array<InputTypeConfig>;
553
+ }
554
+
555
+ /** Represents a rule that can be applied to a data type. */
556
+ export interface ItemOfCollectionConfig {
557
+ __typename?: 'ItemOfCollectionConfig';
558
+ /** The items that can be configured for this rule. */
559
+ items?: Maybe<Array<Scalars['JSON']['output']>>;
560
+ }
561
+
818
562
  /** Represents a literal value, such as a string or number. */
819
563
  export interface LiteralValue {
820
564
  __typename?: 'LiteralValue';
821
565
  /** Time when this LiteralValue was created */
822
- createdAt?: Maybe<Scalars['Time']['output']>;
566
+ createdAt: Scalars['Time']['output'];
823
567
  /** Time when this LiteralValue was last updated */
824
- updatedAt?: Maybe<Scalars['Time']['output']>;
568
+ updatedAt: Scalars['Time']['output'];
825
569
  /** The literal value itself as JSON. */
826
- value?: Maybe<Scalars['JSON']['output']>;
570
+ value: Scalars['JSON']['output'];
827
571
  }
828
572
 
829
573
  /** Represents an error message */
830
574
  export interface MessageError {
831
575
  __typename?: 'MessageError';
832
576
  /** The message provided from the error */
833
- message?: Maybe<Scalars['String']['output']>;
577
+ message: Scalars['String']['output'];
834
578
  }
835
579
 
836
580
  /** Represents the input for mfa authentication */
@@ -842,7 +586,7 @@ export interface MfaInput {
842
586
  }
843
587
 
844
588
  /** Represent all available types to authenticate with mfa */
845
- export const enum MfaType {
589
+ export enum MfaType {
846
590
  /** Single use backup code */
847
591
  BackupCode = 'BACKUP_CODE',
848
592
  /** Time based onetime password */
@@ -859,12 +603,11 @@ export interface Mutation {
859
603
  *
860
604
  * This is expected to be used for testing of endpoints, to verify
861
605
  * that a user has mutation access.
862
- *
863
606
  */
864
607
  echo?: Maybe<EchoPayload>;
865
- /** (EE only) Create a new namespace license. */
608
+ /** Create a new namespace license. */
866
609
  namespacesLicensesCreate?: Maybe<NamespacesLicensesCreatePayload>;
867
- /** (EE only) Deletes an namespace license. */
610
+ /** Deletes an namespace license. */
868
611
  namespacesLicensesDelete?: Maybe<NamespacesLicensesDeletePayload>;
869
612
  /** Update the roles a member is assigned to. */
870
613
  namespacesMembersAssignRoles?: Maybe<NamespacesMembersAssignRolesPayload>;
@@ -908,8 +651,6 @@ export interface Mutation {
908
651
  runtimesRotateToken?: Maybe<RuntimesRotateTokenPayload>;
909
652
  /** Update an existing runtime. */
910
653
  runtimesUpdate?: Maybe<RuntimesUpdatePayload>;
911
- /** Verify your email when changing it or signing up */
912
- usersEmailVerification?: Maybe<UsersEmailVerificationPayload>;
913
654
  /** Links an external identity to an existing user */
914
655
  usersIdentityLink?: Maybe<UsersIdentityLinkPayload>;
915
656
  /** Login to an existing user via an external identity */
@@ -928,10 +669,6 @@ export interface Mutation {
928
669
  usersMfaTotpGenerateSecret?: Maybe<UsersMfaTotpGenerateSecretPayload>;
929
670
  /** Validates a TOTP value for the given secret and enables TOTP MFA for the user */
930
671
  usersMfaTotpValidateSecret?: Maybe<UsersMfaTotpValidateSecretPayload>;
931
- /** Reset the password using a reset token */
932
- usersPasswordReset?: Maybe<UsersPasswordResetPayload>;
933
- /** Request an password reset */
934
- usersPasswordResetRequest?: Maybe<UsersPasswordResetRequestPayload>;
935
672
  /** Register a new user */
936
673
  usersRegister?: Maybe<UsersRegisterPayload>;
937
674
  /** Update an existing user. */
@@ -1089,12 +826,6 @@ export interface MutationRuntimesUpdateArgs {
1089
826
  }
1090
827
 
1091
828
 
1092
- /** Root Mutation type */
1093
- export interface MutationUsersEmailVerificationArgs {
1094
- input: UsersEmailVerificationInput;
1095
- }
1096
-
1097
-
1098
829
  /** Root Mutation type */
1099
830
  export interface MutationUsersIdentityLinkArgs {
1100
831
  input: UsersIdentityLinkInput;
@@ -1149,18 +880,6 @@ export interface MutationUsersMfaTotpValidateSecretArgs {
1149
880
  }
1150
881
 
1151
882
 
1152
- /** Root Mutation type */
1153
- export interface MutationUsersPasswordResetArgs {
1154
- input: UsersPasswordResetInput;
1155
- }
1156
-
1157
-
1158
- /** Root Mutation type */
1159
- export interface MutationUsersPasswordResetRequestArgs {
1160
- input: UsersPasswordResetRequestInput;
1161
- }
1162
-
1163
-
1164
883
  /** Root Mutation type */
1165
884
  export interface MutationUsersRegisterArgs {
1166
885
  input: UsersRegisterInput;
@@ -1176,23 +895,23 @@ export interface MutationUsersUpdateArgs {
1176
895
  export interface Namespace {
1177
896
  __typename?: 'Namespace';
1178
897
  /** Time when this Namespace was created */
1179
- createdAt?: Maybe<Scalars['Time']['output']>;
898
+ createdAt: Scalars['Time']['output'];
1180
899
  /** Global ID of this Namespace */
1181
- id?: Maybe<Scalars['NamespaceID']['output']>;
900
+ id: Scalars['NamespaceID']['output'];
1182
901
  /** Members of the namespace */
1183
- members?: Maybe<NamespaceMemberConnection>;
1184
- /** (EE only) Licenses of the namespace */
1185
- namespaceLicenses?: Maybe<NamespaceLicenseConnection>;
902
+ members: NamespaceMemberConnection;
903
+ /** Licenses of the namespace */
904
+ namespaceLicenses: NamespaceLicenseConnection;
1186
905
  /** Parent of this namespace */
1187
- parent?: Maybe<NamespaceParent>;
906
+ parent: NamespaceParent;
1188
907
  /** Projects of the namespace */
1189
- projects?: Maybe<NamespaceProjectConnection>;
908
+ projects: NamespaceProjectConnection;
1190
909
  /** Roles of the namespace */
1191
- roles?: Maybe<NamespaceRoleConnection>;
910
+ roles: NamespaceRoleConnection;
1192
911
  /** Runtime of the namespace */
1193
- runtimes?: Maybe<RuntimeConnection>;
912
+ runtimes: RuntimeConnection;
1194
913
  /** Time when this Namespace was last updated */
1195
- updatedAt?: Maybe<Scalars['Time']['output']>;
914
+ updatedAt: Scalars['Time']['output'];
1196
915
  }
1197
916
 
1198
917
 
@@ -1240,43 +959,37 @@ export interface NamespaceRuntimesArgs {
1240
959
  last?: InputMaybe<Scalars['Int']['input']>;
1241
960
  }
1242
961
 
1243
- /** (EE only) Represents a Namespace License */
962
+ /** Represents a Namespace License */
1244
963
  export interface NamespaceLicense {
1245
964
  __typename?: 'NamespaceLicense';
1246
965
  /** Time when this NamespaceLicense was created */
1247
- createdAt?: Maybe<Scalars['Time']['output']>;
1248
- /** The end date of the license */
1249
- endDate?: Maybe<Scalars['Time']['output']>;
966
+ createdAt: Scalars['Time']['output'];
1250
967
  /** Global ID of this NamespaceLicense */
1251
- id?: Maybe<Scalars['NamespaceLicenseID']['output']>;
1252
- /** The licensee information */
1253
- licensee?: Maybe<Scalars['JSON']['output']>;
968
+ id: Scalars['NamespaceLicenseID']['output'];
1254
969
  /** The namespace the license belongs to */
1255
- namespace?: Maybe<Namespace>;
1256
- /** The start date of the license */
1257
- startDate?: Maybe<Scalars['Time']['output']>;
970
+ namespace: Namespace;
1258
971
  /** Time when this NamespaceLicense was last updated */
1259
- updatedAt?: Maybe<Scalars['Time']['output']>;
972
+ updatedAt: Scalars['Time']['output'];
1260
973
  }
1261
974
 
1262
975
  /** The connection type for NamespaceLicense. */
1263
976
  export interface NamespaceLicenseConnection {
1264
977
  __typename?: 'NamespaceLicenseConnection';
1265
978
  /** Total count of collection. */
1266
- count?: Maybe<Scalars['Int']['output']>;
979
+ count: Scalars['Int']['output'];
1267
980
  /** A list of edges. */
1268
981
  edges?: Maybe<Array<Maybe<NamespaceLicenseEdge>>>;
1269
982
  /** A list of nodes. */
1270
983
  nodes?: Maybe<Array<Maybe<NamespaceLicense>>>;
1271
984
  /** Information to aid in pagination. */
1272
- pageInfo?: Maybe<PageInfo>;
985
+ pageInfo: PageInfo;
1273
986
  }
1274
987
 
1275
988
  /** An edge in a connection. */
1276
989
  export interface NamespaceLicenseEdge {
1277
990
  __typename?: 'NamespaceLicenseEdge';
1278
991
  /** A cursor for use in pagination. */
1279
- cursor?: Maybe<Scalars['String']['output']>;
992
+ cursor: Scalars['String']['output'];
1280
993
  /** The item at the end of the edge. */
1281
994
  node?: Maybe<NamespaceLicense>;
1282
995
  }
@@ -1285,57 +998,35 @@ export interface NamespaceLicenseEdge {
1285
998
  export interface NamespaceMember {
1286
999
  __typename?: 'NamespaceMember';
1287
1000
  /** Time when this NamespaceMember was created */
1288
- createdAt?: Maybe<Scalars['Time']['output']>;
1001
+ createdAt: Scalars['Time']['output'];
1289
1002
  /** Global ID of this NamespaceMember */
1290
- id?: Maybe<Scalars['NamespaceMemberID']['output']>;
1291
- /** Memberroles of the member */
1292
- memberRoles?: Maybe<NamespaceMemberRoleConnection>;
1003
+ id: Scalars['NamespaceMemberID']['output'];
1293
1004
  /** Namespace this member belongs to */
1294
- namespace?: Maybe<Namespace>;
1295
- /** Roles of the member */
1296
- roles?: Maybe<NamespaceRoleConnection>;
1005
+ namespace: Namespace;
1297
1006
  /** Time when this NamespaceMember was last updated */
1298
- updatedAt?: Maybe<Scalars['Time']['output']>;
1007
+ updatedAt: Scalars['Time']['output'];
1299
1008
  /** User this member belongs to */
1300
- user?: Maybe<User>;
1301
- }
1302
-
1303
-
1304
- /** Represents a namespace member */
1305
- export interface NamespaceMemberMemberRolesArgs {
1306
- after?: InputMaybe<Scalars['String']['input']>;
1307
- before?: InputMaybe<Scalars['String']['input']>;
1308
- first?: InputMaybe<Scalars['Int']['input']>;
1309
- last?: InputMaybe<Scalars['Int']['input']>;
1310
- }
1311
-
1312
-
1313
- /** Represents a namespace member */
1314
- export interface NamespaceMemberRolesArgs {
1315
- after?: InputMaybe<Scalars['String']['input']>;
1316
- before?: InputMaybe<Scalars['String']['input']>;
1317
- first?: InputMaybe<Scalars['Int']['input']>;
1318
- last?: InputMaybe<Scalars['Int']['input']>;
1009
+ user: User;
1319
1010
  }
1320
1011
 
1321
1012
  /** The connection type for NamespaceMember. */
1322
1013
  export interface NamespaceMemberConnection {
1323
1014
  __typename?: 'NamespaceMemberConnection';
1324
1015
  /** Total count of collection. */
1325
- count?: Maybe<Scalars['Int']['output']>;
1016
+ count: Scalars['Int']['output'];
1326
1017
  /** A list of edges. */
1327
1018
  edges?: Maybe<Array<Maybe<NamespaceMemberEdge>>>;
1328
1019
  /** A list of nodes. */
1329
1020
  nodes?: Maybe<Array<Maybe<NamespaceMember>>>;
1330
1021
  /** Information to aid in pagination. */
1331
- pageInfo?: Maybe<PageInfo>;
1022
+ pageInfo: PageInfo;
1332
1023
  }
1333
1024
 
1334
1025
  /** An edge in a connection. */
1335
1026
  export interface NamespaceMemberEdge {
1336
1027
  __typename?: 'NamespaceMemberEdge';
1337
1028
  /** A cursor for use in pagination. */
1338
- cursor?: Maybe<Scalars['String']['output']>;
1029
+ cursor: Scalars['String']['output'];
1339
1030
  /** The item at the end of the edge. */
1340
1031
  node?: Maybe<NamespaceMember>;
1341
1032
  }
@@ -1344,80 +1035,39 @@ export interface NamespaceMemberEdge {
1344
1035
  export interface NamespaceMemberRole {
1345
1036
  __typename?: 'NamespaceMemberRole';
1346
1037
  /** Time when this NamespaceMemberRole was created */
1347
- createdAt?: Maybe<Scalars['Time']['output']>;
1038
+ createdAt: Scalars['Time']['output'];
1348
1039
  /** Global ID of this NamespaceMemberRole */
1349
- id?: Maybe<Scalars['NamespaceMemberRoleID']['output']>;
1040
+ id: Scalars['NamespaceMemberRoleID']['output'];
1350
1041
  /** The member the role is assigned to */
1351
1042
  member?: Maybe<NamespaceMember>;
1352
1043
  /** The assigned role */
1353
1044
  role?: Maybe<NamespaceRole>;
1354
1045
  /** Time when this NamespaceMemberRole was last updated */
1355
- updatedAt?: Maybe<Scalars['Time']['output']>;
1356
- }
1357
-
1358
- /** The connection type for NamespaceMemberRole. */
1359
- export interface NamespaceMemberRoleConnection {
1360
- __typename?: 'NamespaceMemberRoleConnection';
1361
- /** Total count of collection. */
1362
- count?: Maybe<Scalars['Int']['output']>;
1363
- /** A list of edges. */
1364
- edges?: Maybe<Array<Maybe<NamespaceMemberRoleEdge>>>;
1365
- /** A list of nodes. */
1366
- nodes?: Maybe<Array<Maybe<NamespaceMemberRole>>>;
1367
- /** Information to aid in pagination. */
1368
- pageInfo?: Maybe<PageInfo>;
1369
- }
1370
-
1371
- /** An edge in a connection. */
1372
- export interface NamespaceMemberRoleEdge {
1373
- __typename?: 'NamespaceMemberRoleEdge';
1374
- /** A cursor for use in pagination. */
1375
- cursor?: Maybe<Scalars['String']['output']>;
1376
- /** The item at the end of the edge. */
1377
- node?: Maybe<NamespaceMemberRole>;
1046
+ updatedAt: Scalars['Time']['output'];
1378
1047
  }
1379
1048
 
1380
1049
  /** Objects that can present a namespace */
1381
- export type NamespaceParent = Organization | User;
1050
+ export type NamespaceParent = Organization;
1382
1051
 
1383
1052
  /** Represents a namespace project */
1384
1053
  export interface NamespaceProject {
1385
1054
  __typename?: 'NamespaceProject';
1386
1055
  /** Time when this NamespaceProject was created */
1387
- createdAt?: Maybe<Scalars['Time']['output']>;
1056
+ createdAt: Scalars['Time']['output'];
1388
1057
  /** Description of the project */
1389
- description?: Maybe<Scalars['String']['output']>;
1390
- /** Fetches an flow given by its ID */
1391
- flow?: Maybe<Flow>;
1392
- /** Fetches all flows in this project */
1393
- flows?: Maybe<FlowConnection>;
1058
+ description: Scalars['String']['output'];
1394
1059
  /** Global ID of this NamespaceProject */
1395
- id?: Maybe<Scalars['NamespaceProjectID']['output']>;
1060
+ id: Scalars['NamespaceProjectID']['output'];
1396
1061
  /** Name of the project */
1397
- name?: Maybe<Scalars['String']['output']>;
1062
+ name: Scalars['String']['output'];
1398
1063
  /** The namespace where this project belongs to */
1399
- namespace?: Maybe<Namespace>;
1064
+ namespace: Namespace;
1400
1065
  /** The primary runtime for the project */
1401
1066
  primaryRuntime?: Maybe<Runtime>;
1402
1067
  /** Runtimes assigned to this project */
1403
- runtimes?: Maybe<RuntimeConnection>;
1068
+ runtimes: RuntimeConnection;
1404
1069
  /** Time when this NamespaceProject was last updated */
1405
- updatedAt?: Maybe<Scalars['Time']['output']>;
1406
- }
1407
-
1408
-
1409
- /** Represents a namespace project */
1410
- export interface NamespaceProjectFlowArgs {
1411
- id: Scalars['FlowID']['input'];
1412
- }
1413
-
1414
-
1415
- /** Represents a namespace project */
1416
- export interface NamespaceProjectFlowsArgs {
1417
- after?: InputMaybe<Scalars['String']['input']>;
1418
- before?: InputMaybe<Scalars['String']['input']>;
1419
- first?: InputMaybe<Scalars['Int']['input']>;
1420
- last?: InputMaybe<Scalars['Int']['input']>;
1070
+ updatedAt: Scalars['Time']['output'];
1421
1071
  }
1422
1072
 
1423
1073
 
@@ -1433,20 +1083,20 @@ export interface NamespaceProjectRuntimesArgs {
1433
1083
  export interface NamespaceProjectConnection {
1434
1084
  __typename?: 'NamespaceProjectConnection';
1435
1085
  /** Total count of collection. */
1436
- count?: Maybe<Scalars['Int']['output']>;
1086
+ count: Scalars['Int']['output'];
1437
1087
  /** A list of edges. */
1438
1088
  edges?: Maybe<Array<Maybe<NamespaceProjectEdge>>>;
1439
1089
  /** A list of nodes. */
1440
1090
  nodes?: Maybe<Array<Maybe<NamespaceProject>>>;
1441
1091
  /** Information to aid in pagination. */
1442
- pageInfo?: Maybe<PageInfo>;
1092
+ pageInfo: PageInfo;
1443
1093
  }
1444
1094
 
1445
1095
  /** An edge in a connection. */
1446
1096
  export interface NamespaceProjectEdge {
1447
1097
  __typename?: 'NamespaceProjectEdge';
1448
1098
  /** A cursor for use in pagination. */
1449
- cursor?: Maybe<Scalars['String']['output']>;
1099
+ cursor: Scalars['String']['output'];
1450
1100
  /** The item at the end of the edge. */
1451
1101
  node?: Maybe<NamespaceProject>;
1452
1102
  }
@@ -1455,19 +1105,19 @@ export interface NamespaceProjectEdge {
1455
1105
  export interface NamespaceRole {
1456
1106
  __typename?: 'NamespaceRole';
1457
1107
  /** The abilities the role is granted */
1458
- abilities?: Maybe<Array<NamespaceRoleAbility>>;
1108
+ abilities: Array<NamespaceRoleAbility>;
1459
1109
  /** The projects this role is assigned to */
1460
1110
  assignedProjects?: Maybe<NamespaceProjectConnection>;
1461
1111
  /** Time when this NamespaceRole was created */
1462
- createdAt?: Maybe<Scalars['Time']['output']>;
1112
+ createdAt: Scalars['Time']['output'];
1463
1113
  /** Global ID of this NamespaceRole */
1464
- id?: Maybe<Scalars['NamespaceRoleID']['output']>;
1114
+ id: Scalars['NamespaceRoleID']['output'];
1465
1115
  /** The name of this role */
1466
- name?: Maybe<Scalars['String']['output']>;
1116
+ name: Scalars['String']['output'];
1467
1117
  /** The namespace where this role belongs to */
1468
1118
  namespace?: Maybe<Namespace>;
1469
1119
  /** Time when this NamespaceRole was last updated */
1470
- updatedAt?: Maybe<Scalars['Time']['output']>;
1120
+ updatedAt: Scalars['Time']['output'];
1471
1121
  }
1472
1122
 
1473
1123
 
@@ -1480,7 +1130,7 @@ export interface NamespaceRoleAssignedProjectsArgs {
1480
1130
  }
1481
1131
 
1482
1132
  /** Represents abilities that can be granted to roles in namespaces. */
1483
- export const enum NamespaceRoleAbility {
1133
+ export enum NamespaceRoleAbility {
1484
1134
  /** Allows to change the roles of a namespace member */
1485
1135
  AssignMemberRoles = 'ASSIGN_MEMBER_ROLES',
1486
1136
  /** Allows to assign runtimes to a project in the namespace */
@@ -1539,20 +1189,20 @@ export const enum NamespaceRoleAbility {
1539
1189
  export interface NamespaceRoleConnection {
1540
1190
  __typename?: 'NamespaceRoleConnection';
1541
1191
  /** Total count of collection. */
1542
- count?: Maybe<Scalars['Int']['output']>;
1192
+ count: Scalars['Int']['output'];
1543
1193
  /** A list of edges. */
1544
1194
  edges?: Maybe<Array<Maybe<NamespaceRoleEdge>>>;
1545
1195
  /** A list of nodes. */
1546
1196
  nodes?: Maybe<Array<Maybe<NamespaceRole>>>;
1547
1197
  /** Information to aid in pagination. */
1548
- pageInfo?: Maybe<PageInfo>;
1198
+ pageInfo: PageInfo;
1549
1199
  }
1550
1200
 
1551
1201
  /** An edge in a connection. */
1552
1202
  export interface NamespaceRoleEdge {
1553
1203
  __typename?: 'NamespaceRoleEdge';
1554
1204
  /** A cursor for use in pagination. */
1555
- cursor?: Maybe<Scalars['String']['output']>;
1205
+ cursor: Scalars['String']['output'];
1556
1206
  /** The item at the end of the edge. */
1557
1207
  node?: Maybe<NamespaceRole>;
1558
1208
  }
@@ -1573,7 +1223,7 @@ export interface NamespacesLicensesCreatePayload {
1573
1223
  /** A unique identifier for the client performing the mutation. */
1574
1224
  clientMutationId?: Maybe<Scalars['String']['output']>;
1575
1225
  /** Errors encountered during execution of the mutation. */
1576
- errors?: Maybe<Array<Error>>;
1226
+ errors: Array<Error>;
1577
1227
  /** The newly created license. */
1578
1228
  namespaceLicense?: Maybe<NamespaceLicense>;
1579
1229
  }
@@ -1592,7 +1242,7 @@ export interface NamespacesLicensesDeletePayload {
1592
1242
  /** A unique identifier for the client performing the mutation. */
1593
1243
  clientMutationId?: Maybe<Scalars['String']['output']>;
1594
1244
  /** Errors encountered during execution of the mutation. */
1595
- errors?: Maybe<Array<Error>>;
1245
+ errors: Array<Error>;
1596
1246
  /** The deleted namespace license. */
1597
1247
  namespaceLicense?: Maybe<NamespaceLicense>;
1598
1248
  }
@@ -1613,7 +1263,7 @@ export interface NamespacesMembersAssignRolesPayload {
1613
1263
  /** A unique identifier for the client performing the mutation. */
1614
1264
  clientMutationId?: Maybe<Scalars['String']['output']>;
1615
1265
  /** Errors encountered during execution of the mutation. */
1616
- errors?: Maybe<Array<Error>>;
1266
+ errors: Array<Error>;
1617
1267
  /** The roles the member is now assigned to */
1618
1268
  namespaceMemberRoles?: Maybe<Array<NamespaceMemberRole>>;
1619
1269
  }
@@ -1632,7 +1282,7 @@ export interface NamespacesMembersDeletePayload {
1632
1282
  /** A unique identifier for the client performing the mutation. */
1633
1283
  clientMutationId?: Maybe<Scalars['String']['output']>;
1634
1284
  /** Errors encountered during execution of the mutation. */
1635
- errors?: Maybe<Array<Error>>;
1285
+ errors: Array<Error>;
1636
1286
  /** The removed namespace member */
1637
1287
  namespaceMember?: Maybe<NamespaceMember>;
1638
1288
  }
@@ -1653,7 +1303,7 @@ export interface NamespacesMembersInvitePayload {
1653
1303
  /** A unique identifier for the client performing the mutation. */
1654
1304
  clientMutationId?: Maybe<Scalars['String']['output']>;
1655
1305
  /** Errors encountered during execution of the mutation. */
1656
- errors?: Maybe<Array<Error>>;
1306
+ errors: Array<Error>;
1657
1307
  /** The newly created namespace member */
1658
1308
  namespaceMember?: Maybe<NamespaceMember>;
1659
1309
  }
@@ -1674,7 +1324,7 @@ export interface NamespacesProjectsAssignRuntimesPayload {
1674
1324
  /** A unique identifier for the client performing the mutation. */
1675
1325
  clientMutationId?: Maybe<Scalars['String']['output']>;
1676
1326
  /** Errors encountered during execution of the mutation. */
1677
- errors?: Maybe<Array<Error>>;
1327
+ errors: Array<Error>;
1678
1328
  /** The updated project with assigned runtimes */
1679
1329
  namespaceProject?: Maybe<NamespaceProject>;
1680
1330
  }
@@ -1697,7 +1347,7 @@ export interface NamespacesProjectsCreatePayload {
1697
1347
  /** A unique identifier for the client performing the mutation. */
1698
1348
  clientMutationId?: Maybe<Scalars['String']['output']>;
1699
1349
  /** Errors encountered during execution of the mutation. */
1700
- errors?: Maybe<Array<Error>>;
1350
+ errors: Array<Error>;
1701
1351
  /** The newly created project. */
1702
1352
  namespaceProject?: Maybe<NamespaceProject>;
1703
1353
  }
@@ -1716,7 +1366,7 @@ export interface NamespacesProjectsDeletePayload {
1716
1366
  /** A unique identifier for the client performing the mutation. */
1717
1367
  clientMutationId?: Maybe<Scalars['String']['output']>;
1718
1368
  /** Errors encountered during execution of the mutation. */
1719
- errors?: Maybe<Array<Error>>;
1369
+ errors: Array<Error>;
1720
1370
  /** The deleted project. */
1721
1371
  namespaceProject?: Maybe<NamespaceProject>;
1722
1372
  }
@@ -1737,7 +1387,7 @@ export interface NamespacesProjectsFlowsCreatePayload {
1737
1387
  /** A unique identifier for the client performing the mutation. */
1738
1388
  clientMutationId?: Maybe<Scalars['String']['output']>;
1739
1389
  /** Errors encountered during execution of the mutation. */
1740
- errors?: Maybe<Array<Error>>;
1390
+ errors: Array<Error>;
1741
1391
  /** The newly created flow. */
1742
1392
  flow?: Maybe<Flow>;
1743
1393
  }
@@ -1756,7 +1406,7 @@ export interface NamespacesProjectsFlowsDeletePayload {
1756
1406
  /** A unique identifier for the client performing the mutation. */
1757
1407
  clientMutationId?: Maybe<Scalars['String']['output']>;
1758
1408
  /** Errors encountered during execution of the mutation. */
1759
- errors?: Maybe<Array<Error>>;
1409
+ errors: Array<Error>;
1760
1410
  /** The deleted flow. */
1761
1411
  flow?: Maybe<Flow>;
1762
1412
  }
@@ -1781,7 +1431,7 @@ export interface NamespacesProjectsUpdatePayload {
1781
1431
  /** A unique identifier for the client performing the mutation. */
1782
1432
  clientMutationId?: Maybe<Scalars['String']['output']>;
1783
1433
  /** Errors encountered during execution of the mutation. */
1784
- errors?: Maybe<Array<Error>>;
1434
+ errors: Array<Error>;
1785
1435
  /** The updated project. */
1786
1436
  namespaceProject?: Maybe<NamespaceProject>;
1787
1437
  }
@@ -1804,7 +1454,7 @@ export interface NamespacesRolesAssignAbilitiesPayload {
1804
1454
  /** A unique identifier for the client performing the mutation. */
1805
1455
  clientMutationId?: Maybe<Scalars['String']['output']>;
1806
1456
  /** Errors encountered during execution of the mutation. */
1807
- errors?: Maybe<Array<Error>>;
1457
+ errors: Array<Error>;
1808
1458
  }
1809
1459
 
1810
1460
  /** Autogenerated input type of NamespacesRolesAssignProjects */
@@ -1823,7 +1473,7 @@ export interface NamespacesRolesAssignProjectsPayload {
1823
1473
  /** A unique identifier for the client performing the mutation. */
1824
1474
  clientMutationId?: Maybe<Scalars['String']['output']>;
1825
1475
  /** Errors encountered during execution of the mutation. */
1826
- errors?: Maybe<Array<Error>>;
1476
+ errors: Array<Error>;
1827
1477
  /** The now assigned projects */
1828
1478
  projects?: Maybe<Array<NamespaceProject>>;
1829
1479
  }
@@ -1844,7 +1494,7 @@ export interface NamespacesRolesCreatePayload {
1844
1494
  /** A unique identifier for the client performing the mutation. */
1845
1495
  clientMutationId?: Maybe<Scalars['String']['output']>;
1846
1496
  /** Errors encountered during execution of the mutation. */
1847
- errors?: Maybe<Array<Error>>;
1497
+ errors: Array<Error>;
1848
1498
  /** The newly created namespace role */
1849
1499
  namespaceRole?: Maybe<NamespaceRole>;
1850
1500
  }
@@ -1863,7 +1513,7 @@ export interface NamespacesRolesDeletePayload {
1863
1513
  /** A unique identifier for the client performing the mutation. */
1864
1514
  clientMutationId?: Maybe<Scalars['String']['output']>;
1865
1515
  /** Errors encountered during execution of the mutation. */
1866
- errors?: Maybe<Array<Error>>;
1516
+ errors: Array<Error>;
1867
1517
  /** The deleted namespace role */
1868
1518
  namespaceRole?: Maybe<NamespaceRole>;
1869
1519
  }
@@ -1884,7 +1534,7 @@ export interface NamespacesRolesUpdatePayload {
1884
1534
  /** A unique identifier for the client performing the mutation. */
1885
1535
  clientMutationId?: Maybe<Scalars['String']['output']>;
1886
1536
  /** Errors encountered during execution of the mutation. */
1887
- errors?: Maybe<Array<Error>>;
1537
+ errors: Array<Error>;
1888
1538
  /** The updated namespace role. */
1889
1539
  namespaceRole?: Maybe<NamespaceRole>;
1890
1540
  }
@@ -1892,24 +1542,24 @@ export interface NamespacesRolesUpdatePayload {
1892
1542
  /** An object with an ID. */
1893
1543
  export interface Node {
1894
1544
  /** ID of the object. */
1895
- id?: Maybe<Scalars['ID']['output']>;
1545
+ id: Scalars['ID']['output'];
1896
1546
  }
1897
1547
 
1898
1548
  /** Represents a Node Function */
1899
1549
  export interface NodeFunction {
1900
1550
  __typename?: 'NodeFunction';
1901
1551
  /** Time when this NodeFunction was created */
1902
- createdAt?: Maybe<Scalars['Time']['output']>;
1903
- /** The definition of the Node Function */
1904
- functionDefinition?: Maybe<FunctionDefinition>;
1552
+ createdAt: Scalars['Time']['output'];
1905
1553
  /** Global ID of this NodeFunction */
1906
- id?: Maybe<Scalars['NodeFunctionID']['output']>;
1907
- /** The ID of the next Node Function in the flow */
1908
- nextNodeId?: Maybe<Scalars['NodeFunctionID']['output']>;
1554
+ id: Scalars['NodeFunctionID']['output'];
1555
+ /** The next Node Function in the flow */
1556
+ nextNode?: Maybe<NodeFunction>;
1909
1557
  /** The parameters of the Node Function */
1910
- parameters?: Maybe<NodeParameterConnection>;
1558
+ parameters: NodeParameterConnection;
1559
+ /** The definition of the Node Function */
1560
+ runtimeFunction: RuntimeFunctionDefinition;
1911
1561
  /** Time when this NodeFunction was last updated */
1912
- updatedAt?: Maybe<Scalars['Time']['output']>;
1562
+ updatedAt: Scalars['Time']['output'];
1913
1563
  }
1914
1564
 
1915
1565
 
@@ -1921,28 +1571,6 @@ export interface NodeFunctionParametersArgs {
1921
1571
  last?: InputMaybe<Scalars['Int']['input']>;
1922
1572
  }
1923
1573
 
1924
- /** The connection type for NodeFunction. */
1925
- export interface NodeFunctionConnection {
1926
- __typename?: 'NodeFunctionConnection';
1927
- /** Total count of collection. */
1928
- count?: Maybe<Scalars['Int']['output']>;
1929
- /** A list of edges. */
1930
- edges?: Maybe<Array<Maybe<NodeFunctionEdge>>>;
1931
- /** A list of nodes. */
1932
- nodes?: Maybe<Array<Maybe<NodeFunction>>>;
1933
- /** Information to aid in pagination. */
1934
- pageInfo?: Maybe<PageInfo>;
1935
- }
1936
-
1937
- /** An edge in a connection. */
1938
- export interface NodeFunctionEdge {
1939
- __typename?: 'NodeFunctionEdge';
1940
- /** A cursor for use in pagination. */
1941
- cursor?: Maybe<Scalars['String']['output']>;
1942
- /** The item at the end of the edge. */
1943
- node?: Maybe<NodeFunction>;
1944
- }
1945
-
1946
1574
  /** Input type for a Node Function */
1947
1575
  export interface NodeFunctionInput {
1948
1576
  /** The next Node Function in the flow */
@@ -1957,13 +1585,13 @@ export interface NodeFunctionInput {
1957
1585
  export interface NodeParameter {
1958
1586
  __typename?: 'NodeParameter';
1959
1587
  /** Time when this NodeParameter was created */
1960
- createdAt?: Maybe<Scalars['Time']['output']>;
1588
+ createdAt: Scalars['Time']['output'];
1961
1589
  /** Global ID of this NodeParameter */
1962
- id?: Maybe<Scalars['NodeParameterID']['output']>;
1590
+ id: Scalars['NodeParameterID']['output'];
1963
1591
  /** The definition of the parameter */
1964
- runtimeParameter?: Maybe<RuntimeParameterDefinition>;
1592
+ runtimeParameter: RuntimeParameterDefinition;
1965
1593
  /** Time when this NodeParameter was last updated */
1966
- updatedAt?: Maybe<Scalars['Time']['output']>;
1594
+ updatedAt: Scalars['Time']['output'];
1967
1595
  /** The value of the parameter */
1968
1596
  value?: Maybe<NodeParameterValue>;
1969
1597
  }
@@ -1972,20 +1600,20 @@ export interface NodeParameter {
1972
1600
  export interface NodeParameterConnection {
1973
1601
  __typename?: 'NodeParameterConnection';
1974
1602
  /** Total count of collection. */
1975
- count?: Maybe<Scalars['Int']['output']>;
1603
+ count: Scalars['Int']['output'];
1976
1604
  /** A list of edges. */
1977
1605
  edges?: Maybe<Array<Maybe<NodeParameterEdge>>>;
1978
1606
  /** A list of nodes. */
1979
1607
  nodes?: Maybe<Array<Maybe<NodeParameter>>>;
1980
1608
  /** Information to aid in pagination. */
1981
- pageInfo?: Maybe<PageInfo>;
1609
+ pageInfo: PageInfo;
1982
1610
  }
1983
1611
 
1984
1612
  /** An edge in a connection. */
1985
1613
  export interface NodeParameterEdge {
1986
1614
  __typename?: 'NodeParameterEdge';
1987
1615
  /** A cursor for use in pagination. */
1988
- cursor?: Maybe<Scalars['String']['output']>;
1616
+ cursor: Scalars['String']['output'];
1989
1617
  /** The item at the end of the edge. */
1990
1618
  node?: Maybe<NodeParameter>;
1991
1619
  }
@@ -2011,19 +1639,30 @@ export interface NodeParameterValueInput {
2011
1639
  referenceValue?: InputMaybe<ReferenceValueInput>;
2012
1640
  }
2013
1641
 
1642
+ /** Represents a rule that can be applied to a data type. */
1643
+ export interface NumberRangeConfig {
1644
+ __typename?: 'NumberRangeConfig';
1645
+ /** The minimum value of the range */
1646
+ from: Scalars['Int']['output'];
1647
+ /** The step value for the range, if applicable */
1648
+ steps?: Maybe<Scalars['Int']['output']>;
1649
+ /** The maximum value of the range */
1650
+ to: Scalars['Int']['output'];
1651
+ }
1652
+
2014
1653
  /** Represents a Organization */
2015
1654
  export interface Organization {
2016
1655
  __typename?: 'Organization';
2017
1656
  /** Time when this Organization was created */
2018
- createdAt?: Maybe<Scalars['Time']['output']>;
1657
+ createdAt: Scalars['Time']['output'];
2019
1658
  /** Global ID of this Organization */
2020
- id?: Maybe<Scalars['OrganizationID']['output']>;
1659
+ id: Scalars['OrganizationID']['output'];
2021
1660
  /** Name of the organization */
2022
- name?: Maybe<Scalars['String']['output']>;
1661
+ name: Scalars['String']['output'];
2023
1662
  /** Namespace of this organization */
2024
- namespace?: Maybe<Namespace>;
1663
+ namespace: Namespace;
2025
1664
  /** Time when this Organization was last updated */
2026
- updatedAt?: Maybe<Scalars['Time']['output']>;
1665
+ updatedAt: Scalars['Time']['output'];
2027
1666
  }
2028
1667
 
2029
1668
  /** Autogenerated input type of OrganizationsCreate */
@@ -2040,7 +1679,7 @@ export interface OrganizationsCreatePayload {
2040
1679
  /** A unique identifier for the client performing the mutation. */
2041
1680
  clientMutationId?: Maybe<Scalars['String']['output']>;
2042
1681
  /** Errors encountered during execution of the mutation. */
2043
- errors?: Maybe<Array<Error>>;
1682
+ errors: Array<Error>;
2044
1683
  /** The newly created organization. */
2045
1684
  organization?: Maybe<Organization>;
2046
1685
  }
@@ -2059,7 +1698,7 @@ export interface OrganizationsDeletePayload {
2059
1698
  /** A unique identifier for the client performing the mutation. */
2060
1699
  clientMutationId?: Maybe<Scalars['String']['output']>;
2061
1700
  /** Errors encountered during execution of the mutation. */
2062
- errors?: Maybe<Array<Error>>;
1701
+ errors: Array<Error>;
2063
1702
  /** The deleted organization. */
2064
1703
  organization?: Maybe<Organization>;
2065
1704
  }
@@ -2080,7 +1719,7 @@ export interface OrganizationsUpdatePayload {
2080
1719
  /** A unique identifier for the client performing the mutation. */
2081
1720
  clientMutationId?: Maybe<Scalars['String']['output']>;
2082
1721
  /** Errors encountered during execution of the mutation. */
2083
- errors?: Maybe<Array<Error>>;
1722
+ errors: Array<Error>;
2084
1723
  /** The updated organization. */
2085
1724
  organization?: Maybe<Organization>;
2086
1725
  }
@@ -2091,83 +1730,13 @@ export interface PageInfo {
2091
1730
  /** When paginating forwards, the cursor to continue. */
2092
1731
  endCursor?: Maybe<Scalars['String']['output']>;
2093
1732
  /** When paginating forwards, are there more items? */
2094
- hasNextPage?: Maybe<Scalars['Boolean']['output']>;
1733
+ hasNextPage: Scalars['Boolean']['output'];
2095
1734
  /** When paginating backwards, are there more items? */
2096
- hasPreviousPage?: Maybe<Scalars['Boolean']['output']>;
1735
+ hasPreviousPage: Scalars['Boolean']['output'];
2097
1736
  /** When paginating backwards, the cursor to continue. */
2098
1737
  startCursor?: Maybe<Scalars['String']['output']>;
2099
1738
  }
2100
1739
 
2101
- /** Represents a parameter definition */
2102
- export interface ParameterDefinition {
2103
- __typename?: 'ParameterDefinition';
2104
- /** Time when this ParameterDefinition was created */
2105
- createdAt?: Maybe<Scalars['Time']['output']>;
2106
- /** Data type of the parameter */
2107
- dataTypeIdentifier?: Maybe<DataTypeIdentifier>;
2108
- /** Description of the parameter */
2109
- descriptions?: Maybe<TranslationConnection>;
2110
- /** Documentation of the parameter */
2111
- documentations?: Maybe<TranslationConnection>;
2112
- /** Global ID of this ParameterDefinition */
2113
- id?: Maybe<Scalars['ParameterDefinitionID']['output']>;
2114
- /** Identifier of the parameter */
2115
- identifier?: Maybe<Scalars['String']['output']>;
2116
- /** Name of the parameter */
2117
- names?: Maybe<TranslationConnection>;
2118
- /** Time when this ParameterDefinition was last updated */
2119
- updatedAt?: Maybe<Scalars['Time']['output']>;
2120
- }
2121
-
2122
-
2123
- /** Represents a parameter definition */
2124
- export interface ParameterDefinitionDescriptionsArgs {
2125
- after?: InputMaybe<Scalars['String']['input']>;
2126
- before?: InputMaybe<Scalars['String']['input']>;
2127
- first?: InputMaybe<Scalars['Int']['input']>;
2128
- last?: InputMaybe<Scalars['Int']['input']>;
2129
- }
2130
-
2131
-
2132
- /** Represents a parameter definition */
2133
- export interface ParameterDefinitionDocumentationsArgs {
2134
- after?: InputMaybe<Scalars['String']['input']>;
2135
- before?: InputMaybe<Scalars['String']['input']>;
2136
- first?: InputMaybe<Scalars['Int']['input']>;
2137
- last?: InputMaybe<Scalars['Int']['input']>;
2138
- }
2139
-
2140
-
2141
- /** Represents a parameter definition */
2142
- export interface ParameterDefinitionNamesArgs {
2143
- after?: InputMaybe<Scalars['String']['input']>;
2144
- before?: InputMaybe<Scalars['String']['input']>;
2145
- first?: InputMaybe<Scalars['Int']['input']>;
2146
- last?: InputMaybe<Scalars['Int']['input']>;
2147
- }
2148
-
2149
- /** The connection type for ParameterDefinition. */
2150
- export interface ParameterDefinitionConnection {
2151
- __typename?: 'ParameterDefinitionConnection';
2152
- /** Total count of collection. */
2153
- count?: Maybe<Scalars['Int']['output']>;
2154
- /** A list of edges. */
2155
- edges?: Maybe<Array<Maybe<ParameterDefinitionEdge>>>;
2156
- /** A list of nodes. */
2157
- nodes?: Maybe<Array<Maybe<ParameterDefinition>>>;
2158
- /** Information to aid in pagination. */
2159
- pageInfo?: Maybe<PageInfo>;
2160
- }
2161
-
2162
- /** An edge in a connection. */
2163
- export interface ParameterDefinitionEdge {
2164
- __typename?: 'ParameterDefinitionEdge';
2165
- /** A cursor for use in pagination. */
2166
- cursor?: Maybe<Scalars['String']['output']>;
2167
- /** The item at the end of the edge. */
2168
- node?: Maybe<ParameterDefinition>;
2169
- }
2170
-
2171
1740
  /** Root Query type */
2172
1741
  export interface Query {
2173
1742
  __typename?: 'Query';
@@ -2178,9 +1747,9 @@ export interface Query {
2178
1747
  /** Get the currently logged in user */
2179
1748
  currentUser?: Maybe<User>;
2180
1749
  /** Field available for use to test API access */
2181
- echo?: Maybe<Scalars['String']['output']>;
1750
+ echo: Scalars['String']['output'];
2182
1751
  /** Find runtimes */
2183
- globalRuntimes?: Maybe<RuntimeConnection>;
1752
+ globalRuntimes: RuntimeConnection;
2184
1753
  /** Find a namespace */
2185
1754
  namespace?: Maybe<Namespace>;
2186
1755
  /** Fetches an object given its ID */
@@ -2190,7 +1759,7 @@ export interface Query {
2190
1759
  /** Find a organization */
2191
1760
  organization?: Maybe<Organization>;
2192
1761
  /** Find users */
2193
- users?: Maybe<UserConnection>;
1762
+ users: UserConnection;
2194
1763
  }
2195
1764
 
2196
1765
 
@@ -2248,13 +1817,13 @@ export interface ReferencePath {
2248
1817
  /** The array index of the referenced data by the path */
2249
1818
  arrayIndex?: Maybe<Scalars['Int']['output']>;
2250
1819
  /** Time when this ReferencePath was created */
2251
- createdAt?: Maybe<Scalars['Time']['output']>;
1820
+ createdAt: Scalars['Time']['output'];
2252
1821
  /** Global ID of this ReferencePath */
2253
- id?: Maybe<Scalars['ReferencePathID']['output']>;
1822
+ id: Scalars['ReferencePathID']['output'];
2254
1823
  /** The path to the reference in the flow */
2255
1824
  path?: Maybe<Scalars['String']['output']>;
2256
1825
  /** Time when this ReferencePath was last updated */
2257
- updatedAt?: Maybe<Scalars['Time']['output']>;
1826
+ updatedAt: Scalars['Time']['output'];
2258
1827
  }
2259
1828
 
2260
1829
  /** Input type for reference path */
@@ -2269,21 +1838,21 @@ export interface ReferencePathInput {
2269
1838
  export interface ReferenceValue {
2270
1839
  __typename?: 'ReferenceValue';
2271
1840
  /** Time when this ReferenceValue was created */
2272
- createdAt?: Maybe<Scalars['Time']['output']>;
1841
+ createdAt: Scalars['Time']['output'];
2273
1842
  /** The identifier of the data type this reference value belongs to. */
2274
- dataTypeIdentifier?: Maybe<DataTypeIdentifier>;
2275
- /** The depth of the reference value. */
2276
- depth?: Maybe<Scalars['Int']['output']>;
1843
+ dataTypeIdentifier: DataTypeIdentifier;
2277
1844
  /** Global ID of this ReferenceValue */
2278
- id?: Maybe<Scalars['ReferenceValueID']['output']>;
2279
- /** The node of the reference value. */
2280
- node?: Maybe<Scalars['Int']['output']>;
1845
+ id: Scalars['ReferenceValueID']['output'];
1846
+ /** The primary level of the reference value. */
1847
+ primaryLevel: Scalars['Int']['output'];
2281
1848
  /** The paths associated with this reference value. */
2282
- referencePath?: Maybe<Array<ReferencePath>>;
2283
- /** The scope of the reference value. */
2284
- scope?: Maybe<Array<Scalars['Int']['output']>>;
1849
+ referencePath: Array<ReferencePath>;
1850
+ /** The secondary level of the reference value. */
1851
+ secondaryLevel: Scalars['Int']['output'];
1852
+ /** The tertiary level of the reference value, if applicable. */
1853
+ tertiaryLevel?: Maybe<Scalars['Int']['output']>;
2285
1854
  /** Time when this ReferenceValue was last updated */
2286
- updatedAt?: Maybe<Scalars['Time']['output']>;
1855
+ updatedAt: Scalars['Time']['output'];
2287
1856
  }
2288
1857
 
2289
1858
  /** Input type for reference value */
@@ -2300,31 +1869,45 @@ export interface ReferenceValueInput {
2300
1869
  tertiaryLevel?: InputMaybe<Scalars['Int']['input']>;
2301
1870
  }
2302
1871
 
1872
+ /** Represents a rule that can be applied to a data type. */
1873
+ export interface RegexConfig {
1874
+ __typename?: 'RegexConfig';
1875
+ /** The regex pattern to match against the data type value. */
1876
+ pattern: Scalars['String']['output'];
1877
+ }
1878
+
1879
+ /** Represents a rule that can be applied to a data type. */
1880
+ export interface ReturnTypeConfig {
1881
+ __typename?: 'ReturnTypeConfig';
1882
+ /** The data type identifier for the return type. */
1883
+ dataTypeIdentifier: DataTypeIdentifier;
1884
+ }
1885
+
2303
1886
  /** Represents a runtime */
2304
1887
  export interface Runtime {
2305
1888
  __typename?: 'Runtime';
2306
1889
  /** Time when this Runtime was created */
2307
- createdAt?: Maybe<Scalars['Time']['output']>;
1890
+ createdAt: Scalars['Time']['output'];
2308
1891
  /** DataTypes of the runtime */
2309
- dataTypes?: Maybe<DataTypeConnection>;
1892
+ dataTypes: DataTypeConnection;
2310
1893
  /** The description for the runtime if present */
2311
- description?: Maybe<Scalars['String']['output']>;
1894
+ description: Scalars['String']['output'];
2312
1895
  /** FlowTypes of the runtime */
2313
- flowTypes?: Maybe<FlowTypeConnection>;
1896
+ flowTypes: FlowTypeConnection;
2314
1897
  /** Global ID of this Runtime */
2315
- id?: Maybe<Scalars['RuntimeID']['output']>;
1898
+ id: Scalars['RuntimeID']['output'];
2316
1899
  /** The name for the runtime */
2317
- name?: Maybe<Scalars['String']['output']>;
1900
+ name: Scalars['String']['output'];
2318
1901
  /** The parent namespace for the runtime */
2319
1902
  namespace?: Maybe<Namespace>;
2320
1903
  /** Projects associated with the runtime */
2321
- projects?: Maybe<NamespaceProjectConnection>;
1904
+ projects: NamespaceProjectConnection;
2322
1905
  /** The status of the runtime */
2323
- status?: Maybe<RuntimeStatusType>;
1906
+ status: RuntimeStatusType;
2324
1907
  /** Token belonging to the runtime, only present on creation */
2325
1908
  token?: Maybe<Scalars['String']['output']>;
2326
1909
  /** Time when this Runtime was last updated */
2327
- updatedAt?: Maybe<Scalars['Time']['output']>;
1910
+ updatedAt: Scalars['Time']['output'];
2328
1911
  }
2329
1912
 
2330
1913
 
@@ -2358,96 +1941,48 @@ export interface RuntimeProjectsArgs {
2358
1941
  export interface RuntimeConnection {
2359
1942
  __typename?: 'RuntimeConnection';
2360
1943
  /** Total count of collection. */
2361
- count?: Maybe<Scalars['Int']['output']>;
1944
+ count: Scalars['Int']['output'];
2362
1945
  /** A list of edges. */
2363
1946
  edges?: Maybe<Array<Maybe<RuntimeEdge>>>;
2364
1947
  /** A list of nodes. */
2365
1948
  nodes?: Maybe<Array<Maybe<Runtime>>>;
2366
1949
  /** Information to aid in pagination. */
2367
- pageInfo?: Maybe<PageInfo>;
1950
+ pageInfo: PageInfo;
2368
1951
  }
2369
1952
 
2370
1953
  /** An edge in a connection. */
2371
1954
  export interface RuntimeEdge {
2372
1955
  __typename?: 'RuntimeEdge';
2373
1956
  /** A cursor for use in pagination. */
2374
- cursor?: Maybe<Scalars['String']['output']>;
1957
+ cursor: Scalars['String']['output'];
2375
1958
  /** The item at the end of the edge. */
2376
1959
  node?: Maybe<Runtime>;
2377
1960
  }
2378
1961
 
2379
- /** Represents a runtime function definition */
1962
+ /** Represents a Node Function definition */
2380
1963
  export interface RuntimeFunctionDefinition {
2381
1964
  __typename?: 'RuntimeFunctionDefinition';
2382
1965
  /** Time when this RuntimeFunctionDefinition was created */
2383
- createdAt?: Maybe<Scalars['Time']['output']>;
2384
- /** Function definitions of the runtime function definition */
2385
- functionDefinitions?: Maybe<FunctionDefinitionConnection>;
1966
+ createdAt: Scalars['Time']['output'];
2386
1967
  /** Global ID of this RuntimeFunctionDefinition */
2387
- id?: Maybe<Scalars['RuntimeFunctionDefinitionID']['output']>;
2388
- /** Identifier of the runtime function definition */
2389
- identifier?: Maybe<Scalars['String']['output']>;
2390
- /** The runtime this runtime function definition belongs to */
2391
- runtime?: Maybe<Runtime>;
2392
- /** Parameter definitions of the runtime function definition */
2393
- runtimeParameterDefinitions?: Maybe<RuntimeParameterDefinitionConnection>;
1968
+ id: Scalars['RuntimeParameterDefinitionID']['output'];
2394
1969
  /** Time when this RuntimeFunctionDefinition was last updated */
2395
- updatedAt?: Maybe<Scalars['Time']['output']>;
1970
+ updatedAt: Scalars['Time']['output'];
2396
1971
  }
2397
1972
 
2398
-
2399
- /** Represents a runtime function definition */
2400
- export interface RuntimeFunctionDefinitionFunctionDefinitionsArgs {
2401
- after?: InputMaybe<Scalars['String']['input']>;
2402
- before?: InputMaybe<Scalars['String']['input']>;
2403
- first?: InputMaybe<Scalars['Int']['input']>;
2404
- last?: InputMaybe<Scalars['Int']['input']>;
2405
- }
2406
-
2407
-
2408
- /** Represents a runtime function definition */
2409
- export interface RuntimeFunctionDefinitionRuntimeParameterDefinitionsArgs {
2410
- after?: InputMaybe<Scalars['String']['input']>;
2411
- before?: InputMaybe<Scalars['String']['input']>;
2412
- first?: InputMaybe<Scalars['Int']['input']>;
2413
- last?: InputMaybe<Scalars['Int']['input']>;
2414
- }
2415
-
2416
- /** Represents a runtime parameter definition */
1973
+ /** Represents a Node parameter definition */
2417
1974
  export interface RuntimeParameterDefinition {
2418
1975
  __typename?: 'RuntimeParameterDefinition';
2419
1976
  /** Time when this RuntimeParameterDefinition was created */
2420
- createdAt?: Maybe<Scalars['Time']['output']>;
1977
+ createdAt: Scalars['Time']['output'];
2421
1978
  /** Global ID of this RuntimeParameterDefinition */
2422
- id?: Maybe<Scalars['RuntimeParameterDefinitionID']['output']>;
1979
+ id: Scalars['RuntimeParameterDefinitionID']['output'];
2423
1980
  /** Time when this RuntimeParameterDefinition was last updated */
2424
- updatedAt?: Maybe<Scalars['Time']['output']>;
2425
- }
2426
-
2427
- /** The connection type for RuntimeParameterDefinition. */
2428
- export interface RuntimeParameterDefinitionConnection {
2429
- __typename?: 'RuntimeParameterDefinitionConnection';
2430
- /** Total count of collection. */
2431
- count?: Maybe<Scalars['Int']['output']>;
2432
- /** A list of edges. */
2433
- edges?: Maybe<Array<Maybe<RuntimeParameterDefinitionEdge>>>;
2434
- /** A list of nodes. */
2435
- nodes?: Maybe<Array<Maybe<RuntimeParameterDefinition>>>;
2436
- /** Information to aid in pagination. */
2437
- pageInfo?: Maybe<PageInfo>;
2438
- }
2439
-
2440
- /** An edge in a connection. */
2441
- export interface RuntimeParameterDefinitionEdge {
2442
- __typename?: 'RuntimeParameterDefinitionEdge';
2443
- /** A cursor for use in pagination. */
2444
- cursor?: Maybe<Scalars['String']['output']>;
2445
- /** The item at the end of the edge. */
2446
- node?: Maybe<RuntimeParameterDefinition>;
1981
+ updatedAt: Scalars['Time']['output'];
2447
1982
  }
2448
1983
 
2449
1984
  /** Represent all available types of statuses of a runtime */
2450
- export const enum RuntimeStatusType {
1985
+ export enum RuntimeStatusType {
2451
1986
  /** No problem with connection, everything works as expected */
2452
1987
  Connected = 'CONNECTED',
2453
1988
  /** The runtime is disconnected, cause unknown */
@@ -2472,7 +2007,7 @@ export interface RuntimesCreatePayload {
2472
2007
  /** A unique identifier for the client performing the mutation. */
2473
2008
  clientMutationId?: Maybe<Scalars['String']['output']>;
2474
2009
  /** Errors encountered during execution of the mutation. */
2475
- errors?: Maybe<Array<Error>>;
2010
+ errors: Array<Error>;
2476
2011
  /** The newly created runtime. */
2477
2012
  runtime?: Maybe<Runtime>;
2478
2013
  }
@@ -2491,7 +2026,7 @@ export interface RuntimesDeletePayload {
2491
2026
  /** A unique identifier for the client performing the mutation. */
2492
2027
  clientMutationId?: Maybe<Scalars['String']['output']>;
2493
2028
  /** Errors encountered during execution of the mutation. */
2494
- errors?: Maybe<Array<Error>>;
2029
+ errors: Array<Error>;
2495
2030
  /** The updated organization. */
2496
2031
  runtime?: Maybe<Runtime>;
2497
2032
  }
@@ -2510,7 +2045,7 @@ export interface RuntimesRotateTokenPayload {
2510
2045
  /** A unique identifier for the client performing the mutation. */
2511
2046
  clientMutationId?: Maybe<Scalars['String']['output']>;
2512
2047
  /** Errors encountered during execution of the mutation. */
2513
- errors?: Maybe<Array<Error>>;
2048
+ errors: Array<Error>;
2514
2049
  /** The updated runtime. */
2515
2050
  runtime?: Maybe<Runtime>;
2516
2051
  }
@@ -2533,7 +2068,7 @@ export interface RuntimesUpdatePayload {
2533
2068
  /** A unique identifier for the client performing the mutation. */
2534
2069
  clientMutationId?: Maybe<Scalars['String']['output']>;
2535
2070
  /** Errors encountered during execution of the mutation. */
2536
- errors?: Maybe<Array<Error>>;
2071
+ errors: Array<Error>;
2537
2072
  /** The updated runtime. */
2538
2073
  runtime?: Maybe<Runtime>;
2539
2074
  }
@@ -2542,29 +2077,29 @@ export interface RuntimesUpdatePayload {
2542
2077
  export interface Translation {
2543
2078
  __typename?: 'Translation';
2544
2079
  /** Code of the translation */
2545
- code?: Maybe<Scalars['String']['output']>;
2080
+ code: Scalars['String']['output'];
2546
2081
  /** Content of the translation */
2547
- content?: Maybe<Scalars['String']['output']>;
2082
+ content: Scalars['String']['output'];
2548
2083
  }
2549
2084
 
2550
2085
  /** The connection type for Translation. */
2551
2086
  export interface TranslationConnection {
2552
2087
  __typename?: 'TranslationConnection';
2553
2088
  /** Total count of collection. */
2554
- count?: Maybe<Scalars['Int']['output']>;
2089
+ count: Scalars['Int']['output'];
2555
2090
  /** A list of edges. */
2556
2091
  edges?: Maybe<Array<Maybe<TranslationEdge>>>;
2557
2092
  /** A list of nodes. */
2558
2093
  nodes?: Maybe<Array<Maybe<Translation>>>;
2559
2094
  /** Information to aid in pagination. */
2560
- pageInfo?: Maybe<PageInfo>;
2095
+ pageInfo: PageInfo;
2561
2096
  }
2562
2097
 
2563
2098
  /** An edge in a connection. */
2564
2099
  export interface TranslationEdge {
2565
2100
  __typename?: 'TranslationEdge';
2566
2101
  /** A cursor for use in pagination. */
2567
- cursor?: Maybe<Scalars['String']['output']>;
2102
+ cursor: Scalars['String']['output'];
2568
2103
  /** The item at the end of the edge. */
2569
2104
  node?: Maybe<Translation>;
2570
2105
  }
@@ -2573,42 +2108,27 @@ export interface TranslationEdge {
2573
2108
  export interface User {
2574
2109
  __typename?: 'User';
2575
2110
  /** Global admin status of the user */
2576
- admin?: Maybe<Scalars['Boolean']['output']>;
2111
+ admin: Scalars['Boolean']['output'];
2577
2112
  /** The avatar if present of the user */
2578
2113
  avatarPath?: Maybe<Scalars['String']['output']>;
2579
2114
  /** Time when this User was created */
2580
- createdAt?: Maybe<Scalars['Time']['output']>;
2115
+ createdAt: Scalars['Time']['output'];
2581
2116
  /** Email of the user */
2582
- email?: Maybe<Scalars['String']['output']>;
2583
- /** Email verification date of the user if present */
2584
- emailVerifiedAt?: Maybe<Scalars['Time']['output']>;
2117
+ email: Scalars['String']['output'];
2585
2118
  /** Firstname of the user */
2586
- firstname?: Maybe<Scalars['String']['output']>;
2119
+ firstname: Scalars['String']['output'];
2587
2120
  /** Global ID of this User */
2588
- id?: Maybe<Scalars['UserID']['output']>;
2589
- /** Identities of this user */
2590
- identities?: Maybe<UserIdentityConnection>;
2121
+ id: Scalars['UserID']['output'];
2591
2122
  /** Lastname of the user */
2592
- lastname?: Maybe<Scalars['String']['output']>;
2123
+ lastname: Scalars['String']['output'];
2593
2124
  /** Namespace of this user */
2594
2125
  namespace?: Maybe<Namespace>;
2595
2126
  /** Namespace Memberships of this user */
2596
- namespaceMemberships?: Maybe<NamespaceMemberConnection>;
2597
- /** Sessions of this user */
2598
- sessions?: Maybe<UserSessionConnection>;
2127
+ namespaceMemberships: NamespaceMemberConnection;
2599
2128
  /** Time when this User was last updated */
2600
- updatedAt?: Maybe<Scalars['Time']['output']>;
2129
+ updatedAt: Scalars['Time']['output'];
2601
2130
  /** Username of the user */
2602
- username?: Maybe<Scalars['String']['output']>;
2603
- }
2604
-
2605
-
2606
- /** Represents a user */
2607
- export interface UserIdentitiesArgs {
2608
- after?: InputMaybe<Scalars['String']['input']>;
2609
- before?: InputMaybe<Scalars['String']['input']>;
2610
- first?: InputMaybe<Scalars['Int']['input']>;
2611
- last?: InputMaybe<Scalars['Int']['input']>;
2131
+ username: Scalars['String']['output'];
2612
2132
  }
2613
2133
 
2614
2134
 
@@ -2620,33 +2140,24 @@ export interface UserNamespaceMembershipsArgs {
2620
2140
  last?: InputMaybe<Scalars['Int']['input']>;
2621
2141
  }
2622
2142
 
2623
-
2624
- /** Represents a user */
2625
- export interface UserSessionsArgs {
2626
- after?: InputMaybe<Scalars['String']['input']>;
2627
- before?: InputMaybe<Scalars['String']['input']>;
2628
- first?: InputMaybe<Scalars['Int']['input']>;
2629
- last?: InputMaybe<Scalars['Int']['input']>;
2630
- }
2631
-
2632
2143
  /** The connection type for User. */
2633
2144
  export interface UserConnection {
2634
2145
  __typename?: 'UserConnection';
2635
2146
  /** Total count of collection. */
2636
- count?: Maybe<Scalars['Int']['output']>;
2147
+ count: Scalars['Int']['output'];
2637
2148
  /** A list of edges. */
2638
2149
  edges?: Maybe<Array<Maybe<UserEdge>>>;
2639
2150
  /** A list of nodes. */
2640
2151
  nodes?: Maybe<Array<Maybe<User>>>;
2641
2152
  /** Information to aid in pagination. */
2642
- pageInfo?: Maybe<PageInfo>;
2153
+ pageInfo: PageInfo;
2643
2154
  }
2644
2155
 
2645
2156
  /** An edge in a connection. */
2646
2157
  export interface UserEdge {
2647
2158
  __typename?: 'UserEdge';
2648
2159
  /** A cursor for use in pagination. */
2649
- cursor?: Maybe<Scalars['String']['output']>;
2160
+ cursor: Scalars['String']['output'];
2650
2161
  /** The item at the end of the edge. */
2651
2162
  node?: Maybe<User>;
2652
2163
  }
@@ -2655,97 +2166,34 @@ export interface UserEdge {
2655
2166
  export interface UserIdentity {
2656
2167
  __typename?: 'UserIdentity';
2657
2168
  /** Time when this UserIdentity was created */
2658
- createdAt?: Maybe<Scalars['Time']['output']>;
2169
+ createdAt: Scalars['Time']['output'];
2659
2170
  /** Global ID of this UserIdentity */
2660
- id?: Maybe<Scalars['UserIdentityID']['output']>;
2171
+ id: Scalars['UserIdentityID']['output'];
2661
2172
  /** The description for the runtime if present */
2662
- identifier?: Maybe<Scalars['String']['output']>;
2173
+ identifier: Scalars['String']['output'];
2663
2174
  /** The name for the runtime */
2664
- providerId?: Maybe<Scalars['String']['output']>;
2175
+ providerId: Scalars['String']['output'];
2665
2176
  /** Time when this UserIdentity was last updated */
2666
- updatedAt?: Maybe<Scalars['Time']['output']>;
2177
+ updatedAt: Scalars['Time']['output'];
2667
2178
  /** The correlating user of the identity */
2668
- user?: Maybe<User>;
2669
- }
2670
-
2671
- /** The connection type for UserIdentity. */
2672
- export interface UserIdentityConnection {
2673
- __typename?: 'UserIdentityConnection';
2674
- /** Total count of collection. */
2675
- count?: Maybe<Scalars['Int']['output']>;
2676
- /** A list of edges. */
2677
- edges?: Maybe<Array<Maybe<UserIdentityEdge>>>;
2678
- /** A list of nodes. */
2679
- nodes?: Maybe<Array<Maybe<UserIdentity>>>;
2680
- /** Information to aid in pagination. */
2681
- pageInfo?: Maybe<PageInfo>;
2682
- }
2683
-
2684
- /** An edge in a connection. */
2685
- export interface UserIdentityEdge {
2686
- __typename?: 'UserIdentityEdge';
2687
- /** A cursor for use in pagination. */
2688
- cursor?: Maybe<Scalars['String']['output']>;
2689
- /** The item at the end of the edge. */
2690
- node?: Maybe<UserIdentity>;
2179
+ user: User;
2691
2180
  }
2692
2181
 
2693
2182
  /** Represents a user session */
2694
2183
  export interface UserSession {
2695
2184
  __typename?: 'UserSession';
2696
2185
  /** Whether or not the session is active and can be used */
2697
- active?: Maybe<Scalars['Boolean']['output']>;
2186
+ active: Scalars['Boolean']['output'];
2698
2187
  /** Time when this UserSession was created */
2699
- createdAt?: Maybe<Scalars['Time']['output']>;
2188
+ createdAt: Scalars['Time']['output'];
2700
2189
  /** Global ID of this UserSession */
2701
- id?: Maybe<Scalars['UserSessionID']['output']>;
2190
+ id: Scalars['UserSessionID']['output'];
2702
2191
  /** Token belonging to the session, only present on creation */
2703
2192
  token?: Maybe<Scalars['String']['output']>;
2704
2193
  /** Time when this UserSession was last updated */
2705
- updatedAt?: Maybe<Scalars['Time']['output']>;
2194
+ updatedAt: Scalars['Time']['output'];
2706
2195
  /** User that belongs to the session */
2707
- user?: Maybe<User>;
2708
- }
2709
-
2710
- /** The connection type for UserSession. */
2711
- export interface UserSessionConnection {
2712
- __typename?: 'UserSessionConnection';
2713
- /** Total count of collection. */
2714
- count?: Maybe<Scalars['Int']['output']>;
2715
- /** A list of edges. */
2716
- edges?: Maybe<Array<Maybe<UserSessionEdge>>>;
2717
- /** A list of nodes. */
2718
- nodes?: Maybe<Array<Maybe<UserSession>>>;
2719
- /** Information to aid in pagination. */
2720
- pageInfo?: Maybe<PageInfo>;
2721
- }
2722
-
2723
- /** An edge in a connection. */
2724
- export interface UserSessionEdge {
2725
- __typename?: 'UserSessionEdge';
2726
- /** A cursor for use in pagination. */
2727
- cursor?: Maybe<Scalars['String']['output']>;
2728
- /** The item at the end of the edge. */
2729
- node?: Maybe<UserSession>;
2730
- }
2731
-
2732
- /** Autogenerated input type of UsersEmailVerification */
2733
- export interface UsersEmailVerificationInput {
2734
- /** A unique identifier for the client performing the mutation. */
2735
- clientMutationId?: InputMaybe<Scalars['String']['input']>;
2736
- /** The email verification token */
2737
- token: Scalars['String']['input'];
2738
- }
2739
-
2740
- /** Autogenerated return type of UsersEmailVerification. */
2741
- export interface UsersEmailVerificationPayload {
2742
- __typename?: 'UsersEmailVerificationPayload';
2743
- /** A unique identifier for the client performing the mutation. */
2744
- clientMutationId?: Maybe<Scalars['String']['output']>;
2745
- /** Errors encountered during execution of the mutation. */
2746
- errors?: Maybe<Array<Error>>;
2747
- /** The user whose email was verified */
2748
- user?: Maybe<User>;
2196
+ user: User;
2749
2197
  }
2750
2198
 
2751
2199
  /** Autogenerated input type of UsersIdentityLink */
@@ -2764,7 +2212,7 @@ export interface UsersIdentityLinkPayload {
2764
2212
  /** A unique identifier for the client performing the mutation. */
2765
2213
  clientMutationId?: Maybe<Scalars['String']['output']>;
2766
2214
  /** Errors encountered during execution of the mutation. */
2767
- errors?: Maybe<Array<Error>>;
2215
+ errors: Array<Error>;
2768
2216
  /** The created user identity */
2769
2217
  userIdentity?: Maybe<UserIdentity>;
2770
2218
  }
@@ -2785,7 +2233,7 @@ export interface UsersIdentityLoginPayload {
2785
2233
  /** A unique identifier for the client performing the mutation. */
2786
2234
  clientMutationId?: Maybe<Scalars['String']['output']>;
2787
2235
  /** Errors encountered during execution of the mutation. */
2788
- errors?: Maybe<Array<Error>>;
2236
+ errors: Array<Error>;
2789
2237
  /** The created user session */
2790
2238
  userSession?: Maybe<UserSession>;
2791
2239
  }
@@ -2806,7 +2254,7 @@ export interface UsersIdentityRegisterPayload {
2806
2254
  /** A unique identifier for the client performing the mutation. */
2807
2255
  clientMutationId?: Maybe<Scalars['String']['output']>;
2808
2256
  /** Errors encountered during execution of the mutation. */
2809
- errors?: Maybe<Array<Error>>;
2257
+ errors: Array<Error>;
2810
2258
  /** The created users session */
2811
2259
  userSession?: Maybe<UserSession>;
2812
2260
  }
@@ -2825,7 +2273,7 @@ export interface UsersIdentityUnlinkPayload {
2825
2273
  /** A unique identifier for the client performing the mutation. */
2826
2274
  clientMutationId?: Maybe<Scalars['String']['output']>;
2827
2275
  /** Errors encountered during execution of the mutation. */
2828
- errors?: Maybe<Array<Error>>;
2276
+ errors: Array<Error>;
2829
2277
  /** The removed identity */
2830
2278
  userIdentity?: Maybe<UserIdentity>;
2831
2279
  }
@@ -2850,7 +2298,7 @@ export interface UsersLoginPayload {
2850
2298
  /** A unique identifier for the client performing the mutation. */
2851
2299
  clientMutationId?: Maybe<Scalars['String']['output']>;
2852
2300
  /** Errors encountered during execution of the mutation. */
2853
- errors?: Maybe<Array<Error>>;
2301
+ errors: Array<Error>;
2854
2302
  /** The created user session */
2855
2303
  userSession?: Maybe<UserSession>;
2856
2304
  }
@@ -2869,7 +2317,7 @@ export interface UsersLogoutPayload {
2869
2317
  /** A unique identifier for the client performing the mutation. */
2870
2318
  clientMutationId?: Maybe<Scalars['String']['output']>;
2871
2319
  /** Errors encountered during execution of the mutation. */
2872
- errors?: Maybe<Array<Error>>;
2320
+ errors: Array<Error>;
2873
2321
  /** The logged out user session */
2874
2322
  userSession?: Maybe<UserSession>;
2875
2323
  }
@@ -2888,7 +2336,7 @@ export interface UsersMfaBackupCodesRotatePayload {
2888
2336
  /** The newly rotated backup codes. */
2889
2337
  codes?: Maybe<Array<Scalars['String']['output']>>;
2890
2338
  /** Errors encountered during execution of the mutation. */
2891
- errors?: Maybe<Array<Error>>;
2339
+ errors: Array<Error>;
2892
2340
  }
2893
2341
 
2894
2342
  /** Autogenerated input type of UsersMfaTotpGenerateSecret */
@@ -2903,7 +2351,7 @@ export interface UsersMfaTotpGenerateSecretPayload {
2903
2351
  /** A unique identifier for the client performing the mutation. */
2904
2352
  clientMutationId?: Maybe<Scalars['String']['output']>;
2905
2353
  /** Errors encountered during execution of the mutation. */
2906
- errors?: Maybe<Array<Error>>;
2354
+ errors: Array<Error>;
2907
2355
  /** The created and signed secret */
2908
2356
  secret?: Maybe<Scalars['String']['output']>;
2909
2357
  }
@@ -2927,53 +2375,11 @@ export interface UsersMfaTotpValidateSecretPayload {
2927
2375
  /** A unique identifier for the client performing the mutation. */
2928
2376
  clientMutationId?: Maybe<Scalars['String']['output']>;
2929
2377
  /** Errors encountered during execution of the mutation. */
2930
- errors?: Maybe<Array<Error>>;
2378
+ errors: Array<Error>;
2931
2379
  /** The modified user */
2932
2380
  user?: Maybe<User>;
2933
2381
  }
2934
2382
 
2935
- /** Autogenerated input type of UsersPasswordReset */
2936
- export interface UsersPasswordResetInput {
2937
- /** A unique identifier for the client performing the mutation. */
2938
- clientMutationId?: InputMaybe<Scalars['String']['input']>;
2939
- /** The new password to set for the user */
2940
- newPassword: Scalars['String']['input'];
2941
- /** The confirmation of the new password to set for the user needs to be the same as the new password */
2942
- newPasswordConfirmation: Scalars['String']['input'];
2943
- /** The password reset token sent to the user email */
2944
- resetToken: Scalars['String']['input'];
2945
- }
2946
-
2947
- /** Autogenerated return type of UsersPasswordReset. */
2948
- export interface UsersPasswordResetPayload {
2949
- __typename?: 'UsersPasswordResetPayload';
2950
- /** A unique identifier for the client performing the mutation. */
2951
- clientMutationId?: Maybe<Scalars['String']['output']>;
2952
- /** Errors encountered during execution of the mutation. */
2953
- errors?: Maybe<Array<Error>>;
2954
- /** A message indicating the result of the password reset request */
2955
- message?: Maybe<Scalars['String']['output']>;
2956
- }
2957
-
2958
- /** Autogenerated input type of UsersPasswordResetRequest */
2959
- export interface UsersPasswordResetRequestInput {
2960
- /** A unique identifier for the client performing the mutation. */
2961
- clientMutationId?: InputMaybe<Scalars['String']['input']>;
2962
- /** Email of the user to reset the password */
2963
- email: Scalars['String']['input'];
2964
- }
2965
-
2966
- /** Autogenerated return type of UsersPasswordResetRequest. */
2967
- export interface UsersPasswordResetRequestPayload {
2968
- __typename?: 'UsersPasswordResetRequestPayload';
2969
- /** A unique identifier for the client performing the mutation. */
2970
- clientMutationId?: Maybe<Scalars['String']['output']>;
2971
- /** Errors encountered during execution of the mutation. */
2972
- errors?: Maybe<Array<Error>>;
2973
- /** A message indicating the result of the password reset request */
2974
- message?: Maybe<Scalars['String']['output']>;
2975
- }
2976
-
2977
2383
  /** Autogenerated input type of UsersRegister */
2978
2384
  export interface UsersRegisterInput {
2979
2385
  /** A unique identifier for the client performing the mutation. */
@@ -2994,7 +2400,7 @@ export interface UsersRegisterPayload {
2994
2400
  /** A unique identifier for the client performing the mutation. */
2995
2401
  clientMutationId?: Maybe<Scalars['String']['output']>;
2996
2402
  /** Errors encountered during execution of the mutation. */
2997
- errors?: Maybe<Array<Error>>;
2403
+ errors: Array<Error>;
2998
2404
  /** The created users session */
2999
2405
  userSession?: Maybe<UserSession>;
3000
2406
  }
@@ -3029,7 +2435,7 @@ export interface UsersUpdatePayload {
3029
2435
  /** A unique identifier for the client performing the mutation. */
3030
2436
  clientMutationId?: Maybe<Scalars['String']['output']>;
3031
2437
  /** Errors encountered during execution of the mutation. */
3032
- errors?: Maybe<Array<Error>>;
2438
+ errors: Array<Error>;
3033
2439
  /** The updated user. */
3034
2440
  user?: Maybe<User>;
3035
2441
  }