@code0-tech/sagittarius-graphql-types 0.0.0-6f0b32a0eb18c9c3569a090f089c6adf1b4d666c → 0.0.0-beb91167a8ea12eb6d4a6e3933483bacf845f2f6
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.
- package/index.d.ts +1766 -176
- package/package.json +5 -6
- package/index.js +0 -0
package/index.d.ts
CHANGED
|
@@ -1,65 +1,67 @@
|
|
|
1
1
|
export type Maybe<T> = T | null;
|
|
2
2
|
export type InputMaybe<T> = Maybe<T>;
|
|
3
|
-
export type Exact<T extends { [key: string]: unknown }> = { [K in keyof T]: T[K] }
|
|
4
|
-
export type MakeOptional<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]?: Maybe<T[SubKey]> }
|
|
5
|
-
export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]: Maybe<T[SubKey]> }
|
|
6
|
-
export type MakeEmpty<T extends { [key: string]: unknown }, K extends keyof T> = { [_ in K]?: never }
|
|
7
|
-
export type Incremental<T> = T | { [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never }
|
|
3
|
+
export type Exact<T extends { [key: string]: unknown }> = { [K in keyof T]: T[K] }
|
|
4
|
+
export type MakeOptional<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]?: Maybe<T[SubKey]> }
|
|
5
|
+
export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]: Maybe<T[SubKey]> }
|
|
6
|
+
export type MakeEmpty<T extends { [key: string]: unknown }, K extends keyof T> = { [_ in K]?: never }
|
|
7
|
+
export type Incremental<T> = T | { [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never }
|
|
8
8
|
/** All built-in and custom scalars, mapped to their actual values */
|
|
9
9
|
export interface Scalars {
|
|
10
|
-
ID: { input:
|
|
10
|
+
ID: { input: `gid://sagittarius//${number}`; output: `gid://sagittarius//${number}`; }
|
|
11
11
|
String: { input: string; output: string; }
|
|
12
12
|
Boolean: { input: boolean; output: boolean; }
|
|
13
13
|
Int: { input: number; output: number; }
|
|
14
14
|
Float: { input: number; output: number; }
|
|
15
|
-
|
|
16
|
-
|
|
17
|
-
|
|
18
|
-
|
|
19
|
-
|
|
20
|
-
|
|
21
|
-
|
|
22
|
-
|
|
23
|
-
|
|
24
|
-
|
|
25
|
-
|
|
26
|
-
|
|
27
|
-
|
|
28
|
-
|
|
29
|
-
|
|
30
|
-
|
|
31
|
-
|
|
32
|
-
|
|
33
|
-
|
|
34
|
-
|
|
35
|
-
|
|
36
|
-
|
|
37
|
-
|
|
38
|
-
|
|
39
|
-
|
|
40
|
-
|
|
41
|
-
|
|
42
|
-
|
|
43
|
-
|
|
44
|
-
|
|
15
|
+
DataTypeID: { input: `gid://sagittarius/DataType/${number}`; output: `gid://sagittarius/DataType/${number}`; }
|
|
16
|
+
DataTypeIdentifierID: { input: `gid://sagittarius/DataTypeIdentifier/${number}`; output: `gid://sagittarius/DataTypeIdentifier/${number}`; }
|
|
17
|
+
DataTypeRuleID: { input: `gid://sagittarius/DataTypeRule/${number}`; output: `gid://sagittarius/DataTypeRule/${number}`; }
|
|
18
|
+
FlowID: { input: `gid://sagittarius/Flow/${number}`; output: `gid://sagittarius/Flow/${number}`; }
|
|
19
|
+
FlowSettingID: { input: `gid://sagittarius/FlowSetting/${number}`; output: `gid://sagittarius/FlowSetting/${number}`; }
|
|
20
|
+
FlowTypeID: { input: `gid://sagittarius/FlowType/${number}`; output: `gid://sagittarius/FlowType/${number}`; }
|
|
21
|
+
FlowTypeSettingID: { input: `gid://sagittarius/FlowTypeSetting/${number}`; output: `gid://sagittarius/FlowTypeSetting/${number}`; }
|
|
22
|
+
FunctionDefinitionID: { input: `gid://sagittarius/FunctionDefinition/${number}`; output: `gid://sagittarius/FunctionDefinition/${number}`; }
|
|
23
|
+
GenericCombinationStrategyID: { input: `gid://sagittarius/GenericCombinationStrategy/${number}`; output: `gid://sagittarius/GenericCombinationStrategy/${number}`; }
|
|
24
|
+
GenericMapperID: { input: `gid://sagittarius/GenericMapper/${number}`; output: `gid://sagittarius/GenericMapper/${number}`; }
|
|
25
|
+
GenericTypeID: { input: `gid://sagittarius/GenericType/${number}`; output: `gid://sagittarius/GenericType/${number}`; }
|
|
26
|
+
JSON: { input: any; output: any; }
|
|
27
|
+
NamespaceID: { input: `gid://sagittarius/Namespace/${number}`; output: `gid://sagittarius/Namespace/${number}`; }
|
|
28
|
+
NamespaceLicenseID: { input: `gid://sagittarius/NamespaceLicense/${number}`; output: `gid://sagittarius/NamespaceLicense/${number}`; }
|
|
29
|
+
NamespaceMemberID: { input: `gid://sagittarius/NamespaceMember/${number}`; output: `gid://sagittarius/NamespaceMember/${number}`; }
|
|
30
|
+
NamespaceMemberRoleID: { input: `gid://sagittarius/NamespaceMemberRole/${number}`; output: `gid://sagittarius/NamespaceMemberRole/${number}`; }
|
|
31
|
+
NamespaceProjectID: { input: `gid://sagittarius/NamespaceProject/${number}`; output: `gid://sagittarius/NamespaceProject/${number}`; }
|
|
32
|
+
NamespaceRoleID: { input: `gid://sagittarius/NamespaceRole/${number}`; output: `gid://sagittarius/NamespaceRole/${number}`; }
|
|
33
|
+
NodeFunctionID: { input: `gid://sagittarius/NodeFunction/${number}`; output: `gid://sagittarius/NodeFunction/${number}`; }
|
|
34
|
+
NodeParameterID: { input: `gid://sagittarius/NodeParameter/${number}`; output: `gid://sagittarius/NodeParameter/${number}`; }
|
|
35
|
+
OrganizationID: { input: `gid://sagittarius/Organization/${number}`; output: `gid://sagittarius/Organization/${number}`; }
|
|
36
|
+
ParameterDefinitionID: { input: `gid://sagittarius/ParameterDefinition/${number}`; output: `gid://sagittarius/ParameterDefinition/${number}`; }
|
|
37
|
+
ReferencePathID: { input: `gid://sagittarius/ReferencePath/${number}`; output: `gid://sagittarius/ReferencePath/${number}`; }
|
|
38
|
+
ReferenceValueID: { input: `gid://sagittarius/ReferenceValue/${number}`; output: `gid://sagittarius/ReferenceValue/${number}`; }
|
|
39
|
+
RuntimeFunctionDefinitionID: { input: `gid://sagittarius/RuntimeFunctionDefinition/${number}`; output: `gid://sagittarius/RuntimeFunctionDefinition/${number}`; }
|
|
40
|
+
RuntimeID: { input: `gid://sagittarius/Runtime/${number}`; output: `gid://sagittarius/Runtime/${number}`; }
|
|
41
|
+
RuntimeParameterDefinitionID: { input: `gid://sagittarius/RuntimeParameterDefinition/${number}`; output: `gid://sagittarius/RuntimeParameterDefinition/${number}`; }
|
|
42
|
+
Time: { input: string; output: string; }
|
|
43
|
+
TypesFlowTypeID: { input: `gid://sagittarius/TypesFlowType/${number}`; output: `gid://sagittarius/TypesFlowType/${number}`; }
|
|
44
|
+
UserID: { input: `gid://sagittarius/User/${number}`; output: `gid://sagittarius/User/${number}`; }
|
|
45
|
+
UserIdentityID: { input: `gid://sagittarius/UserIdentity/${number}`; output: `gid://sagittarius/UserIdentity/${number}`; }
|
|
46
|
+
UserSessionID: { input: `gid://sagittarius/UserSession/${number}`; output: `gid://sagittarius/UserSession/${number}`; }
|
|
45
47
|
}
|
|
46
48
|
|
|
47
49
|
/** Represents an active model error */
|
|
48
50
|
export interface ActiveModelError {
|
|
49
51
|
__typename?: 'ActiveModelError';
|
|
50
52
|
/** The affected attribute on the model */
|
|
51
|
-
attribute
|
|
53
|
+
attribute?: Maybe<Scalars['String']['output']>;
|
|
52
54
|
/** The validation type that failed for the attribute */
|
|
53
|
-
type
|
|
55
|
+
type?: Maybe<Scalars['String']['output']>;
|
|
54
56
|
}
|
|
55
57
|
|
|
56
58
|
/** Represents the application settings */
|
|
57
59
|
export interface ApplicationSettings {
|
|
58
60
|
__typename?: 'ApplicationSettings';
|
|
59
61
|
/** Shows if organization creation is restricted to administrators */
|
|
60
|
-
organizationCreationRestricted
|
|
62
|
+
organizationCreationRestricted?: Maybe<Scalars['Boolean']['output']>;
|
|
61
63
|
/** Shows if user registration is enabled */
|
|
62
|
-
userRegistrationEnabled
|
|
64
|
+
userRegistrationEnabled?: Maybe<Scalars['Boolean']['output']>;
|
|
63
65
|
}
|
|
64
66
|
|
|
65
67
|
/** Autogenerated input type of ApplicationSettingsUpdate */
|
|
@@ -80,7 +82,7 @@ export interface ApplicationSettingsUpdatePayload {
|
|
|
80
82
|
/** A unique identifier for the client performing the mutation. */
|
|
81
83
|
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
82
84
|
/** Errors encountered during execution of the mutation. */
|
|
83
|
-
errors
|
|
85
|
+
errors?: Maybe<Array<Error>>;
|
|
84
86
|
}
|
|
85
87
|
|
|
86
88
|
/** Objects that can present an authentication */
|
|
@@ -90,47 +92,233 @@ export type Authentication = UserSession;
|
|
|
90
92
|
export interface DataType {
|
|
91
93
|
__typename?: 'DataType';
|
|
92
94
|
/** Time when this DataType was created */
|
|
93
|
-
createdAt
|
|
95
|
+
createdAt?: Maybe<Scalars['Time']['output']>;
|
|
96
|
+
/** Generic keys of the datatype */
|
|
97
|
+
genericKeys?: Maybe<Array<Scalars['String']['output']>>;
|
|
94
98
|
/** Global ID of this DataType */
|
|
95
|
-
id
|
|
99
|
+
id?: Maybe<Scalars['DataTypeID']['output']>;
|
|
96
100
|
/** The identifier scoped to the namespace */
|
|
97
|
-
identifier
|
|
98
|
-
/**
|
|
99
|
-
|
|
101
|
+
identifier?: Maybe<Scalars['String']['output']>;
|
|
102
|
+
/** Names of the flow type setting */
|
|
103
|
+
name?: Maybe<TranslationConnection>;
|
|
104
|
+
/** Rules of the datatype */
|
|
105
|
+
rules?: Maybe<DataTypeRuleConnection>;
|
|
106
|
+
/** The runtime where this datatype belongs to */
|
|
107
|
+
runtime?: Maybe<Runtime>;
|
|
100
108
|
/** Time when this DataType was last updated */
|
|
101
|
-
updatedAt
|
|
109
|
+
updatedAt?: Maybe<Scalars['Time']['output']>;
|
|
102
110
|
/** The type of the datatype */
|
|
103
|
-
variant
|
|
111
|
+
variant?: Maybe<DataTypeVariant>;
|
|
112
|
+
}
|
|
113
|
+
|
|
114
|
+
|
|
115
|
+
/** Represents a DataType */
|
|
116
|
+
export interface DataTypeNameArgs {
|
|
117
|
+
after?: InputMaybe<Scalars['String']['input']>;
|
|
118
|
+
before?: InputMaybe<Scalars['String']['input']>;
|
|
119
|
+
first?: InputMaybe<Scalars['Int']['input']>;
|
|
120
|
+
last?: InputMaybe<Scalars['Int']['input']>;
|
|
121
|
+
}
|
|
122
|
+
|
|
123
|
+
|
|
124
|
+
/** Represents a DataType */
|
|
125
|
+
export interface DataTypeRulesArgs {
|
|
126
|
+
after?: InputMaybe<Scalars['String']['input']>;
|
|
127
|
+
before?: InputMaybe<Scalars['String']['input']>;
|
|
128
|
+
first?: InputMaybe<Scalars['Int']['input']>;
|
|
129
|
+
last?: InputMaybe<Scalars['Int']['input']>;
|
|
104
130
|
}
|
|
105
131
|
|
|
106
132
|
/** The connection type for DataType. */
|
|
107
133
|
export interface DataTypeConnection {
|
|
108
134
|
__typename?: 'DataTypeConnection';
|
|
109
135
|
/** Total count of collection. */
|
|
110
|
-
count
|
|
136
|
+
count?: Maybe<Scalars['Int']['output']>;
|
|
111
137
|
/** A list of edges. */
|
|
112
138
|
edges?: Maybe<Array<Maybe<DataTypeEdge>>>;
|
|
113
139
|
/** A list of nodes. */
|
|
114
140
|
nodes?: Maybe<Array<Maybe<DataType>>>;
|
|
115
141
|
/** Information to aid in pagination. */
|
|
116
|
-
pageInfo
|
|
142
|
+
pageInfo?: Maybe<PageInfo>;
|
|
117
143
|
}
|
|
118
144
|
|
|
119
145
|
/** An edge in a connection. */
|
|
120
146
|
export interface DataTypeEdge {
|
|
121
147
|
__typename?: 'DataTypeEdge';
|
|
122
148
|
/** A cursor for use in pagination. */
|
|
123
|
-
cursor
|
|
149
|
+
cursor?: Maybe<Scalars['String']['output']>;
|
|
124
150
|
/** The item at the end of the edge. */
|
|
125
151
|
node?: Maybe<DataType>;
|
|
126
152
|
}
|
|
127
153
|
|
|
154
|
+
/** Represents a data type identifier. */
|
|
155
|
+
export interface DataTypeIdentifier {
|
|
156
|
+
__typename?: 'DataTypeIdentifier';
|
|
157
|
+
/** Time when this DataTypeIdentifier was created */
|
|
158
|
+
createdAt?: Maybe<Scalars['Time']['output']>;
|
|
159
|
+
/** The data type of the data type identifier. */
|
|
160
|
+
dataType?: Maybe<DataType>;
|
|
161
|
+
/** The generic key of the data type identifier. */
|
|
162
|
+
genericKey?: Maybe<Scalars['String']['output']>;
|
|
163
|
+
/** The generic type of the data type identifier. */
|
|
164
|
+
genericType?: Maybe<GenericType>;
|
|
165
|
+
/** Global ID of this DataTypeIdentifier */
|
|
166
|
+
id?: Maybe<Scalars['DataTypeIdentifierID']['output']>;
|
|
167
|
+
/** Time when this DataTypeIdentifier was last updated */
|
|
168
|
+
updatedAt?: Maybe<Scalars['Time']['output']>;
|
|
169
|
+
}
|
|
170
|
+
|
|
171
|
+
/** Input type for data type identifier */
|
|
172
|
+
export interface DataTypeIdentifierInput {
|
|
173
|
+
/** Data type ID */
|
|
174
|
+
dataTypeId?: InputMaybe<Scalars['DataTypeID']['input']>;
|
|
175
|
+
/** Generic key value */
|
|
176
|
+
genericKey?: InputMaybe<Scalars['String']['input']>;
|
|
177
|
+
/** Generic type information */
|
|
178
|
+
genericType?: InputMaybe<GenericTypeInput>;
|
|
179
|
+
}
|
|
180
|
+
|
|
181
|
+
/** Represents a rule that can be applied to a data type. */
|
|
182
|
+
export interface DataTypeRule {
|
|
183
|
+
__typename?: 'DataTypeRule';
|
|
184
|
+
/** The configuration of the rule */
|
|
185
|
+
config?: Maybe<DataTypeRulesConfig>;
|
|
186
|
+
/** Time when this DataTypeRule was created */
|
|
187
|
+
createdAt?: Maybe<Scalars['Time']['output']>;
|
|
188
|
+
/** Global ID of this DataTypeRule */
|
|
189
|
+
id?: Maybe<Scalars['DataTypeRuleID']['output']>;
|
|
190
|
+
/** Time when this DataTypeRule was last updated */
|
|
191
|
+
updatedAt?: Maybe<Scalars['Time']['output']>;
|
|
192
|
+
/** The type of the rule */
|
|
193
|
+
variant?: Maybe<DataTypeRulesVariant>;
|
|
194
|
+
}
|
|
195
|
+
|
|
196
|
+
/** The connection type for DataTypeRule. */
|
|
197
|
+
export interface DataTypeRuleConnection {
|
|
198
|
+
__typename?: 'DataTypeRuleConnection';
|
|
199
|
+
/** Total count of collection. */
|
|
200
|
+
count?: Maybe<Scalars['Int']['output']>;
|
|
201
|
+
/** A list of edges. */
|
|
202
|
+
edges?: Maybe<Array<Maybe<DataTypeRuleEdge>>>;
|
|
203
|
+
/** A list of nodes. */
|
|
204
|
+
nodes?: Maybe<Array<Maybe<DataTypeRule>>>;
|
|
205
|
+
/** Information to aid in pagination. */
|
|
206
|
+
pageInfo?: Maybe<PageInfo>;
|
|
207
|
+
}
|
|
208
|
+
|
|
209
|
+
/** An edge in a connection. */
|
|
210
|
+
export interface DataTypeRuleEdge {
|
|
211
|
+
__typename?: 'DataTypeRuleEdge';
|
|
212
|
+
/** A cursor for use in pagination. */
|
|
213
|
+
cursor?: Maybe<Scalars['String']['output']>;
|
|
214
|
+
/** The item at the end of the edge. */
|
|
215
|
+
node?: Maybe<DataTypeRule>;
|
|
216
|
+
}
|
|
217
|
+
|
|
218
|
+
/** Represents a rule that can be applied to a data type. */
|
|
219
|
+
export type DataTypeRulesConfig = DataTypeRulesContainsKeyConfig | DataTypeRulesContainsTypeConfig | DataTypeRulesInputTypesConfig | DataTypeRulesItemOfCollectionConfig | DataTypeRulesNumberRangeConfig | DataTypeRulesParentTypeConfig | DataTypeRulesRegexConfig | DataTypeRulesReturnTypeConfig;
|
|
220
|
+
|
|
221
|
+
/** Represents a rule that can be applied to a data type. */
|
|
222
|
+
export interface DataTypeRulesContainsKeyConfig {
|
|
223
|
+
__typename?: 'DataTypeRulesContainsKeyConfig';
|
|
224
|
+
/** The identifier of the data type this rule belongs to */
|
|
225
|
+
dataTypeIdentifier?: Maybe<DataTypeIdentifier>;
|
|
226
|
+
/** The key of the rule */
|
|
227
|
+
key?: Maybe<Scalars['String']['output']>;
|
|
228
|
+
}
|
|
229
|
+
|
|
230
|
+
/** Represents a rule that can be applied to a data type. */
|
|
231
|
+
export interface DataTypeRulesContainsTypeConfig {
|
|
232
|
+
__typename?: 'DataTypeRulesContainsTypeConfig';
|
|
233
|
+
/** The identifier of the data type this rule belongs to */
|
|
234
|
+
dataTypeIdentifier?: Maybe<DataTypeIdentifier>;
|
|
235
|
+
}
|
|
236
|
+
|
|
237
|
+
/** Represents a subtype of input type configuration for a input data type. */
|
|
238
|
+
export interface DataTypeRulesInputTypeConfig {
|
|
239
|
+
__typename?: 'DataTypeRulesInputTypeConfig';
|
|
240
|
+
/** The identifier of the data type this input type belongs to */
|
|
241
|
+
dataTypeIdentifier?: Maybe<DataTypeIdentifier>;
|
|
242
|
+
/** The input identifier that this configuration applies to */
|
|
243
|
+
inputIdentifier?: Maybe<Scalars['String']['output']>;
|
|
244
|
+
}
|
|
245
|
+
|
|
246
|
+
/** Represents a rule that can be applied to a data type. */
|
|
247
|
+
export interface DataTypeRulesInputTypesConfig {
|
|
248
|
+
__typename?: 'DataTypeRulesInputTypesConfig';
|
|
249
|
+
/** The input types that can be used in this data type rule */
|
|
250
|
+
inputTypes?: Maybe<Array<DataTypeRulesInputTypeConfig>>;
|
|
251
|
+
}
|
|
252
|
+
|
|
253
|
+
/** Represents a rule that can be applied to a data type. */
|
|
254
|
+
export interface DataTypeRulesItemOfCollectionConfig {
|
|
255
|
+
__typename?: 'DataTypeRulesItemOfCollectionConfig';
|
|
256
|
+
/** The items that can be configured for this rule. */
|
|
257
|
+
items?: Maybe<Array<Scalars['JSON']['output']>>;
|
|
258
|
+
}
|
|
259
|
+
|
|
260
|
+
/** Represents a rule that can be applied to a data type. */
|
|
261
|
+
export interface DataTypeRulesNumberRangeConfig {
|
|
262
|
+
__typename?: 'DataTypeRulesNumberRangeConfig';
|
|
263
|
+
/** The minimum value of the range */
|
|
264
|
+
from?: Maybe<Scalars['Int']['output']>;
|
|
265
|
+
/** The step value for the range, if applicable */
|
|
266
|
+
steps?: Maybe<Scalars['Int']['output']>;
|
|
267
|
+
/** The maximum value of the range */
|
|
268
|
+
to?: Maybe<Scalars['Int']['output']>;
|
|
269
|
+
}
|
|
270
|
+
|
|
271
|
+
/** Represents a rule that can be applied to a data type. */
|
|
272
|
+
export interface DataTypeRulesParentTypeConfig {
|
|
273
|
+
__typename?: 'DataTypeRulesParentTypeConfig';
|
|
274
|
+
/** The data type identifier for the parent type. */
|
|
275
|
+
dataTypeIdentifier?: Maybe<DataTypeIdentifier>;
|
|
276
|
+
}
|
|
277
|
+
|
|
278
|
+
/** Represents a rule that can be applied to a data type. */
|
|
279
|
+
export interface DataTypeRulesRegexConfig {
|
|
280
|
+
__typename?: 'DataTypeRulesRegexConfig';
|
|
281
|
+
/** The regex pattern to match against the data type value. */
|
|
282
|
+
pattern?: Maybe<Scalars['String']['output']>;
|
|
283
|
+
}
|
|
284
|
+
|
|
285
|
+
/** Represents a rule that can be applied to a data type. */
|
|
286
|
+
export interface DataTypeRulesReturnTypeConfig {
|
|
287
|
+
__typename?: 'DataTypeRulesReturnTypeConfig';
|
|
288
|
+
/** The data type identifier for the return type. */
|
|
289
|
+
dataTypeIdentifier?: Maybe<DataTypeIdentifier>;
|
|
290
|
+
}
|
|
291
|
+
|
|
292
|
+
/** The type of rule that can be applied to a data type. */
|
|
293
|
+
export const enum DataTypeRulesVariant {
|
|
294
|
+
/** The rule checks if a key is present in the data type. */
|
|
295
|
+
ContainsKey = 'CONTAINS_KEY',
|
|
296
|
+
/** The rule checks if a specific type is present in the data type. */
|
|
297
|
+
ContainsType = 'CONTAINS_TYPE',
|
|
298
|
+
/** The rule checks if the data type matches a specific input type. */
|
|
299
|
+
InputType = 'INPUT_TYPE',
|
|
300
|
+
/** The rule checks if an item is part of a collection in the data type. */
|
|
301
|
+
ItemOfCollection = 'ITEM_OF_COLLECTION',
|
|
302
|
+
/** The rule checks if a number falls within a specified range. */
|
|
303
|
+
NumberRange = 'NUMBER_RANGE',
|
|
304
|
+
/** The rule checks if the data type is a child of a specific parent type. */
|
|
305
|
+
ParentType = 'PARENT_TYPE',
|
|
306
|
+
/** The rule checks if a string matches a specified regular expression. */
|
|
307
|
+
Regex = 'REGEX',
|
|
308
|
+
/** The rule checks if the data type matches a specific return type. */
|
|
309
|
+
ReturnType = 'RETURN_TYPE'
|
|
310
|
+
}
|
|
311
|
+
|
|
128
312
|
/** Represent all available types of a datatype */
|
|
129
|
-
export enum DataTypeVariant {
|
|
313
|
+
export const enum DataTypeVariant {
|
|
130
314
|
/** Represents an array */
|
|
131
315
|
Array = 'ARRAY',
|
|
132
316
|
/** Represents an data type containing a data type */
|
|
133
317
|
DataType = 'DATA_TYPE',
|
|
318
|
+
/** Represents a error */
|
|
319
|
+
Error = 'ERROR',
|
|
320
|
+
/** Represents a node */
|
|
321
|
+
Node = 'NODE',
|
|
134
322
|
/** Represents an object */
|
|
135
323
|
Object = 'OBJECT',
|
|
136
324
|
/** Represents a primitive datatype */
|
|
@@ -153,13 +341,486 @@ export interface EchoPayload {
|
|
|
153
341
|
/** A unique identifier for the client performing the mutation. */
|
|
154
342
|
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
155
343
|
/** Errors encountered during execution of the mutation. */
|
|
156
|
-
errors
|
|
344
|
+
errors?: Maybe<Array<Error>>;
|
|
157
345
|
/** Message returned to the user. */
|
|
158
346
|
message?: Maybe<Scalars['String']['output']>;
|
|
159
347
|
}
|
|
160
348
|
|
|
161
349
|
/** Objects that can present an error */
|
|
162
|
-
export type Error = ActiveModelError | MessageError;
|
|
350
|
+
export type Error = ActiveModelError | ErrorCode | MessageError;
|
|
351
|
+
|
|
352
|
+
/** Represents an error code */
|
|
353
|
+
export interface ErrorCode {
|
|
354
|
+
__typename?: 'ErrorCode';
|
|
355
|
+
/** The error code */
|
|
356
|
+
errorCode?: Maybe<ErrorCodeEnum>;
|
|
357
|
+
}
|
|
358
|
+
|
|
359
|
+
/** Represents the available error responses */
|
|
360
|
+
export const enum ErrorCodeEnum {
|
|
361
|
+
/** This action would remove the last administrative role */
|
|
362
|
+
CannotDeleteLastAdminRole = 'CANNOT_DELETE_LAST_ADMIN_ROLE',
|
|
363
|
+
/** This action would remove the last administrator */
|
|
364
|
+
CannotRemoveLastAdministrator = 'CANNOT_REMOVE_LAST_ADMINISTRATOR',
|
|
365
|
+
/** This action would remove the last administrative ability */
|
|
366
|
+
CannotRemoveLastAdminAbility = 'CANNOT_REMOVE_LAST_ADMIN_ABILITY',
|
|
367
|
+
/** This external identity does not exist */
|
|
368
|
+
ExternalIdentityDoesNotExist = 'EXTERNAL_IDENTITY_DOES_NOT_EXIST',
|
|
369
|
+
/** The old backup codes could not be deleted */
|
|
370
|
+
FailedToInvalidateOldBackupCodes = 'FAILED_TO_INVALIDATE_OLD_BACKUP_CODES',
|
|
371
|
+
/** The new backup codes could not be saved */
|
|
372
|
+
FailedToSaveValidBackupCode = 'FAILED_TO_SAVE_VALID_BACKUP_CODE',
|
|
373
|
+
/** The given key was not found in the data type */
|
|
374
|
+
GenericKeyNotFound = 'GENERIC_KEY_NOT_FOUND',
|
|
375
|
+
/** Failed to validate the external identity */
|
|
376
|
+
IdentityValidationFailed = 'IDENTITY_VALIDATION_FAILED',
|
|
377
|
+
/** Resources are from different namespaces */
|
|
378
|
+
InconsistentNamespace = 'INCONSISTENT_NAMESPACE',
|
|
379
|
+
/** This external identity is invalid */
|
|
380
|
+
InvalidExternalIdentity = 'INVALID_EXTERNAL_IDENTITY',
|
|
381
|
+
/** Invalid login data provided */
|
|
382
|
+
InvalidLoginData = 'INVALID_LOGIN_DATA',
|
|
383
|
+
/** Invalid setting provided */
|
|
384
|
+
InvalidSetting = 'INVALID_SETTING',
|
|
385
|
+
/** Invalid verification code provided */
|
|
386
|
+
InvalidVerificationCode = 'INVALID_VERIFICATION_CODE',
|
|
387
|
+
/** Invalid MFA data provided */
|
|
388
|
+
MfaFailed = 'MFA_FAILED',
|
|
389
|
+
/** MFA is required */
|
|
390
|
+
MfaRequired = 'MFA_REQUIRED',
|
|
391
|
+
/** This external identity is missing data */
|
|
392
|
+
MissingIdentityData = 'MISSING_IDENTITY_DATA',
|
|
393
|
+
/** Not all required parameters are present */
|
|
394
|
+
MissingParameter = 'MISSING_PARAMETER',
|
|
395
|
+
/** The user is not permitted to perform this operation */
|
|
396
|
+
MissingPermission = 'MISSING_PERMISSION',
|
|
397
|
+
/** There are no free license seats to complete this operation */
|
|
398
|
+
NoFreeLicenseSeats = 'NO_FREE_LICENSE_SEATS',
|
|
399
|
+
/** The project does not have a primary runtime */
|
|
400
|
+
NoPrimaryRuntime = 'NO_PRIMARY_RUNTIME',
|
|
401
|
+
/** @deprecated Outdated concept */
|
|
402
|
+
PrimaryLevelNotFound = 'PRIMARY_LEVEL_NOT_FOUND',
|
|
403
|
+
/** Self-registration is disabled */
|
|
404
|
+
RegistrationDisabled = 'REGISTRATION_DISABLED',
|
|
405
|
+
/** Resources are from different runtimes */
|
|
406
|
+
RuntimeMismatch = 'RUNTIME_MISMATCH',
|
|
407
|
+
/** @deprecated Outdated concept */
|
|
408
|
+
SecondaryLevelNotFound = 'SECONDARY_LEVEL_NOT_FOUND',
|
|
409
|
+
/** @deprecated Outdated concept */
|
|
410
|
+
TertiaryLevelExceedsParameters = 'TERTIARY_LEVEL_EXCEEDS_PARAMETERS',
|
|
411
|
+
/** This user already has TOTP set up */
|
|
412
|
+
TotpSecretAlreadySet = 'TOTP_SECRET_ALREADY_SET',
|
|
413
|
+
/** The user is not permitted to modify this field */
|
|
414
|
+
UnmodifiableField = 'UNMODIFIABLE_FIELD',
|
|
415
|
+
/** Invalid TOTP code provided */
|
|
416
|
+
WrongTotp = 'WRONG_TOTP'
|
|
417
|
+
}
|
|
418
|
+
|
|
419
|
+
/** Represents a flow */
|
|
420
|
+
export interface Flow {
|
|
421
|
+
__typename?: 'Flow';
|
|
422
|
+
/** Time when this Flow was created */
|
|
423
|
+
createdAt?: Maybe<Scalars['Time']['output']>;
|
|
424
|
+
/** Global ID of this Flow */
|
|
425
|
+
id?: Maybe<Scalars['FlowID']['output']>;
|
|
426
|
+
/** The input data type of the flow */
|
|
427
|
+
inputType?: Maybe<DataType>;
|
|
428
|
+
/** Name of the flow */
|
|
429
|
+
name?: Maybe<Scalars['String']['output']>;
|
|
430
|
+
/** Nodes of the flow */
|
|
431
|
+
nodes?: Maybe<NodeFunctionConnection>;
|
|
432
|
+
/** The return data type of the flow */
|
|
433
|
+
returnType?: Maybe<DataType>;
|
|
434
|
+
/** The settings of the flow */
|
|
435
|
+
settings?: Maybe<FlowSettingConnection>;
|
|
436
|
+
/** The ID of the starting node of the flow */
|
|
437
|
+
startingNodeId?: Maybe<Scalars['NodeFunctionID']['output']>;
|
|
438
|
+
/** The flow type of the flow */
|
|
439
|
+
type?: Maybe<FlowType>;
|
|
440
|
+
/** Time when this Flow was last updated */
|
|
441
|
+
updatedAt?: Maybe<Scalars['Time']['output']>;
|
|
442
|
+
/** Abilities for the current user on this Flow */
|
|
443
|
+
userAbilities?: Maybe<FlowUserAbilities>;
|
|
444
|
+
}
|
|
445
|
+
|
|
446
|
+
|
|
447
|
+
/** Represents a flow */
|
|
448
|
+
export interface FlowNodesArgs {
|
|
449
|
+
after?: InputMaybe<Scalars['String']['input']>;
|
|
450
|
+
before?: InputMaybe<Scalars['String']['input']>;
|
|
451
|
+
first?: InputMaybe<Scalars['Int']['input']>;
|
|
452
|
+
last?: InputMaybe<Scalars['Int']['input']>;
|
|
453
|
+
}
|
|
454
|
+
|
|
455
|
+
|
|
456
|
+
/** Represents a flow */
|
|
457
|
+
export interface FlowSettingsArgs {
|
|
458
|
+
after?: InputMaybe<Scalars['String']['input']>;
|
|
459
|
+
before?: InputMaybe<Scalars['String']['input']>;
|
|
460
|
+
first?: InputMaybe<Scalars['Int']['input']>;
|
|
461
|
+
last?: InputMaybe<Scalars['Int']['input']>;
|
|
462
|
+
}
|
|
463
|
+
|
|
464
|
+
/** The connection type for Flow. */
|
|
465
|
+
export interface FlowConnection {
|
|
466
|
+
__typename?: 'FlowConnection';
|
|
467
|
+
/** Total count of collection. */
|
|
468
|
+
count?: Maybe<Scalars['Int']['output']>;
|
|
469
|
+
/** A list of edges. */
|
|
470
|
+
edges?: Maybe<Array<Maybe<FlowEdge>>>;
|
|
471
|
+
/** A list of nodes. */
|
|
472
|
+
nodes?: Maybe<Array<Maybe<Flow>>>;
|
|
473
|
+
/** Information to aid in pagination. */
|
|
474
|
+
pageInfo?: Maybe<PageInfo>;
|
|
475
|
+
}
|
|
476
|
+
|
|
477
|
+
/** An edge in a connection. */
|
|
478
|
+
export interface FlowEdge {
|
|
479
|
+
__typename?: 'FlowEdge';
|
|
480
|
+
/** A cursor for use in pagination. */
|
|
481
|
+
cursor?: Maybe<Scalars['String']['output']>;
|
|
482
|
+
/** The item at the end of the edge. */
|
|
483
|
+
node?: Maybe<Flow>;
|
|
484
|
+
}
|
|
485
|
+
|
|
486
|
+
/** Input type for creating or updating a flow */
|
|
487
|
+
export interface FlowInput {
|
|
488
|
+
/** The name of the flow */
|
|
489
|
+
name: Scalars['String']['input'];
|
|
490
|
+
/** The settings of the flow */
|
|
491
|
+
settings?: InputMaybe<Array<FlowSettingInput>>;
|
|
492
|
+
/** The starting node of the flow */
|
|
493
|
+
startingNode: NodeFunctionInput;
|
|
494
|
+
/** The identifier of the flow type */
|
|
495
|
+
type: Scalars['FlowTypeID']['input'];
|
|
496
|
+
}
|
|
497
|
+
|
|
498
|
+
/** Represents a flow setting */
|
|
499
|
+
export interface FlowSetting {
|
|
500
|
+
__typename?: 'FlowSetting';
|
|
501
|
+
/** Time when this FlowSetting was created */
|
|
502
|
+
createdAt?: Maybe<Scalars['Time']['output']>;
|
|
503
|
+
/** The identifier of the flow setting */
|
|
504
|
+
flowSettingIdentifier?: Maybe<Scalars['String']['output']>;
|
|
505
|
+
/** Global ID of this FlowSetting */
|
|
506
|
+
id?: Maybe<Scalars['FlowSettingID']['output']>;
|
|
507
|
+
/** Time when this FlowSetting was last updated */
|
|
508
|
+
updatedAt?: Maybe<Scalars['Time']['output']>;
|
|
509
|
+
/** The value of the flow setting */
|
|
510
|
+
value?: Maybe<Scalars['JSON']['output']>;
|
|
511
|
+
}
|
|
512
|
+
|
|
513
|
+
/** The connection type for FlowSetting. */
|
|
514
|
+
export interface FlowSettingConnection {
|
|
515
|
+
__typename?: 'FlowSettingConnection';
|
|
516
|
+
/** Total count of collection. */
|
|
517
|
+
count?: Maybe<Scalars['Int']['output']>;
|
|
518
|
+
/** A list of edges. */
|
|
519
|
+
edges?: Maybe<Array<Maybe<FlowSettingEdge>>>;
|
|
520
|
+
/** A list of nodes. */
|
|
521
|
+
nodes?: Maybe<Array<Maybe<FlowSetting>>>;
|
|
522
|
+
/** Information to aid in pagination. */
|
|
523
|
+
pageInfo?: Maybe<PageInfo>;
|
|
524
|
+
}
|
|
525
|
+
|
|
526
|
+
/** An edge in a connection. */
|
|
527
|
+
export interface FlowSettingEdge {
|
|
528
|
+
__typename?: 'FlowSettingEdge';
|
|
529
|
+
/** A cursor for use in pagination. */
|
|
530
|
+
cursor?: Maybe<Scalars['String']['output']>;
|
|
531
|
+
/** The item at the end of the edge. */
|
|
532
|
+
node?: Maybe<FlowSetting>;
|
|
533
|
+
}
|
|
534
|
+
|
|
535
|
+
/** Input type for flow settings */
|
|
536
|
+
export interface FlowSettingInput {
|
|
537
|
+
/** The identifier (not database id) of the flow setting */
|
|
538
|
+
flowSettingId: Scalars['String']['input'];
|
|
539
|
+
/** The value of the flow setting */
|
|
540
|
+
object: Scalars['JSON']['input'];
|
|
541
|
+
}
|
|
542
|
+
|
|
543
|
+
/** Represents a flow type */
|
|
544
|
+
export interface FlowType {
|
|
545
|
+
__typename?: 'FlowType';
|
|
546
|
+
/** Time when this FlowType was created */
|
|
547
|
+
createdAt?: Maybe<Scalars['Time']['output']>;
|
|
548
|
+
/** Descriptions of the flow type */
|
|
549
|
+
descriptions?: Maybe<TranslationConnection>;
|
|
550
|
+
/** Editable status of the flow type */
|
|
551
|
+
editable?: Maybe<Scalars['Boolean']['output']>;
|
|
552
|
+
/** Flow type settings of the flow type */
|
|
553
|
+
flowTypeSettings?: Maybe<Array<FlowTypeSetting>>;
|
|
554
|
+
/** Global ID of this FlowType */
|
|
555
|
+
id?: Maybe<Scalars['TypesFlowTypeID']['output']>;
|
|
556
|
+
/** Identifier of the flow type */
|
|
557
|
+
identifier?: Maybe<Scalars['String']['output']>;
|
|
558
|
+
/** Input type of the flow type */
|
|
559
|
+
inputType?: Maybe<DataType>;
|
|
560
|
+
/** Names of the flow type */
|
|
561
|
+
names?: Maybe<TranslationConnection>;
|
|
562
|
+
/** Return type of the flow type */
|
|
563
|
+
returnType?: Maybe<DataType>;
|
|
564
|
+
/** Time when this FlowType was last updated */
|
|
565
|
+
updatedAt?: Maybe<Scalars['Time']['output']>;
|
|
566
|
+
}
|
|
567
|
+
|
|
568
|
+
|
|
569
|
+
/** Represents a flow type */
|
|
570
|
+
export interface FlowTypeDescriptionsArgs {
|
|
571
|
+
after?: InputMaybe<Scalars['String']['input']>;
|
|
572
|
+
before?: InputMaybe<Scalars['String']['input']>;
|
|
573
|
+
first?: InputMaybe<Scalars['Int']['input']>;
|
|
574
|
+
last?: InputMaybe<Scalars['Int']['input']>;
|
|
575
|
+
}
|
|
576
|
+
|
|
577
|
+
|
|
578
|
+
/** Represents a flow type */
|
|
579
|
+
export interface FlowTypeNamesArgs {
|
|
580
|
+
after?: InputMaybe<Scalars['String']['input']>;
|
|
581
|
+
before?: InputMaybe<Scalars['String']['input']>;
|
|
582
|
+
first?: InputMaybe<Scalars['Int']['input']>;
|
|
583
|
+
last?: InputMaybe<Scalars['Int']['input']>;
|
|
584
|
+
}
|
|
585
|
+
|
|
586
|
+
/** The connection type for FlowType. */
|
|
587
|
+
export interface FlowTypeConnection {
|
|
588
|
+
__typename?: 'FlowTypeConnection';
|
|
589
|
+
/** Total count of collection. */
|
|
590
|
+
count?: Maybe<Scalars['Int']['output']>;
|
|
591
|
+
/** A list of edges. */
|
|
592
|
+
edges?: Maybe<Array<Maybe<FlowTypeEdge>>>;
|
|
593
|
+
/** A list of nodes. */
|
|
594
|
+
nodes?: Maybe<Array<Maybe<FlowType>>>;
|
|
595
|
+
/** Information to aid in pagination. */
|
|
596
|
+
pageInfo?: Maybe<PageInfo>;
|
|
597
|
+
}
|
|
598
|
+
|
|
599
|
+
/** An edge in a connection. */
|
|
600
|
+
export interface FlowTypeEdge {
|
|
601
|
+
__typename?: 'FlowTypeEdge';
|
|
602
|
+
/** A cursor for use in pagination. */
|
|
603
|
+
cursor?: Maybe<Scalars['String']['output']>;
|
|
604
|
+
/** The item at the end of the edge. */
|
|
605
|
+
node?: Maybe<FlowType>;
|
|
606
|
+
}
|
|
607
|
+
|
|
608
|
+
/** Represents a flow type setting */
|
|
609
|
+
export interface FlowTypeSetting {
|
|
610
|
+
__typename?: 'FlowTypeSetting';
|
|
611
|
+
/** Time when this FlowTypeSetting was created */
|
|
612
|
+
createdAt?: Maybe<Scalars['Time']['output']>;
|
|
613
|
+
/** Data type of the flow type setting */
|
|
614
|
+
dataType?: Maybe<DataType>;
|
|
615
|
+
/** Descriptions of the flow type setting */
|
|
616
|
+
descriptions?: Maybe<TranslationConnection>;
|
|
617
|
+
/** Flow type of the flow type setting */
|
|
618
|
+
flowType?: Maybe<FlowType>;
|
|
619
|
+
/** Global ID of this FlowTypeSetting */
|
|
620
|
+
id?: Maybe<Scalars['FlowTypeSettingID']['output']>;
|
|
621
|
+
/** Identifier of the flow type setting */
|
|
622
|
+
identifier?: Maybe<Scalars['String']['output']>;
|
|
623
|
+
/** Names of the flow type setting */
|
|
624
|
+
names?: Maybe<TranslationConnection>;
|
|
625
|
+
/** Unique status of the flow type setting */
|
|
626
|
+
unique?: Maybe<Scalars['Boolean']['output']>;
|
|
627
|
+
/** Time when this FlowTypeSetting was last updated */
|
|
628
|
+
updatedAt?: Maybe<Scalars['Time']['output']>;
|
|
629
|
+
}
|
|
630
|
+
|
|
631
|
+
|
|
632
|
+
/** Represents a flow type setting */
|
|
633
|
+
export interface FlowTypeSettingDescriptionsArgs {
|
|
634
|
+
after?: InputMaybe<Scalars['String']['input']>;
|
|
635
|
+
before?: InputMaybe<Scalars['String']['input']>;
|
|
636
|
+
first?: InputMaybe<Scalars['Int']['input']>;
|
|
637
|
+
last?: InputMaybe<Scalars['Int']['input']>;
|
|
638
|
+
}
|
|
639
|
+
|
|
640
|
+
|
|
641
|
+
/** Represents a flow type setting */
|
|
642
|
+
export interface FlowTypeSettingNamesArgs {
|
|
643
|
+
after?: InputMaybe<Scalars['String']['input']>;
|
|
644
|
+
before?: InputMaybe<Scalars['String']['input']>;
|
|
645
|
+
first?: InputMaybe<Scalars['Int']['input']>;
|
|
646
|
+
last?: InputMaybe<Scalars['Int']['input']>;
|
|
647
|
+
}
|
|
648
|
+
|
|
649
|
+
/** Abilities for the current user on this Flow */
|
|
650
|
+
export interface FlowUserAbilities {
|
|
651
|
+
__typename?: 'FlowUserAbilities';
|
|
652
|
+
/** Shows if the current user has the `delete_flow` ability on this Flow */
|
|
653
|
+
deleteFlow?: Maybe<Scalars['Boolean']['output']>;
|
|
654
|
+
}
|
|
655
|
+
|
|
656
|
+
/** Represents a function definition */
|
|
657
|
+
export interface FunctionDefinition {
|
|
658
|
+
__typename?: 'FunctionDefinition';
|
|
659
|
+
/** Time when this FunctionDefinition was created */
|
|
660
|
+
createdAt?: Maybe<Scalars['Time']['output']>;
|
|
661
|
+
/** Deprecation message of the function */
|
|
662
|
+
deprecationMessages?: Maybe<TranslationConnection>;
|
|
663
|
+
/** Description of the function */
|
|
664
|
+
descriptions?: Maybe<TranslationConnection>;
|
|
665
|
+
/** Documentation of the function */
|
|
666
|
+
documentations?: Maybe<TranslationConnection>;
|
|
667
|
+
/** Generic keys of the function */
|
|
668
|
+
genericKeys?: Maybe<Array<Scalars['String']['output']>>;
|
|
669
|
+
/** Global ID of this FunctionDefinition */
|
|
670
|
+
id?: Maybe<Scalars['FunctionDefinitionID']['output']>;
|
|
671
|
+
/** Identifier of the function */
|
|
672
|
+
identifier?: Maybe<Scalars['String']['output']>;
|
|
673
|
+
/** Name of the function */
|
|
674
|
+
names?: Maybe<TranslationConnection>;
|
|
675
|
+
/** Parameters of the function */
|
|
676
|
+
parameterDefinitions?: Maybe<ParameterDefinitionConnection>;
|
|
677
|
+
/** Return type of the function */
|
|
678
|
+
returnType?: Maybe<DataTypeIdentifier>;
|
|
679
|
+
/** Runtime function definition */
|
|
680
|
+
runtimeFunctionDefinition?: Maybe<RuntimeFunctionDefinition>;
|
|
681
|
+
/** Indicates if the function can throw an error */
|
|
682
|
+
throwsError?: Maybe<Scalars['Boolean']['output']>;
|
|
683
|
+
/** Time when this FunctionDefinition was last updated */
|
|
684
|
+
updatedAt?: Maybe<Scalars['Time']['output']>;
|
|
685
|
+
}
|
|
686
|
+
|
|
687
|
+
|
|
688
|
+
/** Represents a function definition */
|
|
689
|
+
export interface FunctionDefinitionDeprecationMessagesArgs {
|
|
690
|
+
after?: InputMaybe<Scalars['String']['input']>;
|
|
691
|
+
before?: InputMaybe<Scalars['String']['input']>;
|
|
692
|
+
first?: InputMaybe<Scalars['Int']['input']>;
|
|
693
|
+
last?: InputMaybe<Scalars['Int']['input']>;
|
|
694
|
+
}
|
|
695
|
+
|
|
696
|
+
|
|
697
|
+
/** Represents a function definition */
|
|
698
|
+
export interface FunctionDefinitionDescriptionsArgs {
|
|
699
|
+
after?: InputMaybe<Scalars['String']['input']>;
|
|
700
|
+
before?: InputMaybe<Scalars['String']['input']>;
|
|
701
|
+
first?: InputMaybe<Scalars['Int']['input']>;
|
|
702
|
+
last?: InputMaybe<Scalars['Int']['input']>;
|
|
703
|
+
}
|
|
704
|
+
|
|
705
|
+
|
|
706
|
+
/** Represents a function definition */
|
|
707
|
+
export interface FunctionDefinitionDocumentationsArgs {
|
|
708
|
+
after?: InputMaybe<Scalars['String']['input']>;
|
|
709
|
+
before?: InputMaybe<Scalars['String']['input']>;
|
|
710
|
+
first?: InputMaybe<Scalars['Int']['input']>;
|
|
711
|
+
last?: InputMaybe<Scalars['Int']['input']>;
|
|
712
|
+
}
|
|
713
|
+
|
|
714
|
+
|
|
715
|
+
/** Represents a function definition */
|
|
716
|
+
export interface FunctionDefinitionNamesArgs {
|
|
717
|
+
after?: InputMaybe<Scalars['String']['input']>;
|
|
718
|
+
before?: InputMaybe<Scalars['String']['input']>;
|
|
719
|
+
first?: InputMaybe<Scalars['Int']['input']>;
|
|
720
|
+
last?: InputMaybe<Scalars['Int']['input']>;
|
|
721
|
+
}
|
|
722
|
+
|
|
723
|
+
|
|
724
|
+
/** Represents a function definition */
|
|
725
|
+
export interface FunctionDefinitionParameterDefinitionsArgs {
|
|
726
|
+
after?: InputMaybe<Scalars['String']['input']>;
|
|
727
|
+
before?: InputMaybe<Scalars['String']['input']>;
|
|
728
|
+
first?: InputMaybe<Scalars['Int']['input']>;
|
|
729
|
+
last?: InputMaybe<Scalars['Int']['input']>;
|
|
730
|
+
}
|
|
731
|
+
|
|
732
|
+
/** The connection type for FunctionDefinition. */
|
|
733
|
+
export interface FunctionDefinitionConnection {
|
|
734
|
+
__typename?: 'FunctionDefinitionConnection';
|
|
735
|
+
/** Total count of collection. */
|
|
736
|
+
count?: Maybe<Scalars['Int']['output']>;
|
|
737
|
+
/** A list of edges. */
|
|
738
|
+
edges?: Maybe<Array<Maybe<FunctionDefinitionEdge>>>;
|
|
739
|
+
/** A list of nodes. */
|
|
740
|
+
nodes?: Maybe<Array<Maybe<FunctionDefinition>>>;
|
|
741
|
+
/** Information to aid in pagination. */
|
|
742
|
+
pageInfo?: Maybe<PageInfo>;
|
|
743
|
+
}
|
|
744
|
+
|
|
745
|
+
/** An edge in a connection. */
|
|
746
|
+
export interface FunctionDefinitionEdge {
|
|
747
|
+
__typename?: 'FunctionDefinitionEdge';
|
|
748
|
+
/** A cursor for use in pagination. */
|
|
749
|
+
cursor?: Maybe<Scalars['String']['output']>;
|
|
750
|
+
/** The item at the end of the edge. */
|
|
751
|
+
node?: Maybe<FunctionDefinition>;
|
|
752
|
+
}
|
|
753
|
+
|
|
754
|
+
/** Represents a combination strategy with AND/OR logic used by a generic mapper. */
|
|
755
|
+
export interface GenericCombinationStrategy {
|
|
756
|
+
__typename?: 'GenericCombinationStrategy';
|
|
757
|
+
/** Time when this GenericCombinationStrategy was created */
|
|
758
|
+
createdAt?: Maybe<Scalars['Time']['output']>;
|
|
759
|
+
/** The associated generic mapper, if any. */
|
|
760
|
+
genericMapper?: Maybe<GenericMapper>;
|
|
761
|
+
/** Global ID of this GenericCombinationStrategy */
|
|
762
|
+
id?: Maybe<Scalars['GenericCombinationStrategyID']['output']>;
|
|
763
|
+
/** The combination type ('AND' or 'OR'). */
|
|
764
|
+
type?: Maybe<GenericCombinationStrategyType>;
|
|
765
|
+
/** Time when this GenericCombinationStrategy was last updated */
|
|
766
|
+
updatedAt?: Maybe<Scalars['Time']['output']>;
|
|
767
|
+
}
|
|
768
|
+
|
|
769
|
+
/** The available combination strategy types. */
|
|
770
|
+
export const enum GenericCombinationStrategyType {
|
|
771
|
+
/** Represents a logical AND combination. */
|
|
772
|
+
And = 'AND',
|
|
773
|
+
/** Represents a logical OR combination. */
|
|
774
|
+
Or = 'OR'
|
|
775
|
+
}
|
|
776
|
+
|
|
777
|
+
/** Represents a mapping between a source data type and a target key for generic values. */
|
|
778
|
+
export interface GenericMapper {
|
|
779
|
+
__typename?: 'GenericMapper';
|
|
780
|
+
/** Time when this GenericMapper was created */
|
|
781
|
+
createdAt?: Maybe<Scalars['Time']['output']>;
|
|
782
|
+
/** Combination strategies associated with this generic mapper. */
|
|
783
|
+
genericCombinationStrategies?: Maybe<Array<GenericCombinationStrategy>>;
|
|
784
|
+
/** Global ID of this GenericMapper */
|
|
785
|
+
id?: Maybe<Scalars['GenericMapperID']['output']>;
|
|
786
|
+
/** The source data type identifier. */
|
|
787
|
+
sourceDataTypeIdentifiers?: Maybe<Array<DataTypeIdentifier>>;
|
|
788
|
+
/** The target key for the generic value. */
|
|
789
|
+
target?: Maybe<Scalars['String']['output']>;
|
|
790
|
+
/** Time when this GenericMapper was last updated */
|
|
791
|
+
updatedAt?: Maybe<Scalars['Time']['output']>;
|
|
792
|
+
}
|
|
793
|
+
|
|
794
|
+
/** Input type for generic mappers */
|
|
795
|
+
export interface GenericMapperInput {
|
|
796
|
+
/** The source data type identifier for the mapper */
|
|
797
|
+
sources: Array<DataTypeIdentifierInput>;
|
|
798
|
+
/** The target data type identifier for the mapper */
|
|
799
|
+
target: Scalars['String']['input'];
|
|
800
|
+
}
|
|
801
|
+
|
|
802
|
+
/** Represents a generic type that can be used in various contexts. */
|
|
803
|
+
export interface GenericType {
|
|
804
|
+
__typename?: 'GenericType';
|
|
805
|
+
/** Time when this GenericType was created */
|
|
806
|
+
createdAt?: Maybe<Scalars['Time']['output']>;
|
|
807
|
+
/** The data type associated with this generic type. */
|
|
808
|
+
dataType?: Maybe<DataType>;
|
|
809
|
+
/** The mappers associated with this generic type. */
|
|
810
|
+
genericMappers?: Maybe<Array<GenericMapper>>;
|
|
811
|
+
/** Global ID of this GenericType */
|
|
812
|
+
id?: Maybe<Scalars['GenericTypeID']['output']>;
|
|
813
|
+
/** Time when this GenericType was last updated */
|
|
814
|
+
updatedAt?: Maybe<Scalars['Time']['output']>;
|
|
815
|
+
}
|
|
816
|
+
|
|
817
|
+
/** Input type for generic type operations. */
|
|
818
|
+
export interface GenericTypeInput {
|
|
819
|
+
/** The data type associated with this generic type. */
|
|
820
|
+
dataTypeId: Scalars['DataTypeID']['input'];
|
|
821
|
+
/** The mappers associated with this generic type. */
|
|
822
|
+
genericMappers: Array<GenericMapperInput>;
|
|
823
|
+
}
|
|
163
824
|
|
|
164
825
|
/** Represents the input for external user identity validation */
|
|
165
826
|
export interface IdentityInput {
|
|
@@ -167,11 +828,39 @@ export interface IdentityInput {
|
|
|
167
828
|
code?: InputMaybe<Scalars['String']['input']>;
|
|
168
829
|
}
|
|
169
830
|
|
|
831
|
+
/** Abilities for the current user on this Instance */
|
|
832
|
+
export interface InstanceUserAbilities {
|
|
833
|
+
__typename?: 'InstanceUserAbilities';
|
|
834
|
+
/** Shows if the current user has the `create_organization` ability on this Instance */
|
|
835
|
+
createOrganization?: Maybe<Scalars['Boolean']['output']>;
|
|
836
|
+
/** Shows if the current user has the `create_runtime` ability on this Instance */
|
|
837
|
+
createRuntime?: Maybe<Scalars['Boolean']['output']>;
|
|
838
|
+
/** Shows if the current user has the `delete_runtime` ability on this Instance */
|
|
839
|
+
deleteRuntime?: Maybe<Scalars['Boolean']['output']>;
|
|
840
|
+
/** Shows if the current user has the `rotate_runtime_token` ability on this Instance */
|
|
841
|
+
rotateRuntimeToken?: Maybe<Scalars['Boolean']['output']>;
|
|
842
|
+
/** Shows if the current user has the `update_application_setting` ability on this Instance */
|
|
843
|
+
updateApplicationSetting?: Maybe<Scalars['Boolean']['output']>;
|
|
844
|
+
/** Shows if the current user has the `update_runtime` ability on this Instance */
|
|
845
|
+
updateRuntime?: Maybe<Scalars['Boolean']['output']>;
|
|
846
|
+
}
|
|
847
|
+
|
|
848
|
+
/** Represents a literal value, such as a string or number. */
|
|
849
|
+
export interface LiteralValue {
|
|
850
|
+
__typename?: 'LiteralValue';
|
|
851
|
+
/** Time when this LiteralValue was created */
|
|
852
|
+
createdAt?: Maybe<Scalars['Time']['output']>;
|
|
853
|
+
/** Time when this LiteralValue was last updated */
|
|
854
|
+
updatedAt?: Maybe<Scalars['Time']['output']>;
|
|
855
|
+
/** The literal value itself as JSON. */
|
|
856
|
+
value?: Maybe<Scalars['JSON']['output']>;
|
|
857
|
+
}
|
|
858
|
+
|
|
170
859
|
/** Represents an error message */
|
|
171
860
|
export interface MessageError {
|
|
172
861
|
__typename?: 'MessageError';
|
|
173
862
|
/** The message provided from the error */
|
|
174
|
-
message
|
|
863
|
+
message?: Maybe<Scalars['String']['output']>;
|
|
175
864
|
}
|
|
176
865
|
|
|
177
866
|
/** Represents the input for mfa authentication */
|
|
@@ -183,7 +872,7 @@ export interface MfaInput {
|
|
|
183
872
|
}
|
|
184
873
|
|
|
185
874
|
/** Represent all available types to authenticate with mfa */
|
|
186
|
-
export enum MfaType {
|
|
875
|
+
export const enum MfaType {
|
|
187
876
|
/** Single use backup code */
|
|
188
877
|
BackupCode = 'BACKUP_CODE',
|
|
189
878
|
/** Time based onetime password */
|
|
@@ -200,11 +889,12 @@ export interface Mutation {
|
|
|
200
889
|
*
|
|
201
890
|
* This is expected to be used for testing of endpoints, to verify
|
|
202
891
|
* that a user has mutation access.
|
|
892
|
+
*
|
|
203
893
|
*/
|
|
204
894
|
echo?: Maybe<EchoPayload>;
|
|
205
|
-
/** Create a new namespace license. */
|
|
895
|
+
/** (EE only) Create a new namespace license. */
|
|
206
896
|
namespacesLicensesCreate?: Maybe<NamespacesLicensesCreatePayload>;
|
|
207
|
-
/** Deletes an namespace license. */
|
|
897
|
+
/** (EE only) Deletes an namespace license. */
|
|
208
898
|
namespacesLicensesDelete?: Maybe<NamespacesLicensesDeletePayload>;
|
|
209
899
|
/** Update the roles a member is assigned to. */
|
|
210
900
|
namespacesMembersAssignRoles?: Maybe<NamespacesMembersAssignRolesPayload>;
|
|
@@ -212,10 +902,16 @@ export interface Mutation {
|
|
|
212
902
|
namespacesMembersDelete?: Maybe<NamespacesMembersDeletePayload>;
|
|
213
903
|
/** Invite a new member to a namespace. */
|
|
214
904
|
namespacesMembersInvite?: Maybe<NamespacesMembersInvitePayload>;
|
|
905
|
+
/** Assign runtimes to a project */
|
|
906
|
+
namespacesProjectsAssignRuntimes?: Maybe<NamespacesProjectsAssignRuntimesPayload>;
|
|
215
907
|
/** Creates a new namespace project. */
|
|
216
908
|
namespacesProjectsCreate?: Maybe<NamespacesProjectsCreatePayload>;
|
|
217
909
|
/** Deletes a namespace project. */
|
|
218
910
|
namespacesProjectsDelete?: Maybe<NamespacesProjectsDeletePayload>;
|
|
911
|
+
/** Creates a new flow. */
|
|
912
|
+
namespacesProjectsFlowsCreate?: Maybe<NamespacesProjectsFlowsCreatePayload>;
|
|
913
|
+
/** Deletes a namespace project. */
|
|
914
|
+
namespacesProjectsFlowsDelete?: Maybe<NamespacesProjectsFlowsDeletePayload>;
|
|
219
915
|
/** Updates a namespace project. */
|
|
220
916
|
namespacesProjectsUpdate?: Maybe<NamespacesProjectsUpdatePayload>;
|
|
221
917
|
/** Update the abilities a role is granted. */
|
|
@@ -242,6 +938,8 @@ export interface Mutation {
|
|
|
242
938
|
runtimesRotateToken?: Maybe<RuntimesRotateTokenPayload>;
|
|
243
939
|
/** Update an existing runtime. */
|
|
244
940
|
runtimesUpdate?: Maybe<RuntimesUpdatePayload>;
|
|
941
|
+
/** Verify your email when changing it or signing up */
|
|
942
|
+
usersEmailVerification?: Maybe<UsersEmailVerificationPayload>;
|
|
245
943
|
/** Links an external identity to an existing user */
|
|
246
944
|
usersIdentityLink?: Maybe<UsersIdentityLinkPayload>;
|
|
247
945
|
/** Login to an existing user via an external identity */
|
|
@@ -260,6 +958,10 @@ export interface Mutation {
|
|
|
260
958
|
usersMfaTotpGenerateSecret?: Maybe<UsersMfaTotpGenerateSecretPayload>;
|
|
261
959
|
/** Validates a TOTP value for the given secret and enables TOTP MFA for the user */
|
|
262
960
|
usersMfaTotpValidateSecret?: Maybe<UsersMfaTotpValidateSecretPayload>;
|
|
961
|
+
/** Reset the password using a reset token */
|
|
962
|
+
usersPasswordReset?: Maybe<UsersPasswordResetPayload>;
|
|
963
|
+
/** Request an password reset */
|
|
964
|
+
usersPasswordResetRequest?: Maybe<UsersPasswordResetRequestPayload>;
|
|
263
965
|
/** Register a new user */
|
|
264
966
|
usersRegister?: Maybe<UsersRegisterPayload>;
|
|
265
967
|
/** Update an existing user. */
|
|
@@ -309,6 +1011,12 @@ export interface MutationNamespacesMembersInviteArgs {
|
|
|
309
1011
|
}
|
|
310
1012
|
|
|
311
1013
|
|
|
1014
|
+
/** Root Mutation type */
|
|
1015
|
+
export interface MutationNamespacesProjectsAssignRuntimesArgs {
|
|
1016
|
+
input: NamespacesProjectsAssignRuntimesInput;
|
|
1017
|
+
}
|
|
1018
|
+
|
|
1019
|
+
|
|
312
1020
|
/** Root Mutation type */
|
|
313
1021
|
export interface MutationNamespacesProjectsCreateArgs {
|
|
314
1022
|
input: NamespacesProjectsCreateInput;
|
|
@@ -321,6 +1029,18 @@ export interface MutationNamespacesProjectsDeleteArgs {
|
|
|
321
1029
|
}
|
|
322
1030
|
|
|
323
1031
|
|
|
1032
|
+
/** Root Mutation type */
|
|
1033
|
+
export interface MutationNamespacesProjectsFlowsCreateArgs {
|
|
1034
|
+
input: NamespacesProjectsFlowsCreateInput;
|
|
1035
|
+
}
|
|
1036
|
+
|
|
1037
|
+
|
|
1038
|
+
/** Root Mutation type */
|
|
1039
|
+
export interface MutationNamespacesProjectsFlowsDeleteArgs {
|
|
1040
|
+
input: NamespacesProjectsFlowsDeleteInput;
|
|
1041
|
+
}
|
|
1042
|
+
|
|
1043
|
+
|
|
324
1044
|
/** Root Mutation type */
|
|
325
1045
|
export interface MutationNamespacesProjectsUpdateArgs {
|
|
326
1046
|
input: NamespacesProjectsUpdateInput;
|
|
@@ -399,6 +1119,12 @@ export interface MutationRuntimesUpdateArgs {
|
|
|
399
1119
|
}
|
|
400
1120
|
|
|
401
1121
|
|
|
1122
|
+
/** Root Mutation type */
|
|
1123
|
+
export interface MutationUsersEmailVerificationArgs {
|
|
1124
|
+
input: UsersEmailVerificationInput;
|
|
1125
|
+
}
|
|
1126
|
+
|
|
1127
|
+
|
|
402
1128
|
/** Root Mutation type */
|
|
403
1129
|
export interface MutationUsersIdentityLinkArgs {
|
|
404
1130
|
input: UsersIdentityLinkInput;
|
|
@@ -453,6 +1179,18 @@ export interface MutationUsersMfaTotpValidateSecretArgs {
|
|
|
453
1179
|
}
|
|
454
1180
|
|
|
455
1181
|
|
|
1182
|
+
/** Root Mutation type */
|
|
1183
|
+
export interface MutationUsersPasswordResetArgs {
|
|
1184
|
+
input: UsersPasswordResetInput;
|
|
1185
|
+
}
|
|
1186
|
+
|
|
1187
|
+
|
|
1188
|
+
/** Root Mutation type */
|
|
1189
|
+
export interface MutationUsersPasswordResetRequestArgs {
|
|
1190
|
+
input: UsersPasswordResetRequestInput;
|
|
1191
|
+
}
|
|
1192
|
+
|
|
1193
|
+
|
|
456
1194
|
/** Root Mutation type */
|
|
457
1195
|
export interface MutationUsersRegisterArgs {
|
|
458
1196
|
input: UsersRegisterInput;
|
|
@@ -468,23 +1206,27 @@ export interface MutationUsersUpdateArgs {
|
|
|
468
1206
|
export interface Namespace {
|
|
469
1207
|
__typename?: 'Namespace';
|
|
470
1208
|
/** Time when this Namespace was created */
|
|
471
|
-
createdAt
|
|
1209
|
+
createdAt?: Maybe<Scalars['Time']['output']>;
|
|
1210
|
+
/** (EE only) Currently active license of the namespace */
|
|
1211
|
+
currentNamespaceLicense?: Maybe<NamespaceLicense>;
|
|
472
1212
|
/** Global ID of this Namespace */
|
|
473
|
-
id
|
|
1213
|
+
id?: Maybe<Scalars['NamespaceID']['output']>;
|
|
474
1214
|
/** Members of the namespace */
|
|
475
|
-
members
|
|
476
|
-
/** Licenses of the namespace */
|
|
477
|
-
namespaceLicenses
|
|
1215
|
+
members?: Maybe<NamespaceMemberConnection>;
|
|
1216
|
+
/** (EE only) Licenses of the namespace */
|
|
1217
|
+
namespaceLicenses?: Maybe<NamespaceLicenseConnection>;
|
|
478
1218
|
/** Parent of this namespace */
|
|
479
|
-
parent
|
|
1219
|
+
parent?: Maybe<NamespaceParent>;
|
|
480
1220
|
/** Projects of the namespace */
|
|
481
|
-
projects
|
|
1221
|
+
projects?: Maybe<NamespaceProjectConnection>;
|
|
482
1222
|
/** Roles of the namespace */
|
|
483
|
-
roles
|
|
1223
|
+
roles?: Maybe<NamespaceRoleConnection>;
|
|
484
1224
|
/** Runtime of the namespace */
|
|
485
|
-
runtimes
|
|
1225
|
+
runtimes?: Maybe<RuntimeConnection>;
|
|
486
1226
|
/** Time when this Namespace was last updated */
|
|
487
|
-
updatedAt
|
|
1227
|
+
updatedAt?: Maybe<Scalars['Time']['output']>;
|
|
1228
|
+
/** Abilities for the current user on this Namespace */
|
|
1229
|
+
userAbilities?: Maybe<NamespaceUserAbilities>;
|
|
488
1230
|
}
|
|
489
1231
|
|
|
490
1232
|
|
|
@@ -532,74 +1274,113 @@ export interface NamespaceRuntimesArgs {
|
|
|
532
1274
|
last?: InputMaybe<Scalars['Int']['input']>;
|
|
533
1275
|
}
|
|
534
1276
|
|
|
535
|
-
/** Represents a Namespace License */
|
|
1277
|
+
/** (EE only) Represents a Namespace License */
|
|
536
1278
|
export interface NamespaceLicense {
|
|
537
1279
|
__typename?: 'NamespaceLicense';
|
|
538
1280
|
/** Time when this NamespaceLicense was created */
|
|
539
|
-
createdAt
|
|
1281
|
+
createdAt?: Maybe<Scalars['Time']['output']>;
|
|
1282
|
+
/** The end date of the license */
|
|
1283
|
+
endDate?: Maybe<Scalars['Time']['output']>;
|
|
540
1284
|
/** Global ID of this NamespaceLicense */
|
|
541
|
-
id
|
|
1285
|
+
id?: Maybe<Scalars['NamespaceLicenseID']['output']>;
|
|
1286
|
+
/** The licensee information */
|
|
1287
|
+
licensee?: Maybe<Scalars['JSON']['output']>;
|
|
542
1288
|
/** The namespace the license belongs to */
|
|
543
|
-
namespace
|
|
1289
|
+
namespace?: Maybe<Namespace>;
|
|
1290
|
+
/** The start date of the license */
|
|
1291
|
+
startDate?: Maybe<Scalars['Time']['output']>;
|
|
544
1292
|
/** Time when this NamespaceLicense was last updated */
|
|
545
|
-
updatedAt
|
|
1293
|
+
updatedAt?: Maybe<Scalars['Time']['output']>;
|
|
1294
|
+
/** Abilities for the current user on this NamespaceLicense */
|
|
1295
|
+
userAbilities?: Maybe<NamespaceLicenseUserAbilities>;
|
|
546
1296
|
}
|
|
547
1297
|
|
|
548
1298
|
/** The connection type for NamespaceLicense. */
|
|
549
1299
|
export interface NamespaceLicenseConnection {
|
|
550
1300
|
__typename?: 'NamespaceLicenseConnection';
|
|
551
1301
|
/** Total count of collection. */
|
|
552
|
-
count
|
|
1302
|
+
count?: Maybe<Scalars['Int']['output']>;
|
|
553
1303
|
/** A list of edges. */
|
|
554
1304
|
edges?: Maybe<Array<Maybe<NamespaceLicenseEdge>>>;
|
|
555
1305
|
/** A list of nodes. */
|
|
556
1306
|
nodes?: Maybe<Array<Maybe<NamespaceLicense>>>;
|
|
557
1307
|
/** Information to aid in pagination. */
|
|
558
|
-
pageInfo
|
|
1308
|
+
pageInfo?: Maybe<PageInfo>;
|
|
559
1309
|
}
|
|
560
1310
|
|
|
561
1311
|
/** An edge in a connection. */
|
|
562
1312
|
export interface NamespaceLicenseEdge {
|
|
563
1313
|
__typename?: 'NamespaceLicenseEdge';
|
|
564
1314
|
/** A cursor for use in pagination. */
|
|
565
|
-
cursor
|
|
1315
|
+
cursor?: Maybe<Scalars['String']['output']>;
|
|
566
1316
|
/** The item at the end of the edge. */
|
|
567
1317
|
node?: Maybe<NamespaceLicense>;
|
|
568
1318
|
}
|
|
569
1319
|
|
|
1320
|
+
/** Abilities for the current user on this NamespaceLicense */
|
|
1321
|
+
export interface NamespaceLicenseUserAbilities {
|
|
1322
|
+
__typename?: 'NamespaceLicenseUserAbilities';
|
|
1323
|
+
/** Shows if the current user has the `delete_namespace_license` ability on this NamespaceLicense */
|
|
1324
|
+
deleteNamespaceLicense?: Maybe<Scalars['Boolean']['output']>;
|
|
1325
|
+
}
|
|
1326
|
+
|
|
570
1327
|
/** Represents a namespace member */
|
|
571
1328
|
export interface NamespaceMember {
|
|
572
1329
|
__typename?: 'NamespaceMember';
|
|
573
1330
|
/** Time when this NamespaceMember was created */
|
|
574
|
-
createdAt
|
|
1331
|
+
createdAt?: Maybe<Scalars['Time']['output']>;
|
|
575
1332
|
/** Global ID of this NamespaceMember */
|
|
576
|
-
id
|
|
1333
|
+
id?: Maybe<Scalars['NamespaceMemberID']['output']>;
|
|
1334
|
+
/** Memberroles of the member */
|
|
1335
|
+
memberRoles?: Maybe<NamespaceMemberRoleConnection>;
|
|
577
1336
|
/** Namespace this member belongs to */
|
|
578
|
-
namespace
|
|
1337
|
+
namespace?: Maybe<Namespace>;
|
|
1338
|
+
/** Roles of the member */
|
|
1339
|
+
roles?: Maybe<NamespaceRoleConnection>;
|
|
579
1340
|
/** Time when this NamespaceMember was last updated */
|
|
580
|
-
updatedAt
|
|
1341
|
+
updatedAt?: Maybe<Scalars['Time']['output']>;
|
|
581
1342
|
/** User this member belongs to */
|
|
582
|
-
user
|
|
1343
|
+
user?: Maybe<User>;
|
|
1344
|
+
/** Abilities for the current user on this NamespaceMember */
|
|
1345
|
+
userAbilities?: Maybe<NamespaceMemberUserAbilities>;
|
|
1346
|
+
}
|
|
1347
|
+
|
|
1348
|
+
|
|
1349
|
+
/** Represents a namespace member */
|
|
1350
|
+
export interface NamespaceMemberMemberRolesArgs {
|
|
1351
|
+
after?: InputMaybe<Scalars['String']['input']>;
|
|
1352
|
+
before?: InputMaybe<Scalars['String']['input']>;
|
|
1353
|
+
first?: InputMaybe<Scalars['Int']['input']>;
|
|
1354
|
+
last?: InputMaybe<Scalars['Int']['input']>;
|
|
1355
|
+
}
|
|
1356
|
+
|
|
1357
|
+
|
|
1358
|
+
/** Represents a namespace member */
|
|
1359
|
+
export interface NamespaceMemberRolesArgs {
|
|
1360
|
+
after?: InputMaybe<Scalars['String']['input']>;
|
|
1361
|
+
before?: InputMaybe<Scalars['String']['input']>;
|
|
1362
|
+
first?: InputMaybe<Scalars['Int']['input']>;
|
|
1363
|
+
last?: InputMaybe<Scalars['Int']['input']>;
|
|
583
1364
|
}
|
|
584
1365
|
|
|
585
1366
|
/** The connection type for NamespaceMember. */
|
|
586
1367
|
export interface NamespaceMemberConnection {
|
|
587
1368
|
__typename?: 'NamespaceMemberConnection';
|
|
588
1369
|
/** Total count of collection. */
|
|
589
|
-
count
|
|
1370
|
+
count?: Maybe<Scalars['Int']['output']>;
|
|
590
1371
|
/** A list of edges. */
|
|
591
1372
|
edges?: Maybe<Array<Maybe<NamespaceMemberEdge>>>;
|
|
592
1373
|
/** A list of nodes. */
|
|
593
1374
|
nodes?: Maybe<Array<Maybe<NamespaceMember>>>;
|
|
594
1375
|
/** Information to aid in pagination. */
|
|
595
|
-
pageInfo
|
|
1376
|
+
pageInfo?: Maybe<PageInfo>;
|
|
596
1377
|
}
|
|
597
1378
|
|
|
598
1379
|
/** An edge in a connection. */
|
|
599
1380
|
export interface NamespaceMemberEdge {
|
|
600
1381
|
__typename?: 'NamespaceMemberEdge';
|
|
601
1382
|
/** A cursor for use in pagination. */
|
|
602
|
-
cursor
|
|
1383
|
+
cursor?: Maybe<Scalars['String']['output']>;
|
|
603
1384
|
/** The item at the end of the edge. */
|
|
604
1385
|
node?: Maybe<NamespaceMember>;
|
|
605
1386
|
}
|
|
@@ -608,76 +1389,156 @@ export interface NamespaceMemberEdge {
|
|
|
608
1389
|
export interface NamespaceMemberRole {
|
|
609
1390
|
__typename?: 'NamespaceMemberRole';
|
|
610
1391
|
/** Time when this NamespaceMemberRole was created */
|
|
611
|
-
createdAt
|
|
1392
|
+
createdAt?: Maybe<Scalars['Time']['output']>;
|
|
612
1393
|
/** Global ID of this NamespaceMemberRole */
|
|
613
|
-
id
|
|
1394
|
+
id?: Maybe<Scalars['NamespaceMemberRoleID']['output']>;
|
|
614
1395
|
/** The member the role is assigned to */
|
|
615
1396
|
member?: Maybe<NamespaceMember>;
|
|
616
1397
|
/** The assigned role */
|
|
617
1398
|
role?: Maybe<NamespaceRole>;
|
|
618
1399
|
/** Time when this NamespaceMemberRole was last updated */
|
|
619
|
-
updatedAt
|
|
1400
|
+
updatedAt?: Maybe<Scalars['Time']['output']>;
|
|
1401
|
+
}
|
|
1402
|
+
|
|
1403
|
+
/** The connection type for NamespaceMemberRole. */
|
|
1404
|
+
export interface NamespaceMemberRoleConnection {
|
|
1405
|
+
__typename?: 'NamespaceMemberRoleConnection';
|
|
1406
|
+
/** Total count of collection. */
|
|
1407
|
+
count?: Maybe<Scalars['Int']['output']>;
|
|
1408
|
+
/** A list of edges. */
|
|
1409
|
+
edges?: Maybe<Array<Maybe<NamespaceMemberRoleEdge>>>;
|
|
1410
|
+
/** A list of nodes. */
|
|
1411
|
+
nodes?: Maybe<Array<Maybe<NamespaceMemberRole>>>;
|
|
1412
|
+
/** Information to aid in pagination. */
|
|
1413
|
+
pageInfo?: Maybe<PageInfo>;
|
|
1414
|
+
}
|
|
1415
|
+
|
|
1416
|
+
/** An edge in a connection. */
|
|
1417
|
+
export interface NamespaceMemberRoleEdge {
|
|
1418
|
+
__typename?: 'NamespaceMemberRoleEdge';
|
|
1419
|
+
/** A cursor for use in pagination. */
|
|
1420
|
+
cursor?: Maybe<Scalars['String']['output']>;
|
|
1421
|
+
/** The item at the end of the edge. */
|
|
1422
|
+
node?: Maybe<NamespaceMemberRole>;
|
|
1423
|
+
}
|
|
1424
|
+
|
|
1425
|
+
/** Abilities for the current user on this NamespaceMember */
|
|
1426
|
+
export interface NamespaceMemberUserAbilities {
|
|
1427
|
+
__typename?: 'NamespaceMemberUserAbilities';
|
|
1428
|
+
/** Shows if the current user has the `assign_member_roles` ability on this NamespaceMember */
|
|
1429
|
+
assignMemberRoles?: Maybe<Scalars['Boolean']['output']>;
|
|
1430
|
+
/** Shows if the current user has the `delete_member` ability on this NamespaceMember */
|
|
1431
|
+
deleteMember?: Maybe<Scalars['Boolean']['output']>;
|
|
620
1432
|
}
|
|
621
1433
|
|
|
622
1434
|
/** Objects that can present a namespace */
|
|
623
|
-
export type NamespaceParent = Organization;
|
|
1435
|
+
export type NamespaceParent = Organization | User;
|
|
624
1436
|
|
|
625
1437
|
/** Represents a namespace project */
|
|
626
1438
|
export interface NamespaceProject {
|
|
627
1439
|
__typename?: 'NamespaceProject';
|
|
628
1440
|
/** Time when this NamespaceProject was created */
|
|
629
|
-
createdAt
|
|
1441
|
+
createdAt?: Maybe<Scalars['Time']['output']>;
|
|
630
1442
|
/** Description of the project */
|
|
631
|
-
description
|
|
1443
|
+
description?: Maybe<Scalars['String']['output']>;
|
|
1444
|
+
/** Fetches an flow given by its ID */
|
|
1445
|
+
flow?: Maybe<Flow>;
|
|
1446
|
+
/** Fetches all flows in this project */
|
|
1447
|
+
flows?: Maybe<FlowConnection>;
|
|
632
1448
|
/** Global ID of this NamespaceProject */
|
|
633
|
-
id
|
|
1449
|
+
id?: Maybe<Scalars['NamespaceProjectID']['output']>;
|
|
634
1450
|
/** Name of the project */
|
|
635
|
-
name
|
|
1451
|
+
name?: Maybe<Scalars['String']['output']>;
|
|
636
1452
|
/** The namespace where this project belongs to */
|
|
637
|
-
namespace
|
|
1453
|
+
namespace?: Maybe<Namespace>;
|
|
1454
|
+
/** The primary runtime for the project */
|
|
1455
|
+
primaryRuntime?: Maybe<Runtime>;
|
|
1456
|
+
/** Runtimes assigned to this project */
|
|
1457
|
+
runtimes?: Maybe<RuntimeConnection>;
|
|
638
1458
|
/** Time when this NamespaceProject was last updated */
|
|
639
|
-
updatedAt
|
|
1459
|
+
updatedAt?: Maybe<Scalars['Time']['output']>;
|
|
1460
|
+
/** Abilities for the current user on this NamespaceProject */
|
|
1461
|
+
userAbilities?: Maybe<NamespaceProjectUserAbilities>;
|
|
1462
|
+
}
|
|
1463
|
+
|
|
1464
|
+
|
|
1465
|
+
/** Represents a namespace project */
|
|
1466
|
+
export interface NamespaceProjectFlowArgs {
|
|
1467
|
+
id: Scalars['FlowID']['input'];
|
|
1468
|
+
}
|
|
1469
|
+
|
|
1470
|
+
|
|
1471
|
+
/** Represents a namespace project */
|
|
1472
|
+
export interface NamespaceProjectFlowsArgs {
|
|
1473
|
+
after?: InputMaybe<Scalars['String']['input']>;
|
|
1474
|
+
before?: InputMaybe<Scalars['String']['input']>;
|
|
1475
|
+
first?: InputMaybe<Scalars['Int']['input']>;
|
|
1476
|
+
last?: InputMaybe<Scalars['Int']['input']>;
|
|
1477
|
+
}
|
|
1478
|
+
|
|
1479
|
+
|
|
1480
|
+
/** Represents a namespace project */
|
|
1481
|
+
export interface NamespaceProjectRuntimesArgs {
|
|
1482
|
+
after?: InputMaybe<Scalars['String']['input']>;
|
|
1483
|
+
before?: InputMaybe<Scalars['String']['input']>;
|
|
1484
|
+
first?: InputMaybe<Scalars['Int']['input']>;
|
|
1485
|
+
last?: InputMaybe<Scalars['Int']['input']>;
|
|
640
1486
|
}
|
|
641
1487
|
|
|
642
1488
|
/** The connection type for NamespaceProject. */
|
|
643
1489
|
export interface NamespaceProjectConnection {
|
|
644
1490
|
__typename?: 'NamespaceProjectConnection';
|
|
645
1491
|
/** Total count of collection. */
|
|
646
|
-
count
|
|
1492
|
+
count?: Maybe<Scalars['Int']['output']>;
|
|
647
1493
|
/** A list of edges. */
|
|
648
1494
|
edges?: Maybe<Array<Maybe<NamespaceProjectEdge>>>;
|
|
649
1495
|
/** A list of nodes. */
|
|
650
1496
|
nodes?: Maybe<Array<Maybe<NamespaceProject>>>;
|
|
651
1497
|
/** Information to aid in pagination. */
|
|
652
|
-
pageInfo
|
|
1498
|
+
pageInfo?: Maybe<PageInfo>;
|
|
653
1499
|
}
|
|
654
1500
|
|
|
655
1501
|
/** An edge in a connection. */
|
|
656
1502
|
export interface NamespaceProjectEdge {
|
|
657
1503
|
__typename?: 'NamespaceProjectEdge';
|
|
658
1504
|
/** A cursor for use in pagination. */
|
|
659
|
-
cursor
|
|
1505
|
+
cursor?: Maybe<Scalars['String']['output']>;
|
|
660
1506
|
/** The item at the end of the edge. */
|
|
661
1507
|
node?: Maybe<NamespaceProject>;
|
|
662
1508
|
}
|
|
663
1509
|
|
|
1510
|
+
/** Abilities for the current user on this NamespaceProject */
|
|
1511
|
+
export interface NamespaceProjectUserAbilities {
|
|
1512
|
+
__typename?: 'NamespaceProjectUserAbilities';
|
|
1513
|
+
/** Shows if the current user has the `assign_project_runtimes` ability on this NamespaceProject */
|
|
1514
|
+
assignProjectRuntimes?: Maybe<Scalars['Boolean']['output']>;
|
|
1515
|
+
/** Shows if the current user has the `create_flow` ability on this NamespaceProject */
|
|
1516
|
+
createFlow?: Maybe<Scalars['Boolean']['output']>;
|
|
1517
|
+
/** Shows if the current user has the `delete_namespace_project` ability on this NamespaceProject */
|
|
1518
|
+
deleteNamespaceProject?: Maybe<Scalars['Boolean']['output']>;
|
|
1519
|
+
/** Shows if the current user has the `update_namespace_project` ability on this NamespaceProject */
|
|
1520
|
+
updateNamespaceProject?: Maybe<Scalars['Boolean']['output']>;
|
|
1521
|
+
}
|
|
1522
|
+
|
|
664
1523
|
/** Represents a namespace role. */
|
|
665
1524
|
export interface NamespaceRole {
|
|
666
1525
|
__typename?: 'NamespaceRole';
|
|
667
1526
|
/** The abilities the role is granted */
|
|
668
|
-
abilities
|
|
1527
|
+
abilities?: Maybe<Array<NamespaceRoleAbility>>;
|
|
669
1528
|
/** The projects this role is assigned to */
|
|
670
1529
|
assignedProjects?: Maybe<NamespaceProjectConnection>;
|
|
671
1530
|
/** Time when this NamespaceRole was created */
|
|
672
|
-
createdAt
|
|
1531
|
+
createdAt?: Maybe<Scalars['Time']['output']>;
|
|
673
1532
|
/** Global ID of this NamespaceRole */
|
|
674
|
-
id
|
|
1533
|
+
id?: Maybe<Scalars['NamespaceRoleID']['output']>;
|
|
675
1534
|
/** The name of this role */
|
|
676
|
-
name
|
|
1535
|
+
name?: Maybe<Scalars['String']['output']>;
|
|
677
1536
|
/** The namespace where this role belongs to */
|
|
678
1537
|
namespace?: Maybe<Namespace>;
|
|
679
1538
|
/** Time when this NamespaceRole was last updated */
|
|
680
|
-
updatedAt
|
|
1539
|
+
updatedAt?: Maybe<Scalars['Time']['output']>;
|
|
1540
|
+
/** Abilities for the current user on this NamespaceRole */
|
|
1541
|
+
userAbilities?: Maybe<NamespaceRoleUserAbilities>;
|
|
681
1542
|
}
|
|
682
1543
|
|
|
683
1544
|
|
|
@@ -690,13 +1551,17 @@ export interface NamespaceRoleAssignedProjectsArgs {
|
|
|
690
1551
|
}
|
|
691
1552
|
|
|
692
1553
|
/** Represents abilities that can be granted to roles in namespaces. */
|
|
693
|
-
export enum NamespaceRoleAbility {
|
|
1554
|
+
export const enum NamespaceRoleAbility {
|
|
694
1555
|
/** Allows to change the roles of a namespace member */
|
|
695
1556
|
AssignMemberRoles = 'ASSIGN_MEMBER_ROLES',
|
|
1557
|
+
/** Allows to assign runtimes to a project in the namespace */
|
|
1558
|
+
AssignProjectRuntimes = 'ASSIGN_PROJECT_RUNTIMES',
|
|
696
1559
|
/** Allows to change the abilities of a namespace role */
|
|
697
1560
|
AssignRoleAbilities = 'ASSIGN_ROLE_ABILITIES',
|
|
698
1561
|
/** Allows to change the assigned projects of a namespace role */
|
|
699
1562
|
AssignRoleProjects = 'ASSIGN_ROLE_PROJECTS',
|
|
1563
|
+
/** Allows to create flows in a namespace project */
|
|
1564
|
+
CreateFlow = 'CREATE_FLOW',
|
|
700
1565
|
/** Allows to create a license for the namespace */
|
|
701
1566
|
CreateNamespaceLicense = 'CREATE_NAMESPACE_LICENSE',
|
|
702
1567
|
/** Allows to create a project in the namespace */
|
|
@@ -705,6 +1570,8 @@ export enum NamespaceRoleAbility {
|
|
|
705
1570
|
CreateNamespaceRole = 'CREATE_NAMESPACE_ROLE',
|
|
706
1571
|
/** Allows to create a runtime globally or for the namespace */
|
|
707
1572
|
CreateRuntime = 'CREATE_RUNTIME',
|
|
1573
|
+
/** Allows to delete flows in a namespace project */
|
|
1574
|
+
DeleteFlow = 'DELETE_FLOW',
|
|
708
1575
|
/** Allows to remove members of a namespace */
|
|
709
1576
|
DeleteMember = 'DELETE_MEMBER',
|
|
710
1577
|
/** Allows to delete the license of the namespace */
|
|
@@ -727,6 +1594,8 @@ export enum NamespaceRoleAbility {
|
|
|
727
1594
|
ReadNamespaceProject = 'READ_NAMESPACE_PROJECT',
|
|
728
1595
|
/** Allows to regenerate a runtime token */
|
|
729
1596
|
RotateRuntimeToken = 'ROTATE_RUNTIME_TOKEN',
|
|
1597
|
+
/** Allows to update flows in the project */
|
|
1598
|
+
UpdateFlow = 'UPDATE_FLOW',
|
|
730
1599
|
/** Allows to update the project of the namespace */
|
|
731
1600
|
UpdateNamespaceProject = 'UPDATE_NAMESPACE_PROJECT',
|
|
732
1601
|
/** Allows to update the namespace role */
|
|
@@ -741,24 +1610,52 @@ export enum NamespaceRoleAbility {
|
|
|
741
1610
|
export interface NamespaceRoleConnection {
|
|
742
1611
|
__typename?: 'NamespaceRoleConnection';
|
|
743
1612
|
/** Total count of collection. */
|
|
744
|
-
count
|
|
1613
|
+
count?: Maybe<Scalars['Int']['output']>;
|
|
745
1614
|
/** A list of edges. */
|
|
746
1615
|
edges?: Maybe<Array<Maybe<NamespaceRoleEdge>>>;
|
|
747
1616
|
/** A list of nodes. */
|
|
748
1617
|
nodes?: Maybe<Array<Maybe<NamespaceRole>>>;
|
|
749
1618
|
/** Information to aid in pagination. */
|
|
750
|
-
pageInfo
|
|
1619
|
+
pageInfo?: Maybe<PageInfo>;
|
|
751
1620
|
}
|
|
752
1621
|
|
|
753
1622
|
/** An edge in a connection. */
|
|
754
1623
|
export interface NamespaceRoleEdge {
|
|
755
1624
|
__typename?: 'NamespaceRoleEdge';
|
|
756
1625
|
/** A cursor for use in pagination. */
|
|
757
|
-
cursor
|
|
1626
|
+
cursor?: Maybe<Scalars['String']['output']>;
|
|
758
1627
|
/** The item at the end of the edge. */
|
|
759
1628
|
node?: Maybe<NamespaceRole>;
|
|
760
1629
|
}
|
|
761
1630
|
|
|
1631
|
+
/** Abilities for the current user on this NamespaceRole */
|
|
1632
|
+
export interface NamespaceRoleUserAbilities {
|
|
1633
|
+
__typename?: 'NamespaceRoleUserAbilities';
|
|
1634
|
+
/** Shows if the current user has the `assign_role_abilities` ability on this NamespaceRole */
|
|
1635
|
+
assignRoleAbilities?: Maybe<Scalars['Boolean']['output']>;
|
|
1636
|
+
/** Shows if the current user has the `assign_role_projects` ability on this NamespaceRole */
|
|
1637
|
+
assignRoleProjects?: Maybe<Scalars['Boolean']['output']>;
|
|
1638
|
+
/** Shows if the current user has the `delete_namespace_role` ability on this NamespaceRole */
|
|
1639
|
+
deleteNamespaceRole?: Maybe<Scalars['Boolean']['output']>;
|
|
1640
|
+
/** Shows if the current user has the `update_namespace_role` ability on this NamespaceRole */
|
|
1641
|
+
updateNamespaceRole?: Maybe<Scalars['Boolean']['output']>;
|
|
1642
|
+
}
|
|
1643
|
+
|
|
1644
|
+
/** Abilities for the current user on this Namespace */
|
|
1645
|
+
export interface NamespaceUserAbilities {
|
|
1646
|
+
__typename?: 'NamespaceUserAbilities';
|
|
1647
|
+
/** Shows if the current user has the `create_namespace_license` ability on this Namespace */
|
|
1648
|
+
createNamespaceLicense?: Maybe<Scalars['Boolean']['output']>;
|
|
1649
|
+
/** Shows if the current user has the `create_namespace_project` ability on this Namespace */
|
|
1650
|
+
createNamespaceProject?: Maybe<Scalars['Boolean']['output']>;
|
|
1651
|
+
/** Shows if the current user has the `create_namespace_role` ability on this Namespace */
|
|
1652
|
+
createNamespaceRole?: Maybe<Scalars['Boolean']['output']>;
|
|
1653
|
+
/** Shows if the current user has the `create_runtime` ability on this Namespace */
|
|
1654
|
+
createRuntime?: Maybe<Scalars['Boolean']['output']>;
|
|
1655
|
+
/** Shows if the current user has the `invite_member` ability on this Namespace */
|
|
1656
|
+
inviteMember?: Maybe<Scalars['Boolean']['output']>;
|
|
1657
|
+
}
|
|
1658
|
+
|
|
762
1659
|
/** Autogenerated input type of NamespacesLicensesCreate */
|
|
763
1660
|
export interface NamespacesLicensesCreateInput {
|
|
764
1661
|
/** A unique identifier for the client performing the mutation. */
|
|
@@ -775,7 +1672,7 @@ export interface NamespacesLicensesCreatePayload {
|
|
|
775
1672
|
/** A unique identifier for the client performing the mutation. */
|
|
776
1673
|
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
777
1674
|
/** Errors encountered during execution of the mutation. */
|
|
778
|
-
errors
|
|
1675
|
+
errors?: Maybe<Array<Error>>;
|
|
779
1676
|
/** The newly created license. */
|
|
780
1677
|
namespaceLicense?: Maybe<NamespaceLicense>;
|
|
781
1678
|
}
|
|
@@ -794,7 +1691,7 @@ export interface NamespacesLicensesDeletePayload {
|
|
|
794
1691
|
/** A unique identifier for the client performing the mutation. */
|
|
795
1692
|
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
796
1693
|
/** Errors encountered during execution of the mutation. */
|
|
797
|
-
errors
|
|
1694
|
+
errors?: Maybe<Array<Error>>;
|
|
798
1695
|
/** The deleted namespace license. */
|
|
799
1696
|
namespaceLicense?: Maybe<NamespaceLicense>;
|
|
800
1697
|
}
|
|
@@ -815,7 +1712,7 @@ export interface NamespacesMembersAssignRolesPayload {
|
|
|
815
1712
|
/** A unique identifier for the client performing the mutation. */
|
|
816
1713
|
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
817
1714
|
/** Errors encountered during execution of the mutation. */
|
|
818
|
-
errors
|
|
1715
|
+
errors?: Maybe<Array<Error>>;
|
|
819
1716
|
/** The roles the member is now assigned to */
|
|
820
1717
|
namespaceMemberRoles?: Maybe<Array<NamespaceMemberRole>>;
|
|
821
1718
|
}
|
|
@@ -834,7 +1731,7 @@ export interface NamespacesMembersDeletePayload {
|
|
|
834
1731
|
/** A unique identifier for the client performing the mutation. */
|
|
835
1732
|
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
836
1733
|
/** Errors encountered during execution of the mutation. */
|
|
837
|
-
errors
|
|
1734
|
+
errors?: Maybe<Array<Error>>;
|
|
838
1735
|
/** The removed namespace member */
|
|
839
1736
|
namespaceMember?: Maybe<NamespaceMember>;
|
|
840
1737
|
}
|
|
@@ -855,11 +1752,32 @@ export interface NamespacesMembersInvitePayload {
|
|
|
855
1752
|
/** A unique identifier for the client performing the mutation. */
|
|
856
1753
|
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
857
1754
|
/** Errors encountered during execution of the mutation. */
|
|
858
|
-
errors
|
|
1755
|
+
errors?: Maybe<Array<Error>>;
|
|
859
1756
|
/** The newly created namespace member */
|
|
860
1757
|
namespaceMember?: Maybe<NamespaceMember>;
|
|
861
1758
|
}
|
|
862
1759
|
|
|
1760
|
+
/** Autogenerated input type of NamespacesProjectsAssignRuntimes */
|
|
1761
|
+
export interface NamespacesProjectsAssignRuntimesInput {
|
|
1762
|
+
/** A unique identifier for the client performing the mutation. */
|
|
1763
|
+
clientMutationId?: InputMaybe<Scalars['String']['input']>;
|
|
1764
|
+
/** ID of the project to assign runtimes to */
|
|
1765
|
+
namespaceProjectId: Scalars['NamespaceProjectID']['input'];
|
|
1766
|
+
/** The new runtimes assigned to the project */
|
|
1767
|
+
runtimeIds: Array<Scalars['RuntimeID']['input']>;
|
|
1768
|
+
}
|
|
1769
|
+
|
|
1770
|
+
/** Autogenerated return type of NamespacesProjectsAssignRuntimes. */
|
|
1771
|
+
export interface NamespacesProjectsAssignRuntimesPayload {
|
|
1772
|
+
__typename?: 'NamespacesProjectsAssignRuntimesPayload';
|
|
1773
|
+
/** A unique identifier for the client performing the mutation. */
|
|
1774
|
+
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
1775
|
+
/** Errors encountered during execution of the mutation. */
|
|
1776
|
+
errors?: Maybe<Array<Error>>;
|
|
1777
|
+
/** The updated project with assigned runtimes */
|
|
1778
|
+
namespaceProject?: Maybe<NamespaceProject>;
|
|
1779
|
+
}
|
|
1780
|
+
|
|
863
1781
|
/** Autogenerated input type of NamespacesProjectsCreate */
|
|
864
1782
|
export interface NamespacesProjectsCreateInput {
|
|
865
1783
|
/** A unique identifier for the client performing the mutation. */
|
|
@@ -878,7 +1796,7 @@ export interface NamespacesProjectsCreatePayload {
|
|
|
878
1796
|
/** A unique identifier for the client performing the mutation. */
|
|
879
1797
|
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
880
1798
|
/** Errors encountered during execution of the mutation. */
|
|
881
|
-
errors
|
|
1799
|
+
errors?: Maybe<Array<Error>>;
|
|
882
1800
|
/** The newly created project. */
|
|
883
1801
|
namespaceProject?: Maybe<NamespaceProject>;
|
|
884
1802
|
}
|
|
@@ -897,11 +1815,51 @@ export interface NamespacesProjectsDeletePayload {
|
|
|
897
1815
|
/** A unique identifier for the client performing the mutation. */
|
|
898
1816
|
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
899
1817
|
/** Errors encountered during execution of the mutation. */
|
|
900
|
-
errors
|
|
1818
|
+
errors?: Maybe<Array<Error>>;
|
|
901
1819
|
/** The deleted project. */
|
|
902
1820
|
namespaceProject?: Maybe<NamespaceProject>;
|
|
903
1821
|
}
|
|
904
1822
|
|
|
1823
|
+
/** Autogenerated input type of NamespacesProjectsFlowsCreate */
|
|
1824
|
+
export interface NamespacesProjectsFlowsCreateInput {
|
|
1825
|
+
/** A unique identifier for the client performing the mutation. */
|
|
1826
|
+
clientMutationId?: InputMaybe<Scalars['String']['input']>;
|
|
1827
|
+
/** The flow to create */
|
|
1828
|
+
flow: FlowInput;
|
|
1829
|
+
/** The ID of the project to which the flow belongs to */
|
|
1830
|
+
projectId: Scalars['NamespaceProjectID']['input'];
|
|
1831
|
+
}
|
|
1832
|
+
|
|
1833
|
+
/** Autogenerated return type of NamespacesProjectsFlowsCreate. */
|
|
1834
|
+
export interface NamespacesProjectsFlowsCreatePayload {
|
|
1835
|
+
__typename?: 'NamespacesProjectsFlowsCreatePayload';
|
|
1836
|
+
/** A unique identifier for the client performing the mutation. */
|
|
1837
|
+
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
1838
|
+
/** Errors encountered during execution of the mutation. */
|
|
1839
|
+
errors?: Maybe<Array<Error>>;
|
|
1840
|
+
/** The newly created flow. */
|
|
1841
|
+
flow?: Maybe<Flow>;
|
|
1842
|
+
}
|
|
1843
|
+
|
|
1844
|
+
/** Autogenerated input type of NamespacesProjectsFlowsDelete */
|
|
1845
|
+
export interface NamespacesProjectsFlowsDeleteInput {
|
|
1846
|
+
/** A unique identifier for the client performing the mutation. */
|
|
1847
|
+
clientMutationId?: InputMaybe<Scalars['String']['input']>;
|
|
1848
|
+
/** The id of the flow which will be deleted */
|
|
1849
|
+
flowId: Scalars['FlowID']['input'];
|
|
1850
|
+
}
|
|
1851
|
+
|
|
1852
|
+
/** Autogenerated return type of NamespacesProjectsFlowsDelete. */
|
|
1853
|
+
export interface NamespacesProjectsFlowsDeletePayload {
|
|
1854
|
+
__typename?: 'NamespacesProjectsFlowsDeletePayload';
|
|
1855
|
+
/** A unique identifier for the client performing the mutation. */
|
|
1856
|
+
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
1857
|
+
/** Errors encountered during execution of the mutation. */
|
|
1858
|
+
errors?: Maybe<Array<Error>>;
|
|
1859
|
+
/** The deleted flow. */
|
|
1860
|
+
flow?: Maybe<Flow>;
|
|
1861
|
+
}
|
|
1862
|
+
|
|
905
1863
|
/** Autogenerated input type of NamespacesProjectsUpdate */
|
|
906
1864
|
export interface NamespacesProjectsUpdateInput {
|
|
907
1865
|
/** A unique identifier for the client performing the mutation. */
|
|
@@ -912,6 +1870,8 @@ export interface NamespacesProjectsUpdateInput {
|
|
|
912
1870
|
name?: InputMaybe<Scalars['String']['input']>;
|
|
913
1871
|
/** The id of the namespace project which will be updated */
|
|
914
1872
|
namespaceProjectId: Scalars['NamespaceProjectID']['input'];
|
|
1873
|
+
/** The primary runtime for the updated project. */
|
|
1874
|
+
primaryRuntimeId?: InputMaybe<Scalars['RuntimeID']['input']>;
|
|
915
1875
|
}
|
|
916
1876
|
|
|
917
1877
|
/** Autogenerated return type of NamespacesProjectsUpdate. */
|
|
@@ -920,7 +1880,7 @@ export interface NamespacesProjectsUpdatePayload {
|
|
|
920
1880
|
/** A unique identifier for the client performing the mutation. */
|
|
921
1881
|
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
922
1882
|
/** Errors encountered during execution of the mutation. */
|
|
923
|
-
errors
|
|
1883
|
+
errors?: Maybe<Array<Error>>;
|
|
924
1884
|
/** The updated project. */
|
|
925
1885
|
namespaceProject?: Maybe<NamespaceProject>;
|
|
926
1886
|
}
|
|
@@ -943,7 +1903,7 @@ export interface NamespacesRolesAssignAbilitiesPayload {
|
|
|
943
1903
|
/** A unique identifier for the client performing the mutation. */
|
|
944
1904
|
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
945
1905
|
/** Errors encountered during execution of the mutation. */
|
|
946
|
-
errors
|
|
1906
|
+
errors?: Maybe<Array<Error>>;
|
|
947
1907
|
}
|
|
948
1908
|
|
|
949
1909
|
/** Autogenerated input type of NamespacesRolesAssignProjects */
|
|
@@ -962,7 +1922,7 @@ export interface NamespacesRolesAssignProjectsPayload {
|
|
|
962
1922
|
/** A unique identifier for the client performing the mutation. */
|
|
963
1923
|
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
964
1924
|
/** Errors encountered during execution of the mutation. */
|
|
965
|
-
errors
|
|
1925
|
+
errors?: Maybe<Array<Error>>;
|
|
966
1926
|
/** The now assigned projects */
|
|
967
1927
|
projects?: Maybe<Array<NamespaceProject>>;
|
|
968
1928
|
}
|
|
@@ -983,7 +1943,7 @@ export interface NamespacesRolesCreatePayload {
|
|
|
983
1943
|
/** A unique identifier for the client performing the mutation. */
|
|
984
1944
|
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
985
1945
|
/** Errors encountered during execution of the mutation. */
|
|
986
|
-
errors
|
|
1946
|
+
errors?: Maybe<Array<Error>>;
|
|
987
1947
|
/** The newly created namespace role */
|
|
988
1948
|
namespaceRole?: Maybe<NamespaceRole>;
|
|
989
1949
|
}
|
|
@@ -1002,7 +1962,7 @@ export interface NamespacesRolesDeletePayload {
|
|
|
1002
1962
|
/** A unique identifier for the client performing the mutation. */
|
|
1003
1963
|
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
1004
1964
|
/** Errors encountered during execution of the mutation. */
|
|
1005
|
-
errors
|
|
1965
|
+
errors?: Maybe<Array<Error>>;
|
|
1006
1966
|
/** The deleted namespace role */
|
|
1007
1967
|
namespaceRole?: Maybe<NamespaceRole>;
|
|
1008
1968
|
}
|
|
@@ -1023,7 +1983,7 @@ export interface NamespacesRolesUpdatePayload {
|
|
|
1023
1983
|
/** A unique identifier for the client performing the mutation. */
|
|
1024
1984
|
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
1025
1985
|
/** Errors encountered during execution of the mutation. */
|
|
1026
|
-
errors
|
|
1986
|
+
errors?: Maybe<Array<Error>>;
|
|
1027
1987
|
/** The updated namespace role. */
|
|
1028
1988
|
namespaceRole?: Maybe<NamespaceRole>;
|
|
1029
1989
|
}
|
|
@@ -1031,22 +1991,171 @@ export interface NamespacesRolesUpdatePayload {
|
|
|
1031
1991
|
/** An object with an ID. */
|
|
1032
1992
|
export interface Node {
|
|
1033
1993
|
/** ID of the object. */
|
|
1034
|
-
id
|
|
1994
|
+
id?: Maybe<Scalars['ID']['output']>;
|
|
1995
|
+
}
|
|
1996
|
+
|
|
1997
|
+
/** Represents a Node Function */
|
|
1998
|
+
export interface NodeFunction {
|
|
1999
|
+
__typename?: 'NodeFunction';
|
|
2000
|
+
/** Time when this NodeFunction was created */
|
|
2001
|
+
createdAt?: Maybe<Scalars['Time']['output']>;
|
|
2002
|
+
/** The definition of the Node Function */
|
|
2003
|
+
functionDefinition?: Maybe<FunctionDefinition>;
|
|
2004
|
+
/** Global ID of this NodeFunction */
|
|
2005
|
+
id?: Maybe<Scalars['NodeFunctionID']['output']>;
|
|
2006
|
+
/** The ID of the next Node Function in the flow */
|
|
2007
|
+
nextNodeId?: Maybe<Scalars['NodeFunctionID']['output']>;
|
|
2008
|
+
/** The parameters of the Node Function */
|
|
2009
|
+
parameters?: Maybe<NodeParameterConnection>;
|
|
2010
|
+
/** Time when this NodeFunction was last updated */
|
|
2011
|
+
updatedAt?: Maybe<Scalars['Time']['output']>;
|
|
2012
|
+
}
|
|
2013
|
+
|
|
2014
|
+
|
|
2015
|
+
/** Represents a Node Function */
|
|
2016
|
+
export interface NodeFunctionParametersArgs {
|
|
2017
|
+
after?: InputMaybe<Scalars['String']['input']>;
|
|
2018
|
+
before?: InputMaybe<Scalars['String']['input']>;
|
|
2019
|
+
first?: InputMaybe<Scalars['Int']['input']>;
|
|
2020
|
+
last?: InputMaybe<Scalars['Int']['input']>;
|
|
2021
|
+
}
|
|
2022
|
+
|
|
2023
|
+
/** The connection type for NodeFunction. */
|
|
2024
|
+
export interface NodeFunctionConnection {
|
|
2025
|
+
__typename?: 'NodeFunctionConnection';
|
|
2026
|
+
/** Total count of collection. */
|
|
2027
|
+
count?: Maybe<Scalars['Int']['output']>;
|
|
2028
|
+
/** A list of edges. */
|
|
2029
|
+
edges?: Maybe<Array<Maybe<NodeFunctionEdge>>>;
|
|
2030
|
+
/** A list of nodes. */
|
|
2031
|
+
nodes?: Maybe<Array<Maybe<NodeFunction>>>;
|
|
2032
|
+
/** Information to aid in pagination. */
|
|
2033
|
+
pageInfo?: Maybe<PageInfo>;
|
|
2034
|
+
}
|
|
2035
|
+
|
|
2036
|
+
/** An edge in a connection. */
|
|
2037
|
+
export interface NodeFunctionEdge {
|
|
2038
|
+
__typename?: 'NodeFunctionEdge';
|
|
2039
|
+
/** A cursor for use in pagination. */
|
|
2040
|
+
cursor?: Maybe<Scalars['String']['output']>;
|
|
2041
|
+
/** The item at the end of the edge. */
|
|
2042
|
+
node?: Maybe<NodeFunction>;
|
|
2043
|
+
}
|
|
2044
|
+
|
|
2045
|
+
/** Input type for a Node Function */
|
|
2046
|
+
export interface NodeFunctionInput {
|
|
2047
|
+
/** The next Node Function in the flow */
|
|
2048
|
+
nextNode?: InputMaybe<NodeFunctionInput>;
|
|
2049
|
+
/** The parameters of the Node Function */
|
|
2050
|
+
parameters: Array<NodeParameterInput>;
|
|
2051
|
+
/** The identifier of the Runtime Function Definition */
|
|
2052
|
+
runtimeFunctionId: Scalars['RuntimeFunctionDefinitionID']['input'];
|
|
2053
|
+
}
|
|
2054
|
+
|
|
2055
|
+
/** Represents a Node parameter */
|
|
2056
|
+
export interface NodeParameter {
|
|
2057
|
+
__typename?: 'NodeParameter';
|
|
2058
|
+
/** Time when this NodeParameter was created */
|
|
2059
|
+
createdAt?: Maybe<Scalars['Time']['output']>;
|
|
2060
|
+
/** Global ID of this NodeParameter */
|
|
2061
|
+
id?: Maybe<Scalars['NodeParameterID']['output']>;
|
|
2062
|
+
/** The definition of the parameter */
|
|
2063
|
+
runtimeParameter?: Maybe<RuntimeParameterDefinition>;
|
|
2064
|
+
/** Time when this NodeParameter was last updated */
|
|
2065
|
+
updatedAt?: Maybe<Scalars['Time']['output']>;
|
|
2066
|
+
/** The value of the parameter */
|
|
2067
|
+
value?: Maybe<NodeParameterValue>;
|
|
2068
|
+
}
|
|
2069
|
+
|
|
2070
|
+
/** The connection type for NodeParameter. */
|
|
2071
|
+
export interface NodeParameterConnection {
|
|
2072
|
+
__typename?: 'NodeParameterConnection';
|
|
2073
|
+
/** Total count of collection. */
|
|
2074
|
+
count?: Maybe<Scalars['Int']['output']>;
|
|
2075
|
+
/** A list of edges. */
|
|
2076
|
+
edges?: Maybe<Array<Maybe<NodeParameterEdge>>>;
|
|
2077
|
+
/** A list of nodes. */
|
|
2078
|
+
nodes?: Maybe<Array<Maybe<NodeParameter>>>;
|
|
2079
|
+
/** Information to aid in pagination. */
|
|
2080
|
+
pageInfo?: Maybe<PageInfo>;
|
|
2081
|
+
}
|
|
2082
|
+
|
|
2083
|
+
/** An edge in a connection. */
|
|
2084
|
+
export interface NodeParameterEdge {
|
|
2085
|
+
__typename?: 'NodeParameterEdge';
|
|
2086
|
+
/** A cursor for use in pagination. */
|
|
2087
|
+
cursor?: Maybe<Scalars['String']['output']>;
|
|
2088
|
+
/** The item at the end of the edge. */
|
|
2089
|
+
node?: Maybe<NodeParameter>;
|
|
2090
|
+
}
|
|
2091
|
+
|
|
2092
|
+
/** Input type for Node parameter */
|
|
2093
|
+
export interface NodeParameterInput {
|
|
2094
|
+
/** The identifier of the Runtime Parameter Definition */
|
|
2095
|
+
runtimeParameterDefinitionId: Scalars['RuntimeParameterDefinitionID']['input'];
|
|
2096
|
+
/** The value of the parameter */
|
|
2097
|
+
value?: InputMaybe<NodeParameterValueInput>;
|
|
2098
|
+
}
|
|
2099
|
+
|
|
2100
|
+
/** Represents a parameter value for a node. */
|
|
2101
|
+
export type NodeParameterValue = LiteralValue | NodeFunction | ReferenceValue;
|
|
2102
|
+
|
|
2103
|
+
/** Input type for parameter value */
|
|
2104
|
+
export interface NodeParameterValueInput {
|
|
2105
|
+
/** The function value of the parameter */
|
|
2106
|
+
functionValue?: InputMaybe<NodeFunctionInput>;
|
|
2107
|
+
/** The literal value of the parameter */
|
|
2108
|
+
literalValue?: InputMaybe<Scalars['JSON']['input']>;
|
|
2109
|
+
/** The reference value of the parameter */
|
|
2110
|
+
referenceValue?: InputMaybe<ReferenceValueInput>;
|
|
1035
2111
|
}
|
|
1036
2112
|
|
|
1037
2113
|
/** Represents a Organization */
|
|
1038
2114
|
export interface Organization {
|
|
1039
2115
|
__typename?: 'Organization';
|
|
1040
2116
|
/** Time when this Organization was created */
|
|
1041
|
-
createdAt
|
|
2117
|
+
createdAt?: Maybe<Scalars['Time']['output']>;
|
|
1042
2118
|
/** Global ID of this Organization */
|
|
1043
|
-
id
|
|
2119
|
+
id?: Maybe<Scalars['OrganizationID']['output']>;
|
|
1044
2120
|
/** Name of the organization */
|
|
1045
|
-
name
|
|
2121
|
+
name?: Maybe<Scalars['String']['output']>;
|
|
1046
2122
|
/** Namespace of this organization */
|
|
1047
|
-
namespace
|
|
2123
|
+
namespace?: Maybe<Namespace>;
|
|
1048
2124
|
/** Time when this Organization was last updated */
|
|
1049
|
-
updatedAt
|
|
2125
|
+
updatedAt?: Maybe<Scalars['Time']['output']>;
|
|
2126
|
+
/** Abilities for the current user on this Organization */
|
|
2127
|
+
userAbilities?: Maybe<OrganizationUserAbilities>;
|
|
2128
|
+
}
|
|
2129
|
+
|
|
2130
|
+
/** The connection type for Organization. */
|
|
2131
|
+
export interface OrganizationConnection {
|
|
2132
|
+
__typename?: 'OrganizationConnection';
|
|
2133
|
+
/** Total count of collection. */
|
|
2134
|
+
count?: Maybe<Scalars['Int']['output']>;
|
|
2135
|
+
/** A list of edges. */
|
|
2136
|
+
edges?: Maybe<Array<Maybe<OrganizationEdge>>>;
|
|
2137
|
+
/** A list of nodes. */
|
|
2138
|
+
nodes?: Maybe<Array<Maybe<Organization>>>;
|
|
2139
|
+
/** Information to aid in pagination. */
|
|
2140
|
+
pageInfo?: Maybe<PageInfo>;
|
|
2141
|
+
}
|
|
2142
|
+
|
|
2143
|
+
/** An edge in a connection. */
|
|
2144
|
+
export interface OrganizationEdge {
|
|
2145
|
+
__typename?: 'OrganizationEdge';
|
|
2146
|
+
/** A cursor for use in pagination. */
|
|
2147
|
+
cursor?: Maybe<Scalars['String']['output']>;
|
|
2148
|
+
/** The item at the end of the edge. */
|
|
2149
|
+
node?: Maybe<Organization>;
|
|
2150
|
+
}
|
|
2151
|
+
|
|
2152
|
+
/** Abilities for the current user on this Organization */
|
|
2153
|
+
export interface OrganizationUserAbilities {
|
|
2154
|
+
__typename?: 'OrganizationUserAbilities';
|
|
2155
|
+
/** Shows if the current user has the `delete_organization` ability on this Organization */
|
|
2156
|
+
deleteOrganization?: Maybe<Scalars['Boolean']['output']>;
|
|
2157
|
+
/** Shows if the current user has the `update_organization` ability on this Organization */
|
|
2158
|
+
updateOrganization?: Maybe<Scalars['Boolean']['output']>;
|
|
1050
2159
|
}
|
|
1051
2160
|
|
|
1052
2161
|
/** Autogenerated input type of OrganizationsCreate */
|
|
@@ -1063,7 +2172,7 @@ export interface OrganizationsCreatePayload {
|
|
|
1063
2172
|
/** A unique identifier for the client performing the mutation. */
|
|
1064
2173
|
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
1065
2174
|
/** Errors encountered during execution of the mutation. */
|
|
1066
|
-
errors
|
|
2175
|
+
errors?: Maybe<Array<Error>>;
|
|
1067
2176
|
/** The newly created organization. */
|
|
1068
2177
|
organization?: Maybe<Organization>;
|
|
1069
2178
|
}
|
|
@@ -1082,7 +2191,7 @@ export interface OrganizationsDeletePayload {
|
|
|
1082
2191
|
/** A unique identifier for the client performing the mutation. */
|
|
1083
2192
|
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
1084
2193
|
/** Errors encountered during execution of the mutation. */
|
|
1085
|
-
errors
|
|
2194
|
+
errors?: Maybe<Array<Error>>;
|
|
1086
2195
|
/** The deleted organization. */
|
|
1087
2196
|
organization?: Maybe<Organization>;
|
|
1088
2197
|
}
|
|
@@ -1103,7 +2212,7 @@ export interface OrganizationsUpdatePayload {
|
|
|
1103
2212
|
/** A unique identifier for the client performing the mutation. */
|
|
1104
2213
|
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
1105
2214
|
/** Errors encountered during execution of the mutation. */
|
|
1106
|
-
errors
|
|
2215
|
+
errors?: Maybe<Array<Error>>;
|
|
1107
2216
|
/** The updated organization. */
|
|
1108
2217
|
organization?: Maybe<Organization>;
|
|
1109
2218
|
}
|
|
@@ -1114,13 +2223,83 @@ export interface PageInfo {
|
|
|
1114
2223
|
/** When paginating forwards, the cursor to continue. */
|
|
1115
2224
|
endCursor?: Maybe<Scalars['String']['output']>;
|
|
1116
2225
|
/** When paginating forwards, are there more items? */
|
|
1117
|
-
hasNextPage
|
|
2226
|
+
hasNextPage?: Maybe<Scalars['Boolean']['output']>;
|
|
1118
2227
|
/** When paginating backwards, are there more items? */
|
|
1119
|
-
hasPreviousPage
|
|
2228
|
+
hasPreviousPage?: Maybe<Scalars['Boolean']['output']>;
|
|
1120
2229
|
/** When paginating backwards, the cursor to continue. */
|
|
1121
2230
|
startCursor?: Maybe<Scalars['String']['output']>;
|
|
1122
2231
|
}
|
|
1123
2232
|
|
|
2233
|
+
/** Represents a parameter definition */
|
|
2234
|
+
export interface ParameterDefinition {
|
|
2235
|
+
__typename?: 'ParameterDefinition';
|
|
2236
|
+
/** Time when this ParameterDefinition was created */
|
|
2237
|
+
createdAt?: Maybe<Scalars['Time']['output']>;
|
|
2238
|
+
/** Data type of the parameter */
|
|
2239
|
+
dataTypeIdentifier?: Maybe<DataTypeIdentifier>;
|
|
2240
|
+
/** Description of the parameter */
|
|
2241
|
+
descriptions?: Maybe<TranslationConnection>;
|
|
2242
|
+
/** Documentation of the parameter */
|
|
2243
|
+
documentations?: Maybe<TranslationConnection>;
|
|
2244
|
+
/** Global ID of this ParameterDefinition */
|
|
2245
|
+
id?: Maybe<Scalars['ParameterDefinitionID']['output']>;
|
|
2246
|
+
/** Identifier of the parameter */
|
|
2247
|
+
identifier?: Maybe<Scalars['String']['output']>;
|
|
2248
|
+
/** Name of the parameter */
|
|
2249
|
+
names?: Maybe<TranslationConnection>;
|
|
2250
|
+
/** Time when this ParameterDefinition was last updated */
|
|
2251
|
+
updatedAt?: Maybe<Scalars['Time']['output']>;
|
|
2252
|
+
}
|
|
2253
|
+
|
|
2254
|
+
|
|
2255
|
+
/** Represents a parameter definition */
|
|
2256
|
+
export interface ParameterDefinitionDescriptionsArgs {
|
|
2257
|
+
after?: InputMaybe<Scalars['String']['input']>;
|
|
2258
|
+
before?: InputMaybe<Scalars['String']['input']>;
|
|
2259
|
+
first?: InputMaybe<Scalars['Int']['input']>;
|
|
2260
|
+
last?: InputMaybe<Scalars['Int']['input']>;
|
|
2261
|
+
}
|
|
2262
|
+
|
|
2263
|
+
|
|
2264
|
+
/** Represents a parameter definition */
|
|
2265
|
+
export interface ParameterDefinitionDocumentationsArgs {
|
|
2266
|
+
after?: InputMaybe<Scalars['String']['input']>;
|
|
2267
|
+
before?: InputMaybe<Scalars['String']['input']>;
|
|
2268
|
+
first?: InputMaybe<Scalars['Int']['input']>;
|
|
2269
|
+
last?: InputMaybe<Scalars['Int']['input']>;
|
|
2270
|
+
}
|
|
2271
|
+
|
|
2272
|
+
|
|
2273
|
+
/** Represents a parameter definition */
|
|
2274
|
+
export interface ParameterDefinitionNamesArgs {
|
|
2275
|
+
after?: InputMaybe<Scalars['String']['input']>;
|
|
2276
|
+
before?: InputMaybe<Scalars['String']['input']>;
|
|
2277
|
+
first?: InputMaybe<Scalars['Int']['input']>;
|
|
2278
|
+
last?: InputMaybe<Scalars['Int']['input']>;
|
|
2279
|
+
}
|
|
2280
|
+
|
|
2281
|
+
/** The connection type for ParameterDefinition. */
|
|
2282
|
+
export interface ParameterDefinitionConnection {
|
|
2283
|
+
__typename?: 'ParameterDefinitionConnection';
|
|
2284
|
+
/** Total count of collection. */
|
|
2285
|
+
count?: Maybe<Scalars['Int']['output']>;
|
|
2286
|
+
/** A list of edges. */
|
|
2287
|
+
edges?: Maybe<Array<Maybe<ParameterDefinitionEdge>>>;
|
|
2288
|
+
/** A list of nodes. */
|
|
2289
|
+
nodes?: Maybe<Array<Maybe<ParameterDefinition>>>;
|
|
2290
|
+
/** Information to aid in pagination. */
|
|
2291
|
+
pageInfo?: Maybe<PageInfo>;
|
|
2292
|
+
}
|
|
2293
|
+
|
|
2294
|
+
/** An edge in a connection. */
|
|
2295
|
+
export interface ParameterDefinitionEdge {
|
|
2296
|
+
__typename?: 'ParameterDefinitionEdge';
|
|
2297
|
+
/** A cursor for use in pagination. */
|
|
2298
|
+
cursor?: Maybe<Scalars['String']['output']>;
|
|
2299
|
+
/** The item at the end of the edge. */
|
|
2300
|
+
node?: Maybe<ParameterDefinition>;
|
|
2301
|
+
}
|
|
2302
|
+
|
|
1124
2303
|
/** Root Query type */
|
|
1125
2304
|
export interface Query {
|
|
1126
2305
|
__typename?: 'Query';
|
|
@@ -1131,9 +2310,9 @@ export interface Query {
|
|
|
1131
2310
|
/** Get the currently logged in user */
|
|
1132
2311
|
currentUser?: Maybe<User>;
|
|
1133
2312
|
/** Field available for use to test API access */
|
|
1134
|
-
echo
|
|
2313
|
+
echo?: Maybe<Scalars['String']['output']>;
|
|
1135
2314
|
/** Find runtimes */
|
|
1136
|
-
globalRuntimes
|
|
2315
|
+
globalRuntimes?: Maybe<RuntimeConnection>;
|
|
1137
2316
|
/** Find a namespace */
|
|
1138
2317
|
namespace?: Maybe<Namespace>;
|
|
1139
2318
|
/** Fetches an object given its ID */
|
|
@@ -1142,6 +2321,12 @@ export interface Query {
|
|
|
1142
2321
|
nodes?: Maybe<Array<Maybe<Node>>>;
|
|
1143
2322
|
/** Find a organization */
|
|
1144
2323
|
organization?: Maybe<Organization>;
|
|
2324
|
+
/** Find organizations */
|
|
2325
|
+
organizations?: Maybe<OrganizationConnection>;
|
|
2326
|
+
/** Abilities for the current user on this Instance */
|
|
2327
|
+
userAbilities?: Maybe<InstanceUserAbilities>;
|
|
2328
|
+
/** Find users */
|
|
2329
|
+
users?: Maybe<UserConnection>;
|
|
1145
2330
|
}
|
|
1146
2331
|
|
|
1147
2332
|
|
|
@@ -1184,25 +2369,113 @@ export interface QueryOrganizationArgs {
|
|
|
1184
2369
|
name?: InputMaybe<Scalars['String']['input']>;
|
|
1185
2370
|
}
|
|
1186
2371
|
|
|
2372
|
+
|
|
2373
|
+
/** Root Query type */
|
|
2374
|
+
export interface QueryOrganizationsArgs {
|
|
2375
|
+
after?: InputMaybe<Scalars['String']['input']>;
|
|
2376
|
+
before?: InputMaybe<Scalars['String']['input']>;
|
|
2377
|
+
first?: InputMaybe<Scalars['Int']['input']>;
|
|
2378
|
+
last?: InputMaybe<Scalars['Int']['input']>;
|
|
2379
|
+
}
|
|
2380
|
+
|
|
2381
|
+
|
|
2382
|
+
/** Root Query type */
|
|
2383
|
+
export interface QueryUsersArgs {
|
|
2384
|
+
after?: InputMaybe<Scalars['String']['input']>;
|
|
2385
|
+
before?: InputMaybe<Scalars['String']['input']>;
|
|
2386
|
+
first?: InputMaybe<Scalars['Int']['input']>;
|
|
2387
|
+
last?: InputMaybe<Scalars['Int']['input']>;
|
|
2388
|
+
}
|
|
2389
|
+
|
|
2390
|
+
/** Represents a reference path in a flow */
|
|
2391
|
+
export interface ReferencePath {
|
|
2392
|
+
__typename?: 'ReferencePath';
|
|
2393
|
+
/** The array index of the referenced data by the path */
|
|
2394
|
+
arrayIndex?: Maybe<Scalars['Int']['output']>;
|
|
2395
|
+
/** Time when this ReferencePath was created */
|
|
2396
|
+
createdAt?: Maybe<Scalars['Time']['output']>;
|
|
2397
|
+
/** Global ID of this ReferencePath */
|
|
2398
|
+
id?: Maybe<Scalars['ReferencePathID']['output']>;
|
|
2399
|
+
/** The path to the reference in the flow */
|
|
2400
|
+
path?: Maybe<Scalars['String']['output']>;
|
|
2401
|
+
/** Time when this ReferencePath was last updated */
|
|
2402
|
+
updatedAt?: Maybe<Scalars['Time']['output']>;
|
|
2403
|
+
}
|
|
2404
|
+
|
|
2405
|
+
/** Input type for reference path */
|
|
2406
|
+
export interface ReferencePathInput {
|
|
2407
|
+
/** Array index if applicable */
|
|
2408
|
+
arrayIndex?: InputMaybe<Scalars['Int']['input']>;
|
|
2409
|
+
/** The path to the reference in the flow */
|
|
2410
|
+
path?: InputMaybe<Scalars['String']['input']>;
|
|
2411
|
+
}
|
|
2412
|
+
|
|
2413
|
+
/** Represents a reference value in the system. */
|
|
2414
|
+
export interface ReferenceValue {
|
|
2415
|
+
__typename?: 'ReferenceValue';
|
|
2416
|
+
/** Time when this ReferenceValue was created */
|
|
2417
|
+
createdAt?: Maybe<Scalars['Time']['output']>;
|
|
2418
|
+
/** The identifier of the data type this reference value belongs to. */
|
|
2419
|
+
dataTypeIdentifier?: Maybe<DataTypeIdentifier>;
|
|
2420
|
+
/** The depth of the reference value. */
|
|
2421
|
+
depth?: Maybe<Scalars['Int']['output']>;
|
|
2422
|
+
/** Global ID of this ReferenceValue */
|
|
2423
|
+
id?: Maybe<Scalars['ReferenceValueID']['output']>;
|
|
2424
|
+
/** The node of the reference value. */
|
|
2425
|
+
node?: Maybe<Scalars['Int']['output']>;
|
|
2426
|
+
/** The referenced value. */
|
|
2427
|
+
nodeFunctionId?: Maybe<Scalars['NodeFunctionID']['output']>;
|
|
2428
|
+
/** The paths associated with this reference value. */
|
|
2429
|
+
referencePath?: Maybe<Array<ReferencePath>>;
|
|
2430
|
+
/** The scope of the reference value. */
|
|
2431
|
+
scope?: Maybe<Array<Scalars['Int']['output']>>;
|
|
2432
|
+
/** Time when this ReferenceValue was last updated */
|
|
2433
|
+
updatedAt?: Maybe<Scalars['Time']['output']>;
|
|
2434
|
+
}
|
|
2435
|
+
|
|
2436
|
+
/** Input type for reference value */
|
|
2437
|
+
export interface ReferenceValueInput {
|
|
2438
|
+
/** The identifier of the data type this reference value belongs to */
|
|
2439
|
+
dataTypeIdentifier: DataTypeIdentifierInput;
|
|
2440
|
+
/** The depth of the reference value */
|
|
2441
|
+
depth: Scalars['Int']['input'];
|
|
2442
|
+
/** The node of the reference */
|
|
2443
|
+
node: Scalars['Int']['input'];
|
|
2444
|
+
/** The referenced value */
|
|
2445
|
+
nodeFunctionId: Scalars['NodeFunctionID']['input'];
|
|
2446
|
+
/** The paths associated with this reference value */
|
|
2447
|
+
referencePath: Array<ReferencePathInput>;
|
|
2448
|
+
/** The scope of the reference value */
|
|
2449
|
+
scope: Array<Scalars['Int']['input']>;
|
|
2450
|
+
}
|
|
2451
|
+
|
|
1187
2452
|
/** Represents a runtime */
|
|
1188
2453
|
export interface Runtime {
|
|
1189
2454
|
__typename?: 'Runtime';
|
|
1190
2455
|
/** Time when this Runtime was created */
|
|
1191
|
-
createdAt
|
|
2456
|
+
createdAt?: Maybe<Scalars['Time']['output']>;
|
|
1192
2457
|
/** DataTypes of the runtime */
|
|
1193
|
-
dataTypes
|
|
2458
|
+
dataTypes?: Maybe<DataTypeConnection>;
|
|
1194
2459
|
/** The description for the runtime if present */
|
|
1195
|
-
description
|
|
2460
|
+
description?: Maybe<Scalars['String']['output']>;
|
|
2461
|
+
/** FlowTypes of the runtime */
|
|
2462
|
+
flowTypes?: Maybe<FlowTypeConnection>;
|
|
1196
2463
|
/** Global ID of this Runtime */
|
|
1197
|
-
id
|
|
2464
|
+
id?: Maybe<Scalars['RuntimeID']['output']>;
|
|
1198
2465
|
/** The name for the runtime */
|
|
1199
|
-
name
|
|
2466
|
+
name?: Maybe<Scalars['String']['output']>;
|
|
1200
2467
|
/** The parent namespace for the runtime */
|
|
1201
2468
|
namespace?: Maybe<Namespace>;
|
|
2469
|
+
/** Projects associated with the runtime */
|
|
2470
|
+
projects?: Maybe<NamespaceProjectConnection>;
|
|
2471
|
+
/** The status of the runtime */
|
|
2472
|
+
status?: Maybe<RuntimeStatusType>;
|
|
1202
2473
|
/** Token belonging to the runtime, only present on creation */
|
|
1203
2474
|
token?: Maybe<Scalars['String']['output']>;
|
|
1204
2475
|
/** Time when this Runtime was last updated */
|
|
1205
|
-
updatedAt
|
|
2476
|
+
updatedAt?: Maybe<Scalars['Time']['output']>;
|
|
2477
|
+
/** Abilities for the current user on this Runtime */
|
|
2478
|
+
userAbilities?: Maybe<RuntimeUserAbilities>;
|
|
1206
2479
|
}
|
|
1207
2480
|
|
|
1208
2481
|
|
|
@@ -1214,28 +2487,135 @@ export interface RuntimeDataTypesArgs {
|
|
|
1214
2487
|
last?: InputMaybe<Scalars['Int']['input']>;
|
|
1215
2488
|
}
|
|
1216
2489
|
|
|
2490
|
+
|
|
2491
|
+
/** Represents a runtime */
|
|
2492
|
+
export interface RuntimeFlowTypesArgs {
|
|
2493
|
+
after?: InputMaybe<Scalars['String']['input']>;
|
|
2494
|
+
before?: InputMaybe<Scalars['String']['input']>;
|
|
2495
|
+
first?: InputMaybe<Scalars['Int']['input']>;
|
|
2496
|
+
last?: InputMaybe<Scalars['Int']['input']>;
|
|
2497
|
+
}
|
|
2498
|
+
|
|
2499
|
+
|
|
2500
|
+
/** Represents a runtime */
|
|
2501
|
+
export interface RuntimeProjectsArgs {
|
|
2502
|
+
after?: InputMaybe<Scalars['String']['input']>;
|
|
2503
|
+
before?: InputMaybe<Scalars['String']['input']>;
|
|
2504
|
+
first?: InputMaybe<Scalars['Int']['input']>;
|
|
2505
|
+
last?: InputMaybe<Scalars['Int']['input']>;
|
|
2506
|
+
}
|
|
2507
|
+
|
|
1217
2508
|
/** The connection type for Runtime. */
|
|
1218
2509
|
export interface RuntimeConnection {
|
|
1219
2510
|
__typename?: 'RuntimeConnection';
|
|
1220
2511
|
/** Total count of collection. */
|
|
1221
|
-
count
|
|
2512
|
+
count?: Maybe<Scalars['Int']['output']>;
|
|
1222
2513
|
/** A list of edges. */
|
|
1223
2514
|
edges?: Maybe<Array<Maybe<RuntimeEdge>>>;
|
|
1224
2515
|
/** A list of nodes. */
|
|
1225
2516
|
nodes?: Maybe<Array<Maybe<Runtime>>>;
|
|
1226
2517
|
/** Information to aid in pagination. */
|
|
1227
|
-
pageInfo
|
|
2518
|
+
pageInfo?: Maybe<PageInfo>;
|
|
1228
2519
|
}
|
|
1229
2520
|
|
|
1230
2521
|
/** An edge in a connection. */
|
|
1231
2522
|
export interface RuntimeEdge {
|
|
1232
2523
|
__typename?: 'RuntimeEdge';
|
|
1233
2524
|
/** A cursor for use in pagination. */
|
|
1234
|
-
cursor
|
|
2525
|
+
cursor?: Maybe<Scalars['String']['output']>;
|
|
1235
2526
|
/** The item at the end of the edge. */
|
|
1236
2527
|
node?: Maybe<Runtime>;
|
|
1237
2528
|
}
|
|
1238
2529
|
|
|
2530
|
+
/** Represents a runtime function definition */
|
|
2531
|
+
export interface RuntimeFunctionDefinition {
|
|
2532
|
+
__typename?: 'RuntimeFunctionDefinition';
|
|
2533
|
+
/** Time when this RuntimeFunctionDefinition was created */
|
|
2534
|
+
createdAt?: Maybe<Scalars['Time']['output']>;
|
|
2535
|
+
/** Function definitions of the runtime function definition */
|
|
2536
|
+
functionDefinitions?: Maybe<FunctionDefinitionConnection>;
|
|
2537
|
+
/** Global ID of this RuntimeFunctionDefinition */
|
|
2538
|
+
id?: Maybe<Scalars['RuntimeFunctionDefinitionID']['output']>;
|
|
2539
|
+
/** Identifier of the runtime function definition */
|
|
2540
|
+
identifier?: Maybe<Scalars['String']['output']>;
|
|
2541
|
+
/** The runtime this runtime function definition belongs to */
|
|
2542
|
+
runtime?: Maybe<Runtime>;
|
|
2543
|
+
/** Parameter definitions of the runtime function definition */
|
|
2544
|
+
runtimeParameterDefinitions?: Maybe<RuntimeParameterDefinitionConnection>;
|
|
2545
|
+
/** Time when this RuntimeFunctionDefinition was last updated */
|
|
2546
|
+
updatedAt?: Maybe<Scalars['Time']['output']>;
|
|
2547
|
+
}
|
|
2548
|
+
|
|
2549
|
+
|
|
2550
|
+
/** Represents a runtime function definition */
|
|
2551
|
+
export interface RuntimeFunctionDefinitionFunctionDefinitionsArgs {
|
|
2552
|
+
after?: InputMaybe<Scalars['String']['input']>;
|
|
2553
|
+
before?: InputMaybe<Scalars['String']['input']>;
|
|
2554
|
+
first?: InputMaybe<Scalars['Int']['input']>;
|
|
2555
|
+
last?: InputMaybe<Scalars['Int']['input']>;
|
|
2556
|
+
}
|
|
2557
|
+
|
|
2558
|
+
|
|
2559
|
+
/** Represents a runtime function definition */
|
|
2560
|
+
export interface RuntimeFunctionDefinitionRuntimeParameterDefinitionsArgs {
|
|
2561
|
+
after?: InputMaybe<Scalars['String']['input']>;
|
|
2562
|
+
before?: InputMaybe<Scalars['String']['input']>;
|
|
2563
|
+
first?: InputMaybe<Scalars['Int']['input']>;
|
|
2564
|
+
last?: InputMaybe<Scalars['Int']['input']>;
|
|
2565
|
+
}
|
|
2566
|
+
|
|
2567
|
+
/** Represents a runtime parameter definition */
|
|
2568
|
+
export interface RuntimeParameterDefinition {
|
|
2569
|
+
__typename?: 'RuntimeParameterDefinition';
|
|
2570
|
+
/** Time when this RuntimeParameterDefinition was created */
|
|
2571
|
+
createdAt?: Maybe<Scalars['Time']['output']>;
|
|
2572
|
+
/** Global ID of this RuntimeParameterDefinition */
|
|
2573
|
+
id?: Maybe<Scalars['RuntimeParameterDefinitionID']['output']>;
|
|
2574
|
+
/** Time when this RuntimeParameterDefinition was last updated */
|
|
2575
|
+
updatedAt?: Maybe<Scalars['Time']['output']>;
|
|
2576
|
+
}
|
|
2577
|
+
|
|
2578
|
+
/** The connection type for RuntimeParameterDefinition. */
|
|
2579
|
+
export interface RuntimeParameterDefinitionConnection {
|
|
2580
|
+
__typename?: 'RuntimeParameterDefinitionConnection';
|
|
2581
|
+
/** Total count of collection. */
|
|
2582
|
+
count?: Maybe<Scalars['Int']['output']>;
|
|
2583
|
+
/** A list of edges. */
|
|
2584
|
+
edges?: Maybe<Array<Maybe<RuntimeParameterDefinitionEdge>>>;
|
|
2585
|
+
/** A list of nodes. */
|
|
2586
|
+
nodes?: Maybe<Array<Maybe<RuntimeParameterDefinition>>>;
|
|
2587
|
+
/** Information to aid in pagination. */
|
|
2588
|
+
pageInfo?: Maybe<PageInfo>;
|
|
2589
|
+
}
|
|
2590
|
+
|
|
2591
|
+
/** An edge in a connection. */
|
|
2592
|
+
export interface RuntimeParameterDefinitionEdge {
|
|
2593
|
+
__typename?: 'RuntimeParameterDefinitionEdge';
|
|
2594
|
+
/** A cursor for use in pagination. */
|
|
2595
|
+
cursor?: Maybe<Scalars['String']['output']>;
|
|
2596
|
+
/** The item at the end of the edge. */
|
|
2597
|
+
node?: Maybe<RuntimeParameterDefinition>;
|
|
2598
|
+
}
|
|
2599
|
+
|
|
2600
|
+
/** Represent all available types of statuses of a runtime */
|
|
2601
|
+
export const enum RuntimeStatusType {
|
|
2602
|
+
/** No problem with connection, everything works as expected */
|
|
2603
|
+
Connected = 'CONNECTED',
|
|
2604
|
+
/** The runtime is disconnected, cause unknown */
|
|
2605
|
+
Disconnected = 'DISCONNECTED'
|
|
2606
|
+
}
|
|
2607
|
+
|
|
2608
|
+
/** Abilities for the current user on this Runtime */
|
|
2609
|
+
export interface RuntimeUserAbilities {
|
|
2610
|
+
__typename?: 'RuntimeUserAbilities';
|
|
2611
|
+
/** Shows if the current user has the `delete_runtime` ability on this Runtime */
|
|
2612
|
+
deleteRuntime?: Maybe<Scalars['Boolean']['output']>;
|
|
2613
|
+
/** Shows if the current user has the `rotate_runtime_token` ability on this Runtime */
|
|
2614
|
+
rotateRuntimeToken?: Maybe<Scalars['Boolean']['output']>;
|
|
2615
|
+
/** Shows if the current user has the `update_runtime` ability on this Runtime */
|
|
2616
|
+
updateRuntime?: Maybe<Scalars['Boolean']['output']>;
|
|
2617
|
+
}
|
|
2618
|
+
|
|
1239
2619
|
/** Autogenerated input type of RuntimesCreate */
|
|
1240
2620
|
export interface RuntimesCreateInput {
|
|
1241
2621
|
/** A unique identifier for the client performing the mutation. */
|
|
@@ -1254,7 +2634,7 @@ export interface RuntimesCreatePayload {
|
|
|
1254
2634
|
/** A unique identifier for the client performing the mutation. */
|
|
1255
2635
|
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
1256
2636
|
/** Errors encountered during execution of the mutation. */
|
|
1257
|
-
errors
|
|
2637
|
+
errors?: Maybe<Array<Error>>;
|
|
1258
2638
|
/** The newly created runtime. */
|
|
1259
2639
|
runtime?: Maybe<Runtime>;
|
|
1260
2640
|
}
|
|
@@ -1273,7 +2653,7 @@ export interface RuntimesDeletePayload {
|
|
|
1273
2653
|
/** A unique identifier for the client performing the mutation. */
|
|
1274
2654
|
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
1275
2655
|
/** Errors encountered during execution of the mutation. */
|
|
1276
|
-
errors
|
|
2656
|
+
errors?: Maybe<Array<Error>>;
|
|
1277
2657
|
/** The updated organization. */
|
|
1278
2658
|
runtime?: Maybe<Runtime>;
|
|
1279
2659
|
}
|
|
@@ -1292,7 +2672,7 @@ export interface RuntimesRotateTokenPayload {
|
|
|
1292
2672
|
/** A unique identifier for the client performing the mutation. */
|
|
1293
2673
|
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
1294
2674
|
/** Errors encountered during execution of the mutation. */
|
|
1295
|
-
errors
|
|
2675
|
+
errors?: Maybe<Array<Error>>;
|
|
1296
2676
|
/** The updated runtime. */
|
|
1297
2677
|
runtime?: Maybe<Runtime>;
|
|
1298
2678
|
}
|
|
@@ -1315,36 +2695,84 @@ export interface RuntimesUpdatePayload {
|
|
|
1315
2695
|
/** A unique identifier for the client performing the mutation. */
|
|
1316
2696
|
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
1317
2697
|
/** Errors encountered during execution of the mutation. */
|
|
1318
|
-
errors
|
|
2698
|
+
errors?: Maybe<Array<Error>>;
|
|
1319
2699
|
/** The updated runtime. */
|
|
1320
2700
|
runtime?: Maybe<Runtime>;
|
|
1321
2701
|
}
|
|
1322
2702
|
|
|
2703
|
+
/** Represents a translation */
|
|
2704
|
+
export interface Translation {
|
|
2705
|
+
__typename?: 'Translation';
|
|
2706
|
+
/** Code of the translation */
|
|
2707
|
+
code?: Maybe<Scalars['String']['output']>;
|
|
2708
|
+
/** Content of the translation */
|
|
2709
|
+
content?: Maybe<Scalars['String']['output']>;
|
|
2710
|
+
}
|
|
2711
|
+
|
|
2712
|
+
/** The connection type for Translation. */
|
|
2713
|
+
export interface TranslationConnection {
|
|
2714
|
+
__typename?: 'TranslationConnection';
|
|
2715
|
+
/** Total count of collection. */
|
|
2716
|
+
count?: Maybe<Scalars['Int']['output']>;
|
|
2717
|
+
/** A list of edges. */
|
|
2718
|
+
edges?: Maybe<Array<Maybe<TranslationEdge>>>;
|
|
2719
|
+
/** A list of nodes. */
|
|
2720
|
+
nodes?: Maybe<Array<Maybe<Translation>>>;
|
|
2721
|
+
/** Information to aid in pagination. */
|
|
2722
|
+
pageInfo?: Maybe<PageInfo>;
|
|
2723
|
+
}
|
|
2724
|
+
|
|
2725
|
+
/** An edge in a connection. */
|
|
2726
|
+
export interface TranslationEdge {
|
|
2727
|
+
__typename?: 'TranslationEdge';
|
|
2728
|
+
/** A cursor for use in pagination. */
|
|
2729
|
+
cursor?: Maybe<Scalars['String']['output']>;
|
|
2730
|
+
/** The item at the end of the edge. */
|
|
2731
|
+
node?: Maybe<Translation>;
|
|
2732
|
+
}
|
|
2733
|
+
|
|
1323
2734
|
/** Represents a user */
|
|
1324
2735
|
export interface User {
|
|
1325
2736
|
__typename?: 'User';
|
|
1326
2737
|
/** Global admin status of the user */
|
|
1327
|
-
admin
|
|
2738
|
+
admin?: Maybe<Scalars['Boolean']['output']>;
|
|
1328
2739
|
/** The avatar if present of the user */
|
|
1329
2740
|
avatarPath?: Maybe<Scalars['String']['output']>;
|
|
1330
2741
|
/** Time when this User was created */
|
|
1331
|
-
createdAt
|
|
2742
|
+
createdAt?: Maybe<Scalars['Time']['output']>;
|
|
1332
2743
|
/** Email of the user */
|
|
1333
|
-
email
|
|
2744
|
+
email?: Maybe<Scalars['String']['output']>;
|
|
2745
|
+
/** Email verification date of the user if present */
|
|
2746
|
+
emailVerifiedAt?: Maybe<Scalars['Time']['output']>;
|
|
1334
2747
|
/** Firstname of the user */
|
|
1335
|
-
firstname
|
|
2748
|
+
firstname?: Maybe<Scalars['String']['output']>;
|
|
1336
2749
|
/** Global ID of this User */
|
|
1337
|
-
id
|
|
2750
|
+
id?: Maybe<Scalars['UserID']['output']>;
|
|
2751
|
+
/** Identities of this user */
|
|
2752
|
+
identities?: Maybe<UserIdentityConnection>;
|
|
1338
2753
|
/** Lastname of the user */
|
|
1339
|
-
lastname
|
|
2754
|
+
lastname?: Maybe<Scalars['String']['output']>;
|
|
1340
2755
|
/** Namespace of this user */
|
|
1341
2756
|
namespace?: Maybe<Namespace>;
|
|
1342
2757
|
/** Namespace Memberships of this user */
|
|
1343
|
-
namespaceMemberships
|
|
2758
|
+
namespaceMemberships?: Maybe<NamespaceMemberConnection>;
|
|
2759
|
+
/** Sessions of this user */
|
|
2760
|
+
sessions?: Maybe<UserSessionConnection>;
|
|
1344
2761
|
/** Time when this User was last updated */
|
|
1345
|
-
updatedAt
|
|
2762
|
+
updatedAt?: Maybe<Scalars['Time']['output']>;
|
|
2763
|
+
/** Abilities for the current user on this User */
|
|
2764
|
+
userAbilities?: Maybe<UserUserAbilities>;
|
|
1346
2765
|
/** Username of the user */
|
|
1347
|
-
username
|
|
2766
|
+
username?: Maybe<Scalars['String']['output']>;
|
|
2767
|
+
}
|
|
2768
|
+
|
|
2769
|
+
|
|
2770
|
+
/** Represents a user */
|
|
2771
|
+
export interface UserIdentitiesArgs {
|
|
2772
|
+
after?: InputMaybe<Scalars['String']['input']>;
|
|
2773
|
+
before?: InputMaybe<Scalars['String']['input']>;
|
|
2774
|
+
first?: InputMaybe<Scalars['Int']['input']>;
|
|
2775
|
+
last?: InputMaybe<Scalars['Int']['input']>;
|
|
1348
2776
|
}
|
|
1349
2777
|
|
|
1350
2778
|
|
|
@@ -1356,38 +2784,150 @@ export interface UserNamespaceMembershipsArgs {
|
|
|
1356
2784
|
last?: InputMaybe<Scalars['Int']['input']>;
|
|
1357
2785
|
}
|
|
1358
2786
|
|
|
2787
|
+
|
|
2788
|
+
/** Represents a user */
|
|
2789
|
+
export interface UserSessionsArgs {
|
|
2790
|
+
after?: InputMaybe<Scalars['String']['input']>;
|
|
2791
|
+
before?: InputMaybe<Scalars['String']['input']>;
|
|
2792
|
+
first?: InputMaybe<Scalars['Int']['input']>;
|
|
2793
|
+
last?: InputMaybe<Scalars['Int']['input']>;
|
|
2794
|
+
}
|
|
2795
|
+
|
|
2796
|
+
/** The connection type for User. */
|
|
2797
|
+
export interface UserConnection {
|
|
2798
|
+
__typename?: 'UserConnection';
|
|
2799
|
+
/** Total count of collection. */
|
|
2800
|
+
count?: Maybe<Scalars['Int']['output']>;
|
|
2801
|
+
/** A list of edges. */
|
|
2802
|
+
edges?: Maybe<Array<Maybe<UserEdge>>>;
|
|
2803
|
+
/** A list of nodes. */
|
|
2804
|
+
nodes?: Maybe<Array<Maybe<User>>>;
|
|
2805
|
+
/** Information to aid in pagination. */
|
|
2806
|
+
pageInfo?: Maybe<PageInfo>;
|
|
2807
|
+
}
|
|
2808
|
+
|
|
2809
|
+
/** An edge in a connection. */
|
|
2810
|
+
export interface UserEdge {
|
|
2811
|
+
__typename?: 'UserEdge';
|
|
2812
|
+
/** A cursor for use in pagination. */
|
|
2813
|
+
cursor?: Maybe<Scalars['String']['output']>;
|
|
2814
|
+
/** The item at the end of the edge. */
|
|
2815
|
+
node?: Maybe<User>;
|
|
2816
|
+
}
|
|
2817
|
+
|
|
1359
2818
|
/** Represents an external user identity */
|
|
1360
2819
|
export interface UserIdentity {
|
|
1361
2820
|
__typename?: 'UserIdentity';
|
|
1362
2821
|
/** Time when this UserIdentity was created */
|
|
1363
|
-
createdAt
|
|
2822
|
+
createdAt?: Maybe<Scalars['Time']['output']>;
|
|
1364
2823
|
/** Global ID of this UserIdentity */
|
|
1365
|
-
id
|
|
2824
|
+
id?: Maybe<Scalars['UserIdentityID']['output']>;
|
|
1366
2825
|
/** The description for the runtime if present */
|
|
1367
|
-
identifier
|
|
2826
|
+
identifier?: Maybe<Scalars['String']['output']>;
|
|
1368
2827
|
/** The name for the runtime */
|
|
1369
|
-
providerId
|
|
2828
|
+
providerId?: Maybe<Scalars['String']['output']>;
|
|
1370
2829
|
/** Time when this UserIdentity was last updated */
|
|
1371
|
-
updatedAt
|
|
2830
|
+
updatedAt?: Maybe<Scalars['Time']['output']>;
|
|
1372
2831
|
/** The correlating user of the identity */
|
|
1373
|
-
user
|
|
2832
|
+
user?: Maybe<User>;
|
|
2833
|
+
}
|
|
2834
|
+
|
|
2835
|
+
/** The connection type for UserIdentity. */
|
|
2836
|
+
export interface UserIdentityConnection {
|
|
2837
|
+
__typename?: 'UserIdentityConnection';
|
|
2838
|
+
/** Total count of collection. */
|
|
2839
|
+
count?: Maybe<Scalars['Int']['output']>;
|
|
2840
|
+
/** A list of edges. */
|
|
2841
|
+
edges?: Maybe<Array<Maybe<UserIdentityEdge>>>;
|
|
2842
|
+
/** A list of nodes. */
|
|
2843
|
+
nodes?: Maybe<Array<Maybe<UserIdentity>>>;
|
|
2844
|
+
/** Information to aid in pagination. */
|
|
2845
|
+
pageInfo?: Maybe<PageInfo>;
|
|
2846
|
+
}
|
|
2847
|
+
|
|
2848
|
+
/** An edge in a connection. */
|
|
2849
|
+
export interface UserIdentityEdge {
|
|
2850
|
+
__typename?: 'UserIdentityEdge';
|
|
2851
|
+
/** A cursor for use in pagination. */
|
|
2852
|
+
cursor?: Maybe<Scalars['String']['output']>;
|
|
2853
|
+
/** The item at the end of the edge. */
|
|
2854
|
+
node?: Maybe<UserIdentity>;
|
|
1374
2855
|
}
|
|
1375
2856
|
|
|
1376
2857
|
/** Represents a user session */
|
|
1377
2858
|
export interface UserSession {
|
|
1378
2859
|
__typename?: 'UserSession';
|
|
1379
2860
|
/** Whether or not the session is active and can be used */
|
|
1380
|
-
active
|
|
2861
|
+
active?: Maybe<Scalars['Boolean']['output']>;
|
|
1381
2862
|
/** Time when this UserSession was created */
|
|
1382
|
-
createdAt
|
|
2863
|
+
createdAt?: Maybe<Scalars['Time']['output']>;
|
|
1383
2864
|
/** Global ID of this UserSession */
|
|
1384
|
-
id
|
|
2865
|
+
id?: Maybe<Scalars['UserSessionID']['output']>;
|
|
1385
2866
|
/** Token belonging to the session, only present on creation */
|
|
1386
2867
|
token?: Maybe<Scalars['String']['output']>;
|
|
1387
2868
|
/** Time when this UserSession was last updated */
|
|
1388
|
-
updatedAt
|
|
2869
|
+
updatedAt?: Maybe<Scalars['Time']['output']>;
|
|
1389
2870
|
/** User that belongs to the session */
|
|
1390
|
-
user
|
|
2871
|
+
user?: Maybe<User>;
|
|
2872
|
+
/** Abilities for the current user on this UserSession */
|
|
2873
|
+
userAbilities?: Maybe<UserSessionUserAbilities>;
|
|
2874
|
+
}
|
|
2875
|
+
|
|
2876
|
+
/** The connection type for UserSession. */
|
|
2877
|
+
export interface UserSessionConnection {
|
|
2878
|
+
__typename?: 'UserSessionConnection';
|
|
2879
|
+
/** Total count of collection. */
|
|
2880
|
+
count?: Maybe<Scalars['Int']['output']>;
|
|
2881
|
+
/** A list of edges. */
|
|
2882
|
+
edges?: Maybe<Array<Maybe<UserSessionEdge>>>;
|
|
2883
|
+
/** A list of nodes. */
|
|
2884
|
+
nodes?: Maybe<Array<Maybe<UserSession>>>;
|
|
2885
|
+
/** Information to aid in pagination. */
|
|
2886
|
+
pageInfo?: Maybe<PageInfo>;
|
|
2887
|
+
}
|
|
2888
|
+
|
|
2889
|
+
/** An edge in a connection. */
|
|
2890
|
+
export interface UserSessionEdge {
|
|
2891
|
+
__typename?: 'UserSessionEdge';
|
|
2892
|
+
/** A cursor for use in pagination. */
|
|
2893
|
+
cursor?: Maybe<Scalars['String']['output']>;
|
|
2894
|
+
/** The item at the end of the edge. */
|
|
2895
|
+
node?: Maybe<UserSession>;
|
|
2896
|
+
}
|
|
2897
|
+
|
|
2898
|
+
/** Abilities for the current user on this UserSession */
|
|
2899
|
+
export interface UserSessionUserAbilities {
|
|
2900
|
+
__typename?: 'UserSessionUserAbilities';
|
|
2901
|
+
/** Shows if the current user has the `logout_session` ability on this UserSession */
|
|
2902
|
+
logoutSession?: Maybe<Scalars['Boolean']['output']>;
|
|
2903
|
+
}
|
|
2904
|
+
|
|
2905
|
+
/** Abilities for the current user on this User */
|
|
2906
|
+
export interface UserUserAbilities {
|
|
2907
|
+
__typename?: 'UserUserAbilities';
|
|
2908
|
+
/** Shows if the current user has the `manage_mfa` ability on this User */
|
|
2909
|
+
manageMfa?: Maybe<Scalars['Boolean']['output']>;
|
|
2910
|
+
/** Shows if the current user has the `update_user` ability on this User */
|
|
2911
|
+
updateUser?: Maybe<Scalars['Boolean']['output']>;
|
|
2912
|
+
}
|
|
2913
|
+
|
|
2914
|
+
/** Autogenerated input type of UsersEmailVerification */
|
|
2915
|
+
export interface UsersEmailVerificationInput {
|
|
2916
|
+
/** A unique identifier for the client performing the mutation. */
|
|
2917
|
+
clientMutationId?: InputMaybe<Scalars['String']['input']>;
|
|
2918
|
+
/** The email verification token */
|
|
2919
|
+
token: Scalars['String']['input'];
|
|
2920
|
+
}
|
|
2921
|
+
|
|
2922
|
+
/** Autogenerated return type of UsersEmailVerification. */
|
|
2923
|
+
export interface UsersEmailVerificationPayload {
|
|
2924
|
+
__typename?: 'UsersEmailVerificationPayload';
|
|
2925
|
+
/** A unique identifier for the client performing the mutation. */
|
|
2926
|
+
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
2927
|
+
/** Errors encountered during execution of the mutation. */
|
|
2928
|
+
errors?: Maybe<Array<Error>>;
|
|
2929
|
+
/** The user whose email was verified */
|
|
2930
|
+
user?: Maybe<User>;
|
|
1391
2931
|
}
|
|
1392
2932
|
|
|
1393
2933
|
/** Autogenerated input type of UsersIdentityLink */
|
|
@@ -1406,7 +2946,7 @@ export interface UsersIdentityLinkPayload {
|
|
|
1406
2946
|
/** A unique identifier for the client performing the mutation. */
|
|
1407
2947
|
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
1408
2948
|
/** Errors encountered during execution of the mutation. */
|
|
1409
|
-
errors
|
|
2949
|
+
errors?: Maybe<Array<Error>>;
|
|
1410
2950
|
/** The created user identity */
|
|
1411
2951
|
userIdentity?: Maybe<UserIdentity>;
|
|
1412
2952
|
}
|
|
@@ -1427,7 +2967,7 @@ export interface UsersIdentityLoginPayload {
|
|
|
1427
2967
|
/** A unique identifier for the client performing the mutation. */
|
|
1428
2968
|
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
1429
2969
|
/** Errors encountered during execution of the mutation. */
|
|
1430
|
-
errors
|
|
2970
|
+
errors?: Maybe<Array<Error>>;
|
|
1431
2971
|
/** The created user session */
|
|
1432
2972
|
userSession?: Maybe<UserSession>;
|
|
1433
2973
|
}
|
|
@@ -1448,7 +2988,7 @@ export interface UsersIdentityRegisterPayload {
|
|
|
1448
2988
|
/** A unique identifier for the client performing the mutation. */
|
|
1449
2989
|
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
1450
2990
|
/** Errors encountered during execution of the mutation. */
|
|
1451
|
-
errors
|
|
2991
|
+
errors?: Maybe<Array<Error>>;
|
|
1452
2992
|
/** The created users session */
|
|
1453
2993
|
userSession?: Maybe<UserSession>;
|
|
1454
2994
|
}
|
|
@@ -1467,7 +3007,7 @@ export interface UsersIdentityUnlinkPayload {
|
|
|
1467
3007
|
/** A unique identifier for the client performing the mutation. */
|
|
1468
3008
|
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
1469
3009
|
/** Errors encountered during execution of the mutation. */
|
|
1470
|
-
errors
|
|
3010
|
+
errors?: Maybe<Array<Error>>;
|
|
1471
3011
|
/** The removed identity */
|
|
1472
3012
|
userIdentity?: Maybe<UserIdentity>;
|
|
1473
3013
|
}
|
|
@@ -1492,7 +3032,7 @@ export interface UsersLoginPayload {
|
|
|
1492
3032
|
/** A unique identifier for the client performing the mutation. */
|
|
1493
3033
|
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
1494
3034
|
/** Errors encountered during execution of the mutation. */
|
|
1495
|
-
errors
|
|
3035
|
+
errors?: Maybe<Array<Error>>;
|
|
1496
3036
|
/** The created user session */
|
|
1497
3037
|
userSession?: Maybe<UserSession>;
|
|
1498
3038
|
}
|
|
@@ -1511,7 +3051,7 @@ export interface UsersLogoutPayload {
|
|
|
1511
3051
|
/** A unique identifier for the client performing the mutation. */
|
|
1512
3052
|
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
1513
3053
|
/** Errors encountered during execution of the mutation. */
|
|
1514
|
-
errors
|
|
3054
|
+
errors?: Maybe<Array<Error>>;
|
|
1515
3055
|
/** The logged out user session */
|
|
1516
3056
|
userSession?: Maybe<UserSession>;
|
|
1517
3057
|
}
|
|
@@ -1530,7 +3070,7 @@ export interface UsersMfaBackupCodesRotatePayload {
|
|
|
1530
3070
|
/** The newly rotated backup codes. */
|
|
1531
3071
|
codes?: Maybe<Array<Scalars['String']['output']>>;
|
|
1532
3072
|
/** Errors encountered during execution of the mutation. */
|
|
1533
|
-
errors
|
|
3073
|
+
errors?: Maybe<Array<Error>>;
|
|
1534
3074
|
}
|
|
1535
3075
|
|
|
1536
3076
|
/** Autogenerated input type of UsersMfaTotpGenerateSecret */
|
|
@@ -1545,7 +3085,7 @@ export interface UsersMfaTotpGenerateSecretPayload {
|
|
|
1545
3085
|
/** A unique identifier for the client performing the mutation. */
|
|
1546
3086
|
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
1547
3087
|
/** Errors encountered during execution of the mutation. */
|
|
1548
|
-
errors
|
|
3088
|
+
errors?: Maybe<Array<Error>>;
|
|
1549
3089
|
/** The created and signed secret */
|
|
1550
3090
|
secret?: Maybe<Scalars['String']['output']>;
|
|
1551
3091
|
}
|
|
@@ -1569,11 +3109,53 @@ export interface UsersMfaTotpValidateSecretPayload {
|
|
|
1569
3109
|
/** A unique identifier for the client performing the mutation. */
|
|
1570
3110
|
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
1571
3111
|
/** Errors encountered during execution of the mutation. */
|
|
1572
|
-
errors
|
|
3112
|
+
errors?: Maybe<Array<Error>>;
|
|
1573
3113
|
/** The modified user */
|
|
1574
3114
|
user?: Maybe<User>;
|
|
1575
3115
|
}
|
|
1576
3116
|
|
|
3117
|
+
/** Autogenerated input type of UsersPasswordReset */
|
|
3118
|
+
export interface UsersPasswordResetInput {
|
|
3119
|
+
/** A unique identifier for the client performing the mutation. */
|
|
3120
|
+
clientMutationId?: InputMaybe<Scalars['String']['input']>;
|
|
3121
|
+
/** The new password to set for the user */
|
|
3122
|
+
newPassword: Scalars['String']['input'];
|
|
3123
|
+
/** The confirmation of the new password to set for the user needs to be the same as the new password */
|
|
3124
|
+
newPasswordConfirmation: Scalars['String']['input'];
|
|
3125
|
+
/** The password reset token sent to the user email */
|
|
3126
|
+
resetToken: Scalars['String']['input'];
|
|
3127
|
+
}
|
|
3128
|
+
|
|
3129
|
+
/** Autogenerated return type of UsersPasswordReset. */
|
|
3130
|
+
export interface UsersPasswordResetPayload {
|
|
3131
|
+
__typename?: 'UsersPasswordResetPayload';
|
|
3132
|
+
/** A unique identifier for the client performing the mutation. */
|
|
3133
|
+
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
3134
|
+
/** Errors encountered during execution of the mutation. */
|
|
3135
|
+
errors?: Maybe<Array<Error>>;
|
|
3136
|
+
/** A message indicating the result of the password reset request */
|
|
3137
|
+
message?: Maybe<Scalars['String']['output']>;
|
|
3138
|
+
}
|
|
3139
|
+
|
|
3140
|
+
/** Autogenerated input type of UsersPasswordResetRequest */
|
|
3141
|
+
export interface UsersPasswordResetRequestInput {
|
|
3142
|
+
/** A unique identifier for the client performing the mutation. */
|
|
3143
|
+
clientMutationId?: InputMaybe<Scalars['String']['input']>;
|
|
3144
|
+
/** Email of the user to reset the password */
|
|
3145
|
+
email: Scalars['String']['input'];
|
|
3146
|
+
}
|
|
3147
|
+
|
|
3148
|
+
/** Autogenerated return type of UsersPasswordResetRequest. */
|
|
3149
|
+
export interface UsersPasswordResetRequestPayload {
|
|
3150
|
+
__typename?: 'UsersPasswordResetRequestPayload';
|
|
3151
|
+
/** A unique identifier for the client performing the mutation. */
|
|
3152
|
+
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
3153
|
+
/** Errors encountered during execution of the mutation. */
|
|
3154
|
+
errors?: Maybe<Array<Error>>;
|
|
3155
|
+
/** A message indicating the result of the password reset request */
|
|
3156
|
+
message?: Maybe<Scalars['String']['output']>;
|
|
3157
|
+
}
|
|
3158
|
+
|
|
1577
3159
|
/** Autogenerated input type of UsersRegister */
|
|
1578
3160
|
export interface UsersRegisterInput {
|
|
1579
3161
|
/** A unique identifier for the client performing the mutation. */
|
|
@@ -1582,6 +3164,8 @@ export interface UsersRegisterInput {
|
|
|
1582
3164
|
email: Scalars['String']['input'];
|
|
1583
3165
|
/** Password of the user */
|
|
1584
3166
|
password: Scalars['String']['input'];
|
|
3167
|
+
/** The repeated password of the user to check for typos */
|
|
3168
|
+
passwordRepeat: Scalars['String']['input'];
|
|
1585
3169
|
/** Username of the user */
|
|
1586
3170
|
username: Scalars['String']['input'];
|
|
1587
3171
|
}
|
|
@@ -1592,7 +3176,7 @@ export interface UsersRegisterPayload {
|
|
|
1592
3176
|
/** A unique identifier for the client performing the mutation. */
|
|
1593
3177
|
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
1594
3178
|
/** Errors encountered during execution of the mutation. */
|
|
1595
|
-
errors
|
|
3179
|
+
errors?: Maybe<Array<Error>>;
|
|
1596
3180
|
/** The created users session */
|
|
1597
3181
|
userSession?: Maybe<UserSession>;
|
|
1598
3182
|
}
|
|
@@ -1609,6 +3193,12 @@ export interface UsersUpdateInput {
|
|
|
1609
3193
|
firstname?: InputMaybe<Scalars['String']['input']>;
|
|
1610
3194
|
/** New lastname for the user. */
|
|
1611
3195
|
lastname?: InputMaybe<Scalars['String']['input']>;
|
|
3196
|
+
/** The data of the mfa validation */
|
|
3197
|
+
mfa?: InputMaybe<MfaInput>;
|
|
3198
|
+
/** New password for the user. */
|
|
3199
|
+
password?: InputMaybe<Scalars['String']['input']>;
|
|
3200
|
+
/** New password repeat for the user to check for typos, required if password is set. */
|
|
3201
|
+
passwordRepeat?: InputMaybe<Scalars['String']['input']>;
|
|
1612
3202
|
/** ID of the user to update. */
|
|
1613
3203
|
userId: Scalars['UserID']['input'];
|
|
1614
3204
|
/** New username for the user. */
|
|
@@ -1621,7 +3211,7 @@ export interface UsersUpdatePayload {
|
|
|
1621
3211
|
/** A unique identifier for the client performing the mutation. */
|
|
1622
3212
|
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
1623
3213
|
/** Errors encountered during execution of the mutation. */
|
|
1624
|
-
errors
|
|
3214
|
+
errors?: Maybe<Array<Error>>;
|
|
1625
3215
|
/** The updated user. */
|
|
1626
3216
|
user?: Maybe<User>;
|
|
1627
3217
|
}
|