@code0-tech/sagittarius-graphql-types 0.0.0-c63274fdd34593b8aa24f9f977659fd3d6270150 → 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 +386 -1506
  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,36 +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 */
70
+ TypesFlowTypeID: { input: `gid://sagittarius/TypesFlowType/${number}`; output: `gid://sagittarius/TypesFlowType/${number}`; }
71
+ /** A unique identifier for all User entities of the application */
43
72
  UserID: { input: `gid://sagittarius/User/${number}`; output: `gid://sagittarius/User/${number}`; }
73
+ /** A unique identifier for all UserIdentity entities of the application */
44
74
  UserIdentityID: { input: `gid://sagittarius/UserIdentity/${number}`; output: `gid://sagittarius/UserIdentity/${number}`; }
75
+ /** A unique identifier for all UserSession entities of the application */
45
76
  UserSessionID: { input: `gid://sagittarius/UserSession/${number}`; output: `gid://sagittarius/UserSession/${number}`; }
46
77
  }
47
78
 
@@ -49,35 +80,22 @@ export interface Scalars {
49
80
  export interface ActiveModelError {
50
81
  __typename?: 'ActiveModelError';
51
82
  /** The affected attribute on the model */
52
- attribute?: Maybe<Scalars['String']['output']>;
83
+ attribute: Scalars['String']['output'];
53
84
  /** The validation type that failed for the attribute */
54
- type?: Maybe<Scalars['String']['output']>;
55
- }
56
-
57
- /** Represents the application instance */
58
- export interface Application {
59
- __typename?: 'Application';
60
- /** Metadata about the application */
61
- metadata?: Maybe<Metadata>;
62
- /** Global application settings */
63
- settings?: Maybe<ApplicationSettings>;
85
+ type: Scalars['String']['output'];
64
86
  }
65
87
 
66
88
  /** Represents the application settings */
67
89
  export interface ApplicationSettings {
68
90
  __typename?: 'ApplicationSettings';
69
- /** Shows if admin status can be queried by non-administrators */
70
- adminStatusVisible?: Maybe<Scalars['Boolean']['output']>;
71
91
  /** Shows if organization creation is restricted to administrators */
72
- organizationCreationRestricted?: Maybe<Scalars['Boolean']['output']>;
92
+ organizationCreationRestricted: Scalars['Boolean']['output'];
73
93
  /** Shows if user registration is enabled */
74
- userRegistrationEnabled?: Maybe<Scalars['Boolean']['output']>;
94
+ userRegistrationEnabled: Scalars['Boolean']['output'];
75
95
  }
76
96
 
77
97
  /** Autogenerated input type of ApplicationSettingsUpdate */
78
98
  export interface ApplicationSettingsUpdateInput {
79
- /** Set if admin status can be queried by non-administrators. */
80
- adminStatusVisible?: InputMaybe<Scalars['Boolean']['input']>;
81
99
  /** A unique identifier for the client performing the mutation. */
82
100
  clientMutationId?: InputMaybe<Scalars['String']['input']>;
83
101
  /** Set if organization creation is restricted to administrators. */
@@ -94,55 +112,54 @@ export interface ApplicationSettingsUpdatePayload {
94
112
  /** A unique identifier for the client performing the mutation. */
95
113
  clientMutationId?: Maybe<Scalars['String']['output']>;
96
114
  /** Errors encountered during execution of the mutation. */
97
- errors?: Maybe<Array<Error>>;
115
+ errors: Array<Error>;
98
116
  }
99
117
 
100
118
  /** Objects that can present an authentication */
101
119
  export type Authentication = UserSession;
102
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
+
103
140
  /** Represents a DataType */
104
141
  export interface DataType {
105
142
  __typename?: 'DataType';
106
- /** Name of the function */
107
- aliases?: Maybe<TranslationConnection>;
108
143
  /** Time when this DataType was created */
109
- createdAt?: Maybe<Scalars['Time']['output']>;
110
- /** Display message of the function */
111
- displayMessages?: Maybe<TranslationConnection>;
144
+ createdAt: Scalars['Time']['output'];
112
145
  /** Generic keys of the datatype */
113
146
  genericKeys?: Maybe<Array<Scalars['String']['output']>>;
114
147
  /** Global ID of this DataType */
115
- id?: Maybe<Scalars['DataTypeID']['output']>;
148
+ id: Scalars['DataTypeID']['output'];
116
149
  /** The identifier scoped to the namespace */
117
- identifier?: Maybe<Scalars['String']['output']>;
150
+ identifier: Scalars['String']['output'];
118
151
  /** Names of the flow type setting */
119
- 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>;
120
157
  /** Rules of the datatype */
121
- rules?: Maybe<DataTypeRuleConnection>;
122
- /** The runtime where this datatype belongs to */
123
- runtime?: Maybe<Runtime>;
158
+ rules: DataTypeRuleConnection;
124
159
  /** Time when this DataType was last updated */
125
- updatedAt?: Maybe<Scalars['Time']['output']>;
160
+ updatedAt: Scalars['Time']['output'];
126
161
  /** The type of the datatype */
127
- variant?: Maybe<DataTypeVariant>;
128
- }
129
-
130
-
131
- /** Represents a DataType */
132
- export interface DataTypeAliasesArgs {
133
- after?: InputMaybe<Scalars['String']['input']>;
134
- before?: InputMaybe<Scalars['String']['input']>;
135
- first?: InputMaybe<Scalars['Int']['input']>;
136
- last?: InputMaybe<Scalars['Int']['input']>;
137
- }
138
-
139
-
140
- /** Represents a DataType */
141
- export interface DataTypeDisplayMessagesArgs {
142
- after?: InputMaybe<Scalars['String']['input']>;
143
- before?: InputMaybe<Scalars['String']['input']>;
144
- first?: InputMaybe<Scalars['Int']['input']>;
145
- last?: InputMaybe<Scalars['Int']['input']>;
162
+ variant: DataTypeVariant;
146
163
  }
147
164
 
148
165
 
@@ -167,20 +184,20 @@ export interface DataTypeRulesArgs {
167
184
  export interface DataTypeConnection {
168
185
  __typename?: 'DataTypeConnection';
169
186
  /** Total count of collection. */
170
- count?: Maybe<Scalars['Int']['output']>;
187
+ count: Scalars['Int']['output'];
171
188
  /** A list of edges. */
172
189
  edges?: Maybe<Array<Maybe<DataTypeEdge>>>;
173
190
  /** A list of nodes. */
174
191
  nodes?: Maybe<Array<Maybe<DataType>>>;
175
192
  /** Information to aid in pagination. */
176
- pageInfo?: Maybe<PageInfo>;
193
+ pageInfo: PageInfo;
177
194
  }
178
195
 
179
196
  /** An edge in a connection. */
180
197
  export interface DataTypeEdge {
181
198
  __typename?: 'DataTypeEdge';
182
199
  /** A cursor for use in pagination. */
183
- cursor?: Maybe<Scalars['String']['output']>;
200
+ cursor: Scalars['String']['output'];
184
201
  /** The item at the end of the edge. */
185
202
  node?: Maybe<DataType>;
186
203
  }
@@ -189,7 +206,7 @@ export interface DataTypeEdge {
189
206
  export interface DataTypeIdentifier {
190
207
  __typename?: 'DataTypeIdentifier';
191
208
  /** Time when this DataTypeIdentifier was created */
192
- createdAt?: Maybe<Scalars['Time']['output']>;
209
+ createdAt: Scalars['Time']['output'];
193
210
  /** The data type of the data type identifier. */
194
211
  dataType?: Maybe<DataType>;
195
212
  /** The generic key of the data type identifier. */
@@ -197,9 +214,9 @@ export interface DataTypeIdentifier {
197
214
  /** The generic type of the data type identifier. */
198
215
  genericType?: Maybe<GenericType>;
199
216
  /** Global ID of this DataTypeIdentifier */
200
- id?: Maybe<Scalars['DataTypeIdentifierID']['output']>;
217
+ id: Scalars['DataTypeIdentifierID']['output'];
201
218
  /** Time when this DataTypeIdentifier was last updated */
202
- updatedAt?: Maybe<Scalars['Time']['output']>;
219
+ updatedAt: Scalars['Time']['output'];
203
220
  }
204
221
 
205
222
  /** Input type for data type identifier */
@@ -216,127 +233,51 @@ export interface DataTypeIdentifierInput {
216
233
  export interface DataTypeRule {
217
234
  __typename?: 'DataTypeRule';
218
235
  /** The configuration of the rule */
219
- config?: Maybe<DataTypeRulesConfig>;
236
+ config: Config;
220
237
  /** Time when this DataTypeRule was created */
221
- createdAt?: Maybe<Scalars['Time']['output']>;
238
+ createdAt: Scalars['Time']['output'];
222
239
  /** Global ID of this DataTypeRule */
223
- id?: Maybe<Scalars['DataTypeRuleID']['output']>;
240
+ id: Scalars['DataTypeRuleID']['output'];
224
241
  /** Time when this DataTypeRule was last updated */
225
- updatedAt?: Maybe<Scalars['Time']['output']>;
242
+ updatedAt: Scalars['Time']['output'];
226
243
  /** The type of the rule */
227
- variant?: Maybe<DataTypeRulesVariant>;
244
+ variant: DataTypeRulesDataTypeRuleVariant;
228
245
  }
229
246
 
230
247
  /** The connection type for DataTypeRule. */
231
248
  export interface DataTypeRuleConnection {
232
249
  __typename?: 'DataTypeRuleConnection';
233
250
  /** Total count of collection. */
234
- count?: Maybe<Scalars['Int']['output']>;
251
+ count: Scalars['Int']['output'];
235
252
  /** A list of edges. */
236
253
  edges?: Maybe<Array<Maybe<DataTypeRuleEdge>>>;
237
254
  /** A list of nodes. */
238
255
  nodes?: Maybe<Array<Maybe<DataTypeRule>>>;
239
256
  /** Information to aid in pagination. */
240
- pageInfo?: Maybe<PageInfo>;
257
+ pageInfo: PageInfo;
241
258
  }
242
259
 
243
260
  /** An edge in a connection. */
244
261
  export interface DataTypeRuleEdge {
245
262
  __typename?: 'DataTypeRuleEdge';
246
263
  /** A cursor for use in pagination. */
247
- cursor?: Maybe<Scalars['String']['output']>;
264
+ cursor: Scalars['String']['output'];
248
265
  /** The item at the end of the edge. */
249
266
  node?: Maybe<DataTypeRule>;
250
267
  }
251
268
 
252
- /** Represents a rule that can be applied to a data type. */
253
- export type DataTypeRulesConfig = DataTypeRulesContainsKeyConfig | DataTypeRulesContainsTypeConfig | DataTypeRulesInputTypesConfig | DataTypeRulesItemOfCollectionConfig | DataTypeRulesNumberRangeConfig | DataTypeRulesParentTypeConfig | DataTypeRulesRegexConfig | DataTypeRulesReturnTypeConfig;
254
-
255
- /** Represents a rule that can be applied to a data type. */
256
- export interface DataTypeRulesContainsKeyConfig {
257
- __typename?: 'DataTypeRulesContainsKeyConfig';
258
- /** The identifier of the data type this rule belongs to */
259
- dataTypeIdentifier?: Maybe<DataTypeIdentifier>;
260
- /** The key of the rule */
261
- key?: Maybe<Scalars['String']['output']>;
262
- }
263
-
264
- /** Represents a rule that can be applied to a data type. */
265
- export interface DataTypeRulesContainsTypeConfig {
266
- __typename?: 'DataTypeRulesContainsTypeConfig';
267
- /** The identifier of the data type this rule belongs to */
268
- dataTypeIdentifier?: Maybe<DataTypeIdentifier>;
269
- }
270
-
271
- /** Represents a subtype of input type configuration for a input data type. */
272
- export interface DataTypeRulesInputTypeConfig {
273
- __typename?: 'DataTypeRulesInputTypeConfig';
274
- /** The identifier of the data type this input type belongs to */
275
- dataTypeIdentifier?: Maybe<DataTypeIdentifier>;
276
- /** The input identifier that this configuration applies to */
277
- inputIdentifier?: Maybe<Scalars['String']['output']>;
278
- }
279
-
280
- /** Represents a rule that can be applied to a data type. */
281
- export interface DataTypeRulesInputTypesConfig {
282
- __typename?: 'DataTypeRulesInputTypesConfig';
283
- /** The input types that can be used in this data type rule */
284
- inputTypes?: Maybe<Array<DataTypeRulesInputTypeConfig>>;
285
- }
286
-
287
- /** Represents a rule that can be applied to a data type. */
288
- export interface DataTypeRulesItemOfCollectionConfig {
289
- __typename?: 'DataTypeRulesItemOfCollectionConfig';
290
- /** The items that can be configured for this rule. */
291
- items?: Maybe<Array<Scalars['JSON']['output']>>;
292
- }
293
-
294
- /** Represents a rule that can be applied to a data type. */
295
- export interface DataTypeRulesNumberRangeConfig {
296
- __typename?: 'DataTypeRulesNumberRangeConfig';
297
- /** The minimum value of the range */
298
- from?: Maybe<Scalars['Int']['output']>;
299
- /** The step value for the range, if applicable */
300
- steps?: Maybe<Scalars['Int']['output']>;
301
- /** The maximum value of the range */
302
- to?: Maybe<Scalars['Int']['output']>;
303
- }
304
-
305
- /** Represents a rule that can be applied to a data type. */
306
- export interface DataTypeRulesParentTypeConfig {
307
- __typename?: 'DataTypeRulesParentTypeConfig';
308
- /** The data type identifier for the parent type. */
309
- dataTypeIdentifier?: Maybe<DataTypeIdentifier>;
310
- }
311
-
312
- /** Represents a rule that can be applied to a data type. */
313
- export interface DataTypeRulesRegexConfig {
314
- __typename?: 'DataTypeRulesRegexConfig';
315
- /** The regex pattern to match against the data type value. */
316
- pattern?: Maybe<Scalars['String']['output']>;
317
- }
318
-
319
- /** Represents a rule that can be applied to a data type. */
320
- export interface DataTypeRulesReturnTypeConfig {
321
- __typename?: 'DataTypeRulesReturnTypeConfig';
322
- /** The data type identifier for the return type. */
323
- dataTypeIdentifier?: Maybe<DataTypeIdentifier>;
324
- }
325
-
326
269
  /** The type of rule that can be applied to a data type. */
327
- export const enum DataTypeRulesVariant {
270
+ export enum DataTypeRulesDataTypeRuleVariant {
328
271
  /** The rule checks if a key is present in the data type. */
329
272
  ContainsKey = 'CONTAINS_KEY',
330
273
  /** The rule checks if a specific type is present in the data type. */
331
274
  ContainsType = 'CONTAINS_TYPE',
332
275
  /** The rule checks if the data type matches a specific input type. */
333
- InputTypes = 'INPUT_TYPES',
276
+ InputType = 'INPUT_TYPE',
334
277
  /** The rule checks if an item is part of a collection in the data type. */
335
278
  ItemOfCollection = 'ITEM_OF_COLLECTION',
336
279
  /** The rule checks if a number falls within a specified range. */
337
280
  NumberRange = 'NUMBER_RANGE',
338
- /** The rule checks if the data type is a child of a specific parent type. */
339
- ParentType = 'PARENT_TYPE',
340
281
  /** The rule checks if a string matches a specified regular expression. */
341
282
  Regex = 'REGEX',
342
283
  /** The rule checks if the data type matches a specific return type. */
@@ -344,7 +285,7 @@ export const enum DataTypeRulesVariant {
344
285
  }
345
286
 
346
287
  /** Represent all available types of a datatype */
347
- export const enum DataTypeVariant {
288
+ export enum DataTypeVariant {
348
289
  /** Represents an array */
349
290
  Array = 'ARRAY',
350
291
  /** Represents an data type containing a data type */
@@ -361,9 +302,6 @@ export const enum DataTypeVariant {
361
302
  Type = 'TYPE'
362
303
  }
363
304
 
364
- /** Represents a detailed error with either a message or an active model error */
365
- export type DetailedError = ActiveModelError | FlowValidationError | MessageError;
366
-
367
305
  /** Autogenerated input type of Echo */
368
306
  export interface EchoInput {
369
307
  /** A unique identifier for the client performing the mutation. */
@@ -378,255 +316,41 @@ export interface EchoPayload {
378
316
  /** A unique identifier for the client performing the mutation. */
379
317
  clientMutationId?: Maybe<Scalars['String']['output']>;
380
318
  /** Errors encountered during execution of the mutation. */
381
- errors?: Maybe<Array<Error>>;
319
+ errors: Array<Error>;
382
320
  /** Message returned to the user. */
383
321
  message?: Maybe<Scalars['String']['output']>;
384
322
  }
385
323
 
386
324
  /** Objects that can present an error */
387
- export interface Error {
388
- __typename?: 'Error';
389
- /** Detailed validation errors if applicable */
390
- details?: Maybe<Array<DetailedError>>;
391
- /** The code representing the error type */
392
- errorCode?: Maybe<ErrorCodeEnum>;
393
- }
394
-
395
- /** Represents the available error responses */
396
- export const enum ErrorCodeEnum {
397
- /** This action would remove the last administrative role */
398
- CannotDeleteLastAdminRole = 'CANNOT_DELETE_LAST_ADMIN_ROLE',
399
- /** Only administrators can modify admin status of users */
400
- CannotModifyAdmin = 'CANNOT_MODIFY_ADMIN',
401
- /** Users cannot modify their own admin status */
402
- CannotModifyOwnAdmin = 'CANNOT_MODIFY_OWN_ADMIN',
403
- /** This action would remove the last administrator */
404
- CannotRemoveLastAdministrator = 'CANNOT_REMOVE_LAST_ADMINISTRATOR',
405
- /** This action would remove the last administrative ability */
406
- CannotRemoveLastAdminAbility = 'CANNOT_REMOVE_LAST_ADMIN_ABILITY',
407
- /** The data type identifier with the given identifier was not found */
408
- DataTypeIdentifierNotFound = 'DATA_TYPE_IDENTIFIER_NOT_FOUND',
409
- /** The data type with the given identifier was not found */
410
- DataTypeNotFound = 'DATA_TYPE_NOT_FOUND',
411
- /** Failed to send the email verification */
412
- EmailVerificationSendFailed = 'EMAIL_VERIFICATION_SEND_FAILED',
413
- /** This external identity does not exist */
414
- ExternalIdentityDoesNotExist = 'EXTERNAL_IDENTITY_DOES_NOT_EXIST',
415
- /** The old backup codes could not be deleted */
416
- FailedToInvalidateOldBackupCodes = 'FAILED_TO_INVALIDATE_OLD_BACKUP_CODES',
417
- /** Failed to reset the user password */
418
- FailedToResetPassword = 'FAILED_TO_RESET_PASSWORD',
419
- /** The new backup codes could not be saved */
420
- FailedToSaveValidBackupCode = 'FAILED_TO_SAVE_VALID_BACKUP_CODE',
421
- /** The flow with the given identifier was not found */
422
- FlowNotFound = 'FLOW_NOT_FOUND',
423
- /** The flow type with the given identifier was not found */
424
- FlowTypeNotFound = 'FLOW_TYPE_NOT_FOUND',
425
- /** The flow validation has failed */
426
- FlowValidationFailed = 'FLOW_VALIDATION_FAILED',
427
- /** The given key was not found in the data type */
428
- GenericKeyNotFound = 'GENERIC_KEY_NOT_FOUND',
429
- /** The external identity with the given identifier was not found */
430
- IdentityNotFound = 'IDENTITY_NOT_FOUND',
431
- /** Failed to validate the external identity */
432
- IdentityValidationFailed = 'IDENTITY_VALIDATION_FAILED',
433
- /** Resources are from different namespaces */
434
- InconsistentNamespace = 'INCONSISTENT_NAMESPACE',
435
- /** The attachment is invalid because of active model errors */
436
- InvalidAttachment = 'INVALID_ATTACHMENT',
437
- /** The data type is invalid because of active model errors */
438
- InvalidDataType = 'INVALID_DATA_TYPE',
439
- /** This external identity is invalid */
440
- InvalidExternalIdentity = 'INVALID_EXTERNAL_IDENTITY',
441
- /** The flow is invalid because of active model errors */
442
- InvalidFlow = 'INVALID_FLOW',
443
- /** The flow setting is invalid because of active model errors */
444
- InvalidFlowSetting = 'INVALID_FLOW_SETTING',
445
- /** The flow type is invalid because of active model errors */
446
- InvalidFlowType = 'INVALID_FLOW_TYPE',
447
- /** The generic mapper is invalid because of active model errors */
448
- InvalidGenericMapper = 'INVALID_GENERIC_MAPPER',
449
- /** Invalid login data provided */
450
- InvalidLoginData = 'INVALID_LOGIN_DATA',
451
- /** The namespace license is invalid because of active model errors */
452
- InvalidNamespaceLicense = 'INVALID_NAMESPACE_LICENSE',
453
- /** The namespace member is invalid because of active model errors */
454
- InvalidNamespaceMember = 'INVALID_NAMESPACE_MEMBER',
455
- /** The namespace project is invalid because of active model errors */
456
- InvalidNamespaceProject = 'INVALID_NAMESPACE_PROJECT',
457
- /** The namespace role is invalid because of active model errors */
458
- InvalidNamespaceRole = 'INVALID_NAMESPACE_ROLE',
459
- /** The organization is invalid because of active model errors */
460
- InvalidOrganization = 'INVALID_ORGANIZATION',
461
- /** The provided password repeat does not match the password */
462
- InvalidPasswordRepeat = 'INVALID_PASSWORD_REPEAT',
463
- /** The runtime is invalid because of active model errors */
464
- InvalidRuntime = 'INVALID_RUNTIME',
465
- /** The runtime function definition is invalid */
466
- InvalidRuntimeFunctionDefinition = 'INVALID_RUNTIME_FUNCTION_DEFINITION',
467
- /** The runtime function ID is invalid */
468
- InvalidRuntimeFunctionId = 'INVALID_RUNTIME_FUNCTION_ID',
469
- /** The runtime parameter definition is invalid */
470
- InvalidRuntimeParameterDefinition = 'INVALID_RUNTIME_PARAMETER_DEFINITION',
471
- /** The runtime parameter ID is invalid */
472
- InvalidRuntimeParameterId = 'INVALID_RUNTIME_PARAMETER_ID',
473
- /** Invalid setting provided */
474
- InvalidSetting = 'INVALID_SETTING',
475
- /** The TOTP secret is invalid or cannot be verified */
476
- InvalidTotpSecret = 'INVALID_TOTP_SECRET',
477
- /** The user is invalid because of active model errors */
478
- InvalidUser = 'INVALID_USER',
479
- /** The user identity is invalid because of active model errors */
480
- InvalidUserIdentity = 'INVALID_USER_IDENTITY',
481
- /** The user session is invalid because of active model errors */
482
- InvalidUserSession = 'INVALID_USER_SESSION',
483
- /** Invalid verification code provided */
484
- InvalidVerificationCode = 'INVALID_VERIFICATION_CODE',
485
- /** The namespace license with the given identifier was not found */
486
- LicenseNotFound = 'LICENSE_NOT_FOUND',
487
- /** Failed to load user identity from external provider */
488
- LoadingIdentityFailed = 'LOADING_IDENTITY_FAILED',
489
- /** Invalid MFA data provided */
490
- MfaFailed = 'MFA_FAILED',
491
- /** MFA is required */
492
- MfaRequired = 'MFA_REQUIRED',
493
- /** The primary runtime has more definitions than this one */
494
- MissingDefinition = 'MISSING_DEFINITION',
495
- /** This external identity is missing data */
496
- MissingIdentityData = 'MISSING_IDENTITY_DATA',
497
- /** Not all required parameters are present */
498
- MissingParameter = 'MISSING_PARAMETER',
499
- /** The user is not permitted to perform this operation */
500
- MissingPermission = 'MISSING_PERMISSION',
501
- /** The project is missing a primary runtime */
502
- MissingPrimaryRuntime = 'MISSING_PRIMARY_RUNTIME',
503
- /** The namespace member with the given identifier was not found */
504
- NamespaceMemberNotFound = 'NAMESPACE_MEMBER_NOT_FOUND',
505
- /** The namespace with the given identifier was not found */
506
- NamespaceNotFound = 'NAMESPACE_NOT_FOUND',
507
- /** The namespace project with the given identifier was not found */
508
- NamespaceProjectNotFound = 'NAMESPACE_PROJECT_NOT_FOUND',
509
- /** The namespace role with the given identifier was not found */
510
- NamespaceRoleNotFound = 'NAMESPACE_ROLE_NOT_FOUND',
511
- /** No data type identifier could be found for the given generic key */
512
- NoDatatypeIdentifierForGenericKey = 'NO_DATATYPE_IDENTIFIER_FOR_GENERIC_KEY',
513
- /** No data type could be found for the given identifier */
514
- NoDataTypeForIdentifier = 'NO_DATA_TYPE_FOR_IDENTIFIER',
515
- /** There are no free license seats to complete this operation */
516
- NoFreeLicenseSeats = 'NO_FREE_LICENSE_SEATS',
517
- /** No generic type could be found for the given identifier */
518
- NoGenericTypeForIdentifier = 'NO_GENERIC_TYPE_FOR_IDENTIFIER',
519
- /** The project does not have a primary runtime */
520
- NoPrimaryRuntime = 'NO_PRIMARY_RUNTIME',
521
- /** The organization with the given identifier was not found */
522
- OrganizationNotFound = 'ORGANIZATION_NOT_FOUND',
523
- /** The primary runtime has a newer definition than this one */
524
- OutdatedDefinition = 'OUTDATED_DEFINITION',
525
- /** @deprecated Outdated concept */
526
- PrimaryLevelNotFound = 'PRIMARY_LEVEL_NOT_FOUND',
527
- /** The namespace project with the given identifier was not found */
528
- ProjectNotFound = 'PROJECT_NOT_FOUND',
529
- /** A referenced value could not be found */
530
- ReferencedValueNotFound = 'REFERENCED_VALUE_NOT_FOUND',
531
- /** Self-registration is disabled */
532
- RegistrationDisabled = 'REGISTRATION_DISABLED',
533
- /** Resources are from different runtimes */
534
- RuntimeMismatch = 'RUNTIME_MISMATCH',
535
- /** The runtime with the given identifier was not found */
536
- RuntimeNotFound = 'RUNTIME_NOT_FOUND',
537
- /** @deprecated Outdated concept */
538
- SecondaryLevelNotFound = 'SECONDARY_LEVEL_NOT_FOUND',
539
- /** @deprecated Outdated concept */
540
- TertiaryLevelExceedsParameters = 'TERTIARY_LEVEL_EXCEEDS_PARAMETERS',
541
- /** This user already has TOTP set up */
542
- TotpSecretAlreadySet = 'TOTP_SECRET_ALREADY_SET',
543
- /** The user is not permitted to modify this field */
544
- UnmodifiableField = 'UNMODIFIABLE_FIELD',
545
- /** The user with the given identifier was not found */
546
- UserNotFound = 'USER_NOT_FOUND',
547
- /** The user session with the given identifier was not found */
548
- UserSessionNotFound = 'USER_SESSION_NOT_FOUND',
549
- /** Invalid TOTP code provided */
550
- WrongTotp = 'WRONG_TOTP'
551
- }
325
+ export type Error = ActiveModelError | MessageError;
552
326
 
553
327
  /** Represents a flow */
554
328
  export interface Flow {
555
329
  __typename?: 'Flow';
556
330
  /** Time when this Flow was created */
557
- createdAt?: Maybe<Scalars['Time']['output']>;
331
+ createdAt: Scalars['Time']['output'];
558
332
  /** Global ID of this Flow */
559
- id?: Maybe<Scalars['FlowID']['output']>;
333
+ id: Scalars['FlowID']['output'];
560
334
  /** The input data type of the flow */
561
335
  inputType?: Maybe<DataType>;
562
- /** Name of the flow */
563
- name?: Maybe<Scalars['String']['output']>;
564
- /** Nodes of the flow */
565
- nodes?: Maybe<NodeFunctionConnection>;
566
336
  /** The return data type of the flow */
567
337
  returnType?: Maybe<DataType>;
568
338
  /** The settings of the flow */
569
- settings?: Maybe<FlowSettingConnection>;
570
- /** The ID of the starting node of the flow */
571
- startingNodeId?: Maybe<Scalars['NodeFunctionID']['output']>;
339
+ settings?: Maybe<Array<FlowSetting>>;
340
+ /** The starting node of the flow */
341
+ startingNode: NodeFunction;
572
342
  /** The flow type of the flow */
573
- type?: Maybe<FlowType>;
343
+ type: FlowType;
574
344
  /** Time when this Flow was last updated */
575
- updatedAt?: Maybe<Scalars['Time']['output']>;
576
- /** Abilities for the current user on this Flow */
577
- userAbilities?: Maybe<FlowUserAbilities>;
578
- }
579
-
580
-
581
- /** Represents a flow */
582
- export interface FlowNodesArgs {
583
- after?: InputMaybe<Scalars['String']['input']>;
584
- before?: InputMaybe<Scalars['String']['input']>;
585
- first?: InputMaybe<Scalars['Int']['input']>;
586
- last?: InputMaybe<Scalars['Int']['input']>;
587
- }
588
-
589
-
590
- /** Represents a flow */
591
- export interface FlowSettingsArgs {
592
- after?: InputMaybe<Scalars['String']['input']>;
593
- before?: InputMaybe<Scalars['String']['input']>;
594
- first?: InputMaybe<Scalars['Int']['input']>;
595
- last?: InputMaybe<Scalars['Int']['input']>;
596
- }
597
-
598
- /** The connection type for Flow. */
599
- export interface FlowConnection {
600
- __typename?: 'FlowConnection';
601
- /** Total count of collection. */
602
- count?: Maybe<Scalars['Int']['output']>;
603
- /** A list of edges. */
604
- edges?: Maybe<Array<Maybe<FlowEdge>>>;
605
- /** A list of nodes. */
606
- nodes?: Maybe<Array<Maybe<Flow>>>;
607
- /** Information to aid in pagination. */
608
- pageInfo?: Maybe<PageInfo>;
609
- }
610
-
611
- /** An edge in a connection. */
612
- export interface FlowEdge {
613
- __typename?: 'FlowEdge';
614
- /** A cursor for use in pagination. */
615
- cursor?: Maybe<Scalars['String']['output']>;
616
- /** The item at the end of the edge. */
617
- node?: Maybe<Flow>;
345
+ updatedAt: Scalars['Time']['output'];
618
346
  }
619
347
 
620
348
  /** Input type for creating or updating a flow */
621
349
  export interface FlowInput {
622
- /** The name of the flow */
623
- name: Scalars['String']['input'];
624
- /** The node functions of the flow */
625
- nodes: Array<NodeFunctionInput>;
626
350
  /** The settings of the flow */
627
351
  settings?: InputMaybe<Array<FlowSettingInput>>;
628
352
  /** The starting node of the flow */
629
- startingNodeId: Scalars['NodeFunctionID']['input'];
353
+ startingNode: NodeFunctionInput;
630
354
  /** The identifier of the flow type */
631
355
  type: Scalars['FlowTypeID']['input'];
632
356
  }
@@ -635,66 +359,40 @@ export interface FlowInput {
635
359
  export interface FlowSetting {
636
360
  __typename?: 'FlowSetting';
637
361
  /** Time when this FlowSetting was created */
638
- createdAt?: Maybe<Scalars['Time']['output']>;
362
+ createdAt: Scalars['Time']['output'];
639
363
  /** The identifier of the flow setting */
640
- flowSettingIdentifier?: Maybe<Scalars['String']['output']>;
364
+ flowSettingId: Scalars['String']['output'];
641
365
  /** Global ID of this FlowSetting */
642
- id?: Maybe<Scalars['FlowSettingID']['output']>;
366
+ id: Scalars['FlowSettingID']['output'];
643
367
  /** Time when this FlowSetting was last updated */
644
- updatedAt?: Maybe<Scalars['Time']['output']>;
368
+ updatedAt: Scalars['Time']['output'];
645
369
  /** The value of the flow setting */
646
- value?: Maybe<Scalars['JSON']['output']>;
647
- }
648
-
649
- /** The connection type for FlowSetting. */
650
- export interface FlowSettingConnection {
651
- __typename?: 'FlowSettingConnection';
652
- /** Total count of collection. */
653
- count?: Maybe<Scalars['Int']['output']>;
654
- /** A list of edges. */
655
- edges?: Maybe<Array<Maybe<FlowSettingEdge>>>;
656
- /** A list of nodes. */
657
- nodes?: Maybe<Array<Maybe<FlowSetting>>>;
658
- /** Information to aid in pagination. */
659
- pageInfo?: Maybe<PageInfo>;
660
- }
661
-
662
- /** An edge in a connection. */
663
- export interface FlowSettingEdge {
664
- __typename?: 'FlowSettingEdge';
665
- /** A cursor for use in pagination. */
666
- cursor?: Maybe<Scalars['String']['output']>;
667
- /** The item at the end of the edge. */
668
- node?: Maybe<FlowSetting>;
370
+ value: Scalars['JSON']['output'];
669
371
  }
670
372
 
671
373
  /** Input type for flow settings */
672
374
  export interface FlowSettingInput {
673
375
  /** The identifier (not database id) of the flow setting */
674
- flowSettingIdentifier: Scalars['String']['input'];
376
+ flowSettingId: Scalars['String']['input'];
675
377
  /** The value of the flow setting */
676
- value: Scalars['JSON']['input'];
378
+ object: Scalars['JSON']['input'];
677
379
  }
678
380
 
679
381
  /** Represents a flow type */
680
382
  export interface FlowType {
681
383
  __typename?: 'FlowType';
682
- /** Name of the function */
683
- aliases?: Maybe<TranslationConnection>;
684
384
  /** Time when this FlowType was created */
685
- createdAt?: Maybe<Scalars['Time']['output']>;
385
+ createdAt: Scalars['Time']['output'];
686
386
  /** Descriptions of the flow type */
687
387
  descriptions?: Maybe<TranslationConnection>;
688
- /** Display message of the function */
689
- displayMessages?: Maybe<TranslationConnection>;
690
388
  /** Editable status of the flow type */
691
- editable?: Maybe<Scalars['Boolean']['output']>;
389
+ editable: Scalars['Boolean']['output'];
692
390
  /** Flow type settings of the flow type */
693
- flowTypeSettings?: Maybe<Array<FlowTypeSetting>>;
391
+ flowTypeSettings: Array<FlowTypeSetting>;
694
392
  /** Global ID of this FlowType */
695
- id?: Maybe<Scalars['FlowTypeID']['output']>;
393
+ id: Scalars['TypesFlowTypeID']['output'];
696
394
  /** Identifier of the flow type */
697
- identifier?: Maybe<Scalars['String']['output']>;
395
+ identifier: Scalars['String']['output'];
698
396
  /** Input type of the flow type */
699
397
  inputType?: Maybe<DataType>;
700
398
  /** Names of the flow type */
@@ -702,16 +400,7 @@ export interface FlowType {
702
400
  /** Return type of the flow type */
703
401
  returnType?: Maybe<DataType>;
704
402
  /** Time when this FlowType was last updated */
705
- updatedAt?: Maybe<Scalars['Time']['output']>;
706
- }
707
-
708
-
709
- /** Represents a flow type */
710
- export interface FlowTypeAliasesArgs {
711
- after?: InputMaybe<Scalars['String']['input']>;
712
- before?: InputMaybe<Scalars['String']['input']>;
713
- first?: InputMaybe<Scalars['Int']['input']>;
714
- last?: InputMaybe<Scalars['Int']['input']>;
403
+ updatedAt: Scalars['Time']['output'];
715
404
  }
716
405
 
717
406
 
@@ -724,15 +413,6 @@ export interface FlowTypeDescriptionsArgs {
724
413
  }
725
414
 
726
415
 
727
- /** Represents a flow type */
728
- export interface FlowTypeDisplayMessagesArgs {
729
- after?: InputMaybe<Scalars['String']['input']>;
730
- before?: InputMaybe<Scalars['String']['input']>;
731
- first?: InputMaybe<Scalars['Int']['input']>;
732
- last?: InputMaybe<Scalars['Int']['input']>;
733
- }
734
-
735
-
736
416
  /** Represents a flow type */
737
417
  export interface FlowTypeNamesArgs {
738
418
  after?: InputMaybe<Scalars['String']['input']>;
@@ -745,20 +425,20 @@ export interface FlowTypeNamesArgs {
745
425
  export interface FlowTypeConnection {
746
426
  __typename?: 'FlowTypeConnection';
747
427
  /** Total count of collection. */
748
- count?: Maybe<Scalars['Int']['output']>;
428
+ count: Scalars['Int']['output'];
749
429
  /** A list of edges. */
750
430
  edges?: Maybe<Array<Maybe<FlowTypeEdge>>>;
751
431
  /** A list of nodes. */
752
432
  nodes?: Maybe<Array<Maybe<FlowType>>>;
753
433
  /** Information to aid in pagination. */
754
- pageInfo?: Maybe<PageInfo>;
434
+ pageInfo: PageInfo;
755
435
  }
756
436
 
757
437
  /** An edge in a connection. */
758
438
  export interface FlowTypeEdge {
759
439
  __typename?: 'FlowTypeEdge';
760
440
  /** A cursor for use in pagination. */
761
- cursor?: Maybe<Scalars['String']['output']>;
441
+ cursor: Scalars['String']['output'];
762
442
  /** The item at the end of the edge. */
763
443
  node?: Maybe<FlowType>;
764
444
  }
@@ -767,23 +447,23 @@ export interface FlowTypeEdge {
767
447
  export interface FlowTypeSetting {
768
448
  __typename?: 'FlowTypeSetting';
769
449
  /** Time when this FlowTypeSetting was created */
770
- createdAt?: Maybe<Scalars['Time']['output']>;
450
+ createdAt: Scalars['Time']['output'];
771
451
  /** Data type of the flow type setting */
772
452
  dataType?: Maybe<DataType>;
773
453
  /** Descriptions of the flow type setting */
774
- descriptions?: Maybe<TranslationConnection>;
454
+ descriptions: TranslationConnection;
775
455
  /** Flow type of the flow type setting */
776
456
  flowType?: Maybe<FlowType>;
777
457
  /** Global ID of this FlowTypeSetting */
778
- id?: Maybe<Scalars['FlowTypeSettingID']['output']>;
458
+ id: Scalars['FlowTypeSettingID']['output'];
779
459
  /** Identifier of the flow type setting */
780
- identifier?: Maybe<Scalars['String']['output']>;
460
+ identifier: Scalars['String']['output'];
781
461
  /** Names of the flow type setting */
782
- names?: Maybe<TranslationConnection>;
462
+ names: TranslationConnection;
783
463
  /** Unique status of the flow type setting */
784
- unique?: Maybe<Scalars['Boolean']['output']>;
464
+ unique: Scalars['Boolean']['output'];
785
465
  /** Time when this FlowTypeSetting was last updated */
786
- updatedAt?: Maybe<Scalars['Time']['output']>;
466
+ updatedAt: Scalars['Time']['output'];
787
467
  }
788
468
 
789
469
 
@@ -804,220 +484,25 @@ export interface FlowTypeSettingNamesArgs {
804
484
  last?: InputMaybe<Scalars['Int']['input']>;
805
485
  }
806
486
 
807
- /** Abilities for the current user on this Flow */
808
- export interface FlowUserAbilities {
809
- __typename?: 'FlowUserAbilities';
810
- /** Shows if the current user has the `delete_flow` ability on this Flow */
811
- deleteFlow?: Maybe<Scalars['Boolean']['output']>;
812
- }
813
-
814
- /** Represents a flow validation error */
815
- export interface FlowValidationError {
816
- __typename?: 'FlowValidationError';
817
- /** Additional details about the validation error */
818
- details?: Maybe<ActiveModelError>;
819
- /** The code representing the validation error type */
820
- errorCode?: Maybe<FlowValidationErrorCodeEnum>;
821
- /** The severity of the validation error */
822
- severity?: Maybe<FlowValidationSeverityEnum>;
823
- }
824
-
825
- /** Represents the available error responses */
826
- export const enum FlowValidationErrorCodeEnum {
827
- /** The generic key for the data type identifier was not found. */
828
- DataTypeIdentifierGenericKeyNotFound = 'DATA_TYPE_IDENTIFIER_GENERIC_KEY_NOT_FOUND',
829
- /** The data type identifier runtime does not match the flow type runtime. */
830
- DataTypeIdentifierRuntimeMismatch = 'DATA_TYPE_IDENTIFIER_RUNTIME_MISMATCH',
831
- /** The data type rule model is invalid. */
832
- DataTypeRuleModelInvalid = 'DATA_TYPE_RULE_MODEL_INVALID',
833
- /** The data type runtime does not match the flow type runtime. */
834
- DataTypeRuntimeMismatch = 'DATA_TYPE_RUNTIME_MISMATCH',
835
- /** The flow setting model is invalid. */
836
- FlowSettingModelInvalid = 'FLOW_SETTING_MODEL_INVALID',
837
- /** The flow type runtime does not match the project primary runtime. */
838
- FlowTypeRuntimeMismatch = 'FLOW_TYPE_RUNTIME_MISMATCH',
839
- /** The node function runtime does not match the project primary runtime. */
840
- NodeFunctionRuntimeMismatch = 'NODE_FUNCTION_RUNTIME_MISMATCH',
841
- /** The project does not have a primary runtime set. */
842
- NoPrimaryRuntime = 'NO_PRIMARY_RUNTIME'
843
- }
844
-
845
- /** Represents the severity of a flow validation error */
846
- export const enum FlowValidationSeverityEnum {
847
- /** A blocking validation error */
848
- Error = 'ERROR',
849
- /** A minor typographical issue can also be blocking */
850
- Typo = 'TYPO',
851
- /** A non-blocking validation warning */
852
- Warning = 'WARNING',
853
- /** A weak validation issue that may not need to be addressed */
854
- Weak = 'WEAK'
855
- }
856
-
857
- /** Represents a function definition */
858
- export interface FunctionDefinition {
859
- __typename?: 'FunctionDefinition';
860
- /** Name of the function */
861
- aliases?: Maybe<TranslationConnection>;
862
- /** Time when this FunctionDefinition was created */
863
- createdAt?: Maybe<Scalars['Time']['output']>;
864
- /** Deprecation message of the function */
865
- deprecationMessages?: Maybe<TranslationConnection>;
866
- /** Description of the function */
867
- descriptions?: Maybe<TranslationConnection>;
868
- /** Display message of the function */
869
- displayMessages?: Maybe<TranslationConnection>;
870
- /** Documentation of the function */
871
- documentations?: Maybe<TranslationConnection>;
872
- /** Generic keys of the function */
873
- genericKeys?: Maybe<Array<Scalars['String']['output']>>;
874
- /** Global ID of this FunctionDefinition */
875
- id?: Maybe<Scalars['FunctionDefinitionID']['output']>;
876
- /** Identifier of the function */
877
- identifier?: Maybe<Scalars['String']['output']>;
878
- /** Name of the function */
879
- names?: Maybe<TranslationConnection>;
880
- /** Parameters of the function */
881
- parameterDefinitions?: Maybe<ParameterDefinitionConnection>;
882
- /** Return type of the function */
883
- returnType?: Maybe<DataTypeIdentifier>;
884
- /** Runtime function definition */
885
- runtimeFunctionDefinition?: Maybe<RuntimeFunctionDefinition>;
886
- /** Indicates if the function can throw an error */
887
- throwsError?: Maybe<Scalars['Boolean']['output']>;
888
- /** Time when this FunctionDefinition was last updated */
889
- updatedAt?: Maybe<Scalars['Time']['output']>;
890
- }
891
-
892
-
893
- /** Represents a function definition */
894
- export interface FunctionDefinitionAliasesArgs {
895
- after?: InputMaybe<Scalars['String']['input']>;
896
- before?: InputMaybe<Scalars['String']['input']>;
897
- first?: InputMaybe<Scalars['Int']['input']>;
898
- last?: InputMaybe<Scalars['Int']['input']>;
899
- }
900
-
901
-
902
- /** Represents a function definition */
903
- export interface FunctionDefinitionDeprecationMessagesArgs {
904
- after?: InputMaybe<Scalars['String']['input']>;
905
- before?: InputMaybe<Scalars['String']['input']>;
906
- first?: InputMaybe<Scalars['Int']['input']>;
907
- last?: InputMaybe<Scalars['Int']['input']>;
908
- }
909
-
910
-
911
- /** Represents a function definition */
912
- export interface FunctionDefinitionDescriptionsArgs {
913
- after?: InputMaybe<Scalars['String']['input']>;
914
- before?: InputMaybe<Scalars['String']['input']>;
915
- first?: InputMaybe<Scalars['Int']['input']>;
916
- last?: InputMaybe<Scalars['Int']['input']>;
917
- }
918
-
919
-
920
- /** Represents a function definition */
921
- export interface FunctionDefinitionDisplayMessagesArgs {
922
- after?: InputMaybe<Scalars['String']['input']>;
923
- before?: InputMaybe<Scalars['String']['input']>;
924
- first?: InputMaybe<Scalars['Int']['input']>;
925
- last?: InputMaybe<Scalars['Int']['input']>;
926
- }
927
-
928
-
929
- /** Represents a function definition */
930
- export interface FunctionDefinitionDocumentationsArgs {
931
- after?: InputMaybe<Scalars['String']['input']>;
932
- before?: InputMaybe<Scalars['String']['input']>;
933
- first?: InputMaybe<Scalars['Int']['input']>;
934
- last?: InputMaybe<Scalars['Int']['input']>;
935
- }
936
-
937
-
938
- /** Represents a function definition */
939
- export interface FunctionDefinitionNamesArgs {
940
- after?: InputMaybe<Scalars['String']['input']>;
941
- before?: InputMaybe<Scalars['String']['input']>;
942
- first?: InputMaybe<Scalars['Int']['input']>;
943
- last?: InputMaybe<Scalars['Int']['input']>;
944
- }
945
-
946
-
947
- /** Represents a function definition */
948
- export interface FunctionDefinitionParameterDefinitionsArgs {
949
- after?: InputMaybe<Scalars['String']['input']>;
950
- before?: InputMaybe<Scalars['String']['input']>;
951
- first?: InputMaybe<Scalars['Int']['input']>;
952
- last?: InputMaybe<Scalars['Int']['input']>;
953
- }
954
-
955
- /** The connection type for FunctionDefinition. */
956
- export interface FunctionDefinitionConnection {
957
- __typename?: 'FunctionDefinitionConnection';
958
- /** Total count of collection. */
959
- count?: Maybe<Scalars['Int']['output']>;
960
- /** A list of edges. */
961
- edges?: Maybe<Array<Maybe<FunctionDefinitionEdge>>>;
962
- /** A list of nodes. */
963
- nodes?: Maybe<Array<Maybe<FunctionDefinition>>>;
964
- /** Information to aid in pagination. */
965
- pageInfo?: Maybe<PageInfo>;
966
- }
967
-
968
- /** An edge in a connection. */
969
- export interface FunctionDefinitionEdge {
970
- __typename?: 'FunctionDefinitionEdge';
971
- /** A cursor for use in pagination. */
972
- cursor?: Maybe<Scalars['String']['output']>;
973
- /** The item at the end of the edge. */
974
- node?: Maybe<FunctionDefinition>;
975
- }
976
-
977
- /** Represents a combination strategy with AND/OR logic used by a generic mapper. */
978
- export interface GenericCombinationStrategy {
979
- __typename?: 'GenericCombinationStrategy';
980
- /** Time when this GenericCombinationStrategy was created */
981
- createdAt?: Maybe<Scalars['Time']['output']>;
982
- /** The associated generic mapper, if any. */
983
- genericMapper?: Maybe<GenericMapper>;
984
- /** Global ID of this GenericCombinationStrategy */
985
- id?: Maybe<Scalars['GenericCombinationStrategyID']['output']>;
986
- /** The combination type ('AND' or 'OR'). */
987
- type?: Maybe<GenericCombinationStrategyType>;
988
- /** Time when this GenericCombinationStrategy was last updated */
989
- updatedAt?: Maybe<Scalars['Time']['output']>;
990
- }
991
-
992
- /** The available combination strategy types. */
993
- export const enum GenericCombinationStrategyType {
994
- /** Represents a logical AND combination. */
995
- And = 'AND',
996
- /** Represents a logical OR combination. */
997
- Or = 'OR'
998
- }
999
-
1000
487
  /** Represents a mapping between a source data type and a target key for generic values. */
1001
488
  export interface GenericMapper {
1002
489
  __typename?: 'GenericMapper';
1003
490
  /** Time when this GenericMapper was created */
1004
- createdAt?: Maybe<Scalars['Time']['output']>;
1005
- /** Combination strategies associated with this generic mapper. */
1006
- genericCombinationStrategies?: Maybe<Array<GenericCombinationStrategy>>;
491
+ createdAt: Scalars['Time']['output'];
1007
492
  /** Global ID of this GenericMapper */
1008
- id?: Maybe<Scalars['GenericMapperID']['output']>;
493
+ id: Scalars['GenericMapperID']['output'];
1009
494
  /** The source data type identifier. */
1010
- sourceDataTypeIdentifiers?: Maybe<Array<DataTypeIdentifier>>;
495
+ source: DataTypeIdentifier;
1011
496
  /** The target key for the generic value. */
1012
- target?: Maybe<Scalars['String']['output']>;
497
+ target: Scalars['String']['output'];
1013
498
  /** Time when this GenericMapper was last updated */
1014
- updatedAt?: Maybe<Scalars['Time']['output']>;
499
+ updatedAt: Scalars['Time']['output'];
1015
500
  }
1016
501
 
1017
502
  /** Input type for generic mappers */
1018
503
  export interface GenericMapperInput {
1019
504
  /** The source data type identifier for the mapper */
1020
- sourceDataTypeIdentifiers: Array<DataTypeIdentifierInput>;
505
+ sources: Array<DataTypeIdentifierInput>;
1021
506
  /** The target data type identifier for the mapper */
1022
507
  target: Scalars['String']['input'];
1023
508
  }
@@ -1026,15 +511,15 @@ export interface GenericMapperInput {
1026
511
  export interface GenericType {
1027
512
  __typename?: 'GenericType';
1028
513
  /** Time when this GenericType was created */
1029
- createdAt?: Maybe<Scalars['Time']['output']>;
514
+ createdAt: Scalars['Time']['output'];
1030
515
  /** The data type associated with this generic type. */
1031
- dataType?: Maybe<DataType>;
516
+ dataType: DataType;
1032
517
  /** The mappers associated with this generic type. */
1033
- genericMappers?: Maybe<Array<GenericMapper>>;
518
+ genericMappers: Array<GenericMapper>;
1034
519
  /** Global ID of this GenericType */
1035
- id?: Maybe<Scalars['GenericTypeID']['output']>;
520
+ id: Scalars['GenericTypeID']['output'];
1036
521
  /** Time when this GenericType was last updated */
1037
- updatedAt?: Maybe<Scalars['Time']['output']>;
522
+ updatedAt: Scalars['Time']['output'];
1038
523
  }
1039
524
 
1040
525
  /** Input type for generic type operations. */
@@ -1051,48 +536,45 @@ export interface IdentityInput {
1051
536
  code?: InputMaybe<Scalars['String']['input']>;
1052
537
  }
1053
538
 
1054
- /** Abilities for the current user on this Instance */
1055
- export interface InstanceUserAbilities {
1056
- __typename?: 'InstanceUserAbilities';
1057
- /** Shows if the current user has the `create_organization` ability on this Instance */
1058
- createOrganization?: Maybe<Scalars['Boolean']['output']>;
1059
- /** Shows if the current user has the `create_runtime` ability on this Instance */
1060
- createRuntime?: Maybe<Scalars['Boolean']['output']>;
1061
- /** Shows if the current user has the `delete_runtime` ability on this Instance */
1062
- deleteRuntime?: Maybe<Scalars['Boolean']['output']>;
1063
- /** Shows if the current user has the `rotate_runtime_token` ability on this Instance */
1064
- rotateRuntimeToken?: Maybe<Scalars['Boolean']['output']>;
1065
- /** Shows if the current user has the `update_application_setting` ability on this Instance */
1066
- updateApplicationSetting?: Maybe<Scalars['Boolean']['output']>;
1067
- /** Shows if the current user has the `update_runtime` ability on this Instance */
1068
- updateRuntime?: Maybe<Scalars['Boolean']['output']>;
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']>>;
1069
560
  }
1070
561
 
1071
562
  /** Represents a literal value, such as a string or number. */
1072
563
  export interface LiteralValue {
1073
564
  __typename?: 'LiteralValue';
1074
565
  /** Time when this LiteralValue was created */
1075
- createdAt?: Maybe<Scalars['Time']['output']>;
566
+ createdAt: Scalars['Time']['output'];
1076
567
  /** Time when this LiteralValue was last updated */
1077
- updatedAt?: Maybe<Scalars['Time']['output']>;
568
+ updatedAt: Scalars['Time']['output'];
1078
569
  /** The literal value itself as JSON. */
1079
- value?: Maybe<Scalars['JSON']['output']>;
570
+ value: Scalars['JSON']['output'];
1080
571
  }
1081
572
 
1082
573
  /** Represents an error message */
1083
574
  export interface MessageError {
1084
575
  __typename?: 'MessageError';
1085
576
  /** The message provided from the error */
1086
- message?: Maybe<Scalars['String']['output']>;
1087
- }
1088
-
1089
- /** Application metadata */
1090
- export interface Metadata {
1091
- __typename?: 'Metadata';
1092
- /** List of loaded extensions */
1093
- extensions?: Maybe<Array<Scalars['String']['output']>>;
1094
- /** Application version */
1095
- version?: Maybe<Scalars['String']['output']>;
577
+ message: Scalars['String']['output'];
1096
578
  }
1097
579
 
1098
580
  /** Represents the input for mfa authentication */
@@ -1103,19 +585,8 @@ export interface MfaInput {
1103
585
  value: Scalars['String']['input'];
1104
586
  }
1105
587
 
1106
- /** Represents the MFA status of a user */
1107
- export interface MfaStatus {
1108
- __typename?: 'MfaStatus';
1109
- /** The number of backup codes remaining for the user. */
1110
- backupCodesCount?: Maybe<Scalars['Int']['output']>;
1111
- /** Indicates whether MFA is enabled for the user. */
1112
- enabled?: Maybe<Scalars['Boolean']['output']>;
1113
- /** Indicates whether TOTP MFA is enabled for the user. */
1114
- totpEnabled?: Maybe<Scalars['Boolean']['output']>;
1115
- }
1116
-
1117
588
  /** Represent all available types to authenticate with mfa */
1118
- export const enum MfaType {
589
+ export enum MfaType {
1119
590
  /** Single use backup code */
1120
591
  BackupCode = 'BACKUP_CODE',
1121
592
  /** Time based onetime password */
@@ -1132,12 +603,11 @@ export interface Mutation {
1132
603
  *
1133
604
  * This is expected to be used for testing of endpoints, to verify
1134
605
  * that a user has mutation access.
1135
- *
1136
606
  */
1137
607
  echo?: Maybe<EchoPayload>;
1138
- /** (EE only) Create a new namespace license. */
608
+ /** Create a new namespace license. */
1139
609
  namespacesLicensesCreate?: Maybe<NamespacesLicensesCreatePayload>;
1140
- /** (EE only) Deletes an namespace license. */
610
+ /** Deletes an namespace license. */
1141
611
  namespacesLicensesDelete?: Maybe<NamespacesLicensesDeletePayload>;
1142
612
  /** Update the roles a member is assigned to. */
1143
613
  namespacesMembersAssignRoles?: Maybe<NamespacesMembersAssignRolesPayload>;
@@ -1181,12 +651,6 @@ export interface Mutation {
1181
651
  runtimesRotateToken?: Maybe<RuntimesRotateTokenPayload>;
1182
652
  /** Update an existing runtime. */
1183
653
  runtimesUpdate?: Maybe<RuntimesUpdatePayload>;
1184
- /** Admin-create a user. */
1185
- usersCreate?: Maybe<UsersCreatePayload>;
1186
- /** Delete an existing user. */
1187
- usersDelete?: Maybe<UsersDeletePayload>;
1188
- /** Verify your email when changing it or signing up */
1189
- usersEmailVerification?: Maybe<UsersEmailVerificationPayload>;
1190
654
  /** Links an external identity to an existing user */
1191
655
  usersIdentityLink?: Maybe<UsersIdentityLinkPayload>;
1192
656
  /** Login to an existing user via an external identity */
@@ -1205,10 +669,6 @@ export interface Mutation {
1205
669
  usersMfaTotpGenerateSecret?: Maybe<UsersMfaTotpGenerateSecretPayload>;
1206
670
  /** Validates a TOTP value for the given secret and enables TOTP MFA for the user */
1207
671
  usersMfaTotpValidateSecret?: Maybe<UsersMfaTotpValidateSecretPayload>;
1208
- /** Reset the password using a reset token */
1209
- usersPasswordReset?: Maybe<UsersPasswordResetPayload>;
1210
- /** Request an password reset */
1211
- usersPasswordResetRequest?: Maybe<UsersPasswordResetRequestPayload>;
1212
672
  /** Register a new user */
1213
673
  usersRegister?: Maybe<UsersRegisterPayload>;
1214
674
  /** Update an existing user. */
@@ -1366,24 +826,6 @@ export interface MutationRuntimesUpdateArgs {
1366
826
  }
1367
827
 
1368
828
 
1369
- /** Root Mutation type */
1370
- export interface MutationUsersCreateArgs {
1371
- input: UsersCreateInput;
1372
- }
1373
-
1374
-
1375
- /** Root Mutation type */
1376
- export interface MutationUsersDeleteArgs {
1377
- input: UsersDeleteInput;
1378
- }
1379
-
1380
-
1381
- /** Root Mutation type */
1382
- export interface MutationUsersEmailVerificationArgs {
1383
- input: UsersEmailVerificationInput;
1384
- }
1385
-
1386
-
1387
829
  /** Root Mutation type */
1388
830
  export interface MutationUsersIdentityLinkArgs {
1389
831
  input: UsersIdentityLinkInput;
@@ -1438,18 +880,6 @@ export interface MutationUsersMfaTotpValidateSecretArgs {
1438
880
  }
1439
881
 
1440
882
 
1441
- /** Root Mutation type */
1442
- export interface MutationUsersPasswordResetArgs {
1443
- input: UsersPasswordResetInput;
1444
- }
1445
-
1446
-
1447
- /** Root Mutation type */
1448
- export interface MutationUsersPasswordResetRequestArgs {
1449
- input: UsersPasswordResetRequestInput;
1450
- }
1451
-
1452
-
1453
883
  /** Root Mutation type */
1454
884
  export interface MutationUsersRegisterArgs {
1455
885
  input: UsersRegisterInput;
@@ -1465,27 +895,23 @@ export interface MutationUsersUpdateArgs {
1465
895
  export interface Namespace {
1466
896
  __typename?: 'Namespace';
1467
897
  /** Time when this Namespace was created */
1468
- createdAt?: Maybe<Scalars['Time']['output']>;
1469
- /** (EE only) Currently active license of the namespace */
1470
- currentNamespaceLicense?: Maybe<NamespaceLicense>;
898
+ createdAt: Scalars['Time']['output'];
1471
899
  /** Global ID of this Namespace */
1472
- id?: Maybe<Scalars['NamespaceID']['output']>;
900
+ id: Scalars['NamespaceID']['output'];
1473
901
  /** Members of the namespace */
1474
- members?: Maybe<NamespaceMemberConnection>;
1475
- /** (EE only) Licenses of the namespace */
1476
- namespaceLicenses?: Maybe<NamespaceLicenseConnection>;
902
+ members: NamespaceMemberConnection;
903
+ /** Licenses of the namespace */
904
+ namespaceLicenses: NamespaceLicenseConnection;
1477
905
  /** Parent of this namespace */
1478
- parent?: Maybe<NamespaceParent>;
906
+ parent: NamespaceParent;
1479
907
  /** Projects of the namespace */
1480
- projects?: Maybe<NamespaceProjectConnection>;
908
+ projects: NamespaceProjectConnection;
1481
909
  /** Roles of the namespace */
1482
- roles?: Maybe<NamespaceRoleConnection>;
910
+ roles: NamespaceRoleConnection;
1483
911
  /** Runtime of the namespace */
1484
- runtimes?: Maybe<RuntimeConnection>;
912
+ runtimes: RuntimeConnection;
1485
913
  /** Time when this Namespace was last updated */
1486
- updatedAt?: Maybe<Scalars['Time']['output']>;
1487
- /** Abilities for the current user on this Namespace */
1488
- userAbilities?: Maybe<NamespaceUserAbilities>;
914
+ updatedAt: Scalars['Time']['output'];
1489
915
  }
1490
916
 
1491
917
 
@@ -1533,113 +959,74 @@ export interface NamespaceRuntimesArgs {
1533
959
  last?: InputMaybe<Scalars['Int']['input']>;
1534
960
  }
1535
961
 
1536
- /** (EE only) Represents a Namespace License */
962
+ /** Represents a Namespace License */
1537
963
  export interface NamespaceLicense {
1538
964
  __typename?: 'NamespaceLicense';
1539
965
  /** Time when this NamespaceLicense was created */
1540
- createdAt?: Maybe<Scalars['Time']['output']>;
1541
- /** The end date of the license */
1542
- endDate?: Maybe<Scalars['Time']['output']>;
966
+ createdAt: Scalars['Time']['output'];
1543
967
  /** Global ID of this NamespaceLicense */
1544
- id?: Maybe<Scalars['NamespaceLicenseID']['output']>;
1545
- /** The licensee information */
1546
- licensee?: Maybe<Scalars['JSON']['output']>;
968
+ id: Scalars['NamespaceLicenseID']['output'];
1547
969
  /** The namespace the license belongs to */
1548
- namespace?: Maybe<Namespace>;
1549
- /** The start date of the license */
1550
- startDate?: Maybe<Scalars['Time']['output']>;
970
+ namespace: Namespace;
1551
971
  /** Time when this NamespaceLicense was last updated */
1552
- updatedAt?: Maybe<Scalars['Time']['output']>;
1553
- /** Abilities for the current user on this NamespaceLicense */
1554
- userAbilities?: Maybe<NamespaceLicenseUserAbilities>;
972
+ updatedAt: Scalars['Time']['output'];
1555
973
  }
1556
974
 
1557
975
  /** The connection type for NamespaceLicense. */
1558
976
  export interface NamespaceLicenseConnection {
1559
977
  __typename?: 'NamespaceLicenseConnection';
1560
978
  /** Total count of collection. */
1561
- count?: Maybe<Scalars['Int']['output']>;
979
+ count: Scalars['Int']['output'];
1562
980
  /** A list of edges. */
1563
981
  edges?: Maybe<Array<Maybe<NamespaceLicenseEdge>>>;
1564
982
  /** A list of nodes. */
1565
983
  nodes?: Maybe<Array<Maybe<NamespaceLicense>>>;
1566
984
  /** Information to aid in pagination. */
1567
- pageInfo?: Maybe<PageInfo>;
985
+ pageInfo: PageInfo;
1568
986
  }
1569
987
 
1570
988
  /** An edge in a connection. */
1571
989
  export interface NamespaceLicenseEdge {
1572
990
  __typename?: 'NamespaceLicenseEdge';
1573
991
  /** A cursor for use in pagination. */
1574
- cursor?: Maybe<Scalars['String']['output']>;
992
+ cursor: Scalars['String']['output'];
1575
993
  /** The item at the end of the edge. */
1576
994
  node?: Maybe<NamespaceLicense>;
1577
995
  }
1578
996
 
1579
- /** Abilities for the current user on this NamespaceLicense */
1580
- export interface NamespaceLicenseUserAbilities {
1581
- __typename?: 'NamespaceLicenseUserAbilities';
1582
- /** Shows if the current user has the `delete_namespace_license` ability on this NamespaceLicense */
1583
- deleteNamespaceLicense?: Maybe<Scalars['Boolean']['output']>;
1584
- }
1585
-
1586
997
  /** Represents a namespace member */
1587
998
  export interface NamespaceMember {
1588
999
  __typename?: 'NamespaceMember';
1589
1000
  /** Time when this NamespaceMember was created */
1590
- createdAt?: Maybe<Scalars['Time']['output']>;
1001
+ createdAt: Scalars['Time']['output'];
1591
1002
  /** Global ID of this NamespaceMember */
1592
- id?: Maybe<Scalars['NamespaceMemberID']['output']>;
1593
- /** Memberroles of the member */
1594
- memberRoles?: Maybe<NamespaceMemberRoleConnection>;
1003
+ id: Scalars['NamespaceMemberID']['output'];
1595
1004
  /** Namespace this member belongs to */
1596
- namespace?: Maybe<Namespace>;
1597
- /** Roles of the member */
1598
- roles?: Maybe<NamespaceRoleConnection>;
1005
+ namespace: Namespace;
1599
1006
  /** Time when this NamespaceMember was last updated */
1600
- updatedAt?: Maybe<Scalars['Time']['output']>;
1007
+ updatedAt: Scalars['Time']['output'];
1601
1008
  /** User this member belongs to */
1602
- user?: Maybe<User>;
1603
- /** Abilities for the current user on this NamespaceMember */
1604
- userAbilities?: Maybe<NamespaceMemberUserAbilities>;
1605
- }
1606
-
1607
-
1608
- /** Represents a namespace member */
1609
- export interface NamespaceMemberMemberRolesArgs {
1610
- after?: InputMaybe<Scalars['String']['input']>;
1611
- before?: InputMaybe<Scalars['String']['input']>;
1612
- first?: InputMaybe<Scalars['Int']['input']>;
1613
- last?: InputMaybe<Scalars['Int']['input']>;
1614
- }
1615
-
1616
-
1617
- /** Represents a namespace member */
1618
- export interface NamespaceMemberRolesArgs {
1619
- after?: InputMaybe<Scalars['String']['input']>;
1620
- before?: InputMaybe<Scalars['String']['input']>;
1621
- first?: InputMaybe<Scalars['Int']['input']>;
1622
- last?: InputMaybe<Scalars['Int']['input']>;
1009
+ user: User;
1623
1010
  }
1624
1011
 
1625
1012
  /** The connection type for NamespaceMember. */
1626
1013
  export interface NamespaceMemberConnection {
1627
1014
  __typename?: 'NamespaceMemberConnection';
1628
1015
  /** Total count of collection. */
1629
- count?: Maybe<Scalars['Int']['output']>;
1016
+ count: Scalars['Int']['output'];
1630
1017
  /** A list of edges. */
1631
1018
  edges?: Maybe<Array<Maybe<NamespaceMemberEdge>>>;
1632
1019
  /** A list of nodes. */
1633
1020
  nodes?: Maybe<Array<Maybe<NamespaceMember>>>;
1634
1021
  /** Information to aid in pagination. */
1635
- pageInfo?: Maybe<PageInfo>;
1022
+ pageInfo: PageInfo;
1636
1023
  }
1637
1024
 
1638
1025
  /** An edge in a connection. */
1639
1026
  export interface NamespaceMemberEdge {
1640
1027
  __typename?: 'NamespaceMemberEdge';
1641
1028
  /** A cursor for use in pagination. */
1642
- cursor?: Maybe<Scalars['String']['output']>;
1029
+ cursor: Scalars['String']['output'];
1643
1030
  /** The item at the end of the edge. */
1644
1031
  node?: Maybe<NamespaceMember>;
1645
1032
  }
@@ -1648,102 +1035,39 @@ export interface NamespaceMemberEdge {
1648
1035
  export interface NamespaceMemberRole {
1649
1036
  __typename?: 'NamespaceMemberRole';
1650
1037
  /** Time when this NamespaceMemberRole was created */
1651
- createdAt?: Maybe<Scalars['Time']['output']>;
1038
+ createdAt: Scalars['Time']['output'];
1652
1039
  /** Global ID of this NamespaceMemberRole */
1653
- id?: Maybe<Scalars['NamespaceMemberRoleID']['output']>;
1040
+ id: Scalars['NamespaceMemberRoleID']['output'];
1654
1041
  /** The member the role is assigned to */
1655
1042
  member?: Maybe<NamespaceMember>;
1656
1043
  /** The assigned role */
1657
1044
  role?: Maybe<NamespaceRole>;
1658
1045
  /** Time when this NamespaceMemberRole was last updated */
1659
- updatedAt?: Maybe<Scalars['Time']['output']>;
1660
- }
1661
-
1662
- /** The connection type for NamespaceMemberRole. */
1663
- export interface NamespaceMemberRoleConnection {
1664
- __typename?: 'NamespaceMemberRoleConnection';
1665
- /** Total count of collection. */
1666
- count?: Maybe<Scalars['Int']['output']>;
1667
- /** A list of edges. */
1668
- edges?: Maybe<Array<Maybe<NamespaceMemberRoleEdge>>>;
1669
- /** A list of nodes. */
1670
- nodes?: Maybe<Array<Maybe<NamespaceMemberRole>>>;
1671
- /** Information to aid in pagination. */
1672
- pageInfo?: Maybe<PageInfo>;
1673
- }
1674
-
1675
- /** An edge in a connection. */
1676
- export interface NamespaceMemberRoleEdge {
1677
- __typename?: 'NamespaceMemberRoleEdge';
1678
- /** A cursor for use in pagination. */
1679
- cursor?: Maybe<Scalars['String']['output']>;
1680
- /** The item at the end of the edge. */
1681
- node?: Maybe<NamespaceMemberRole>;
1682
- }
1683
-
1684
- /** Abilities for the current user on this NamespaceMember */
1685
- export interface NamespaceMemberUserAbilities {
1686
- __typename?: 'NamespaceMemberUserAbilities';
1687
- /** Shows if the current user has the `assign_member_roles` ability on this NamespaceMember */
1688
- assignMemberRoles?: Maybe<Scalars['Boolean']['output']>;
1689
- /** Shows if the current user has the `delete_member` ability on this NamespaceMember */
1690
- deleteMember?: Maybe<Scalars['Boolean']['output']>;
1691
- }
1692
-
1693
- /** Objects that can present a namespace */
1694
- export type NamespaceParent = Organization | User;
1695
-
1696
- /** Represents a namespace project */
1697
- export interface NamespaceProject {
1698
- __typename?: 'NamespaceProject';
1699
- /** Time when this NamespaceProject was created */
1700
- createdAt?: Maybe<Scalars['Time']['output']>;
1701
- /** Description of the project */
1702
- description?: Maybe<Scalars['String']['output']>;
1703
- /** Fetches an flow given by its ID */
1704
- flow?: Maybe<Flow>;
1705
- /** Fetches all flows in this project */
1706
- flows?: Maybe<FlowConnection>;
1707
- /** Global ID of this NamespaceProject */
1708
- id?: Maybe<Scalars['NamespaceProjectID']['output']>;
1709
- /** Name of the project */
1710
- name?: Maybe<Scalars['String']['output']>;
1711
- /** The namespace where this project belongs to */
1712
- namespace?: Maybe<Namespace>;
1713
- /** The primary runtime for the project */
1714
- primaryRuntime?: Maybe<Runtime>;
1715
- /** Roles assigned to this project */
1716
- roles?: Maybe<NamespaceRoleConnection>;
1717
- /** Runtimes assigned to this project */
1718
- runtimes?: Maybe<RuntimeConnection>;
1719
- /** Time when this NamespaceProject was last updated */
1720
- updatedAt?: Maybe<Scalars['Time']['output']>;
1721
- /** Abilities for the current user on this NamespaceProject */
1722
- userAbilities?: Maybe<NamespaceProjectUserAbilities>;
1723
- }
1724
-
1725
-
1726
- /** Represents a namespace project */
1727
- export interface NamespaceProjectFlowArgs {
1728
- id: Scalars['FlowID']['input'];
1729
- }
1730
-
1731
-
1732
- /** Represents a namespace project */
1733
- export interface NamespaceProjectFlowsArgs {
1734
- after?: InputMaybe<Scalars['String']['input']>;
1735
- before?: InputMaybe<Scalars['String']['input']>;
1736
- first?: InputMaybe<Scalars['Int']['input']>;
1737
- last?: InputMaybe<Scalars['Int']['input']>;
1046
+ updatedAt: Scalars['Time']['output'];
1738
1047
  }
1739
1048
 
1049
+ /** Objects that can present a namespace */
1050
+ export type NamespaceParent = Organization;
1740
1051
 
1741
1052
  /** Represents a namespace project */
1742
- export interface NamespaceProjectRolesArgs {
1743
- after?: InputMaybe<Scalars['String']['input']>;
1744
- before?: InputMaybe<Scalars['String']['input']>;
1745
- first?: InputMaybe<Scalars['Int']['input']>;
1746
- last?: InputMaybe<Scalars['Int']['input']>;
1053
+ export interface NamespaceProject {
1054
+ __typename?: 'NamespaceProject';
1055
+ /** Time when this NamespaceProject was created */
1056
+ createdAt: Scalars['Time']['output'];
1057
+ /** Description of the project */
1058
+ description: Scalars['String']['output'];
1059
+ /** Global ID of this NamespaceProject */
1060
+ id: Scalars['NamespaceProjectID']['output'];
1061
+ /** Name of the project */
1062
+ name: Scalars['String']['output'];
1063
+ /** The namespace where this project belongs to */
1064
+ namespace: Namespace;
1065
+ /** The primary runtime for the project */
1066
+ primaryRuntime?: Maybe<Runtime>;
1067
+ /** Runtimes assigned to this project */
1068
+ runtimes: RuntimeConnection;
1069
+ /** Time when this NamespaceProject was last updated */
1070
+ updatedAt: Scalars['Time']['output'];
1747
1071
  }
1748
1072
 
1749
1073
 
@@ -1759,58 +1083,41 @@ export interface NamespaceProjectRuntimesArgs {
1759
1083
  export interface NamespaceProjectConnection {
1760
1084
  __typename?: 'NamespaceProjectConnection';
1761
1085
  /** Total count of collection. */
1762
- count?: Maybe<Scalars['Int']['output']>;
1086
+ count: Scalars['Int']['output'];
1763
1087
  /** A list of edges. */
1764
1088
  edges?: Maybe<Array<Maybe<NamespaceProjectEdge>>>;
1765
1089
  /** A list of nodes. */
1766
1090
  nodes?: Maybe<Array<Maybe<NamespaceProject>>>;
1767
1091
  /** Information to aid in pagination. */
1768
- pageInfo?: Maybe<PageInfo>;
1092
+ pageInfo: PageInfo;
1769
1093
  }
1770
1094
 
1771
1095
  /** An edge in a connection. */
1772
1096
  export interface NamespaceProjectEdge {
1773
1097
  __typename?: 'NamespaceProjectEdge';
1774
1098
  /** A cursor for use in pagination. */
1775
- cursor?: Maybe<Scalars['String']['output']>;
1099
+ cursor: Scalars['String']['output'];
1776
1100
  /** The item at the end of the edge. */
1777
1101
  node?: Maybe<NamespaceProject>;
1778
1102
  }
1779
1103
 
1780
- /** Abilities for the current user on this NamespaceProject */
1781
- export interface NamespaceProjectUserAbilities {
1782
- __typename?: 'NamespaceProjectUserAbilities';
1783
- /** Shows if the current user has the `assign_project_runtimes` ability on this NamespaceProject */
1784
- assignProjectRuntimes?: Maybe<Scalars['Boolean']['output']>;
1785
- /** Shows if the current user has the `create_flow` ability on this NamespaceProject */
1786
- createFlow?: Maybe<Scalars['Boolean']['output']>;
1787
- /** Shows if the current user has the `delete_namespace_project` ability on this NamespaceProject */
1788
- deleteNamespaceProject?: Maybe<Scalars['Boolean']['output']>;
1789
- /** Shows if the current user has the `update_namespace_project` ability on this NamespaceProject */
1790
- updateNamespaceProject?: Maybe<Scalars['Boolean']['output']>;
1791
- }
1792
-
1793
1104
  /** Represents a namespace role. */
1794
1105
  export interface NamespaceRole {
1795
1106
  __typename?: 'NamespaceRole';
1796
1107
  /** The abilities the role is granted */
1797
- abilities?: Maybe<Array<NamespaceRoleAbility>>;
1108
+ abilities: Array<NamespaceRoleAbility>;
1798
1109
  /** The projects this role is assigned to */
1799
1110
  assignedProjects?: Maybe<NamespaceProjectConnection>;
1800
1111
  /** Time when this NamespaceRole was created */
1801
- createdAt?: Maybe<Scalars['Time']['output']>;
1112
+ createdAt: Scalars['Time']['output'];
1802
1113
  /** Global ID of this NamespaceRole */
1803
- id?: Maybe<Scalars['NamespaceRoleID']['output']>;
1804
- /** The members this role is assigned to */
1805
- members?: Maybe<NamespaceMemberConnection>;
1114
+ id: Scalars['NamespaceRoleID']['output'];
1806
1115
  /** The name of this role */
1807
- name?: Maybe<Scalars['String']['output']>;
1116
+ name: Scalars['String']['output'];
1808
1117
  /** The namespace where this role belongs to */
1809
1118
  namespace?: Maybe<Namespace>;
1810
1119
  /** Time when this NamespaceRole was last updated */
1811
- updatedAt?: Maybe<Scalars['Time']['output']>;
1812
- /** Abilities for the current user on this NamespaceRole */
1813
- userAbilities?: Maybe<NamespaceRoleUserAbilities>;
1120
+ updatedAt: Scalars['Time']['output'];
1814
1121
  }
1815
1122
 
1816
1123
 
@@ -1822,17 +1129,8 @@ export interface NamespaceRoleAssignedProjectsArgs {
1822
1129
  last?: InputMaybe<Scalars['Int']['input']>;
1823
1130
  }
1824
1131
 
1825
-
1826
- /** Represents a namespace role. */
1827
- export interface NamespaceRoleMembersArgs {
1828
- after?: InputMaybe<Scalars['String']['input']>;
1829
- before?: InputMaybe<Scalars['String']['input']>;
1830
- first?: InputMaybe<Scalars['Int']['input']>;
1831
- last?: InputMaybe<Scalars['Int']['input']>;
1832
- }
1833
-
1834
1132
  /** Represents abilities that can be granted to roles in namespaces. */
1835
- export const enum NamespaceRoleAbility {
1133
+ export enum NamespaceRoleAbility {
1836
1134
  /** Allows to change the roles of a namespace member */
1837
1135
  AssignMemberRoles = 'ASSIGN_MEMBER_ROLES',
1838
1136
  /** Allows to assign runtimes to a project in the namespace */
@@ -1842,7 +1140,7 @@ export const enum NamespaceRoleAbility {
1842
1140
  /** Allows to change the assigned projects of a namespace role */
1843
1141
  AssignRoleProjects = 'ASSIGN_ROLE_PROJECTS',
1844
1142
  /** Allows to create flows in a namespace project */
1845
- CreateFlow = 'CREATE_FLOW',
1143
+ CreateFlows = 'CREATE_FLOWS',
1846
1144
  /** Allows to create a license for the namespace */
1847
1145
  CreateNamespaceLicense = 'CREATE_NAMESPACE_LICENSE',
1848
1146
  /** Allows to create a project in the namespace */
@@ -1852,7 +1150,7 @@ export const enum NamespaceRoleAbility {
1852
1150
  /** Allows to create a runtime globally or for the namespace */
1853
1151
  CreateRuntime = 'CREATE_RUNTIME',
1854
1152
  /** Allows to delete flows in a namespace project */
1855
- DeleteFlow = 'DELETE_FLOW',
1153
+ DeleteFlows = 'DELETE_FLOWS',
1856
1154
  /** Allows to remove members of a namespace */
1857
1155
  DeleteMember = 'DELETE_MEMBER',
1858
1156
  /** Allows to delete the license of the namespace */
@@ -1876,7 +1174,7 @@ export const enum NamespaceRoleAbility {
1876
1174
  /** Allows to regenerate a runtime token */
1877
1175
  RotateRuntimeToken = 'ROTATE_RUNTIME_TOKEN',
1878
1176
  /** Allows to update flows in the project */
1879
- UpdateFlow = 'UPDATE_FLOW',
1177
+ UpdateFlows = 'UPDATE_FLOWS',
1880
1178
  /** Allows to update the project of the namespace */
1881
1179
  UpdateNamespaceProject = 'UPDATE_NAMESPACE_PROJECT',
1882
1180
  /** Allows to update the namespace role */
@@ -1891,52 +1189,24 @@ export const enum NamespaceRoleAbility {
1891
1189
  export interface NamespaceRoleConnection {
1892
1190
  __typename?: 'NamespaceRoleConnection';
1893
1191
  /** Total count of collection. */
1894
- count?: Maybe<Scalars['Int']['output']>;
1192
+ count: Scalars['Int']['output'];
1895
1193
  /** A list of edges. */
1896
1194
  edges?: Maybe<Array<Maybe<NamespaceRoleEdge>>>;
1897
1195
  /** A list of nodes. */
1898
1196
  nodes?: Maybe<Array<Maybe<NamespaceRole>>>;
1899
1197
  /** Information to aid in pagination. */
1900
- pageInfo?: Maybe<PageInfo>;
1198
+ pageInfo: PageInfo;
1901
1199
  }
1902
1200
 
1903
1201
  /** An edge in a connection. */
1904
1202
  export interface NamespaceRoleEdge {
1905
1203
  __typename?: 'NamespaceRoleEdge';
1906
1204
  /** A cursor for use in pagination. */
1907
- cursor?: Maybe<Scalars['String']['output']>;
1205
+ cursor: Scalars['String']['output'];
1908
1206
  /** The item at the end of the edge. */
1909
1207
  node?: Maybe<NamespaceRole>;
1910
1208
  }
1911
1209
 
1912
- /** Abilities for the current user on this NamespaceRole */
1913
- export interface NamespaceRoleUserAbilities {
1914
- __typename?: 'NamespaceRoleUserAbilities';
1915
- /** Shows if the current user has the `assign_role_abilities` ability on this NamespaceRole */
1916
- assignRoleAbilities?: Maybe<Scalars['Boolean']['output']>;
1917
- /** Shows if the current user has the `assign_role_projects` ability on this NamespaceRole */
1918
- assignRoleProjects?: Maybe<Scalars['Boolean']['output']>;
1919
- /** Shows if the current user has the `delete_namespace_role` ability on this NamespaceRole */
1920
- deleteNamespaceRole?: Maybe<Scalars['Boolean']['output']>;
1921
- /** Shows if the current user has the `update_namespace_role` ability on this NamespaceRole */
1922
- updateNamespaceRole?: Maybe<Scalars['Boolean']['output']>;
1923
- }
1924
-
1925
- /** Abilities for the current user on this Namespace */
1926
- export interface NamespaceUserAbilities {
1927
- __typename?: 'NamespaceUserAbilities';
1928
- /** Shows if the current user has the `create_namespace_license` ability on this Namespace */
1929
- createNamespaceLicense?: Maybe<Scalars['Boolean']['output']>;
1930
- /** Shows if the current user has the `create_namespace_project` ability on this Namespace */
1931
- createNamespaceProject?: Maybe<Scalars['Boolean']['output']>;
1932
- /** Shows if the current user has the `create_namespace_role` ability on this Namespace */
1933
- createNamespaceRole?: Maybe<Scalars['Boolean']['output']>;
1934
- /** Shows if the current user has the `create_runtime` ability on this Namespace */
1935
- createRuntime?: Maybe<Scalars['Boolean']['output']>;
1936
- /** Shows if the current user has the `invite_member` ability on this Namespace */
1937
- inviteMember?: Maybe<Scalars['Boolean']['output']>;
1938
- }
1939
-
1940
1210
  /** Autogenerated input type of NamespacesLicensesCreate */
1941
1211
  export interface NamespacesLicensesCreateInput {
1942
1212
  /** A unique identifier for the client performing the mutation. */
@@ -1953,7 +1223,7 @@ export interface NamespacesLicensesCreatePayload {
1953
1223
  /** A unique identifier for the client performing the mutation. */
1954
1224
  clientMutationId?: Maybe<Scalars['String']['output']>;
1955
1225
  /** Errors encountered during execution of the mutation. */
1956
- errors?: Maybe<Array<Error>>;
1226
+ errors: Array<Error>;
1957
1227
  /** The newly created license. */
1958
1228
  namespaceLicense?: Maybe<NamespaceLicense>;
1959
1229
  }
@@ -1972,7 +1242,7 @@ export interface NamespacesLicensesDeletePayload {
1972
1242
  /** A unique identifier for the client performing the mutation. */
1973
1243
  clientMutationId?: Maybe<Scalars['String']['output']>;
1974
1244
  /** Errors encountered during execution of the mutation. */
1975
- errors?: Maybe<Array<Error>>;
1245
+ errors: Array<Error>;
1976
1246
  /** The deleted namespace license. */
1977
1247
  namespaceLicense?: Maybe<NamespaceLicense>;
1978
1248
  }
@@ -1993,9 +1263,9 @@ export interface NamespacesMembersAssignRolesPayload {
1993
1263
  /** A unique identifier for the client performing the mutation. */
1994
1264
  clientMutationId?: Maybe<Scalars['String']['output']>;
1995
1265
  /** Errors encountered during execution of the mutation. */
1996
- errors?: Maybe<Array<Error>>;
1997
- /** The member which was assigned the roles */
1998
- member?: Maybe<NamespaceMember>;
1266
+ errors: Array<Error>;
1267
+ /** The roles the member is now assigned to */
1268
+ namespaceMemberRoles?: Maybe<Array<NamespaceMemberRole>>;
1999
1269
  }
2000
1270
 
2001
1271
  /** Autogenerated input type of NamespacesMembersDelete */
@@ -2012,7 +1282,7 @@ export interface NamespacesMembersDeletePayload {
2012
1282
  /** A unique identifier for the client performing the mutation. */
2013
1283
  clientMutationId?: Maybe<Scalars['String']['output']>;
2014
1284
  /** Errors encountered during execution of the mutation. */
2015
- errors?: Maybe<Array<Error>>;
1285
+ errors: Array<Error>;
2016
1286
  /** The removed namespace member */
2017
1287
  namespaceMember?: Maybe<NamespaceMember>;
2018
1288
  }
@@ -2033,7 +1303,7 @@ export interface NamespacesMembersInvitePayload {
2033
1303
  /** A unique identifier for the client performing the mutation. */
2034
1304
  clientMutationId?: Maybe<Scalars['String']['output']>;
2035
1305
  /** Errors encountered during execution of the mutation. */
2036
- errors?: Maybe<Array<Error>>;
1306
+ errors: Array<Error>;
2037
1307
  /** The newly created namespace member */
2038
1308
  namespaceMember?: Maybe<NamespaceMember>;
2039
1309
  }
@@ -2054,7 +1324,7 @@ export interface NamespacesProjectsAssignRuntimesPayload {
2054
1324
  /** A unique identifier for the client performing the mutation. */
2055
1325
  clientMutationId?: Maybe<Scalars['String']['output']>;
2056
1326
  /** Errors encountered during execution of the mutation. */
2057
- errors?: Maybe<Array<Error>>;
1327
+ errors: Array<Error>;
2058
1328
  /** The updated project with assigned runtimes */
2059
1329
  namespaceProject?: Maybe<NamespaceProject>;
2060
1330
  }
@@ -2077,7 +1347,7 @@ export interface NamespacesProjectsCreatePayload {
2077
1347
  /** A unique identifier for the client performing the mutation. */
2078
1348
  clientMutationId?: Maybe<Scalars['String']['output']>;
2079
1349
  /** Errors encountered during execution of the mutation. */
2080
- errors?: Maybe<Array<Error>>;
1350
+ errors: Array<Error>;
2081
1351
  /** The newly created project. */
2082
1352
  namespaceProject?: Maybe<NamespaceProject>;
2083
1353
  }
@@ -2096,7 +1366,7 @@ export interface NamespacesProjectsDeletePayload {
2096
1366
  /** A unique identifier for the client performing the mutation. */
2097
1367
  clientMutationId?: Maybe<Scalars['String']['output']>;
2098
1368
  /** Errors encountered during execution of the mutation. */
2099
- errors?: Maybe<Array<Error>>;
1369
+ errors: Array<Error>;
2100
1370
  /** The deleted project. */
2101
1371
  namespaceProject?: Maybe<NamespaceProject>;
2102
1372
  }
@@ -2117,7 +1387,7 @@ export interface NamespacesProjectsFlowsCreatePayload {
2117
1387
  /** A unique identifier for the client performing the mutation. */
2118
1388
  clientMutationId?: Maybe<Scalars['String']['output']>;
2119
1389
  /** Errors encountered during execution of the mutation. */
2120
- errors?: Maybe<Array<Error>>;
1390
+ errors: Array<Error>;
2121
1391
  /** The newly created flow. */
2122
1392
  flow?: Maybe<Flow>;
2123
1393
  }
@@ -2136,7 +1406,7 @@ export interface NamespacesProjectsFlowsDeletePayload {
2136
1406
  /** A unique identifier for the client performing the mutation. */
2137
1407
  clientMutationId?: Maybe<Scalars['String']['output']>;
2138
1408
  /** Errors encountered during execution of the mutation. */
2139
- errors?: Maybe<Array<Error>>;
1409
+ errors: Array<Error>;
2140
1410
  /** The deleted flow. */
2141
1411
  flow?: Maybe<Flow>;
2142
1412
  }
@@ -2161,7 +1431,7 @@ export interface NamespacesProjectsUpdatePayload {
2161
1431
  /** A unique identifier for the client performing the mutation. */
2162
1432
  clientMutationId?: Maybe<Scalars['String']['output']>;
2163
1433
  /** Errors encountered during execution of the mutation. */
2164
- errors?: Maybe<Array<Error>>;
1434
+ errors: Array<Error>;
2165
1435
  /** The updated project. */
2166
1436
  namespaceProject?: Maybe<NamespaceProject>;
2167
1437
  }
@@ -2184,7 +1454,7 @@ export interface NamespacesRolesAssignAbilitiesPayload {
2184
1454
  /** A unique identifier for the client performing the mutation. */
2185
1455
  clientMutationId?: Maybe<Scalars['String']['output']>;
2186
1456
  /** Errors encountered during execution of the mutation. */
2187
- errors?: Maybe<Array<Error>>;
1457
+ errors: Array<Error>;
2188
1458
  }
2189
1459
 
2190
1460
  /** Autogenerated input type of NamespacesRolesAssignProjects */
@@ -2203,7 +1473,7 @@ export interface NamespacesRolesAssignProjectsPayload {
2203
1473
  /** A unique identifier for the client performing the mutation. */
2204
1474
  clientMutationId?: Maybe<Scalars['String']['output']>;
2205
1475
  /** Errors encountered during execution of the mutation. */
2206
- errors?: Maybe<Array<Error>>;
1476
+ errors: Array<Error>;
2207
1477
  /** The now assigned projects */
2208
1478
  projects?: Maybe<Array<NamespaceProject>>;
2209
1479
  }
@@ -2224,7 +1494,7 @@ export interface NamespacesRolesCreatePayload {
2224
1494
  /** A unique identifier for the client performing the mutation. */
2225
1495
  clientMutationId?: Maybe<Scalars['String']['output']>;
2226
1496
  /** Errors encountered during execution of the mutation. */
2227
- errors?: Maybe<Array<Error>>;
1497
+ errors: Array<Error>;
2228
1498
  /** The newly created namespace role */
2229
1499
  namespaceRole?: Maybe<NamespaceRole>;
2230
1500
  }
@@ -2243,7 +1513,7 @@ export interface NamespacesRolesDeletePayload {
2243
1513
  /** A unique identifier for the client performing the mutation. */
2244
1514
  clientMutationId?: Maybe<Scalars['String']['output']>;
2245
1515
  /** Errors encountered during execution of the mutation. */
2246
- errors?: Maybe<Array<Error>>;
1516
+ errors: Array<Error>;
2247
1517
  /** The deleted namespace role */
2248
1518
  namespaceRole?: Maybe<NamespaceRole>;
2249
1519
  }
@@ -2264,7 +1534,7 @@ export interface NamespacesRolesUpdatePayload {
2264
1534
  /** A unique identifier for the client performing the mutation. */
2265
1535
  clientMutationId?: Maybe<Scalars['String']['output']>;
2266
1536
  /** Errors encountered during execution of the mutation. */
2267
- errors?: Maybe<Array<Error>>;
1537
+ errors: Array<Error>;
2268
1538
  /** The updated namespace role. */
2269
1539
  namespaceRole?: Maybe<NamespaceRole>;
2270
1540
  }
@@ -2272,24 +1542,24 @@ export interface NamespacesRolesUpdatePayload {
2272
1542
  /** An object with an ID. */
2273
1543
  export interface Node {
2274
1544
  /** ID of the object. */
2275
- id?: Maybe<Scalars['ID']['output']>;
1545
+ id: Scalars['ID']['output'];
2276
1546
  }
2277
1547
 
2278
1548
  /** Represents a Node Function */
2279
1549
  export interface NodeFunction {
2280
1550
  __typename?: 'NodeFunction';
2281
1551
  /** Time when this NodeFunction was created */
2282
- createdAt?: Maybe<Scalars['Time']['output']>;
2283
- /** The definition of the Node Function */
2284
- functionDefinition?: Maybe<FunctionDefinition>;
1552
+ createdAt: Scalars['Time']['output'];
2285
1553
  /** Global ID of this NodeFunction */
2286
- id?: Maybe<Scalars['NodeFunctionID']['output']>;
2287
- /** The ID of the next Node Function in the flow */
2288
- nextNodeId?: Maybe<Scalars['NodeFunctionID']['output']>;
1554
+ id: Scalars['NodeFunctionID']['output'];
1555
+ /** The next Node Function in the flow */
1556
+ nextNode?: Maybe<NodeFunction>;
2289
1557
  /** The parameters of the Node Function */
2290
- parameters?: Maybe<NodeParameterConnection>;
1558
+ parameters: NodeParameterConnection;
1559
+ /** The definition of the Node Function */
1560
+ runtimeFunction: RuntimeFunctionDefinition;
2291
1561
  /** Time when this NodeFunction was last updated */
2292
- updatedAt?: Maybe<Scalars['Time']['output']>;
1562
+ updatedAt: Scalars['Time']['output'];
2293
1563
  }
2294
1564
 
2295
1565
 
@@ -2301,34 +1571,10 @@ export interface NodeFunctionParametersArgs {
2301
1571
  last?: InputMaybe<Scalars['Int']['input']>;
2302
1572
  }
2303
1573
 
2304
- /** The connection type for NodeFunction. */
2305
- export interface NodeFunctionConnection {
2306
- __typename?: 'NodeFunctionConnection';
2307
- /** Total count of collection. */
2308
- count?: Maybe<Scalars['Int']['output']>;
2309
- /** A list of edges. */
2310
- edges?: Maybe<Array<Maybe<NodeFunctionEdge>>>;
2311
- /** A list of nodes. */
2312
- nodes?: Maybe<Array<Maybe<NodeFunction>>>;
2313
- /** Information to aid in pagination. */
2314
- pageInfo?: Maybe<PageInfo>;
2315
- }
2316
-
2317
- /** An edge in a connection. */
2318
- export interface NodeFunctionEdge {
2319
- __typename?: 'NodeFunctionEdge';
2320
- /** A cursor for use in pagination. */
2321
- cursor?: Maybe<Scalars['String']['output']>;
2322
- /** The item at the end of the edge. */
2323
- node?: Maybe<NodeFunction>;
2324
- }
2325
-
2326
1574
  /** Input type for a Node Function */
2327
1575
  export interface NodeFunctionInput {
2328
- /** The identifier of the Node Function used to create/update the flow */
2329
- id: Scalars['NodeFunctionID']['input'];
2330
1576
  /** The next Node Function in the flow */
2331
- nextNodeId?: InputMaybe<Scalars['NodeFunctionID']['input']>;
1577
+ nextNode?: InputMaybe<NodeFunctionInput>;
2332
1578
  /** The parameters of the Node Function */
2333
1579
  parameters: Array<NodeParameterInput>;
2334
1580
  /** The identifier of the Runtime Function Definition */
@@ -2339,13 +1585,13 @@ export interface NodeFunctionInput {
2339
1585
  export interface NodeParameter {
2340
1586
  __typename?: 'NodeParameter';
2341
1587
  /** Time when this NodeParameter was created */
2342
- createdAt?: Maybe<Scalars['Time']['output']>;
1588
+ createdAt: Scalars['Time']['output'];
2343
1589
  /** Global ID of this NodeParameter */
2344
- id?: Maybe<Scalars['NodeParameterID']['output']>;
1590
+ id: Scalars['NodeParameterID']['output'];
2345
1591
  /** The definition of the parameter */
2346
- runtimeParameter?: Maybe<RuntimeParameterDefinition>;
1592
+ runtimeParameter: RuntimeParameterDefinition;
2347
1593
  /** Time when this NodeParameter was last updated */
2348
- updatedAt?: Maybe<Scalars['Time']['output']>;
1594
+ updatedAt: Scalars['Time']['output'];
2349
1595
  /** The value of the parameter */
2350
1596
  value?: Maybe<NodeParameterValue>;
2351
1597
  }
@@ -2354,20 +1600,20 @@ export interface NodeParameter {
2354
1600
  export interface NodeParameterConnection {
2355
1601
  __typename?: 'NodeParameterConnection';
2356
1602
  /** Total count of collection. */
2357
- count?: Maybe<Scalars['Int']['output']>;
1603
+ count: Scalars['Int']['output'];
2358
1604
  /** A list of edges. */
2359
1605
  edges?: Maybe<Array<Maybe<NodeParameterEdge>>>;
2360
1606
  /** A list of nodes. */
2361
1607
  nodes?: Maybe<Array<Maybe<NodeParameter>>>;
2362
1608
  /** Information to aid in pagination. */
2363
- pageInfo?: Maybe<PageInfo>;
1609
+ pageInfo: PageInfo;
2364
1610
  }
2365
1611
 
2366
1612
  /** An edge in a connection. */
2367
1613
  export interface NodeParameterEdge {
2368
1614
  __typename?: 'NodeParameterEdge';
2369
1615
  /** A cursor for use in pagination. */
2370
- cursor?: Maybe<Scalars['String']['output']>;
1616
+ cursor: Scalars['String']['output'];
2371
1617
  /** The item at the end of the edge. */
2372
1618
  node?: Maybe<NodeParameter>;
2373
1619
  }
@@ -2393,52 +1639,30 @@ export interface NodeParameterValueInput {
2393
1639
  referenceValue?: InputMaybe<ReferenceValueInput>;
2394
1640
  }
2395
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
+
2396
1653
  /** Represents a Organization */
2397
1654
  export interface Organization {
2398
1655
  __typename?: 'Organization';
2399
1656
  /** Time when this Organization was created */
2400
- createdAt?: Maybe<Scalars['Time']['output']>;
1657
+ createdAt: Scalars['Time']['output'];
2401
1658
  /** Global ID of this Organization */
2402
- id?: Maybe<Scalars['OrganizationID']['output']>;
1659
+ id: Scalars['OrganizationID']['output'];
2403
1660
  /** Name of the organization */
2404
- name?: Maybe<Scalars['String']['output']>;
1661
+ name: Scalars['String']['output'];
2405
1662
  /** Namespace of this organization */
2406
- namespace?: Maybe<Namespace>;
1663
+ namespace: Namespace;
2407
1664
  /** Time when this Organization was last updated */
2408
- updatedAt?: Maybe<Scalars['Time']['output']>;
2409
- /** Abilities for the current user on this Organization */
2410
- userAbilities?: Maybe<OrganizationUserAbilities>;
2411
- }
2412
-
2413
- /** The connection type for Organization. */
2414
- export interface OrganizationConnection {
2415
- __typename?: 'OrganizationConnection';
2416
- /** Total count of collection. */
2417
- count?: Maybe<Scalars['Int']['output']>;
2418
- /** A list of edges. */
2419
- edges?: Maybe<Array<Maybe<OrganizationEdge>>>;
2420
- /** A list of nodes. */
2421
- nodes?: Maybe<Array<Maybe<Organization>>>;
2422
- /** Information to aid in pagination. */
2423
- pageInfo?: Maybe<PageInfo>;
2424
- }
2425
-
2426
- /** An edge in a connection. */
2427
- export interface OrganizationEdge {
2428
- __typename?: 'OrganizationEdge';
2429
- /** A cursor for use in pagination. */
2430
- cursor?: Maybe<Scalars['String']['output']>;
2431
- /** The item at the end of the edge. */
2432
- node?: Maybe<Organization>;
2433
- }
2434
-
2435
- /** Abilities for the current user on this Organization */
2436
- export interface OrganizationUserAbilities {
2437
- __typename?: 'OrganizationUserAbilities';
2438
- /** Shows if the current user has the `delete_organization` ability on this Organization */
2439
- deleteOrganization?: Maybe<Scalars['Boolean']['output']>;
2440
- /** Shows if the current user has the `update_organization` ability on this Organization */
2441
- updateOrganization?: Maybe<Scalars['Boolean']['output']>;
1665
+ updatedAt: Scalars['Time']['output'];
2442
1666
  }
2443
1667
 
2444
1668
  /** Autogenerated input type of OrganizationsCreate */
@@ -2455,7 +1679,7 @@ export interface OrganizationsCreatePayload {
2455
1679
  /** A unique identifier for the client performing the mutation. */
2456
1680
  clientMutationId?: Maybe<Scalars['String']['output']>;
2457
1681
  /** Errors encountered during execution of the mutation. */
2458
- errors?: Maybe<Array<Error>>;
1682
+ errors: Array<Error>;
2459
1683
  /** The newly created organization. */
2460
1684
  organization?: Maybe<Organization>;
2461
1685
  }
@@ -2474,7 +1698,7 @@ export interface OrganizationsDeletePayload {
2474
1698
  /** A unique identifier for the client performing the mutation. */
2475
1699
  clientMutationId?: Maybe<Scalars['String']['output']>;
2476
1700
  /** Errors encountered during execution of the mutation. */
2477
- errors?: Maybe<Array<Error>>;
1701
+ errors: Array<Error>;
2478
1702
  /** The deleted organization. */
2479
1703
  organization?: Maybe<Organization>;
2480
1704
  }
@@ -2495,7 +1719,7 @@ export interface OrganizationsUpdatePayload {
2495
1719
  /** A unique identifier for the client performing the mutation. */
2496
1720
  clientMutationId?: Maybe<Scalars['String']['output']>;
2497
1721
  /** Errors encountered during execution of the mutation. */
2498
- errors?: Maybe<Array<Error>>;
1722
+ errors: Array<Error>;
2499
1723
  /** The updated organization. */
2500
1724
  organization?: Maybe<Organization>;
2501
1725
  }
@@ -2506,96 +1730,26 @@ export interface PageInfo {
2506
1730
  /** When paginating forwards, the cursor to continue. */
2507
1731
  endCursor?: Maybe<Scalars['String']['output']>;
2508
1732
  /** When paginating forwards, are there more items? */
2509
- hasNextPage?: Maybe<Scalars['Boolean']['output']>;
1733
+ hasNextPage: Scalars['Boolean']['output'];
2510
1734
  /** When paginating backwards, are there more items? */
2511
- hasPreviousPage?: Maybe<Scalars['Boolean']['output']>;
1735
+ hasPreviousPage: Scalars['Boolean']['output'];
2512
1736
  /** When paginating backwards, the cursor to continue. */
2513
1737
  startCursor?: Maybe<Scalars['String']['output']>;
2514
1738
  }
2515
1739
 
2516
- /** Represents a parameter definition */
2517
- export interface ParameterDefinition {
2518
- __typename?: 'ParameterDefinition';
2519
- /** Time when this ParameterDefinition was created */
2520
- createdAt?: Maybe<Scalars['Time']['output']>;
2521
- /** Data type of the parameter */
2522
- dataTypeIdentifier?: Maybe<DataTypeIdentifier>;
2523
- /** Description of the parameter */
2524
- descriptions?: Maybe<TranslationConnection>;
2525
- /** Documentation of the parameter */
2526
- documentations?: Maybe<TranslationConnection>;
2527
- /** Global ID of this ParameterDefinition */
2528
- id?: Maybe<Scalars['ParameterDefinitionID']['output']>;
2529
- /** Identifier of the parameter */
2530
- identifier?: Maybe<Scalars['String']['output']>;
2531
- /** Name of the parameter */
2532
- names?: Maybe<TranslationConnection>;
2533
- /** Time when this ParameterDefinition was last updated */
2534
- updatedAt?: Maybe<Scalars['Time']['output']>;
2535
- }
2536
-
2537
-
2538
- /** Represents a parameter definition */
2539
- export interface ParameterDefinitionDescriptionsArgs {
2540
- after?: InputMaybe<Scalars['String']['input']>;
2541
- before?: InputMaybe<Scalars['String']['input']>;
2542
- first?: InputMaybe<Scalars['Int']['input']>;
2543
- last?: InputMaybe<Scalars['Int']['input']>;
2544
- }
2545
-
2546
-
2547
- /** Represents a parameter definition */
2548
- export interface ParameterDefinitionDocumentationsArgs {
2549
- after?: InputMaybe<Scalars['String']['input']>;
2550
- before?: InputMaybe<Scalars['String']['input']>;
2551
- first?: InputMaybe<Scalars['Int']['input']>;
2552
- last?: InputMaybe<Scalars['Int']['input']>;
2553
- }
2554
-
2555
-
2556
- /** Represents a parameter definition */
2557
- export interface ParameterDefinitionNamesArgs {
2558
- after?: InputMaybe<Scalars['String']['input']>;
2559
- before?: InputMaybe<Scalars['String']['input']>;
2560
- first?: InputMaybe<Scalars['Int']['input']>;
2561
- last?: InputMaybe<Scalars['Int']['input']>;
2562
- }
2563
-
2564
- /** The connection type for ParameterDefinition. */
2565
- export interface ParameterDefinitionConnection {
2566
- __typename?: 'ParameterDefinitionConnection';
2567
- /** Total count of collection. */
2568
- count?: Maybe<Scalars['Int']['output']>;
2569
- /** A list of edges. */
2570
- edges?: Maybe<Array<Maybe<ParameterDefinitionEdge>>>;
2571
- /** A list of nodes. */
2572
- nodes?: Maybe<Array<Maybe<ParameterDefinition>>>;
2573
- /** Information to aid in pagination. */
2574
- pageInfo?: Maybe<PageInfo>;
2575
- }
2576
-
2577
- /** An edge in a connection. */
2578
- export interface ParameterDefinitionEdge {
2579
- __typename?: 'ParameterDefinitionEdge';
2580
- /** A cursor for use in pagination. */
2581
- cursor?: Maybe<Scalars['String']['output']>;
2582
- /** The item at the end of the edge. */
2583
- node?: Maybe<ParameterDefinition>;
2584
- }
2585
-
2586
1740
  /** Root Query type */
2587
1741
  export interface Query {
2588
1742
  __typename?: 'Query';
2589
- /** Get application information */
2590
- application?: Maybe<Application>;
1743
+ /** Get global application settings */
1744
+ applicationSettings?: Maybe<ApplicationSettings>;
2591
1745
  /** Get the currently logged in authentication */
2592
1746
  currentAuthentication?: Maybe<Authentication>;
2593
1747
  /** Get the currently logged in user */
2594
1748
  currentUser?: Maybe<User>;
2595
1749
  /** Field available for use to test API access */
2596
- echo?: Maybe<Scalars['String']['output']>;
1750
+ echo: Scalars['String']['output'];
2597
1751
  /** Find runtimes */
2598
- globalRuntimes?: Maybe<RuntimeConnection>;
1752
+ globalRuntimes: RuntimeConnection;
2599
1753
  /** Find a namespace */
2600
1754
  namespace?: Maybe<Namespace>;
2601
1755
  /** Fetches an object given its ID */
@@ -2604,14 +1758,8 @@ export interface Query {
2604
1758
  nodes?: Maybe<Array<Maybe<Node>>>;
2605
1759
  /** Find a organization */
2606
1760
  organization?: Maybe<Organization>;
2607
- /** Find organizations */
2608
- organizations?: Maybe<OrganizationConnection>;
2609
- /** Find a user */
2610
- user?: Maybe<User>;
2611
- /** Abilities for the current user on this Instance */
2612
- userAbilities?: Maybe<InstanceUserAbilities>;
2613
1761
  /** Find users */
2614
- users?: Maybe<UserConnection>;
1762
+ users: UserConnection;
2615
1763
  }
2616
1764
 
2617
1765
 
@@ -2655,22 +1803,6 @@ export interface QueryOrganizationArgs {
2655
1803
  }
2656
1804
 
2657
1805
 
2658
- /** Root Query type */
2659
- export interface QueryOrganizationsArgs {
2660
- after?: InputMaybe<Scalars['String']['input']>;
2661
- before?: InputMaybe<Scalars['String']['input']>;
2662
- first?: InputMaybe<Scalars['Int']['input']>;
2663
- last?: InputMaybe<Scalars['Int']['input']>;
2664
- }
2665
-
2666
-
2667
- /** Root Query type */
2668
- export interface QueryUserArgs {
2669
- id?: InputMaybe<Scalars['UserID']['input']>;
2670
- username?: InputMaybe<Scalars['String']['input']>;
2671
- }
2672
-
2673
-
2674
1806
  /** Root Query type */
2675
1807
  export interface QueryUsersArgs {
2676
1808
  after?: InputMaybe<Scalars['String']['input']>;
@@ -2685,13 +1817,13 @@ export interface ReferencePath {
2685
1817
  /** The array index of the referenced data by the path */
2686
1818
  arrayIndex?: Maybe<Scalars['Int']['output']>;
2687
1819
  /** Time when this ReferencePath was created */
2688
- createdAt?: Maybe<Scalars['Time']['output']>;
1820
+ createdAt: Scalars['Time']['output'];
2689
1821
  /** Global ID of this ReferencePath */
2690
- id?: Maybe<Scalars['ReferencePathID']['output']>;
1822
+ id: Scalars['ReferencePathID']['output'];
2691
1823
  /** The path to the reference in the flow */
2692
1824
  path?: Maybe<Scalars['String']['output']>;
2693
1825
  /** Time when this ReferencePath was last updated */
2694
- updatedAt?: Maybe<Scalars['Time']['output']>;
1826
+ updatedAt: Scalars['Time']['output'];
2695
1827
  }
2696
1828
 
2697
1829
  /** Input type for reference path */
@@ -2706,68 +1838,76 @@ export interface ReferencePathInput {
2706
1838
  export interface ReferenceValue {
2707
1839
  __typename?: 'ReferenceValue';
2708
1840
  /** Time when this ReferenceValue was created */
2709
- createdAt?: Maybe<Scalars['Time']['output']>;
1841
+ createdAt: Scalars['Time']['output'];
2710
1842
  /** The identifier of the data type this reference value belongs to. */
2711
- dataTypeIdentifier?: Maybe<DataTypeIdentifier>;
2712
- /** The depth of the reference value. */
2713
- depth?: Maybe<Scalars['Int']['output']>;
1843
+ dataTypeIdentifier: DataTypeIdentifier;
2714
1844
  /** Global ID of this ReferenceValue */
2715
- id?: Maybe<Scalars['ReferenceValueID']['output']>;
2716
- /** The node of the reference value. */
2717
- node?: Maybe<Scalars['Int']['output']>;
2718
- /** The referenced value. */
2719
- nodeFunctionId?: Maybe<Scalars['NodeFunctionID']['output']>;
1845
+ id: Scalars['ReferenceValueID']['output'];
1846
+ /** The primary level of the reference value. */
1847
+ primaryLevel: Scalars['Int']['output'];
2720
1848
  /** The paths associated with this reference value. */
2721
- referencePath?: Maybe<Array<ReferencePath>>;
2722
- /** The scope of the reference value. */
2723
- 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']>;
2724
1854
  /** Time when this ReferenceValue was last updated */
2725
- updatedAt?: Maybe<Scalars['Time']['output']>;
1855
+ updatedAt: Scalars['Time']['output'];
2726
1856
  }
2727
1857
 
2728
1858
  /** Input type for reference value */
2729
1859
  export interface ReferenceValueInput {
2730
1860
  /** The identifier of the data type this reference value belongs to */
2731
1861
  dataTypeIdentifier: DataTypeIdentifierInput;
2732
- /** The depth of the reference value */
2733
- depth: Scalars['Int']['input'];
2734
- /** The node of the reference */
2735
- node: Scalars['Int']['input'];
2736
- /** The referenced value */
2737
- nodeFunctionId: Scalars['NodeFunctionID']['input'];
1862
+ /** The primary level of the reference value */
1863
+ primaryLevel: Scalars['Int']['input'];
2738
1864
  /** The paths associated with this reference value */
2739
1865
  referencePath: Array<ReferencePathInput>;
2740
- /** The scope of the reference value */
2741
- scope: Array<Scalars['Int']['input']>;
1866
+ /** The secondary level of the reference value */
1867
+ secondaryLevel: Scalars['Int']['input'];
1868
+ /** The tertiary level of the reference value */
1869
+ tertiaryLevel?: InputMaybe<Scalars['Int']['input']>;
1870
+ }
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;
2742
1884
  }
2743
1885
 
2744
1886
  /** Represents a runtime */
2745
1887
  export interface Runtime {
2746
1888
  __typename?: 'Runtime';
2747
1889
  /** Time when this Runtime was created */
2748
- createdAt?: Maybe<Scalars['Time']['output']>;
1890
+ createdAt: Scalars['Time']['output'];
2749
1891
  /** DataTypes of the runtime */
2750
- dataTypes?: Maybe<DataTypeConnection>;
1892
+ dataTypes: DataTypeConnection;
2751
1893
  /** The description for the runtime if present */
2752
- description?: Maybe<Scalars['String']['output']>;
1894
+ description: Scalars['String']['output'];
2753
1895
  /** FlowTypes of the runtime */
2754
- flowTypes?: Maybe<FlowTypeConnection>;
1896
+ flowTypes: FlowTypeConnection;
2755
1897
  /** Global ID of this Runtime */
2756
- id?: Maybe<Scalars['RuntimeID']['output']>;
1898
+ id: Scalars['RuntimeID']['output'];
2757
1899
  /** The name for the runtime */
2758
- name?: Maybe<Scalars['String']['output']>;
1900
+ name: Scalars['String']['output'];
2759
1901
  /** The parent namespace for the runtime */
2760
1902
  namespace?: Maybe<Namespace>;
2761
1903
  /** Projects associated with the runtime */
2762
- projects?: Maybe<NamespaceProjectConnection>;
1904
+ projects: NamespaceProjectConnection;
2763
1905
  /** The status of the runtime */
2764
- status?: Maybe<RuntimeStatusType>;
1906
+ status: RuntimeStatusType;
2765
1907
  /** Token belonging to the runtime, only present on creation */
2766
1908
  token?: Maybe<Scalars['String']['output']>;
2767
1909
  /** Time when this Runtime was last updated */
2768
- updatedAt?: Maybe<Scalars['Time']['output']>;
2769
- /** Abilities for the current user on this Runtime */
2770
- userAbilities?: Maybe<RuntimeUserAbilities>;
1910
+ updatedAt: Scalars['Time']['output'];
2771
1911
  }
2772
1912
 
2773
1913
 
@@ -2801,113 +1941,54 @@ export interface RuntimeProjectsArgs {
2801
1941
  export interface RuntimeConnection {
2802
1942
  __typename?: 'RuntimeConnection';
2803
1943
  /** Total count of collection. */
2804
- count?: Maybe<Scalars['Int']['output']>;
1944
+ count: Scalars['Int']['output'];
2805
1945
  /** A list of edges. */
2806
1946
  edges?: Maybe<Array<Maybe<RuntimeEdge>>>;
2807
1947
  /** A list of nodes. */
2808
1948
  nodes?: Maybe<Array<Maybe<Runtime>>>;
2809
1949
  /** Information to aid in pagination. */
2810
- pageInfo?: Maybe<PageInfo>;
1950
+ pageInfo: PageInfo;
2811
1951
  }
2812
1952
 
2813
1953
  /** An edge in a connection. */
2814
1954
  export interface RuntimeEdge {
2815
1955
  __typename?: 'RuntimeEdge';
2816
1956
  /** A cursor for use in pagination. */
2817
- cursor?: Maybe<Scalars['String']['output']>;
1957
+ cursor: Scalars['String']['output'];
2818
1958
  /** The item at the end of the edge. */
2819
1959
  node?: Maybe<Runtime>;
2820
1960
  }
2821
1961
 
2822
- /** Represents a runtime function definition */
1962
+ /** Represents a Node Function definition */
2823
1963
  export interface RuntimeFunctionDefinition {
2824
1964
  __typename?: 'RuntimeFunctionDefinition';
2825
1965
  /** Time when this RuntimeFunctionDefinition was created */
2826
- createdAt?: Maybe<Scalars['Time']['output']>;
2827
- /** Function definitions of the runtime function definition */
2828
- functionDefinitions?: Maybe<FunctionDefinitionConnection>;
1966
+ createdAt: Scalars['Time']['output'];
2829
1967
  /** Global ID of this RuntimeFunctionDefinition */
2830
- id?: Maybe<Scalars['RuntimeFunctionDefinitionID']['output']>;
2831
- /** Identifier of the runtime function definition */
2832
- identifier?: Maybe<Scalars['String']['output']>;
2833
- /** The runtime this runtime function definition belongs to */
2834
- runtime?: Maybe<Runtime>;
2835
- /** Parameter definitions of the runtime function definition */
2836
- runtimeParameterDefinitions?: Maybe<RuntimeParameterDefinitionConnection>;
1968
+ id: Scalars['RuntimeParameterDefinitionID']['output'];
2837
1969
  /** Time when this RuntimeFunctionDefinition was last updated */
2838
- updatedAt?: Maybe<Scalars['Time']['output']>;
2839
- }
2840
-
2841
-
2842
- /** Represents a runtime function definition */
2843
- export interface RuntimeFunctionDefinitionFunctionDefinitionsArgs {
2844
- after?: InputMaybe<Scalars['String']['input']>;
2845
- before?: InputMaybe<Scalars['String']['input']>;
2846
- first?: InputMaybe<Scalars['Int']['input']>;
2847
- last?: InputMaybe<Scalars['Int']['input']>;
2848
- }
2849
-
2850
-
2851
- /** Represents a runtime function definition */
2852
- export interface RuntimeFunctionDefinitionRuntimeParameterDefinitionsArgs {
2853
- after?: InputMaybe<Scalars['String']['input']>;
2854
- before?: InputMaybe<Scalars['String']['input']>;
2855
- first?: InputMaybe<Scalars['Int']['input']>;
2856
- last?: InputMaybe<Scalars['Int']['input']>;
1970
+ updatedAt: Scalars['Time']['output'];
2857
1971
  }
2858
1972
 
2859
- /** Represents a runtime parameter definition */
1973
+ /** Represents a Node parameter definition */
2860
1974
  export interface RuntimeParameterDefinition {
2861
1975
  __typename?: 'RuntimeParameterDefinition';
2862
1976
  /** Time when this RuntimeParameterDefinition was created */
2863
- createdAt?: Maybe<Scalars['Time']['output']>;
1977
+ createdAt: Scalars['Time']['output'];
2864
1978
  /** Global ID of this RuntimeParameterDefinition */
2865
- id?: Maybe<Scalars['RuntimeParameterDefinitionID']['output']>;
1979
+ id: Scalars['RuntimeParameterDefinitionID']['output'];
2866
1980
  /** Time when this RuntimeParameterDefinition was last updated */
2867
- updatedAt?: Maybe<Scalars['Time']['output']>;
2868
- }
2869
-
2870
- /** The connection type for RuntimeParameterDefinition. */
2871
- export interface RuntimeParameterDefinitionConnection {
2872
- __typename?: 'RuntimeParameterDefinitionConnection';
2873
- /** Total count of collection. */
2874
- count?: Maybe<Scalars['Int']['output']>;
2875
- /** A list of edges. */
2876
- edges?: Maybe<Array<Maybe<RuntimeParameterDefinitionEdge>>>;
2877
- /** A list of nodes. */
2878
- nodes?: Maybe<Array<Maybe<RuntimeParameterDefinition>>>;
2879
- /** Information to aid in pagination. */
2880
- pageInfo?: Maybe<PageInfo>;
2881
- }
2882
-
2883
- /** An edge in a connection. */
2884
- export interface RuntimeParameterDefinitionEdge {
2885
- __typename?: 'RuntimeParameterDefinitionEdge';
2886
- /** A cursor for use in pagination. */
2887
- cursor?: Maybe<Scalars['String']['output']>;
2888
- /** The item at the end of the edge. */
2889
- node?: Maybe<RuntimeParameterDefinition>;
1981
+ updatedAt: Scalars['Time']['output'];
2890
1982
  }
2891
1983
 
2892
1984
  /** Represent all available types of statuses of a runtime */
2893
- export const enum RuntimeStatusType {
1985
+ export enum RuntimeStatusType {
2894
1986
  /** No problem with connection, everything works as expected */
2895
1987
  Connected = 'CONNECTED',
2896
1988
  /** The runtime is disconnected, cause unknown */
2897
1989
  Disconnected = 'DISCONNECTED'
2898
1990
  }
2899
1991
 
2900
- /** Abilities for the current user on this Runtime */
2901
- export interface RuntimeUserAbilities {
2902
- __typename?: 'RuntimeUserAbilities';
2903
- /** Shows if the current user has the `delete_runtime` ability on this Runtime */
2904
- deleteRuntime?: Maybe<Scalars['Boolean']['output']>;
2905
- /** Shows if the current user has the `rotate_runtime_token` ability on this Runtime */
2906
- rotateRuntimeToken?: Maybe<Scalars['Boolean']['output']>;
2907
- /** Shows if the current user has the `update_runtime` ability on this Runtime */
2908
- updateRuntime?: Maybe<Scalars['Boolean']['output']>;
2909
- }
2910
-
2911
1992
  /** Autogenerated input type of RuntimesCreate */
2912
1993
  export interface RuntimesCreateInput {
2913
1994
  /** A unique identifier for the client performing the mutation. */
@@ -2926,7 +2007,7 @@ export interface RuntimesCreatePayload {
2926
2007
  /** A unique identifier for the client performing the mutation. */
2927
2008
  clientMutationId?: Maybe<Scalars['String']['output']>;
2928
2009
  /** Errors encountered during execution of the mutation. */
2929
- errors?: Maybe<Array<Error>>;
2010
+ errors: Array<Error>;
2930
2011
  /** The newly created runtime. */
2931
2012
  runtime?: Maybe<Runtime>;
2932
2013
  }
@@ -2945,7 +2026,7 @@ export interface RuntimesDeletePayload {
2945
2026
  /** A unique identifier for the client performing the mutation. */
2946
2027
  clientMutationId?: Maybe<Scalars['String']['output']>;
2947
2028
  /** Errors encountered during execution of the mutation. */
2948
- errors?: Maybe<Array<Error>>;
2029
+ errors: Array<Error>;
2949
2030
  /** The updated organization. */
2950
2031
  runtime?: Maybe<Runtime>;
2951
2032
  }
@@ -2964,7 +2045,7 @@ export interface RuntimesRotateTokenPayload {
2964
2045
  /** A unique identifier for the client performing the mutation. */
2965
2046
  clientMutationId?: Maybe<Scalars['String']['output']>;
2966
2047
  /** Errors encountered during execution of the mutation. */
2967
- errors?: Maybe<Array<Error>>;
2048
+ errors: Array<Error>;
2968
2049
  /** The updated runtime. */
2969
2050
  runtime?: Maybe<Runtime>;
2970
2051
  }
@@ -2987,7 +2068,7 @@ export interface RuntimesUpdatePayload {
2987
2068
  /** A unique identifier for the client performing the mutation. */
2988
2069
  clientMutationId?: Maybe<Scalars['String']['output']>;
2989
2070
  /** Errors encountered during execution of the mutation. */
2990
- errors?: Maybe<Array<Error>>;
2071
+ errors: Array<Error>;
2991
2072
  /** The updated runtime. */
2992
2073
  runtime?: Maybe<Runtime>;
2993
2074
  }
@@ -2996,29 +2077,29 @@ export interface RuntimesUpdatePayload {
2996
2077
  export interface Translation {
2997
2078
  __typename?: 'Translation';
2998
2079
  /** Code of the translation */
2999
- code?: Maybe<Scalars['String']['output']>;
2080
+ code: Scalars['String']['output'];
3000
2081
  /** Content of the translation */
3001
- content?: Maybe<Scalars['String']['output']>;
2082
+ content: Scalars['String']['output'];
3002
2083
  }
3003
2084
 
3004
2085
  /** The connection type for Translation. */
3005
2086
  export interface TranslationConnection {
3006
2087
  __typename?: 'TranslationConnection';
3007
2088
  /** Total count of collection. */
3008
- count?: Maybe<Scalars['Int']['output']>;
2089
+ count: Scalars['Int']['output'];
3009
2090
  /** A list of edges. */
3010
2091
  edges?: Maybe<Array<Maybe<TranslationEdge>>>;
3011
2092
  /** A list of nodes. */
3012
2093
  nodes?: Maybe<Array<Maybe<Translation>>>;
3013
2094
  /** Information to aid in pagination. */
3014
- pageInfo?: Maybe<PageInfo>;
2095
+ pageInfo: PageInfo;
3015
2096
  }
3016
2097
 
3017
2098
  /** An edge in a connection. */
3018
2099
  export interface TranslationEdge {
3019
2100
  __typename?: 'TranslationEdge';
3020
2101
  /** A cursor for use in pagination. */
3021
- cursor?: Maybe<Scalars['String']['output']>;
2102
+ cursor: Scalars['String']['output'];
3022
2103
  /** The item at the end of the edge. */
3023
2104
  node?: Maybe<Translation>;
3024
2105
  }
@@ -3027,46 +2108,27 @@ export interface TranslationEdge {
3027
2108
  export interface User {
3028
2109
  __typename?: 'User';
3029
2110
  /** Global admin status of the user */
3030
- admin?: Maybe<Scalars['Boolean']['output']>;
2111
+ admin: Scalars['Boolean']['output'];
3031
2112
  /** The avatar if present of the user */
3032
2113
  avatarPath?: Maybe<Scalars['String']['output']>;
3033
2114
  /** Time when this User was created */
3034
- createdAt?: Maybe<Scalars['Time']['output']>;
2115
+ createdAt: Scalars['Time']['output'];
3035
2116
  /** Email of the user */
3036
- email?: Maybe<Scalars['String']['output']>;
3037
- /** Email verification date of the user if present */
3038
- emailVerifiedAt?: Maybe<Scalars['Time']['output']>;
2117
+ email: Scalars['String']['output'];
3039
2118
  /** Firstname of the user */
3040
- firstname?: Maybe<Scalars['String']['output']>;
2119
+ firstname: Scalars['String']['output'];
3041
2120
  /** Global ID of this User */
3042
- id?: Maybe<Scalars['UserID']['output']>;
3043
- /** Identities of this user */
3044
- identities?: Maybe<UserIdentityConnection>;
2121
+ id: Scalars['UserID']['output'];
3045
2122
  /** Lastname of the user */
3046
- lastname?: Maybe<Scalars['String']['output']>;
3047
- /** Multi-factor authentication status of this user */
3048
- mfaStatus?: Maybe<MfaStatus>;
2123
+ lastname: Scalars['String']['output'];
3049
2124
  /** Namespace of this user */
3050
2125
  namespace?: Maybe<Namespace>;
3051
2126
  /** Namespace Memberships of this user */
3052
- namespaceMemberships?: Maybe<NamespaceMemberConnection>;
3053
- /** Sessions of this user */
3054
- sessions?: Maybe<UserSessionConnection>;
2127
+ namespaceMemberships: NamespaceMemberConnection;
3055
2128
  /** Time when this User was last updated */
3056
- updatedAt?: Maybe<Scalars['Time']['output']>;
3057
- /** Abilities for the current user on this User */
3058
- userAbilities?: Maybe<UserUserAbilities>;
2129
+ updatedAt: Scalars['Time']['output'];
3059
2130
  /** Username of the user */
3060
- username?: Maybe<Scalars['String']['output']>;
3061
- }
3062
-
3063
-
3064
- /** Represents a user */
3065
- export interface UserIdentitiesArgs {
3066
- after?: InputMaybe<Scalars['String']['input']>;
3067
- before?: InputMaybe<Scalars['String']['input']>;
3068
- first?: InputMaybe<Scalars['Int']['input']>;
3069
- last?: InputMaybe<Scalars['Int']['input']>;
2131
+ username: Scalars['String']['output'];
3070
2132
  }
3071
2133
 
3072
2134
 
@@ -3078,33 +2140,24 @@ export interface UserNamespaceMembershipsArgs {
3078
2140
  last?: InputMaybe<Scalars['Int']['input']>;
3079
2141
  }
3080
2142
 
3081
-
3082
- /** Represents a user */
3083
- export interface UserSessionsArgs {
3084
- after?: InputMaybe<Scalars['String']['input']>;
3085
- before?: InputMaybe<Scalars['String']['input']>;
3086
- first?: InputMaybe<Scalars['Int']['input']>;
3087
- last?: InputMaybe<Scalars['Int']['input']>;
3088
- }
3089
-
3090
2143
  /** The connection type for User. */
3091
2144
  export interface UserConnection {
3092
2145
  __typename?: 'UserConnection';
3093
2146
  /** Total count of collection. */
3094
- count?: Maybe<Scalars['Int']['output']>;
2147
+ count: Scalars['Int']['output'];
3095
2148
  /** A list of edges. */
3096
2149
  edges?: Maybe<Array<Maybe<UserEdge>>>;
3097
2150
  /** A list of nodes. */
3098
2151
  nodes?: Maybe<Array<Maybe<User>>>;
3099
2152
  /** Information to aid in pagination. */
3100
- pageInfo?: Maybe<PageInfo>;
2153
+ pageInfo: PageInfo;
3101
2154
  }
3102
2155
 
3103
2156
  /** An edge in a connection. */
3104
2157
  export interface UserEdge {
3105
2158
  __typename?: 'UserEdge';
3106
2159
  /** A cursor for use in pagination. */
3107
- cursor?: Maybe<Scalars['String']['output']>;
2160
+ cursor: Scalars['String']['output'];
3108
2161
  /** The item at the end of the edge. */
3109
2162
  node?: Maybe<User>;
3110
2163
  }
@@ -3113,165 +2166,34 @@ export interface UserEdge {
3113
2166
  export interface UserIdentity {
3114
2167
  __typename?: 'UserIdentity';
3115
2168
  /** Time when this UserIdentity was created */
3116
- createdAt?: Maybe<Scalars['Time']['output']>;
2169
+ createdAt: Scalars['Time']['output'];
3117
2170
  /** Global ID of this UserIdentity */
3118
- id?: Maybe<Scalars['UserIdentityID']['output']>;
2171
+ id: Scalars['UserIdentityID']['output'];
3119
2172
  /** The description for the runtime if present */
3120
- identifier?: Maybe<Scalars['String']['output']>;
2173
+ identifier: Scalars['String']['output'];
3121
2174
  /** The name for the runtime */
3122
- providerId?: Maybe<Scalars['String']['output']>;
2175
+ providerId: Scalars['String']['output'];
3123
2176
  /** Time when this UserIdentity was last updated */
3124
- updatedAt?: Maybe<Scalars['Time']['output']>;
2177
+ updatedAt: Scalars['Time']['output'];
3125
2178
  /** The correlating user of the identity */
3126
- user?: Maybe<User>;
3127
- }
3128
-
3129
- /** The connection type for UserIdentity. */
3130
- export interface UserIdentityConnection {
3131
- __typename?: 'UserIdentityConnection';
3132
- /** Total count of collection. */
3133
- count?: Maybe<Scalars['Int']['output']>;
3134
- /** A list of edges. */
3135
- edges?: Maybe<Array<Maybe<UserIdentityEdge>>>;
3136
- /** A list of nodes. */
3137
- nodes?: Maybe<Array<Maybe<UserIdentity>>>;
3138
- /** Information to aid in pagination. */
3139
- pageInfo?: Maybe<PageInfo>;
3140
- }
3141
-
3142
- /** An edge in a connection. */
3143
- export interface UserIdentityEdge {
3144
- __typename?: 'UserIdentityEdge';
3145
- /** A cursor for use in pagination. */
3146
- cursor?: Maybe<Scalars['String']['output']>;
3147
- /** The item at the end of the edge. */
3148
- node?: Maybe<UserIdentity>;
2179
+ user: User;
3149
2180
  }
3150
2181
 
3151
2182
  /** Represents a user session */
3152
2183
  export interface UserSession {
3153
2184
  __typename?: 'UserSession';
3154
2185
  /** Whether or not the session is active and can be used */
3155
- active?: Maybe<Scalars['Boolean']['output']>;
2186
+ active: Scalars['Boolean']['output'];
3156
2187
  /** Time when this UserSession was created */
3157
- createdAt?: Maybe<Scalars['Time']['output']>;
2188
+ createdAt: Scalars['Time']['output'];
3158
2189
  /** Global ID of this UserSession */
3159
- id?: Maybe<Scalars['UserSessionID']['output']>;
2190
+ id: Scalars['UserSessionID']['output'];
3160
2191
  /** Token belonging to the session, only present on creation */
3161
2192
  token?: Maybe<Scalars['String']['output']>;
3162
2193
  /** Time when this UserSession was last updated */
3163
- updatedAt?: Maybe<Scalars['Time']['output']>;
2194
+ updatedAt: Scalars['Time']['output'];
3164
2195
  /** User that belongs to the session */
3165
- user?: Maybe<User>;
3166
- /** Abilities for the current user on this UserSession */
3167
- userAbilities?: Maybe<UserSessionUserAbilities>;
3168
- }
3169
-
3170
- /** The connection type for UserSession. */
3171
- export interface UserSessionConnection {
3172
- __typename?: 'UserSessionConnection';
3173
- /** Total count of collection. */
3174
- count?: Maybe<Scalars['Int']['output']>;
3175
- /** A list of edges. */
3176
- edges?: Maybe<Array<Maybe<UserSessionEdge>>>;
3177
- /** A list of nodes. */
3178
- nodes?: Maybe<Array<Maybe<UserSession>>>;
3179
- /** Information to aid in pagination. */
3180
- pageInfo?: Maybe<PageInfo>;
3181
- }
3182
-
3183
- /** An edge in a connection. */
3184
- export interface UserSessionEdge {
3185
- __typename?: 'UserSessionEdge';
3186
- /** A cursor for use in pagination. */
3187
- cursor?: Maybe<Scalars['String']['output']>;
3188
- /** The item at the end of the edge. */
3189
- node?: Maybe<UserSession>;
3190
- }
3191
-
3192
- /** Abilities for the current user on this UserSession */
3193
- export interface UserSessionUserAbilities {
3194
- __typename?: 'UserSessionUserAbilities';
3195
- /** Shows if the current user has the `logout_session` ability on this UserSession */
3196
- logoutSession?: Maybe<Scalars['Boolean']['output']>;
3197
- }
3198
-
3199
- /** Abilities for the current user on this User */
3200
- export interface UserUserAbilities {
3201
- __typename?: 'UserUserAbilities';
3202
- /** Shows if the current user has the `manage_mfa` ability on this User */
3203
- manageMfa?: Maybe<Scalars['Boolean']['output']>;
3204
- /** Shows if the current user has the `update_user` ability on this User */
3205
- updateUser?: Maybe<Scalars['Boolean']['output']>;
3206
- }
3207
-
3208
- /** Autogenerated input type of UsersCreate */
3209
- export interface UsersCreateInput {
3210
- /** Admin status for the user. */
3211
- admin?: InputMaybe<Scalars['Boolean']['input']>;
3212
- /** A unique identifier for the client performing the mutation. */
3213
- clientMutationId?: InputMaybe<Scalars['String']['input']>;
3214
- /** Email for the user. */
3215
- email: Scalars['String']['input'];
3216
- /** Firstname for the user. */
3217
- firstname?: InputMaybe<Scalars['String']['input']>;
3218
- /** Lastname for the user. */
3219
- lastname?: InputMaybe<Scalars['String']['input']>;
3220
- /** Password for the user. */
3221
- password: Scalars['String']['input'];
3222
- /** Password repeat for the user to check for typos. */
3223
- passwordRepeat: Scalars['String']['input'];
3224
- /** Username for the user. */
3225
- username: Scalars['String']['input'];
3226
- }
3227
-
3228
- /** Autogenerated return type of UsersCreate. */
3229
- export interface UsersCreatePayload {
3230
- __typename?: 'UsersCreatePayload';
3231
- /** A unique identifier for the client performing the mutation. */
3232
- clientMutationId?: Maybe<Scalars['String']['output']>;
3233
- /** Errors encountered during execution of the mutation. */
3234
- errors?: Maybe<Array<Error>>;
3235
- /** The created user. */
3236
- user?: Maybe<User>;
3237
- }
3238
-
3239
- /** Autogenerated input type of UsersDelete */
3240
- export interface UsersDeleteInput {
3241
- /** A unique identifier for the client performing the mutation. */
3242
- clientMutationId?: InputMaybe<Scalars['String']['input']>;
3243
- /** The user to delete. */
3244
- userId: Scalars['UserID']['input'];
3245
- }
3246
-
3247
- /** Autogenerated return type of UsersDelete. */
3248
- export interface UsersDeletePayload {
3249
- __typename?: 'UsersDeletePayload';
3250
- /** A unique identifier for the client performing the mutation. */
3251
- clientMutationId?: Maybe<Scalars['String']['output']>;
3252
- /** Errors encountered during execution of the mutation. */
3253
- errors?: Maybe<Array<Error>>;
3254
- /** The deleted user. */
3255
- user?: Maybe<User>;
3256
- }
3257
-
3258
- /** Autogenerated input type of UsersEmailVerification */
3259
- export interface UsersEmailVerificationInput {
3260
- /** A unique identifier for the client performing the mutation. */
3261
- clientMutationId?: InputMaybe<Scalars['String']['input']>;
3262
- /** The email verification token */
3263
- token: Scalars['String']['input'];
3264
- }
3265
-
3266
- /** Autogenerated return type of UsersEmailVerification. */
3267
- export interface UsersEmailVerificationPayload {
3268
- __typename?: 'UsersEmailVerificationPayload';
3269
- /** A unique identifier for the client performing the mutation. */
3270
- clientMutationId?: Maybe<Scalars['String']['output']>;
3271
- /** Errors encountered during execution of the mutation. */
3272
- errors?: Maybe<Array<Error>>;
3273
- /** The user whose email was verified */
3274
- user?: Maybe<User>;
2196
+ user: User;
3275
2197
  }
3276
2198
 
3277
2199
  /** Autogenerated input type of UsersIdentityLink */
@@ -3290,7 +2212,7 @@ export interface UsersIdentityLinkPayload {
3290
2212
  /** A unique identifier for the client performing the mutation. */
3291
2213
  clientMutationId?: Maybe<Scalars['String']['output']>;
3292
2214
  /** Errors encountered during execution of the mutation. */
3293
- errors?: Maybe<Array<Error>>;
2215
+ errors: Array<Error>;
3294
2216
  /** The created user identity */
3295
2217
  userIdentity?: Maybe<UserIdentity>;
3296
2218
  }
@@ -3311,7 +2233,7 @@ export interface UsersIdentityLoginPayload {
3311
2233
  /** A unique identifier for the client performing the mutation. */
3312
2234
  clientMutationId?: Maybe<Scalars['String']['output']>;
3313
2235
  /** Errors encountered during execution of the mutation. */
3314
- errors?: Maybe<Array<Error>>;
2236
+ errors: Array<Error>;
3315
2237
  /** The created user session */
3316
2238
  userSession?: Maybe<UserSession>;
3317
2239
  }
@@ -3332,7 +2254,7 @@ export interface UsersIdentityRegisterPayload {
3332
2254
  /** A unique identifier for the client performing the mutation. */
3333
2255
  clientMutationId?: Maybe<Scalars['String']['output']>;
3334
2256
  /** Errors encountered during execution of the mutation. */
3335
- errors?: Maybe<Array<Error>>;
2257
+ errors: Array<Error>;
3336
2258
  /** The created users session */
3337
2259
  userSession?: Maybe<UserSession>;
3338
2260
  }
@@ -3351,7 +2273,7 @@ export interface UsersIdentityUnlinkPayload {
3351
2273
  /** A unique identifier for the client performing the mutation. */
3352
2274
  clientMutationId?: Maybe<Scalars['String']['output']>;
3353
2275
  /** Errors encountered during execution of the mutation. */
3354
- errors?: Maybe<Array<Error>>;
2276
+ errors: Array<Error>;
3355
2277
  /** The removed identity */
3356
2278
  userIdentity?: Maybe<UserIdentity>;
3357
2279
  }
@@ -3376,7 +2298,7 @@ export interface UsersLoginPayload {
3376
2298
  /** A unique identifier for the client performing the mutation. */
3377
2299
  clientMutationId?: Maybe<Scalars['String']['output']>;
3378
2300
  /** Errors encountered during execution of the mutation. */
3379
- errors?: Maybe<Array<Error>>;
2301
+ errors: Array<Error>;
3380
2302
  /** The created user session */
3381
2303
  userSession?: Maybe<UserSession>;
3382
2304
  }
@@ -3395,7 +2317,7 @@ export interface UsersLogoutPayload {
3395
2317
  /** A unique identifier for the client performing the mutation. */
3396
2318
  clientMutationId?: Maybe<Scalars['String']['output']>;
3397
2319
  /** Errors encountered during execution of the mutation. */
3398
- errors?: Maybe<Array<Error>>;
2320
+ errors: Array<Error>;
3399
2321
  /** The logged out user session */
3400
2322
  userSession?: Maybe<UserSession>;
3401
2323
  }
@@ -3414,7 +2336,7 @@ export interface UsersMfaBackupCodesRotatePayload {
3414
2336
  /** The newly rotated backup codes. */
3415
2337
  codes?: Maybe<Array<Scalars['String']['output']>>;
3416
2338
  /** Errors encountered during execution of the mutation. */
3417
- errors?: Maybe<Array<Error>>;
2339
+ errors: Array<Error>;
3418
2340
  }
3419
2341
 
3420
2342
  /** Autogenerated input type of UsersMfaTotpGenerateSecret */
@@ -3429,7 +2351,7 @@ export interface UsersMfaTotpGenerateSecretPayload {
3429
2351
  /** A unique identifier for the client performing the mutation. */
3430
2352
  clientMutationId?: Maybe<Scalars['String']['output']>;
3431
2353
  /** Errors encountered during execution of the mutation. */
3432
- errors?: Maybe<Array<Error>>;
2354
+ errors: Array<Error>;
3433
2355
  /** The created and signed secret */
3434
2356
  secret?: Maybe<Scalars['String']['output']>;
3435
2357
  }
@@ -3453,53 +2375,11 @@ export interface UsersMfaTotpValidateSecretPayload {
3453
2375
  /** A unique identifier for the client performing the mutation. */
3454
2376
  clientMutationId?: Maybe<Scalars['String']['output']>;
3455
2377
  /** Errors encountered during execution of the mutation. */
3456
- errors?: Maybe<Array<Error>>;
2378
+ errors: Array<Error>;
3457
2379
  /** The modified user */
3458
2380
  user?: Maybe<User>;
3459
2381
  }
3460
2382
 
3461
- /** Autogenerated input type of UsersPasswordReset */
3462
- export interface UsersPasswordResetInput {
3463
- /** A unique identifier for the client performing the mutation. */
3464
- clientMutationId?: InputMaybe<Scalars['String']['input']>;
3465
- /** The new password to set for the user */
3466
- newPassword: Scalars['String']['input'];
3467
- /** The confirmation of the new password to set for the user needs to be the same as the new password */
3468
- newPasswordConfirmation: Scalars['String']['input'];
3469
- /** The password reset token sent to the user email */
3470
- resetToken: Scalars['String']['input'];
3471
- }
3472
-
3473
- /** Autogenerated return type of UsersPasswordReset. */
3474
- export interface UsersPasswordResetPayload {
3475
- __typename?: 'UsersPasswordResetPayload';
3476
- /** A unique identifier for the client performing the mutation. */
3477
- clientMutationId?: Maybe<Scalars['String']['output']>;
3478
- /** Errors encountered during execution of the mutation. */
3479
- errors?: Maybe<Array<Error>>;
3480
- /** A message indicating the result of the password reset request */
3481
- message?: Maybe<Scalars['String']['output']>;
3482
- }
3483
-
3484
- /** Autogenerated input type of UsersPasswordResetRequest */
3485
- export interface UsersPasswordResetRequestInput {
3486
- /** A unique identifier for the client performing the mutation. */
3487
- clientMutationId?: InputMaybe<Scalars['String']['input']>;
3488
- /** Email of the user to reset the password */
3489
- email: Scalars['String']['input'];
3490
- }
3491
-
3492
- /** Autogenerated return type of UsersPasswordResetRequest. */
3493
- export interface UsersPasswordResetRequestPayload {
3494
- __typename?: 'UsersPasswordResetRequestPayload';
3495
- /** A unique identifier for the client performing the mutation. */
3496
- clientMutationId?: Maybe<Scalars['String']['output']>;
3497
- /** Errors encountered during execution of the mutation. */
3498
- errors?: Maybe<Array<Error>>;
3499
- /** A message indicating the result of the password reset request */
3500
- message?: Maybe<Scalars['String']['output']>;
3501
- }
3502
-
3503
2383
  /** Autogenerated input type of UsersRegister */
3504
2384
  export interface UsersRegisterInput {
3505
2385
  /** A unique identifier for the client performing the mutation. */
@@ -3520,7 +2400,7 @@ export interface UsersRegisterPayload {
3520
2400
  /** A unique identifier for the client performing the mutation. */
3521
2401
  clientMutationId?: Maybe<Scalars['String']['output']>;
3522
2402
  /** Errors encountered during execution of the mutation. */
3523
- errors?: Maybe<Array<Error>>;
2403
+ errors: Array<Error>;
3524
2404
  /** The created users session */
3525
2405
  userSession?: Maybe<UserSession>;
3526
2406
  }
@@ -3555,7 +2435,7 @@ export interface UsersUpdatePayload {
3555
2435
  /** A unique identifier for the client performing the mutation. */
3556
2436
  clientMutationId?: Maybe<Scalars['String']['output']>;
3557
2437
  /** Errors encountered during execution of the mutation. */
3558
- errors?: Maybe<Array<Error>>;
2438
+ errors: Array<Error>;
3559
2439
  /** The updated user. */
3560
2440
  user?: Maybe<User>;
3561
2441
  }