@code0-tech/sagittarius-graphql-types 0.0.0-6f0b32a0eb18c9c3569a090f089c6adf1b4d666c → 0.0.0-7d24b48c8b78d8f07d3805cd04b406334b0784d4
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 +2201 -188
- package/package.json +5 -6
- package/index.js +0 -0
package/index.d.ts
CHANGED
|
@@ -1,73 +1,120 @@
|
|
|
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
|
+
UserID: { input: `gid://sagittarius/User/${number}`; output: `gid://sagittarius/User/${number}`; }
|
|
44
|
+
UserIdentityID: { input: `gid://sagittarius/UserIdentity/${number}`; output: `gid://sagittarius/UserIdentity/${number}`; }
|
|
45
|
+
UserSessionID: { input: `gid://sagittarius/UserSession/${number}`; output: `gid://sagittarius/UserSession/${number}`; }
|
|
45
46
|
}
|
|
46
47
|
|
|
47
48
|
/** Represents an active model error */
|
|
48
49
|
export interface ActiveModelError {
|
|
49
50
|
__typename?: 'ActiveModelError';
|
|
50
51
|
/** The affected attribute on the model */
|
|
51
|
-
attribute
|
|
52
|
+
attribute?: Maybe<Scalars['String']['output']>;
|
|
52
53
|
/** The validation type that failed for the attribute */
|
|
53
|
-
type
|
|
54
|
+
type?: Maybe<Scalars['String']['output']>;
|
|
55
|
+
}
|
|
56
|
+
|
|
57
|
+
/** Represents the application instance */
|
|
58
|
+
export interface Application {
|
|
59
|
+
__typename?: 'Application';
|
|
60
|
+
/** URL to the legal notice page */
|
|
61
|
+
legalNoticeUrl?: Maybe<Scalars['String']['output']>;
|
|
62
|
+
/** Metadata about the application */
|
|
63
|
+
metadata?: Maybe<Metadata>;
|
|
64
|
+
/** URL to the privacy policy page */
|
|
65
|
+
privacyUrl?: Maybe<Scalars['String']['output']>;
|
|
66
|
+
/** Global application settings */
|
|
67
|
+
settings?: Maybe<ApplicationSettings>;
|
|
68
|
+
/** URL to the terms and conditions page */
|
|
69
|
+
termsAndConditionsUrl?: Maybe<Scalars['String']['output']>;
|
|
70
|
+
/** Abilities for the current user on this Application */
|
|
71
|
+
userAbilities?: Maybe<ApplicationUserAbilities>;
|
|
54
72
|
}
|
|
55
73
|
|
|
56
74
|
/** Represents the application settings */
|
|
57
75
|
export interface ApplicationSettings {
|
|
58
76
|
__typename?: 'ApplicationSettings';
|
|
77
|
+
/** Shows if admin status can be queried by non-administrators */
|
|
78
|
+
adminStatusVisible?: Maybe<Scalars['Boolean']['output']>;
|
|
79
|
+
/** List of configured identity providers */
|
|
80
|
+
identityProviders?: Maybe<IdentityProviderConnection>;
|
|
81
|
+
/** URL to the legal notice page */
|
|
82
|
+
legalNoticeUrl?: Maybe<Scalars['String']['output']>;
|
|
59
83
|
/** Shows if organization creation is restricted to administrators */
|
|
60
|
-
organizationCreationRestricted
|
|
84
|
+
organizationCreationRestricted?: Maybe<Scalars['Boolean']['output']>;
|
|
85
|
+
/** URL to the privacy policy page */
|
|
86
|
+
privacyUrl?: Maybe<Scalars['String']['output']>;
|
|
87
|
+
/** URL to the terms and conditions page */
|
|
88
|
+
termsAndConditionsUrl?: Maybe<Scalars['String']['output']>;
|
|
61
89
|
/** Shows if user registration is enabled */
|
|
62
|
-
userRegistrationEnabled
|
|
90
|
+
userRegistrationEnabled?: Maybe<Scalars['Boolean']['output']>;
|
|
91
|
+
}
|
|
92
|
+
|
|
93
|
+
|
|
94
|
+
/** Represents the application settings */
|
|
95
|
+
export interface ApplicationSettingsIdentityProvidersArgs {
|
|
96
|
+
after?: InputMaybe<Scalars['String']['input']>;
|
|
97
|
+
before?: InputMaybe<Scalars['String']['input']>;
|
|
98
|
+
first?: InputMaybe<Scalars['Int']['input']>;
|
|
99
|
+
last?: InputMaybe<Scalars['Int']['input']>;
|
|
63
100
|
}
|
|
64
101
|
|
|
65
102
|
/** Autogenerated input type of ApplicationSettingsUpdate */
|
|
66
103
|
export interface ApplicationSettingsUpdateInput {
|
|
104
|
+
/** Set if admin status can be queried by non-administrators. */
|
|
105
|
+
adminStatusVisible?: InputMaybe<Scalars['Boolean']['input']>;
|
|
67
106
|
/** A unique identifier for the client performing the mutation. */
|
|
68
107
|
clientMutationId?: InputMaybe<Scalars['String']['input']>;
|
|
108
|
+
/** Set the list of configured identity providers. */
|
|
109
|
+
identityProviders?: InputMaybe<Array<IdentityProviderInput>>;
|
|
110
|
+
/** Set the URL to the legal notice page. */
|
|
111
|
+
legalNoticeUrl?: InputMaybe<Scalars['String']['input']>;
|
|
69
112
|
/** Set if organization creation is restricted to administrators. */
|
|
70
113
|
organizationCreationRestricted?: InputMaybe<Scalars['Boolean']['input']>;
|
|
114
|
+
/** Set the URL to the privacy policy page. */
|
|
115
|
+
privacyUrl?: InputMaybe<Scalars['String']['input']>;
|
|
116
|
+
/** Set the URL to the terms and conditions page. */
|
|
117
|
+
termsAndConditionsUrl?: InputMaybe<Scalars['String']['input']>;
|
|
71
118
|
/** Set if user registration is enabled. */
|
|
72
119
|
userRegistrationEnabled?: InputMaybe<Scalars['Boolean']['input']>;
|
|
73
120
|
}
|
|
@@ -80,7 +127,24 @@ export interface ApplicationSettingsUpdatePayload {
|
|
|
80
127
|
/** A unique identifier for the client performing the mutation. */
|
|
81
128
|
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
82
129
|
/** Errors encountered during execution of the mutation. */
|
|
83
|
-
errors
|
|
130
|
+
errors?: Maybe<Array<Error>>;
|
|
131
|
+
}
|
|
132
|
+
|
|
133
|
+
/** Abilities for the current user on this Application */
|
|
134
|
+
export interface ApplicationUserAbilities {
|
|
135
|
+
__typename?: 'ApplicationUserAbilities';
|
|
136
|
+
/** Shows if the current user has the `create_organization` ability on this Application */
|
|
137
|
+
createOrganization?: Maybe<Scalars['Boolean']['output']>;
|
|
138
|
+
/** Shows if the current user has the `create_runtime` ability on this Application */
|
|
139
|
+
createRuntime?: Maybe<Scalars['Boolean']['output']>;
|
|
140
|
+
/** Shows if the current user has the `delete_runtime` ability on this Application */
|
|
141
|
+
deleteRuntime?: Maybe<Scalars['Boolean']['output']>;
|
|
142
|
+
/** Shows if the current user has the `rotate_runtime_token` ability on this Application */
|
|
143
|
+
rotateRuntimeToken?: Maybe<Scalars['Boolean']['output']>;
|
|
144
|
+
/** Shows if the current user has the `update_application_setting` ability on this Application */
|
|
145
|
+
updateApplicationSetting?: Maybe<Scalars['Boolean']['output']>;
|
|
146
|
+
/** Shows if the current user has the `update_runtime` ability on this Application */
|
|
147
|
+
updateRuntime?: Maybe<Scalars['Boolean']['output']>;
|
|
84
148
|
}
|
|
85
149
|
|
|
86
150
|
/** Objects that can present an authentication */
|
|
@@ -89,48 +153,251 @@ export type Authentication = UserSession;
|
|
|
89
153
|
/** Represents a DataType */
|
|
90
154
|
export interface DataType {
|
|
91
155
|
__typename?: 'DataType';
|
|
156
|
+
/** Name of the function */
|
|
157
|
+
aliases?: Maybe<Array<Translation>>;
|
|
92
158
|
/** Time when this DataType was created */
|
|
93
|
-
createdAt
|
|
159
|
+
createdAt?: Maybe<Scalars['Time']['output']>;
|
|
160
|
+
/** Display message of the function */
|
|
161
|
+
displayMessages?: Maybe<Array<Translation>>;
|
|
162
|
+
/** Generic keys of the datatype */
|
|
163
|
+
genericKeys?: Maybe<Array<Scalars['String']['output']>>;
|
|
94
164
|
/** Global ID of this DataType */
|
|
95
|
-
id
|
|
165
|
+
id?: Maybe<Scalars['DataTypeID']['output']>;
|
|
96
166
|
/** The identifier scoped to the namespace */
|
|
97
|
-
identifier
|
|
98
|
-
/**
|
|
99
|
-
|
|
167
|
+
identifier?: Maybe<Scalars['String']['output']>;
|
|
168
|
+
/** Names of the flow type setting */
|
|
169
|
+
name?: Maybe<Array<Translation>>;
|
|
170
|
+
/** Rules of the datatype */
|
|
171
|
+
rules?: Maybe<DataTypeRuleConnection>;
|
|
172
|
+
/** The runtime where this datatype belongs to */
|
|
173
|
+
runtime?: Maybe<Runtime>;
|
|
100
174
|
/** Time when this DataType was last updated */
|
|
101
|
-
updatedAt
|
|
175
|
+
updatedAt?: Maybe<Scalars['Time']['output']>;
|
|
102
176
|
/** The type of the datatype */
|
|
103
|
-
variant
|
|
177
|
+
variant?: Maybe<DataTypeVariant>;
|
|
178
|
+
}
|
|
179
|
+
|
|
180
|
+
|
|
181
|
+
/** Represents a DataType */
|
|
182
|
+
export interface DataTypeRulesArgs {
|
|
183
|
+
after?: InputMaybe<Scalars['String']['input']>;
|
|
184
|
+
before?: InputMaybe<Scalars['String']['input']>;
|
|
185
|
+
first?: InputMaybe<Scalars['Int']['input']>;
|
|
186
|
+
last?: InputMaybe<Scalars['Int']['input']>;
|
|
104
187
|
}
|
|
105
188
|
|
|
106
189
|
/** The connection type for DataType. */
|
|
107
190
|
export interface DataTypeConnection {
|
|
108
191
|
__typename?: 'DataTypeConnection';
|
|
109
192
|
/** Total count of collection. */
|
|
110
|
-
count
|
|
193
|
+
count?: Maybe<Scalars['Int']['output']>;
|
|
111
194
|
/** A list of edges. */
|
|
112
195
|
edges?: Maybe<Array<Maybe<DataTypeEdge>>>;
|
|
113
196
|
/** A list of nodes. */
|
|
114
197
|
nodes?: Maybe<Array<Maybe<DataType>>>;
|
|
115
198
|
/** Information to aid in pagination. */
|
|
116
|
-
pageInfo
|
|
199
|
+
pageInfo?: Maybe<PageInfo>;
|
|
117
200
|
}
|
|
118
201
|
|
|
119
202
|
/** An edge in a connection. */
|
|
120
203
|
export interface DataTypeEdge {
|
|
121
204
|
__typename?: 'DataTypeEdge';
|
|
122
205
|
/** A cursor for use in pagination. */
|
|
123
|
-
cursor
|
|
206
|
+
cursor?: Maybe<Scalars['String']['output']>;
|
|
124
207
|
/** The item at the end of the edge. */
|
|
125
208
|
node?: Maybe<DataType>;
|
|
126
209
|
}
|
|
127
210
|
|
|
211
|
+
/** Represents a data type identifier. */
|
|
212
|
+
export interface DataTypeIdentifier {
|
|
213
|
+
__typename?: 'DataTypeIdentifier';
|
|
214
|
+
/** Time when this DataTypeIdentifier was created */
|
|
215
|
+
createdAt?: Maybe<Scalars['Time']['output']>;
|
|
216
|
+
/** The data type of the data type identifier. */
|
|
217
|
+
dataType?: Maybe<DataType>;
|
|
218
|
+
/** The generic key of the data type identifier. */
|
|
219
|
+
genericKey?: Maybe<Scalars['String']['output']>;
|
|
220
|
+
/** The generic type of the data type identifier. */
|
|
221
|
+
genericType?: Maybe<GenericType>;
|
|
222
|
+
/** Global ID of this DataTypeIdentifier */
|
|
223
|
+
id?: Maybe<Scalars['DataTypeIdentifierID']['output']>;
|
|
224
|
+
/** Time when this DataTypeIdentifier was last updated */
|
|
225
|
+
updatedAt?: Maybe<Scalars['Time']['output']>;
|
|
226
|
+
}
|
|
227
|
+
|
|
228
|
+
/** The connection type for DataTypeIdentifier. */
|
|
229
|
+
export interface DataTypeIdentifierConnection {
|
|
230
|
+
__typename?: 'DataTypeIdentifierConnection';
|
|
231
|
+
/** Total count of collection. */
|
|
232
|
+
count?: Maybe<Scalars['Int']['output']>;
|
|
233
|
+
/** A list of edges. */
|
|
234
|
+
edges?: Maybe<Array<Maybe<DataTypeIdentifierEdge>>>;
|
|
235
|
+
/** A list of nodes. */
|
|
236
|
+
nodes?: Maybe<Array<Maybe<DataTypeIdentifier>>>;
|
|
237
|
+
/** Information to aid in pagination. */
|
|
238
|
+
pageInfo?: Maybe<PageInfo>;
|
|
239
|
+
}
|
|
240
|
+
|
|
241
|
+
/** An edge in a connection. */
|
|
242
|
+
export interface DataTypeIdentifierEdge {
|
|
243
|
+
__typename?: 'DataTypeIdentifierEdge';
|
|
244
|
+
/** A cursor for use in pagination. */
|
|
245
|
+
cursor?: Maybe<Scalars['String']['output']>;
|
|
246
|
+
/** The item at the end of the edge. */
|
|
247
|
+
node?: Maybe<DataTypeIdentifier>;
|
|
248
|
+
}
|
|
249
|
+
|
|
250
|
+
/** Input type for data type identifier */
|
|
251
|
+
export interface DataTypeIdentifierInput {
|
|
252
|
+
/** Data type ID */
|
|
253
|
+
dataTypeId?: InputMaybe<Scalars['DataTypeID']['input']>;
|
|
254
|
+
/** Generic key value */
|
|
255
|
+
genericKey?: InputMaybe<Scalars['String']['input']>;
|
|
256
|
+
/** Generic type information */
|
|
257
|
+
genericType?: InputMaybe<GenericTypeInput>;
|
|
258
|
+
}
|
|
259
|
+
|
|
260
|
+
/** Represents a rule that can be applied to a data type. */
|
|
261
|
+
export interface DataTypeRule {
|
|
262
|
+
__typename?: 'DataTypeRule';
|
|
263
|
+
/** The configuration of the rule */
|
|
264
|
+
config?: Maybe<DataTypeRulesConfig>;
|
|
265
|
+
/** Time when this DataTypeRule was created */
|
|
266
|
+
createdAt?: Maybe<Scalars['Time']['output']>;
|
|
267
|
+
/** Global ID of this DataTypeRule */
|
|
268
|
+
id?: Maybe<Scalars['DataTypeRuleID']['output']>;
|
|
269
|
+
/** Time when this DataTypeRule was last updated */
|
|
270
|
+
updatedAt?: Maybe<Scalars['Time']['output']>;
|
|
271
|
+
/** The type of the rule */
|
|
272
|
+
variant?: Maybe<DataTypeRulesVariant>;
|
|
273
|
+
}
|
|
274
|
+
|
|
275
|
+
/** The connection type for DataTypeRule. */
|
|
276
|
+
export interface DataTypeRuleConnection {
|
|
277
|
+
__typename?: 'DataTypeRuleConnection';
|
|
278
|
+
/** Total count of collection. */
|
|
279
|
+
count?: Maybe<Scalars['Int']['output']>;
|
|
280
|
+
/** A list of edges. */
|
|
281
|
+
edges?: Maybe<Array<Maybe<DataTypeRuleEdge>>>;
|
|
282
|
+
/** A list of nodes. */
|
|
283
|
+
nodes?: Maybe<Array<Maybe<DataTypeRule>>>;
|
|
284
|
+
/** Information to aid in pagination. */
|
|
285
|
+
pageInfo?: Maybe<PageInfo>;
|
|
286
|
+
}
|
|
287
|
+
|
|
288
|
+
/** An edge in a connection. */
|
|
289
|
+
export interface DataTypeRuleEdge {
|
|
290
|
+
__typename?: 'DataTypeRuleEdge';
|
|
291
|
+
/** A cursor for use in pagination. */
|
|
292
|
+
cursor?: Maybe<Scalars['String']['output']>;
|
|
293
|
+
/** The item at the end of the edge. */
|
|
294
|
+
node?: Maybe<DataTypeRule>;
|
|
295
|
+
}
|
|
296
|
+
|
|
297
|
+
/** Represents a rule that can be applied to a data type. */
|
|
298
|
+
export type DataTypeRulesConfig = DataTypeRulesContainsKeyConfig | DataTypeRulesContainsTypeConfig | DataTypeRulesInputTypesConfig | DataTypeRulesItemOfCollectionConfig | DataTypeRulesNumberRangeConfig | DataTypeRulesParentTypeConfig | DataTypeRulesRegexConfig | DataTypeRulesReturnTypeConfig;
|
|
299
|
+
|
|
300
|
+
/** Represents a rule that can be applied to a data type. */
|
|
301
|
+
export interface DataTypeRulesContainsKeyConfig {
|
|
302
|
+
__typename?: 'DataTypeRulesContainsKeyConfig';
|
|
303
|
+
/** The identifier of the data type this rule belongs to */
|
|
304
|
+
dataTypeIdentifier?: Maybe<DataTypeIdentifier>;
|
|
305
|
+
/** The key of the rule */
|
|
306
|
+
key?: Maybe<Scalars['String']['output']>;
|
|
307
|
+
}
|
|
308
|
+
|
|
309
|
+
/** Represents a rule that can be applied to a data type. */
|
|
310
|
+
export interface DataTypeRulesContainsTypeConfig {
|
|
311
|
+
__typename?: 'DataTypeRulesContainsTypeConfig';
|
|
312
|
+
/** The identifier of the data type this rule belongs to */
|
|
313
|
+
dataTypeIdentifier?: Maybe<DataTypeIdentifier>;
|
|
314
|
+
}
|
|
315
|
+
|
|
316
|
+
/** Represents a subtype of input type configuration for a input data type. */
|
|
317
|
+
export interface DataTypeRulesInputTypeConfig {
|
|
318
|
+
__typename?: 'DataTypeRulesInputTypeConfig';
|
|
319
|
+
/** The identifier of the data type this input type belongs to */
|
|
320
|
+
dataTypeIdentifier?: Maybe<DataTypeIdentifier>;
|
|
321
|
+
/** The input identifier that this configuration applies to */
|
|
322
|
+
inputIdentifier?: Maybe<Scalars['String']['output']>;
|
|
323
|
+
}
|
|
324
|
+
|
|
325
|
+
/** Represents a rule that can be applied to a data type. */
|
|
326
|
+
export interface DataTypeRulesInputTypesConfig {
|
|
327
|
+
__typename?: 'DataTypeRulesInputTypesConfig';
|
|
328
|
+
/** The input types that can be used in this data type rule */
|
|
329
|
+
inputTypes?: Maybe<Array<DataTypeRulesInputTypeConfig>>;
|
|
330
|
+
}
|
|
331
|
+
|
|
332
|
+
/** Represents a rule that can be applied to a data type. */
|
|
333
|
+
export interface DataTypeRulesItemOfCollectionConfig {
|
|
334
|
+
__typename?: 'DataTypeRulesItemOfCollectionConfig';
|
|
335
|
+
/** The items that can be configured for this rule. */
|
|
336
|
+
items?: Maybe<Array<Scalars['JSON']['output']>>;
|
|
337
|
+
}
|
|
338
|
+
|
|
339
|
+
/** Represents a rule that can be applied to a data type. */
|
|
340
|
+
export interface DataTypeRulesNumberRangeConfig {
|
|
341
|
+
__typename?: 'DataTypeRulesNumberRangeConfig';
|
|
342
|
+
/** The minimum value of the range */
|
|
343
|
+
from?: Maybe<Scalars['Int']['output']>;
|
|
344
|
+
/** The step value for the range, if applicable */
|
|
345
|
+
steps?: Maybe<Scalars['Int']['output']>;
|
|
346
|
+
/** The maximum value of the range */
|
|
347
|
+
to?: Maybe<Scalars['Int']['output']>;
|
|
348
|
+
}
|
|
349
|
+
|
|
350
|
+
/** Represents a rule that can be applied to a data type. */
|
|
351
|
+
export interface DataTypeRulesParentTypeConfig {
|
|
352
|
+
__typename?: 'DataTypeRulesParentTypeConfig';
|
|
353
|
+
/** The data type identifier for the parent type. */
|
|
354
|
+
dataTypeIdentifier?: Maybe<DataTypeIdentifier>;
|
|
355
|
+
}
|
|
356
|
+
|
|
357
|
+
/** Represents a rule that can be applied to a data type. */
|
|
358
|
+
export interface DataTypeRulesRegexConfig {
|
|
359
|
+
__typename?: 'DataTypeRulesRegexConfig';
|
|
360
|
+
/** The regex pattern to match against the data type value. */
|
|
361
|
+
pattern?: Maybe<Scalars['String']['output']>;
|
|
362
|
+
}
|
|
363
|
+
|
|
364
|
+
/** Represents a rule that can be applied to a data type. */
|
|
365
|
+
export interface DataTypeRulesReturnTypeConfig {
|
|
366
|
+
__typename?: 'DataTypeRulesReturnTypeConfig';
|
|
367
|
+
/** The data type identifier for the return type. */
|
|
368
|
+
dataTypeIdentifier?: Maybe<DataTypeIdentifier>;
|
|
369
|
+
}
|
|
370
|
+
|
|
371
|
+
/** The type of rule that can be applied to a data type. */
|
|
372
|
+
export const enum DataTypeRulesVariant {
|
|
373
|
+
/** The rule checks if a key is present in the data type. */
|
|
374
|
+
ContainsKey = 'CONTAINS_KEY',
|
|
375
|
+
/** The rule checks if a specific type is present in the data type. */
|
|
376
|
+
ContainsType = 'CONTAINS_TYPE',
|
|
377
|
+
/** The rule checks if the data type matches a specific input type. */
|
|
378
|
+
InputTypes = 'INPUT_TYPES',
|
|
379
|
+
/** The rule checks if an item is part of a collection in the data type. */
|
|
380
|
+
ItemOfCollection = 'ITEM_OF_COLLECTION',
|
|
381
|
+
/** The rule checks if a number falls within a specified range. */
|
|
382
|
+
NumberRange = 'NUMBER_RANGE',
|
|
383
|
+
/** The rule checks if the data type is a child of a specific parent type. */
|
|
384
|
+
ParentType = 'PARENT_TYPE',
|
|
385
|
+
/** The rule checks if a string matches a specified regular expression. */
|
|
386
|
+
Regex = 'REGEX',
|
|
387
|
+
/** The rule checks if the data type matches a specific return type. */
|
|
388
|
+
ReturnType = 'RETURN_TYPE'
|
|
389
|
+
}
|
|
390
|
+
|
|
128
391
|
/** Represent all available types of a datatype */
|
|
129
|
-
export enum DataTypeVariant {
|
|
392
|
+
export const enum DataTypeVariant {
|
|
130
393
|
/** Represents an array */
|
|
131
394
|
Array = 'ARRAY',
|
|
132
395
|
/** Represents an data type containing a data type */
|
|
133
396
|
DataType = 'DATA_TYPE',
|
|
397
|
+
/** Represents a error */
|
|
398
|
+
Error = 'ERROR',
|
|
399
|
+
/** Represents a node */
|
|
400
|
+
Node = 'NODE',
|
|
134
401
|
/** Represents an object */
|
|
135
402
|
Object = 'OBJECT',
|
|
136
403
|
/** Represents a primitive datatype */
|
|
@@ -139,6 +406,9 @@ export enum DataTypeVariant {
|
|
|
139
406
|
Type = 'TYPE'
|
|
140
407
|
}
|
|
141
408
|
|
|
409
|
+
/** Represents a detailed error with either a message or an active model error */
|
|
410
|
+
export type DetailedError = ActiveModelError | FlowValidationError | MessageError;
|
|
411
|
+
|
|
142
412
|
/** Autogenerated input type of Echo */
|
|
143
413
|
export interface EchoInput {
|
|
144
414
|
/** A unique identifier for the client performing the mutation. */
|
|
@@ -153,13 +423,589 @@ export interface EchoPayload {
|
|
|
153
423
|
/** A unique identifier for the client performing the mutation. */
|
|
154
424
|
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
155
425
|
/** Errors encountered during execution of the mutation. */
|
|
156
|
-
errors
|
|
426
|
+
errors?: Maybe<Array<Error>>;
|
|
157
427
|
/** Message returned to the user. */
|
|
158
428
|
message?: Maybe<Scalars['String']['output']>;
|
|
159
429
|
}
|
|
160
430
|
|
|
161
431
|
/** Objects that can present an error */
|
|
162
|
-
export
|
|
432
|
+
export interface Error {
|
|
433
|
+
__typename?: 'Error';
|
|
434
|
+
/** Detailed validation errors if applicable */
|
|
435
|
+
details?: Maybe<Array<DetailedError>>;
|
|
436
|
+
/** The code representing the error type */
|
|
437
|
+
errorCode?: Maybe<ErrorCodeEnum>;
|
|
438
|
+
}
|
|
439
|
+
|
|
440
|
+
/** Represents the available error responses */
|
|
441
|
+
export const enum ErrorCodeEnum {
|
|
442
|
+
/** This action would remove the last administrative role */
|
|
443
|
+
CannotDeleteLastAdminRole = 'CANNOT_DELETE_LAST_ADMIN_ROLE',
|
|
444
|
+
/** Only administrators can modify admin status of users */
|
|
445
|
+
CannotModifyAdmin = 'CANNOT_MODIFY_ADMIN',
|
|
446
|
+
/** Users cannot modify their own admin status */
|
|
447
|
+
CannotModifyOwnAdmin = 'CANNOT_MODIFY_OWN_ADMIN',
|
|
448
|
+
/** This action would remove the last administrator */
|
|
449
|
+
CannotRemoveLastAdministrator = 'CANNOT_REMOVE_LAST_ADMINISTRATOR',
|
|
450
|
+
/** This action would remove the last administrative ability */
|
|
451
|
+
CannotRemoveLastAdminAbility = 'CANNOT_REMOVE_LAST_ADMIN_ABILITY',
|
|
452
|
+
/** The data type identifier with the given identifier was not found */
|
|
453
|
+
DataTypeIdentifierNotFound = 'DATA_TYPE_IDENTIFIER_NOT_FOUND',
|
|
454
|
+
/** The data type with the given identifier was not found */
|
|
455
|
+
DataTypeNotFound = 'DATA_TYPE_NOT_FOUND',
|
|
456
|
+
/** Failed to send the email verification */
|
|
457
|
+
EmailVerificationSendFailed = 'EMAIL_VERIFICATION_SEND_FAILED',
|
|
458
|
+
/** This external identity does not exist */
|
|
459
|
+
ExternalIdentityDoesNotExist = 'EXTERNAL_IDENTITY_DOES_NOT_EXIST',
|
|
460
|
+
/** The old backup codes could not be deleted */
|
|
461
|
+
FailedToInvalidateOldBackupCodes = 'FAILED_TO_INVALIDATE_OLD_BACKUP_CODES',
|
|
462
|
+
/** Failed to reset the user password */
|
|
463
|
+
FailedToResetPassword = 'FAILED_TO_RESET_PASSWORD',
|
|
464
|
+
/** The new backup codes could not be saved */
|
|
465
|
+
FailedToSaveValidBackupCode = 'FAILED_TO_SAVE_VALID_BACKUP_CODE',
|
|
466
|
+
/** The flow with the given identifier was not found */
|
|
467
|
+
FlowNotFound = 'FLOW_NOT_FOUND',
|
|
468
|
+
/** The flow type with the given identifier was not found */
|
|
469
|
+
FlowTypeNotFound = 'FLOW_TYPE_NOT_FOUND',
|
|
470
|
+
/** The flow validation has failed */
|
|
471
|
+
FlowValidationFailed = 'FLOW_VALIDATION_FAILED',
|
|
472
|
+
/** The id for the function value node does not exist */
|
|
473
|
+
FunctionValueNotFound = 'FUNCTION_VALUE_NOT_FOUND',
|
|
474
|
+
/** The given key was not found in the data type */
|
|
475
|
+
GenericKeyNotFound = 'GENERIC_KEY_NOT_FOUND',
|
|
476
|
+
/** The external identity with the given identifier was not found */
|
|
477
|
+
IdentityNotFound = 'IDENTITY_NOT_FOUND',
|
|
478
|
+
/** Failed to validate the external identity */
|
|
479
|
+
IdentityValidationFailed = 'IDENTITY_VALIDATION_FAILED',
|
|
480
|
+
/** Resources are from different namespaces */
|
|
481
|
+
InconsistentNamespace = 'INCONSISTENT_NAMESPACE',
|
|
482
|
+
/** The attachment is invalid because of active model errors */
|
|
483
|
+
InvalidAttachment = 'INVALID_ATTACHMENT',
|
|
484
|
+
/** The data type is invalid because of active model errors */
|
|
485
|
+
InvalidDataType = 'INVALID_DATA_TYPE',
|
|
486
|
+
/** This external identity is invalid */
|
|
487
|
+
InvalidExternalIdentity = 'INVALID_EXTERNAL_IDENTITY',
|
|
488
|
+
/** The flow is invalid because of active model errors */
|
|
489
|
+
InvalidFlow = 'INVALID_FLOW',
|
|
490
|
+
/** The flow setting is invalid because of active model errors */
|
|
491
|
+
InvalidFlowSetting = 'INVALID_FLOW_SETTING',
|
|
492
|
+
/** The flow type is invalid because of active model errors */
|
|
493
|
+
InvalidFlowType = 'INVALID_FLOW_TYPE',
|
|
494
|
+
/** The flow type setting is invalid because of active model errors */
|
|
495
|
+
InvalidFlowTypeSetting = 'INVALID_FLOW_TYPE_SETTING',
|
|
496
|
+
/** The generic mapper is invalid because of active model errors */
|
|
497
|
+
InvalidGenericMapper = 'INVALID_GENERIC_MAPPER',
|
|
498
|
+
/** Invalid login data provided */
|
|
499
|
+
InvalidLoginData = 'INVALID_LOGIN_DATA',
|
|
500
|
+
/** The namespace license is invalid because of active model errors */
|
|
501
|
+
InvalidNamespaceLicense = 'INVALID_NAMESPACE_LICENSE',
|
|
502
|
+
/** The namespace member is invalid because of active model errors */
|
|
503
|
+
InvalidNamespaceMember = 'INVALID_NAMESPACE_MEMBER',
|
|
504
|
+
/** The namespace project is invalid because of active model errors */
|
|
505
|
+
InvalidNamespaceProject = 'INVALID_NAMESPACE_PROJECT',
|
|
506
|
+
/** The namespace role is invalid because of active model errors */
|
|
507
|
+
InvalidNamespaceRole = 'INVALID_NAMESPACE_ROLE',
|
|
508
|
+
/** The node function is invalid */
|
|
509
|
+
InvalidNodeFunction = 'INVALID_NODE_FUNCTION',
|
|
510
|
+
/** The node parameter is invalid */
|
|
511
|
+
InvalidNodeParameter = 'INVALID_NODE_PARAMETER',
|
|
512
|
+
/** The organization is invalid because of active model errors */
|
|
513
|
+
InvalidOrganization = 'INVALID_ORGANIZATION',
|
|
514
|
+
/** The provided password repeat does not match the password */
|
|
515
|
+
InvalidPasswordRepeat = 'INVALID_PASSWORD_REPEAT',
|
|
516
|
+
/** The runtime is invalid because of active model errors */
|
|
517
|
+
InvalidRuntime = 'INVALID_RUNTIME',
|
|
518
|
+
/** The runtime function definition is invalid */
|
|
519
|
+
InvalidRuntimeFunctionDefinition = 'INVALID_RUNTIME_FUNCTION_DEFINITION',
|
|
520
|
+
/** The runtime function ID is invalid */
|
|
521
|
+
InvalidRuntimeFunctionId = 'INVALID_RUNTIME_FUNCTION_ID',
|
|
522
|
+
/** The runtime parameter definition is invalid */
|
|
523
|
+
InvalidRuntimeParameterDefinition = 'INVALID_RUNTIME_PARAMETER_DEFINITION',
|
|
524
|
+
/** The runtime parameter ID is invalid */
|
|
525
|
+
InvalidRuntimeParameterId = 'INVALID_RUNTIME_PARAMETER_ID',
|
|
526
|
+
/** Invalid setting provided */
|
|
527
|
+
InvalidSetting = 'INVALID_SETTING',
|
|
528
|
+
/** The TOTP secret is invalid or cannot be verified */
|
|
529
|
+
InvalidTotpSecret = 'INVALID_TOTP_SECRET',
|
|
530
|
+
/** The user is invalid because of active model errors */
|
|
531
|
+
InvalidUser = 'INVALID_USER',
|
|
532
|
+
/** The user identity is invalid because of active model errors */
|
|
533
|
+
InvalidUserIdentity = 'INVALID_USER_IDENTITY',
|
|
534
|
+
/** The user session is invalid because of active model errors */
|
|
535
|
+
InvalidUserSession = 'INVALID_USER_SESSION',
|
|
536
|
+
/** Invalid verification code provided */
|
|
537
|
+
InvalidVerificationCode = 'INVALID_VERIFICATION_CODE',
|
|
538
|
+
/** The namespace license with the given identifier was not found */
|
|
539
|
+
LicenseNotFound = 'LICENSE_NOT_FOUND',
|
|
540
|
+
/** Failed to load user identity from external provider */
|
|
541
|
+
LoadingIdentityFailed = 'LOADING_IDENTITY_FAILED',
|
|
542
|
+
/** Invalid MFA data provided */
|
|
543
|
+
MfaFailed = 'MFA_FAILED',
|
|
544
|
+
/** MFA is required */
|
|
545
|
+
MfaRequired = 'MFA_REQUIRED',
|
|
546
|
+
/** The primary runtime has more definitions than this one */
|
|
547
|
+
MissingDefinition = 'MISSING_DEFINITION',
|
|
548
|
+
/** This external identity is missing data */
|
|
549
|
+
MissingIdentityData = 'MISSING_IDENTITY_DATA',
|
|
550
|
+
/** Not all required parameters are present */
|
|
551
|
+
MissingParameter = 'MISSING_PARAMETER',
|
|
552
|
+
/** The user is not permitted to perform this operation */
|
|
553
|
+
MissingPermission = 'MISSING_PERMISSION',
|
|
554
|
+
/** The project is missing a primary runtime */
|
|
555
|
+
MissingPrimaryRuntime = 'MISSING_PRIMARY_RUNTIME',
|
|
556
|
+
/** The namespace member with the given identifier was not found */
|
|
557
|
+
NamespaceMemberNotFound = 'NAMESPACE_MEMBER_NOT_FOUND',
|
|
558
|
+
/** The namespace with the given identifier was not found */
|
|
559
|
+
NamespaceNotFound = 'NAMESPACE_NOT_FOUND',
|
|
560
|
+
/** The namespace project with the given identifier was not found */
|
|
561
|
+
NamespaceProjectNotFound = 'NAMESPACE_PROJECT_NOT_FOUND',
|
|
562
|
+
/** The namespace role with the given identifier was not found */
|
|
563
|
+
NamespaceRoleNotFound = 'NAMESPACE_ROLE_NOT_FOUND',
|
|
564
|
+
/** The node with this id does not exist */
|
|
565
|
+
NodeNotFound = 'NODE_NOT_FOUND',
|
|
566
|
+
/** No data type identifier could be found for the given generic key */
|
|
567
|
+
NoDatatypeIdentifierForGenericKey = 'NO_DATATYPE_IDENTIFIER_FOR_GENERIC_KEY',
|
|
568
|
+
/** No data type could be found for the given identifier */
|
|
569
|
+
NoDataTypeForIdentifier = 'NO_DATA_TYPE_FOR_IDENTIFIER',
|
|
570
|
+
/** There are no free license seats to complete this operation */
|
|
571
|
+
NoFreeLicenseSeats = 'NO_FREE_LICENSE_SEATS',
|
|
572
|
+
/** No generic type could be found for the given identifier */
|
|
573
|
+
NoGenericTypeForIdentifier = 'NO_GENERIC_TYPE_FOR_IDENTIFIER',
|
|
574
|
+
/** The project does not have a primary runtime */
|
|
575
|
+
NoPrimaryRuntime = 'NO_PRIMARY_RUNTIME',
|
|
576
|
+
/** The organization with the given identifier was not found */
|
|
577
|
+
OrganizationNotFound = 'ORGANIZATION_NOT_FOUND',
|
|
578
|
+
/** The primary runtime has a newer definition than this one */
|
|
579
|
+
OutdatedDefinition = 'OUTDATED_DEFINITION',
|
|
580
|
+
/** @deprecated Outdated concept */
|
|
581
|
+
PrimaryLevelNotFound = 'PRIMARY_LEVEL_NOT_FOUND',
|
|
582
|
+
/** The namespace project with the given identifier was not found */
|
|
583
|
+
ProjectNotFound = 'PROJECT_NOT_FOUND',
|
|
584
|
+
/** A referenced value could not be found */
|
|
585
|
+
ReferencedValueNotFound = 'REFERENCED_VALUE_NOT_FOUND',
|
|
586
|
+
/** Self-registration is disabled */
|
|
587
|
+
RegistrationDisabled = 'REGISTRATION_DISABLED',
|
|
588
|
+
/** Resources are from different runtimes */
|
|
589
|
+
RuntimeMismatch = 'RUNTIME_MISMATCH',
|
|
590
|
+
/** The runtime with the given identifier was not found */
|
|
591
|
+
RuntimeNotFound = 'RUNTIME_NOT_FOUND',
|
|
592
|
+
/** @deprecated Outdated concept */
|
|
593
|
+
SecondaryLevelNotFound = 'SECONDARY_LEVEL_NOT_FOUND',
|
|
594
|
+
/** @deprecated Outdated concept */
|
|
595
|
+
TertiaryLevelExceedsParameters = 'TERTIARY_LEVEL_EXCEEDS_PARAMETERS',
|
|
596
|
+
/** This user already has TOTP set up */
|
|
597
|
+
TotpSecretAlreadySet = 'TOTP_SECRET_ALREADY_SET',
|
|
598
|
+
/** The user is not permitted to modify this field */
|
|
599
|
+
UnmodifiableField = 'UNMODIFIABLE_FIELD',
|
|
600
|
+
/** The user with the given identifier was not found */
|
|
601
|
+
UserNotFound = 'USER_NOT_FOUND',
|
|
602
|
+
/** The user session with the given identifier was not found */
|
|
603
|
+
UserSessionNotFound = 'USER_SESSION_NOT_FOUND',
|
|
604
|
+
/** Invalid TOTP code provided */
|
|
605
|
+
WrongTotp = 'WRONG_TOTP'
|
|
606
|
+
}
|
|
607
|
+
|
|
608
|
+
/** Represents a flow */
|
|
609
|
+
export interface Flow {
|
|
610
|
+
__typename?: 'Flow';
|
|
611
|
+
/** Time when this Flow was created */
|
|
612
|
+
createdAt?: Maybe<Scalars['Time']['output']>;
|
|
613
|
+
/** Global ID of this Flow */
|
|
614
|
+
id?: Maybe<Scalars['FlowID']['output']>;
|
|
615
|
+
/** The input data type of the flow */
|
|
616
|
+
inputType?: Maybe<DataType>;
|
|
617
|
+
/** Name of the flow */
|
|
618
|
+
name?: Maybe<Scalars['String']['output']>;
|
|
619
|
+
/** Nodes of the flow */
|
|
620
|
+
nodes?: Maybe<NodeFunctionConnection>;
|
|
621
|
+
/** The project the flow belongs to */
|
|
622
|
+
project?: Maybe<NamespaceProject>;
|
|
623
|
+
/** The return data type of the flow */
|
|
624
|
+
returnType?: Maybe<DataType>;
|
|
625
|
+
/** The settings of the flow */
|
|
626
|
+
settings?: Maybe<FlowSettingConnection>;
|
|
627
|
+
/** The ID of the starting node of the flow */
|
|
628
|
+
startingNodeId?: Maybe<Scalars['NodeFunctionID']['output']>;
|
|
629
|
+
/** The flow type of the flow */
|
|
630
|
+
type?: Maybe<FlowType>;
|
|
631
|
+
/** Time when this Flow was last updated */
|
|
632
|
+
updatedAt?: Maybe<Scalars['Time']['output']>;
|
|
633
|
+
/** Abilities for the current user on this Flow */
|
|
634
|
+
userAbilities?: Maybe<FlowUserAbilities>;
|
|
635
|
+
}
|
|
636
|
+
|
|
637
|
+
|
|
638
|
+
/** Represents a flow */
|
|
639
|
+
export interface FlowNodesArgs {
|
|
640
|
+
after?: InputMaybe<Scalars['String']['input']>;
|
|
641
|
+
before?: InputMaybe<Scalars['String']['input']>;
|
|
642
|
+
first?: InputMaybe<Scalars['Int']['input']>;
|
|
643
|
+
last?: InputMaybe<Scalars['Int']['input']>;
|
|
644
|
+
}
|
|
645
|
+
|
|
646
|
+
|
|
647
|
+
/** Represents a flow */
|
|
648
|
+
export interface FlowSettingsArgs {
|
|
649
|
+
after?: InputMaybe<Scalars['String']['input']>;
|
|
650
|
+
before?: InputMaybe<Scalars['String']['input']>;
|
|
651
|
+
first?: InputMaybe<Scalars['Int']['input']>;
|
|
652
|
+
last?: InputMaybe<Scalars['Int']['input']>;
|
|
653
|
+
}
|
|
654
|
+
|
|
655
|
+
/** The connection type for Flow. */
|
|
656
|
+
export interface FlowConnection {
|
|
657
|
+
__typename?: 'FlowConnection';
|
|
658
|
+
/** Total count of collection. */
|
|
659
|
+
count?: Maybe<Scalars['Int']['output']>;
|
|
660
|
+
/** A list of edges. */
|
|
661
|
+
edges?: Maybe<Array<Maybe<FlowEdge>>>;
|
|
662
|
+
/** A list of nodes. */
|
|
663
|
+
nodes?: Maybe<Array<Maybe<Flow>>>;
|
|
664
|
+
/** Information to aid in pagination. */
|
|
665
|
+
pageInfo?: Maybe<PageInfo>;
|
|
666
|
+
}
|
|
667
|
+
|
|
668
|
+
/** An edge in a connection. */
|
|
669
|
+
export interface FlowEdge {
|
|
670
|
+
__typename?: 'FlowEdge';
|
|
671
|
+
/** A cursor for use in pagination. */
|
|
672
|
+
cursor?: Maybe<Scalars['String']['output']>;
|
|
673
|
+
/** The item at the end of the edge. */
|
|
674
|
+
node?: Maybe<Flow>;
|
|
675
|
+
}
|
|
676
|
+
|
|
677
|
+
/** Input type for creating or updating a flow */
|
|
678
|
+
export interface FlowInput {
|
|
679
|
+
/** The name of the flow */
|
|
680
|
+
name: Scalars['String']['input'];
|
|
681
|
+
/** The node functions of the flow */
|
|
682
|
+
nodes: Array<NodeFunctionInput>;
|
|
683
|
+
/** The settings of the flow */
|
|
684
|
+
settings?: InputMaybe<Array<FlowSettingInput>>;
|
|
685
|
+
/** The starting node of the flow */
|
|
686
|
+
startingNodeId: Scalars['NodeFunctionID']['input'];
|
|
687
|
+
/** The identifier of the flow type */
|
|
688
|
+
type: Scalars['FlowTypeID']['input'];
|
|
689
|
+
}
|
|
690
|
+
|
|
691
|
+
/** Represents a flow setting */
|
|
692
|
+
export interface FlowSetting {
|
|
693
|
+
__typename?: 'FlowSetting';
|
|
694
|
+
/** Time when this FlowSetting was created */
|
|
695
|
+
createdAt?: Maybe<Scalars['Time']['output']>;
|
|
696
|
+
/** The identifier of the flow setting */
|
|
697
|
+
flowSettingIdentifier?: Maybe<Scalars['String']['output']>;
|
|
698
|
+
/** Global ID of this FlowSetting */
|
|
699
|
+
id?: Maybe<Scalars['FlowSettingID']['output']>;
|
|
700
|
+
/** Time when this FlowSetting was last updated */
|
|
701
|
+
updatedAt?: Maybe<Scalars['Time']['output']>;
|
|
702
|
+
/** The value of the flow setting */
|
|
703
|
+
value?: Maybe<Scalars['JSON']['output']>;
|
|
704
|
+
}
|
|
705
|
+
|
|
706
|
+
/** The connection type for FlowSetting. */
|
|
707
|
+
export interface FlowSettingConnection {
|
|
708
|
+
__typename?: 'FlowSettingConnection';
|
|
709
|
+
/** Total count of collection. */
|
|
710
|
+
count?: Maybe<Scalars['Int']['output']>;
|
|
711
|
+
/** A list of edges. */
|
|
712
|
+
edges?: Maybe<Array<Maybe<FlowSettingEdge>>>;
|
|
713
|
+
/** A list of nodes. */
|
|
714
|
+
nodes?: Maybe<Array<Maybe<FlowSetting>>>;
|
|
715
|
+
/** Information to aid in pagination. */
|
|
716
|
+
pageInfo?: Maybe<PageInfo>;
|
|
717
|
+
}
|
|
718
|
+
|
|
719
|
+
/** An edge in a connection. */
|
|
720
|
+
export interface FlowSettingEdge {
|
|
721
|
+
__typename?: 'FlowSettingEdge';
|
|
722
|
+
/** A cursor for use in pagination. */
|
|
723
|
+
cursor?: Maybe<Scalars['String']['output']>;
|
|
724
|
+
/** The item at the end of the edge. */
|
|
725
|
+
node?: Maybe<FlowSetting>;
|
|
726
|
+
}
|
|
727
|
+
|
|
728
|
+
/** Input type for flow settings */
|
|
729
|
+
export interface FlowSettingInput {
|
|
730
|
+
/** The identifier (not database id) of the flow setting */
|
|
731
|
+
flowSettingIdentifier: Scalars['String']['input'];
|
|
732
|
+
/** The value of the flow setting */
|
|
733
|
+
value: Scalars['JSON']['input'];
|
|
734
|
+
}
|
|
735
|
+
|
|
736
|
+
/** Represents a flow type */
|
|
737
|
+
export interface FlowType {
|
|
738
|
+
__typename?: 'FlowType';
|
|
739
|
+
/** Name of the function */
|
|
740
|
+
aliases?: Maybe<Array<Translation>>;
|
|
741
|
+
/** Time when this FlowType was created */
|
|
742
|
+
createdAt?: Maybe<Scalars['Time']['output']>;
|
|
743
|
+
/** Descriptions of the flow type */
|
|
744
|
+
descriptions?: Maybe<Array<Translation>>;
|
|
745
|
+
/** Display message of the function */
|
|
746
|
+
displayMessages?: Maybe<Array<Translation>>;
|
|
747
|
+
/** Editable status of the flow type */
|
|
748
|
+
editable?: Maybe<Scalars['Boolean']['output']>;
|
|
749
|
+
/** Flow type settings of the flow type */
|
|
750
|
+
flowTypeSettings?: Maybe<Array<FlowTypeSetting>>;
|
|
751
|
+
/** Global ID of this FlowType */
|
|
752
|
+
id?: Maybe<Scalars['FlowTypeID']['output']>;
|
|
753
|
+
/** Identifier of the flow type */
|
|
754
|
+
identifier?: Maybe<Scalars['String']['output']>;
|
|
755
|
+
/** Input type of the flow type */
|
|
756
|
+
inputType?: Maybe<DataType>;
|
|
757
|
+
/** Names of the flow type */
|
|
758
|
+
names?: Maybe<Array<Translation>>;
|
|
759
|
+
/** Return type of the flow type */
|
|
760
|
+
returnType?: Maybe<DataType>;
|
|
761
|
+
/** Runtime of the flow type */
|
|
762
|
+
runtime?: Maybe<Runtime>;
|
|
763
|
+
/** Time when this FlowType was last updated */
|
|
764
|
+
updatedAt?: Maybe<Scalars['Time']['output']>;
|
|
765
|
+
}
|
|
766
|
+
|
|
767
|
+
/** The connection type for FlowType. */
|
|
768
|
+
export interface FlowTypeConnection {
|
|
769
|
+
__typename?: 'FlowTypeConnection';
|
|
770
|
+
/** Total count of collection. */
|
|
771
|
+
count?: Maybe<Scalars['Int']['output']>;
|
|
772
|
+
/** A list of edges. */
|
|
773
|
+
edges?: Maybe<Array<Maybe<FlowTypeEdge>>>;
|
|
774
|
+
/** A list of nodes. */
|
|
775
|
+
nodes?: Maybe<Array<Maybe<FlowType>>>;
|
|
776
|
+
/** Information to aid in pagination. */
|
|
777
|
+
pageInfo?: Maybe<PageInfo>;
|
|
778
|
+
}
|
|
779
|
+
|
|
780
|
+
/** An edge in a connection. */
|
|
781
|
+
export interface FlowTypeEdge {
|
|
782
|
+
__typename?: 'FlowTypeEdge';
|
|
783
|
+
/** A cursor for use in pagination. */
|
|
784
|
+
cursor?: Maybe<Scalars['String']['output']>;
|
|
785
|
+
/** The item at the end of the edge. */
|
|
786
|
+
node?: Maybe<FlowType>;
|
|
787
|
+
}
|
|
788
|
+
|
|
789
|
+
/** Represents a flow type setting */
|
|
790
|
+
export interface FlowTypeSetting {
|
|
791
|
+
__typename?: 'FlowTypeSetting';
|
|
792
|
+
/** Time when this FlowTypeSetting was created */
|
|
793
|
+
createdAt?: Maybe<Scalars['Time']['output']>;
|
|
794
|
+
/** Data type of the flow type setting */
|
|
795
|
+
dataType?: Maybe<DataType>;
|
|
796
|
+
/** Descriptions of the flow type setting */
|
|
797
|
+
descriptions?: Maybe<Array<Translation>>;
|
|
798
|
+
/** Flow type of the flow type setting */
|
|
799
|
+
flowType?: Maybe<FlowType>;
|
|
800
|
+
/** Global ID of this FlowTypeSetting */
|
|
801
|
+
id?: Maybe<Scalars['FlowTypeSettingID']['output']>;
|
|
802
|
+
/** Identifier of the flow type setting */
|
|
803
|
+
identifier?: Maybe<Scalars['String']['output']>;
|
|
804
|
+
/** Names of the flow type setting */
|
|
805
|
+
names?: Maybe<Array<Translation>>;
|
|
806
|
+
/** Unique status of the flow type setting */
|
|
807
|
+
unique?: Maybe<Scalars['Boolean']['output']>;
|
|
808
|
+
/** Time when this FlowTypeSetting was last updated */
|
|
809
|
+
updatedAt?: Maybe<Scalars['Time']['output']>;
|
|
810
|
+
}
|
|
811
|
+
|
|
812
|
+
/** Abilities for the current user on this Flow */
|
|
813
|
+
export interface FlowUserAbilities {
|
|
814
|
+
__typename?: 'FlowUserAbilities';
|
|
815
|
+
/** Shows if the current user has the `delete_flow` ability on this Flow */
|
|
816
|
+
deleteFlow?: Maybe<Scalars['Boolean']['output']>;
|
|
817
|
+
}
|
|
818
|
+
|
|
819
|
+
/** Represents a flow validation error */
|
|
820
|
+
export interface FlowValidationError {
|
|
821
|
+
__typename?: 'FlowValidationError';
|
|
822
|
+
/** Additional details about the validation error */
|
|
823
|
+
details?: Maybe<ActiveModelError>;
|
|
824
|
+
/** The code representing the validation error type */
|
|
825
|
+
errorCode?: Maybe<FlowValidationErrorCodeEnum>;
|
|
826
|
+
/** The severity of the validation error */
|
|
827
|
+
severity?: Maybe<FlowValidationSeverityEnum>;
|
|
828
|
+
}
|
|
829
|
+
|
|
830
|
+
/** Represents the available error responses */
|
|
831
|
+
export const enum FlowValidationErrorCodeEnum {
|
|
832
|
+
/** The generic key for the data type identifier was not found. */
|
|
833
|
+
DataTypeIdentifierGenericKeyNotFound = 'DATA_TYPE_IDENTIFIER_GENERIC_KEY_NOT_FOUND',
|
|
834
|
+
/** The data type identifier runtime does not match the flow type runtime. */
|
|
835
|
+
DataTypeIdentifierRuntimeMismatch = 'DATA_TYPE_IDENTIFIER_RUNTIME_MISMATCH',
|
|
836
|
+
/** The data type rule model is invalid. */
|
|
837
|
+
DataTypeRuleModelInvalid = 'DATA_TYPE_RULE_MODEL_INVALID',
|
|
838
|
+
/** The data type runtime does not match the flow type runtime. */
|
|
839
|
+
DataTypeRuntimeMismatch = 'DATA_TYPE_RUNTIME_MISMATCH',
|
|
840
|
+
/** The flow setting model is invalid. */
|
|
841
|
+
FlowSettingModelInvalid = 'FLOW_SETTING_MODEL_INVALID',
|
|
842
|
+
/** The flow type runtime does not match the project primary runtime. */
|
|
843
|
+
FlowTypeRuntimeMismatch = 'FLOW_TYPE_RUNTIME_MISMATCH',
|
|
844
|
+
/** The node function runtime does not match the project primary runtime. */
|
|
845
|
+
NodeFunctionRuntimeMismatch = 'NODE_FUNCTION_RUNTIME_MISMATCH',
|
|
846
|
+
/** The project does not have a primary runtime set. */
|
|
847
|
+
NoPrimaryRuntime = 'NO_PRIMARY_RUNTIME'
|
|
848
|
+
}
|
|
849
|
+
|
|
850
|
+
/** Represents the severity of a flow validation error */
|
|
851
|
+
export const enum FlowValidationSeverityEnum {
|
|
852
|
+
/** A blocking validation error */
|
|
853
|
+
Error = 'ERROR',
|
|
854
|
+
/** A minor typographical issue can also be blocking */
|
|
855
|
+
Typo = 'TYPO',
|
|
856
|
+
/** A non-blocking validation warning */
|
|
857
|
+
Warning = 'WARNING',
|
|
858
|
+
/** A weak validation issue that may not need to be addressed */
|
|
859
|
+
Weak = 'WEAK'
|
|
860
|
+
}
|
|
861
|
+
|
|
862
|
+
/** Represents a function definition */
|
|
863
|
+
export interface FunctionDefinition {
|
|
864
|
+
__typename?: 'FunctionDefinition';
|
|
865
|
+
/** Name of the function */
|
|
866
|
+
aliases?: Maybe<Array<Translation>>;
|
|
867
|
+
/** Time when this FunctionDefinition was created */
|
|
868
|
+
createdAt?: Maybe<Scalars['Time']['output']>;
|
|
869
|
+
/** All data type identifiers used within this Node Function */
|
|
870
|
+
dataTypeIdentifiers?: Maybe<DataTypeIdentifierConnection>;
|
|
871
|
+
/** Deprecation message of the function */
|
|
872
|
+
deprecationMessages?: Maybe<Array<Translation>>;
|
|
873
|
+
/** Description of the function */
|
|
874
|
+
descriptions?: Maybe<Array<Translation>>;
|
|
875
|
+
/** Display message of the function */
|
|
876
|
+
displayMessages?: Maybe<Array<Translation>>;
|
|
877
|
+
/** Documentation of the function */
|
|
878
|
+
documentations?: Maybe<Array<Translation>>;
|
|
879
|
+
/** Generic keys of the function */
|
|
880
|
+
genericKeys?: Maybe<Array<Scalars['String']['output']>>;
|
|
881
|
+
/** Global ID of this FunctionDefinition */
|
|
882
|
+
id?: Maybe<Scalars['FunctionDefinitionID']['output']>;
|
|
883
|
+
/** Identifier of the function */
|
|
884
|
+
identifier?: Maybe<Scalars['String']['output']>;
|
|
885
|
+
/** Name of the function */
|
|
886
|
+
names?: Maybe<Array<Translation>>;
|
|
887
|
+
/** Parameters of the function */
|
|
888
|
+
parameterDefinitions?: Maybe<ParameterDefinitionConnection>;
|
|
889
|
+
/** Return type of the function */
|
|
890
|
+
returnType?: Maybe<DataTypeIdentifier>;
|
|
891
|
+
/** Runtime function definition */
|
|
892
|
+
runtimeFunctionDefinition?: Maybe<RuntimeFunctionDefinition>;
|
|
893
|
+
/** Indicates if the function can throw an error */
|
|
894
|
+
throwsError?: Maybe<Scalars['Boolean']['output']>;
|
|
895
|
+
/** Time when this FunctionDefinition was last updated */
|
|
896
|
+
updatedAt?: Maybe<Scalars['Time']['output']>;
|
|
897
|
+
}
|
|
898
|
+
|
|
899
|
+
|
|
900
|
+
/** Represents a function definition */
|
|
901
|
+
export interface FunctionDefinitionDataTypeIdentifiersArgs {
|
|
902
|
+
after?: InputMaybe<Scalars['String']['input']>;
|
|
903
|
+
before?: InputMaybe<Scalars['String']['input']>;
|
|
904
|
+
first?: InputMaybe<Scalars['Int']['input']>;
|
|
905
|
+
last?: InputMaybe<Scalars['Int']['input']>;
|
|
906
|
+
}
|
|
907
|
+
|
|
908
|
+
|
|
909
|
+
/** Represents a function definition */
|
|
910
|
+
export interface FunctionDefinitionParameterDefinitionsArgs {
|
|
911
|
+
after?: InputMaybe<Scalars['String']['input']>;
|
|
912
|
+
before?: InputMaybe<Scalars['String']['input']>;
|
|
913
|
+
first?: InputMaybe<Scalars['Int']['input']>;
|
|
914
|
+
last?: InputMaybe<Scalars['Int']['input']>;
|
|
915
|
+
}
|
|
916
|
+
|
|
917
|
+
/** The connection type for FunctionDefinition. */
|
|
918
|
+
export interface FunctionDefinitionConnection {
|
|
919
|
+
__typename?: 'FunctionDefinitionConnection';
|
|
920
|
+
/** Total count of collection. */
|
|
921
|
+
count?: Maybe<Scalars['Int']['output']>;
|
|
922
|
+
/** A list of edges. */
|
|
923
|
+
edges?: Maybe<Array<Maybe<FunctionDefinitionEdge>>>;
|
|
924
|
+
/** A list of nodes. */
|
|
925
|
+
nodes?: Maybe<Array<Maybe<FunctionDefinition>>>;
|
|
926
|
+
/** Information to aid in pagination. */
|
|
927
|
+
pageInfo?: Maybe<PageInfo>;
|
|
928
|
+
}
|
|
929
|
+
|
|
930
|
+
/** An edge in a connection. */
|
|
931
|
+
export interface FunctionDefinitionEdge {
|
|
932
|
+
__typename?: 'FunctionDefinitionEdge';
|
|
933
|
+
/** A cursor for use in pagination. */
|
|
934
|
+
cursor?: Maybe<Scalars['String']['output']>;
|
|
935
|
+
/** The item at the end of the edge. */
|
|
936
|
+
node?: Maybe<FunctionDefinition>;
|
|
937
|
+
}
|
|
938
|
+
|
|
939
|
+
/** Represents a combination strategy with AND/OR logic used by a generic mapper. */
|
|
940
|
+
export interface GenericCombinationStrategy {
|
|
941
|
+
__typename?: 'GenericCombinationStrategy';
|
|
942
|
+
/** Time when this GenericCombinationStrategy was created */
|
|
943
|
+
createdAt?: Maybe<Scalars['Time']['output']>;
|
|
944
|
+
/** The associated generic mapper, if any. */
|
|
945
|
+
genericMapper?: Maybe<GenericMapper>;
|
|
946
|
+
/** Global ID of this GenericCombinationStrategy */
|
|
947
|
+
id?: Maybe<Scalars['GenericCombinationStrategyID']['output']>;
|
|
948
|
+
/** The combination type ('AND' or 'OR'). */
|
|
949
|
+
type?: Maybe<GenericCombinationStrategyType>;
|
|
950
|
+
/** Time when this GenericCombinationStrategy was last updated */
|
|
951
|
+
updatedAt?: Maybe<Scalars['Time']['output']>;
|
|
952
|
+
}
|
|
953
|
+
|
|
954
|
+
/** The available combination strategy types. */
|
|
955
|
+
export const enum GenericCombinationStrategyType {
|
|
956
|
+
/** Represents a logical AND combination. */
|
|
957
|
+
And = 'AND',
|
|
958
|
+
/** Represents a logical OR combination. */
|
|
959
|
+
Or = 'OR'
|
|
960
|
+
}
|
|
961
|
+
|
|
962
|
+
/** Represents a mapping between a source data type and a target key for generic values. */
|
|
963
|
+
export interface GenericMapper {
|
|
964
|
+
__typename?: 'GenericMapper';
|
|
965
|
+
/** Time when this GenericMapper was created */
|
|
966
|
+
createdAt?: Maybe<Scalars['Time']['output']>;
|
|
967
|
+
/** Combination strategies associated with this generic mapper. */
|
|
968
|
+
genericCombinationStrategies?: Maybe<Array<GenericCombinationStrategy>>;
|
|
969
|
+
/** Global ID of this GenericMapper */
|
|
970
|
+
id?: Maybe<Scalars['GenericMapperID']['output']>;
|
|
971
|
+
/** The source data type identifier. */
|
|
972
|
+
sourceDataTypeIdentifierIds?: Maybe<Array<Scalars['DataTypeIdentifierID']['output']>>;
|
|
973
|
+
/** The target key for the generic value. */
|
|
974
|
+
target?: Maybe<Scalars['String']['output']>;
|
|
975
|
+
/** Time when this GenericMapper was last updated */
|
|
976
|
+
updatedAt?: Maybe<Scalars['Time']['output']>;
|
|
977
|
+
}
|
|
978
|
+
|
|
979
|
+
/** Input type for generic mappers */
|
|
980
|
+
export interface GenericMapperInput {
|
|
981
|
+
/** The source data type identifier for the mapper */
|
|
982
|
+
sourceDataTypeIdentifiers: Array<DataTypeIdentifierInput>;
|
|
983
|
+
/** The target data type identifier for the mapper */
|
|
984
|
+
target: Scalars['String']['input'];
|
|
985
|
+
}
|
|
986
|
+
|
|
987
|
+
/** Represents a generic type that can be used in various contexts. */
|
|
988
|
+
export interface GenericType {
|
|
989
|
+
__typename?: 'GenericType';
|
|
990
|
+
/** Time when this GenericType was created */
|
|
991
|
+
createdAt?: Maybe<Scalars['Time']['output']>;
|
|
992
|
+
/** The data type associated with this generic type. */
|
|
993
|
+
dataType?: Maybe<DataType>;
|
|
994
|
+
/** The mappers associated with this generic type. */
|
|
995
|
+
genericMappers?: Maybe<Array<GenericMapper>>;
|
|
996
|
+
/** Global ID of this GenericType */
|
|
997
|
+
id?: Maybe<Scalars['GenericTypeID']['output']>;
|
|
998
|
+
/** Time when this GenericType was last updated */
|
|
999
|
+
updatedAt?: Maybe<Scalars['Time']['output']>;
|
|
1000
|
+
}
|
|
1001
|
+
|
|
1002
|
+
/** Input type for generic type operations. */
|
|
1003
|
+
export interface GenericTypeInput {
|
|
1004
|
+
/** The data type associated with this generic type. */
|
|
1005
|
+
dataTypeId: Scalars['DataTypeID']['input'];
|
|
1006
|
+
/** The mappers associated with this generic type. */
|
|
1007
|
+
genericMappers: Array<GenericMapperInput>;
|
|
1008
|
+
}
|
|
163
1009
|
|
|
164
1010
|
/** Represents the input for external user identity validation */
|
|
165
1011
|
export interface IdentityInput {
|
|
@@ -167,11 +1013,119 @@ export interface IdentityInput {
|
|
|
167
1013
|
code?: InputMaybe<Scalars['String']['input']>;
|
|
168
1014
|
}
|
|
169
1015
|
|
|
1016
|
+
/** Represents an identity provider configuration. */
|
|
1017
|
+
export interface IdentityProvider {
|
|
1018
|
+
__typename?: 'IdentityProvider';
|
|
1019
|
+
/** Configuration details of the identity provider. */
|
|
1020
|
+
config?: Maybe<IdentityProviderConfig>;
|
|
1021
|
+
/** Unique identifier of the identity provider. */
|
|
1022
|
+
id?: Maybe<Scalars['String']['output']>;
|
|
1023
|
+
/** Type of the identity provider. */
|
|
1024
|
+
type?: Maybe<IdentityProviderType>;
|
|
1025
|
+
}
|
|
1026
|
+
|
|
1027
|
+
/** Represents the configuration of an identity provider. */
|
|
1028
|
+
export type IdentityProviderConfig = OidcIdentityProviderConfig | SamlIdentityProviderConfig;
|
|
1029
|
+
|
|
1030
|
+
/** Input for identity provider configuration. Contains fields for both OIDC and SAML. */
|
|
1031
|
+
export interface IdentityProviderConfigInput {
|
|
1032
|
+
/** List of attribute statements for the identity provider */
|
|
1033
|
+
attributeStatements?: InputMaybe<Scalars['JSON']['input']>;
|
|
1034
|
+
/** The authorization URL for the OIDC identity provider */
|
|
1035
|
+
authorizationUrl?: InputMaybe<Scalars['String']['input']>;
|
|
1036
|
+
/** The client ID for the OIDC identity provider */
|
|
1037
|
+
clientId?: InputMaybe<Scalars['String']['input']>;
|
|
1038
|
+
/** The client secret for the OIDC identity provider */
|
|
1039
|
+
clientSecret?: InputMaybe<Scalars['String']['input']>;
|
|
1040
|
+
/** Optional metadata URL to fetch metadata (alternative to settings) */
|
|
1041
|
+
metadataUrl?: InputMaybe<Scalars['String']['input']>;
|
|
1042
|
+
/** The name of the identity provider */
|
|
1043
|
+
providerName?: InputMaybe<Scalars['String']['input']>;
|
|
1044
|
+
/** The redirect URI for the OIDC identity provider */
|
|
1045
|
+
redirectUri?: InputMaybe<Scalars['String']['input']>;
|
|
1046
|
+
/** The SAML response settings for the identity provider */
|
|
1047
|
+
responseSettings?: InputMaybe<Scalars['JSON']['input']>;
|
|
1048
|
+
/** The SAML settings for the identity provider */
|
|
1049
|
+
settings?: InputMaybe<Scalars['JSON']['input']>;
|
|
1050
|
+
/** The user details URL for the OIDC identity provider */
|
|
1051
|
+
userDetailsUrl?: InputMaybe<Scalars['String']['input']>;
|
|
1052
|
+
}
|
|
1053
|
+
|
|
1054
|
+
/** The connection type for IdentityProvider. */
|
|
1055
|
+
export interface IdentityProviderConnection {
|
|
1056
|
+
__typename?: 'IdentityProviderConnection';
|
|
1057
|
+
/** Total count of collection. */
|
|
1058
|
+
count?: Maybe<Scalars['Int']['output']>;
|
|
1059
|
+
/** A list of edges. */
|
|
1060
|
+
edges?: Maybe<Array<Maybe<IdentityProviderEdge>>>;
|
|
1061
|
+
/** A list of nodes. */
|
|
1062
|
+
nodes?: Maybe<Array<Maybe<IdentityProvider>>>;
|
|
1063
|
+
/** Information to aid in pagination. */
|
|
1064
|
+
pageInfo?: Maybe<PageInfo>;
|
|
1065
|
+
}
|
|
1066
|
+
|
|
1067
|
+
/** An edge in a connection. */
|
|
1068
|
+
export interface IdentityProviderEdge {
|
|
1069
|
+
__typename?: 'IdentityProviderEdge';
|
|
1070
|
+
/** A cursor for use in pagination. */
|
|
1071
|
+
cursor?: Maybe<Scalars['String']['output']>;
|
|
1072
|
+
/** The item at the end of the edge. */
|
|
1073
|
+
node?: Maybe<IdentityProvider>;
|
|
1074
|
+
}
|
|
1075
|
+
|
|
1076
|
+
/** Input for creating or updating an identity provider */
|
|
1077
|
+
export interface IdentityProviderInput {
|
|
1078
|
+
/** Configuration for the identity provider */
|
|
1079
|
+
config: IdentityProviderConfigInput;
|
|
1080
|
+
/** Unique identifier of the identity provider */
|
|
1081
|
+
id: Scalars['String']['input'];
|
|
1082
|
+
/** Type of the identity provider */
|
|
1083
|
+
type: IdentityProviderType;
|
|
1084
|
+
}
|
|
1085
|
+
|
|
1086
|
+
/** The available identity provider types. */
|
|
1087
|
+
export const enum IdentityProviderType {
|
|
1088
|
+
/** Identity provider of type discord */
|
|
1089
|
+
Discord = 'DISCORD',
|
|
1090
|
+
/** Identity provider of type github */
|
|
1091
|
+
Github = 'GITHUB',
|
|
1092
|
+
/** Identity provider of type gitlab */
|
|
1093
|
+
Gitlab = 'GITLAB',
|
|
1094
|
+
/** Identity provider of type google */
|
|
1095
|
+
Google = 'GOOGLE',
|
|
1096
|
+
/** Identity provider of type microsoft */
|
|
1097
|
+
Microsoft = 'MICROSOFT',
|
|
1098
|
+
/** Identity provider of type oidc */
|
|
1099
|
+
Oidc = 'OIDC',
|
|
1100
|
+
/** Identity provider of type saml */
|
|
1101
|
+
Saml = 'SAML'
|
|
1102
|
+
}
|
|
1103
|
+
|
|
1104
|
+
/** Represents a literal value, such as a string or number. */
|
|
1105
|
+
export interface LiteralValue {
|
|
1106
|
+
__typename?: 'LiteralValue';
|
|
1107
|
+
/** Time when this LiteralValue was created */
|
|
1108
|
+
createdAt?: Maybe<Scalars['Time']['output']>;
|
|
1109
|
+
/** Time when this LiteralValue was last updated */
|
|
1110
|
+
updatedAt?: Maybe<Scalars['Time']['output']>;
|
|
1111
|
+
/** The literal value itself as JSON. */
|
|
1112
|
+
value?: Maybe<Scalars['JSON']['output']>;
|
|
1113
|
+
}
|
|
1114
|
+
|
|
170
1115
|
/** Represents an error message */
|
|
171
1116
|
export interface MessageError {
|
|
172
1117
|
__typename?: 'MessageError';
|
|
173
1118
|
/** The message provided from the error */
|
|
174
|
-
message
|
|
1119
|
+
message?: Maybe<Scalars['String']['output']>;
|
|
1120
|
+
}
|
|
1121
|
+
|
|
1122
|
+
/** Application metadata */
|
|
1123
|
+
export interface Metadata {
|
|
1124
|
+
__typename?: 'Metadata';
|
|
1125
|
+
/** List of loaded extensions */
|
|
1126
|
+
extensions?: Maybe<Array<Scalars['String']['output']>>;
|
|
1127
|
+
/** Application version */
|
|
1128
|
+
version?: Maybe<Scalars['String']['output']>;
|
|
175
1129
|
}
|
|
176
1130
|
|
|
177
1131
|
/** Represents the input for mfa authentication */
|
|
@@ -182,8 +1136,19 @@ export interface MfaInput {
|
|
|
182
1136
|
value: Scalars['String']['input'];
|
|
183
1137
|
}
|
|
184
1138
|
|
|
1139
|
+
/** Represents the MFA status of a user */
|
|
1140
|
+
export interface MfaStatus {
|
|
1141
|
+
__typename?: 'MfaStatus';
|
|
1142
|
+
/** The number of backup codes remaining for the user. */
|
|
1143
|
+
backupCodesCount?: Maybe<Scalars['Int']['output']>;
|
|
1144
|
+
/** Indicates whether MFA is enabled for the user. */
|
|
1145
|
+
enabled?: Maybe<Scalars['Boolean']['output']>;
|
|
1146
|
+
/** Indicates whether TOTP MFA is enabled for the user. */
|
|
1147
|
+
totpEnabled?: Maybe<Scalars['Boolean']['output']>;
|
|
1148
|
+
}
|
|
1149
|
+
|
|
185
1150
|
/** Represent all available types to authenticate with mfa */
|
|
186
|
-
export enum MfaType {
|
|
1151
|
+
export const enum MfaType {
|
|
187
1152
|
/** Single use backup code */
|
|
188
1153
|
BackupCode = 'BACKUP_CODE',
|
|
189
1154
|
/** Time based onetime password */
|
|
@@ -200,11 +1165,12 @@ export interface Mutation {
|
|
|
200
1165
|
*
|
|
201
1166
|
* This is expected to be used for testing of endpoints, to verify
|
|
202
1167
|
* that a user has mutation access.
|
|
1168
|
+
*
|
|
203
1169
|
*/
|
|
204
1170
|
echo?: Maybe<EchoPayload>;
|
|
205
|
-
/** Create a new namespace license. */
|
|
1171
|
+
/** (EE only) Create a new namespace license. */
|
|
206
1172
|
namespacesLicensesCreate?: Maybe<NamespacesLicensesCreatePayload>;
|
|
207
|
-
/** Deletes an namespace license. */
|
|
1173
|
+
/** (EE only) Deletes an namespace license. */
|
|
208
1174
|
namespacesLicensesDelete?: Maybe<NamespacesLicensesDeletePayload>;
|
|
209
1175
|
/** Update the roles a member is assigned to. */
|
|
210
1176
|
namespacesMembersAssignRoles?: Maybe<NamespacesMembersAssignRolesPayload>;
|
|
@@ -212,10 +1178,18 @@ export interface Mutation {
|
|
|
212
1178
|
namespacesMembersDelete?: Maybe<NamespacesMembersDeletePayload>;
|
|
213
1179
|
/** Invite a new member to a namespace. */
|
|
214
1180
|
namespacesMembersInvite?: Maybe<NamespacesMembersInvitePayload>;
|
|
1181
|
+
/** Assign runtimes to a project */
|
|
1182
|
+
namespacesProjectsAssignRuntimes?: Maybe<NamespacesProjectsAssignRuntimesPayload>;
|
|
215
1183
|
/** Creates a new namespace project. */
|
|
216
1184
|
namespacesProjectsCreate?: Maybe<NamespacesProjectsCreatePayload>;
|
|
217
1185
|
/** Deletes a namespace project. */
|
|
218
1186
|
namespacesProjectsDelete?: Maybe<NamespacesProjectsDeletePayload>;
|
|
1187
|
+
/** Creates a new flow. */
|
|
1188
|
+
namespacesProjectsFlowsCreate?: Maybe<NamespacesProjectsFlowsCreatePayload>;
|
|
1189
|
+
/** Deletes a namespace project. */
|
|
1190
|
+
namespacesProjectsFlowsDelete?: Maybe<NamespacesProjectsFlowsDeletePayload>;
|
|
1191
|
+
/** Update an existing flow. */
|
|
1192
|
+
namespacesProjectsFlowsUpdate?: Maybe<NamespacesProjectsFlowsUpdatePayload>;
|
|
219
1193
|
/** Updates a namespace project. */
|
|
220
1194
|
namespacesProjectsUpdate?: Maybe<NamespacesProjectsUpdatePayload>;
|
|
221
1195
|
/** Update the abilities a role is granted. */
|
|
@@ -242,6 +1216,12 @@ export interface Mutation {
|
|
|
242
1216
|
runtimesRotateToken?: Maybe<RuntimesRotateTokenPayload>;
|
|
243
1217
|
/** Update an existing runtime. */
|
|
244
1218
|
runtimesUpdate?: Maybe<RuntimesUpdatePayload>;
|
|
1219
|
+
/** Admin-create a user. */
|
|
1220
|
+
usersCreate?: Maybe<UsersCreatePayload>;
|
|
1221
|
+
/** Delete an existing user. */
|
|
1222
|
+
usersDelete?: Maybe<UsersDeletePayload>;
|
|
1223
|
+
/** Verify your email when changing it or signing up */
|
|
1224
|
+
usersEmailVerification?: Maybe<UsersEmailVerificationPayload>;
|
|
245
1225
|
/** Links an external identity to an existing user */
|
|
246
1226
|
usersIdentityLink?: Maybe<UsersIdentityLinkPayload>;
|
|
247
1227
|
/** Login to an existing user via an external identity */
|
|
@@ -260,6 +1240,10 @@ export interface Mutation {
|
|
|
260
1240
|
usersMfaTotpGenerateSecret?: Maybe<UsersMfaTotpGenerateSecretPayload>;
|
|
261
1241
|
/** Validates a TOTP value for the given secret and enables TOTP MFA for the user */
|
|
262
1242
|
usersMfaTotpValidateSecret?: Maybe<UsersMfaTotpValidateSecretPayload>;
|
|
1243
|
+
/** Reset the password using a reset token */
|
|
1244
|
+
usersPasswordReset?: Maybe<UsersPasswordResetPayload>;
|
|
1245
|
+
/** Request an password reset */
|
|
1246
|
+
usersPasswordResetRequest?: Maybe<UsersPasswordResetRequestPayload>;
|
|
263
1247
|
/** Register a new user */
|
|
264
1248
|
usersRegister?: Maybe<UsersRegisterPayload>;
|
|
265
1249
|
/** Update an existing user. */
|
|
@@ -309,6 +1293,12 @@ export interface MutationNamespacesMembersInviteArgs {
|
|
|
309
1293
|
}
|
|
310
1294
|
|
|
311
1295
|
|
|
1296
|
+
/** Root Mutation type */
|
|
1297
|
+
export interface MutationNamespacesProjectsAssignRuntimesArgs {
|
|
1298
|
+
input: NamespacesProjectsAssignRuntimesInput;
|
|
1299
|
+
}
|
|
1300
|
+
|
|
1301
|
+
|
|
312
1302
|
/** Root Mutation type */
|
|
313
1303
|
export interface MutationNamespacesProjectsCreateArgs {
|
|
314
1304
|
input: NamespacesProjectsCreateInput;
|
|
@@ -321,6 +1311,24 @@ export interface MutationNamespacesProjectsDeleteArgs {
|
|
|
321
1311
|
}
|
|
322
1312
|
|
|
323
1313
|
|
|
1314
|
+
/** Root Mutation type */
|
|
1315
|
+
export interface MutationNamespacesProjectsFlowsCreateArgs {
|
|
1316
|
+
input: NamespacesProjectsFlowsCreateInput;
|
|
1317
|
+
}
|
|
1318
|
+
|
|
1319
|
+
|
|
1320
|
+
/** Root Mutation type */
|
|
1321
|
+
export interface MutationNamespacesProjectsFlowsDeleteArgs {
|
|
1322
|
+
input: NamespacesProjectsFlowsDeleteInput;
|
|
1323
|
+
}
|
|
1324
|
+
|
|
1325
|
+
|
|
1326
|
+
/** Root Mutation type */
|
|
1327
|
+
export interface MutationNamespacesProjectsFlowsUpdateArgs {
|
|
1328
|
+
input: NamespacesProjectsFlowsUpdateInput;
|
|
1329
|
+
}
|
|
1330
|
+
|
|
1331
|
+
|
|
324
1332
|
/** Root Mutation type */
|
|
325
1333
|
export interface MutationNamespacesProjectsUpdateArgs {
|
|
326
1334
|
input: NamespacesProjectsUpdateInput;
|
|
@@ -399,6 +1407,24 @@ export interface MutationRuntimesUpdateArgs {
|
|
|
399
1407
|
}
|
|
400
1408
|
|
|
401
1409
|
|
|
1410
|
+
/** Root Mutation type */
|
|
1411
|
+
export interface MutationUsersCreateArgs {
|
|
1412
|
+
input: UsersCreateInput;
|
|
1413
|
+
}
|
|
1414
|
+
|
|
1415
|
+
|
|
1416
|
+
/** Root Mutation type */
|
|
1417
|
+
export interface MutationUsersDeleteArgs {
|
|
1418
|
+
input: UsersDeleteInput;
|
|
1419
|
+
}
|
|
1420
|
+
|
|
1421
|
+
|
|
1422
|
+
/** Root Mutation type */
|
|
1423
|
+
export interface MutationUsersEmailVerificationArgs {
|
|
1424
|
+
input: UsersEmailVerificationInput;
|
|
1425
|
+
}
|
|
1426
|
+
|
|
1427
|
+
|
|
402
1428
|
/** Root Mutation type */
|
|
403
1429
|
export interface MutationUsersIdentityLinkArgs {
|
|
404
1430
|
input: UsersIdentityLinkInput;
|
|
@@ -453,6 +1479,18 @@ export interface MutationUsersMfaTotpValidateSecretArgs {
|
|
|
453
1479
|
}
|
|
454
1480
|
|
|
455
1481
|
|
|
1482
|
+
/** Root Mutation type */
|
|
1483
|
+
export interface MutationUsersPasswordResetArgs {
|
|
1484
|
+
input: UsersPasswordResetInput;
|
|
1485
|
+
}
|
|
1486
|
+
|
|
1487
|
+
|
|
1488
|
+
/** Root Mutation type */
|
|
1489
|
+
export interface MutationUsersPasswordResetRequestArgs {
|
|
1490
|
+
input: UsersPasswordResetRequestInput;
|
|
1491
|
+
}
|
|
1492
|
+
|
|
1493
|
+
|
|
456
1494
|
/** Root Mutation type */
|
|
457
1495
|
export interface MutationUsersRegisterArgs {
|
|
458
1496
|
input: UsersRegisterInput;
|
|
@@ -468,23 +1506,29 @@ export interface MutationUsersUpdateArgs {
|
|
|
468
1506
|
export interface Namespace {
|
|
469
1507
|
__typename?: 'Namespace';
|
|
470
1508
|
/** Time when this Namespace was created */
|
|
471
|
-
createdAt
|
|
1509
|
+
createdAt?: Maybe<Scalars['Time']['output']>;
|
|
1510
|
+
/** (EE only) Currently active license of the namespace */
|
|
1511
|
+
currentNamespaceLicense?: Maybe<NamespaceLicense>;
|
|
472
1512
|
/** Global ID of this Namespace */
|
|
473
|
-
id
|
|
1513
|
+
id?: Maybe<Scalars['NamespaceID']['output']>;
|
|
474
1514
|
/** Members of the namespace */
|
|
475
|
-
members
|
|
476
|
-
/** Licenses of the namespace */
|
|
477
|
-
namespaceLicenses
|
|
1515
|
+
members?: Maybe<NamespaceMemberConnection>;
|
|
1516
|
+
/** (EE only) Licenses of the namespace */
|
|
1517
|
+
namespaceLicenses?: Maybe<NamespaceLicenseConnection>;
|
|
478
1518
|
/** Parent of this namespace */
|
|
479
|
-
parent
|
|
1519
|
+
parent?: Maybe<NamespaceParent>;
|
|
1520
|
+
/** Query a project by its id */
|
|
1521
|
+
project?: Maybe<NamespaceProject>;
|
|
480
1522
|
/** Projects of the namespace */
|
|
481
|
-
projects
|
|
1523
|
+
projects?: Maybe<NamespaceProjectConnection>;
|
|
482
1524
|
/** Roles of the namespace */
|
|
483
|
-
roles
|
|
1525
|
+
roles?: Maybe<NamespaceRoleConnection>;
|
|
484
1526
|
/** Runtime of the namespace */
|
|
485
|
-
runtimes
|
|
1527
|
+
runtimes?: Maybe<RuntimeConnection>;
|
|
486
1528
|
/** Time when this Namespace was last updated */
|
|
487
|
-
updatedAt
|
|
1529
|
+
updatedAt?: Maybe<Scalars['Time']['output']>;
|
|
1530
|
+
/** Abilities for the current user on this Namespace */
|
|
1531
|
+
userAbilities?: Maybe<NamespaceUserAbilities>;
|
|
488
1532
|
}
|
|
489
1533
|
|
|
490
1534
|
|
|
@@ -506,6 +1550,12 @@ export interface NamespaceNamespaceLicensesArgs {
|
|
|
506
1550
|
}
|
|
507
1551
|
|
|
508
1552
|
|
|
1553
|
+
/** Represents a Namespace */
|
|
1554
|
+
export interface NamespaceProjectArgs {
|
|
1555
|
+
id: Scalars['NamespaceProjectID']['input'];
|
|
1556
|
+
}
|
|
1557
|
+
|
|
1558
|
+
|
|
509
1559
|
/** Represents a Namespace */
|
|
510
1560
|
export interface NamespaceProjectsArgs {
|
|
511
1561
|
after?: InputMaybe<Scalars['String']['input']>;
|
|
@@ -532,74 +1582,113 @@ export interface NamespaceRuntimesArgs {
|
|
|
532
1582
|
last?: InputMaybe<Scalars['Int']['input']>;
|
|
533
1583
|
}
|
|
534
1584
|
|
|
535
|
-
/** Represents a Namespace License */
|
|
1585
|
+
/** (EE only) Represents a Namespace License */
|
|
536
1586
|
export interface NamespaceLicense {
|
|
537
1587
|
__typename?: 'NamespaceLicense';
|
|
538
1588
|
/** Time when this NamespaceLicense was created */
|
|
539
|
-
createdAt
|
|
1589
|
+
createdAt?: Maybe<Scalars['Time']['output']>;
|
|
1590
|
+
/** The end date of the license */
|
|
1591
|
+
endDate?: Maybe<Scalars['Time']['output']>;
|
|
540
1592
|
/** Global ID of this NamespaceLicense */
|
|
541
|
-
id
|
|
1593
|
+
id?: Maybe<Scalars['NamespaceLicenseID']['output']>;
|
|
1594
|
+
/** The licensee information */
|
|
1595
|
+
licensee?: Maybe<Scalars['JSON']['output']>;
|
|
542
1596
|
/** The namespace the license belongs to */
|
|
543
|
-
namespace
|
|
1597
|
+
namespace?: Maybe<Namespace>;
|
|
1598
|
+
/** The start date of the license */
|
|
1599
|
+
startDate?: Maybe<Scalars['Time']['output']>;
|
|
544
1600
|
/** Time when this NamespaceLicense was last updated */
|
|
545
|
-
updatedAt
|
|
1601
|
+
updatedAt?: Maybe<Scalars['Time']['output']>;
|
|
1602
|
+
/** Abilities for the current user on this NamespaceLicense */
|
|
1603
|
+
userAbilities?: Maybe<NamespaceLicenseUserAbilities>;
|
|
546
1604
|
}
|
|
547
1605
|
|
|
548
1606
|
/** The connection type for NamespaceLicense. */
|
|
549
1607
|
export interface NamespaceLicenseConnection {
|
|
550
1608
|
__typename?: 'NamespaceLicenseConnection';
|
|
551
1609
|
/** Total count of collection. */
|
|
552
|
-
count
|
|
1610
|
+
count?: Maybe<Scalars['Int']['output']>;
|
|
553
1611
|
/** A list of edges. */
|
|
554
1612
|
edges?: Maybe<Array<Maybe<NamespaceLicenseEdge>>>;
|
|
555
1613
|
/** A list of nodes. */
|
|
556
1614
|
nodes?: Maybe<Array<Maybe<NamespaceLicense>>>;
|
|
557
1615
|
/** Information to aid in pagination. */
|
|
558
|
-
pageInfo
|
|
1616
|
+
pageInfo?: Maybe<PageInfo>;
|
|
559
1617
|
}
|
|
560
1618
|
|
|
561
1619
|
/** An edge in a connection. */
|
|
562
1620
|
export interface NamespaceLicenseEdge {
|
|
563
1621
|
__typename?: 'NamespaceLicenseEdge';
|
|
564
1622
|
/** A cursor for use in pagination. */
|
|
565
|
-
cursor
|
|
1623
|
+
cursor?: Maybe<Scalars['String']['output']>;
|
|
566
1624
|
/** The item at the end of the edge. */
|
|
567
1625
|
node?: Maybe<NamespaceLicense>;
|
|
568
1626
|
}
|
|
569
1627
|
|
|
1628
|
+
/** Abilities for the current user on this NamespaceLicense */
|
|
1629
|
+
export interface NamespaceLicenseUserAbilities {
|
|
1630
|
+
__typename?: 'NamespaceLicenseUserAbilities';
|
|
1631
|
+
/** Shows if the current user has the `delete_namespace_license` ability on this NamespaceLicense */
|
|
1632
|
+
deleteNamespaceLicense?: Maybe<Scalars['Boolean']['output']>;
|
|
1633
|
+
}
|
|
1634
|
+
|
|
570
1635
|
/** Represents a namespace member */
|
|
571
1636
|
export interface NamespaceMember {
|
|
572
1637
|
__typename?: 'NamespaceMember';
|
|
573
1638
|
/** Time when this NamespaceMember was created */
|
|
574
|
-
createdAt
|
|
1639
|
+
createdAt?: Maybe<Scalars['Time']['output']>;
|
|
575
1640
|
/** Global ID of this NamespaceMember */
|
|
576
|
-
id
|
|
1641
|
+
id?: Maybe<Scalars['NamespaceMemberID']['output']>;
|
|
1642
|
+
/** Memberroles of the member */
|
|
1643
|
+
memberRoles?: Maybe<NamespaceMemberRoleConnection>;
|
|
577
1644
|
/** Namespace this member belongs to */
|
|
578
|
-
namespace
|
|
1645
|
+
namespace?: Maybe<Namespace>;
|
|
1646
|
+
/** Roles of the member */
|
|
1647
|
+
roles?: Maybe<NamespaceRoleConnection>;
|
|
579
1648
|
/** Time when this NamespaceMember was last updated */
|
|
580
|
-
updatedAt
|
|
1649
|
+
updatedAt?: Maybe<Scalars['Time']['output']>;
|
|
581
1650
|
/** User this member belongs to */
|
|
582
|
-
user
|
|
1651
|
+
user?: Maybe<User>;
|
|
1652
|
+
/** Abilities for the current user on this NamespaceMember */
|
|
1653
|
+
userAbilities?: Maybe<NamespaceMemberUserAbilities>;
|
|
1654
|
+
}
|
|
1655
|
+
|
|
1656
|
+
|
|
1657
|
+
/** Represents a namespace member */
|
|
1658
|
+
export interface NamespaceMemberMemberRolesArgs {
|
|
1659
|
+
after?: InputMaybe<Scalars['String']['input']>;
|
|
1660
|
+
before?: InputMaybe<Scalars['String']['input']>;
|
|
1661
|
+
first?: InputMaybe<Scalars['Int']['input']>;
|
|
1662
|
+
last?: InputMaybe<Scalars['Int']['input']>;
|
|
1663
|
+
}
|
|
1664
|
+
|
|
1665
|
+
|
|
1666
|
+
/** Represents a namespace member */
|
|
1667
|
+
export interface NamespaceMemberRolesArgs {
|
|
1668
|
+
after?: InputMaybe<Scalars['String']['input']>;
|
|
1669
|
+
before?: InputMaybe<Scalars['String']['input']>;
|
|
1670
|
+
first?: InputMaybe<Scalars['Int']['input']>;
|
|
1671
|
+
last?: InputMaybe<Scalars['Int']['input']>;
|
|
583
1672
|
}
|
|
584
1673
|
|
|
585
1674
|
/** The connection type for NamespaceMember. */
|
|
586
1675
|
export interface NamespaceMemberConnection {
|
|
587
1676
|
__typename?: 'NamespaceMemberConnection';
|
|
588
1677
|
/** Total count of collection. */
|
|
589
|
-
count
|
|
1678
|
+
count?: Maybe<Scalars['Int']['output']>;
|
|
590
1679
|
/** A list of edges. */
|
|
591
1680
|
edges?: Maybe<Array<Maybe<NamespaceMemberEdge>>>;
|
|
592
1681
|
/** A list of nodes. */
|
|
593
1682
|
nodes?: Maybe<Array<Maybe<NamespaceMember>>>;
|
|
594
1683
|
/** Information to aid in pagination. */
|
|
595
|
-
pageInfo
|
|
1684
|
+
pageInfo?: Maybe<PageInfo>;
|
|
596
1685
|
}
|
|
597
1686
|
|
|
598
1687
|
/** An edge in a connection. */
|
|
599
1688
|
export interface NamespaceMemberEdge {
|
|
600
1689
|
__typename?: 'NamespaceMemberEdge';
|
|
601
1690
|
/** A cursor for use in pagination. */
|
|
602
|
-
cursor
|
|
1691
|
+
cursor?: Maybe<Scalars['String']['output']>;
|
|
603
1692
|
/** The item at the end of the edge. */
|
|
604
1693
|
node?: Maybe<NamespaceMember>;
|
|
605
1694
|
}
|
|
@@ -608,76 +1697,171 @@ export interface NamespaceMemberEdge {
|
|
|
608
1697
|
export interface NamespaceMemberRole {
|
|
609
1698
|
__typename?: 'NamespaceMemberRole';
|
|
610
1699
|
/** Time when this NamespaceMemberRole was created */
|
|
611
|
-
createdAt
|
|
1700
|
+
createdAt?: Maybe<Scalars['Time']['output']>;
|
|
612
1701
|
/** Global ID of this NamespaceMemberRole */
|
|
613
|
-
id
|
|
1702
|
+
id?: Maybe<Scalars['NamespaceMemberRoleID']['output']>;
|
|
614
1703
|
/** The member the role is assigned to */
|
|
615
1704
|
member?: Maybe<NamespaceMember>;
|
|
616
1705
|
/** The assigned role */
|
|
617
1706
|
role?: Maybe<NamespaceRole>;
|
|
618
1707
|
/** Time when this NamespaceMemberRole was last updated */
|
|
619
|
-
updatedAt
|
|
1708
|
+
updatedAt?: Maybe<Scalars['Time']['output']>;
|
|
1709
|
+
}
|
|
1710
|
+
|
|
1711
|
+
/** The connection type for NamespaceMemberRole. */
|
|
1712
|
+
export interface NamespaceMemberRoleConnection {
|
|
1713
|
+
__typename?: 'NamespaceMemberRoleConnection';
|
|
1714
|
+
/** Total count of collection. */
|
|
1715
|
+
count?: Maybe<Scalars['Int']['output']>;
|
|
1716
|
+
/** A list of edges. */
|
|
1717
|
+
edges?: Maybe<Array<Maybe<NamespaceMemberRoleEdge>>>;
|
|
1718
|
+
/** A list of nodes. */
|
|
1719
|
+
nodes?: Maybe<Array<Maybe<NamespaceMemberRole>>>;
|
|
1720
|
+
/** Information to aid in pagination. */
|
|
1721
|
+
pageInfo?: Maybe<PageInfo>;
|
|
1722
|
+
}
|
|
1723
|
+
|
|
1724
|
+
/** An edge in a connection. */
|
|
1725
|
+
export interface NamespaceMemberRoleEdge {
|
|
1726
|
+
__typename?: 'NamespaceMemberRoleEdge';
|
|
1727
|
+
/** A cursor for use in pagination. */
|
|
1728
|
+
cursor?: Maybe<Scalars['String']['output']>;
|
|
1729
|
+
/** The item at the end of the edge. */
|
|
1730
|
+
node?: Maybe<NamespaceMemberRole>;
|
|
1731
|
+
}
|
|
1732
|
+
|
|
1733
|
+
/** Abilities for the current user on this NamespaceMember */
|
|
1734
|
+
export interface NamespaceMemberUserAbilities {
|
|
1735
|
+
__typename?: 'NamespaceMemberUserAbilities';
|
|
1736
|
+
/** Shows if the current user has the `assign_member_roles` ability on this NamespaceMember */
|
|
1737
|
+
assignMemberRoles?: Maybe<Scalars['Boolean']['output']>;
|
|
1738
|
+
/** Shows if the current user has the `delete_member` ability on this NamespaceMember */
|
|
1739
|
+
deleteMember?: Maybe<Scalars['Boolean']['output']>;
|
|
620
1740
|
}
|
|
621
1741
|
|
|
622
1742
|
/** Objects that can present a namespace */
|
|
623
|
-
export type NamespaceParent = Organization;
|
|
1743
|
+
export type NamespaceParent = Organization | User;
|
|
624
1744
|
|
|
625
1745
|
/** Represents a namespace project */
|
|
626
1746
|
export interface NamespaceProject {
|
|
627
1747
|
__typename?: 'NamespaceProject';
|
|
628
1748
|
/** Time when this NamespaceProject was created */
|
|
629
|
-
createdAt
|
|
1749
|
+
createdAt?: Maybe<Scalars['Time']['output']>;
|
|
630
1750
|
/** Description of the project */
|
|
631
|
-
description
|
|
1751
|
+
description?: Maybe<Scalars['String']['output']>;
|
|
1752
|
+
/** Fetches an flow given by its ID */
|
|
1753
|
+
flow?: Maybe<Flow>;
|
|
1754
|
+
/** Fetches all flows in this project */
|
|
1755
|
+
flows?: Maybe<FlowConnection>;
|
|
632
1756
|
/** Global ID of this NamespaceProject */
|
|
633
|
-
id
|
|
1757
|
+
id?: Maybe<Scalars['NamespaceProjectID']['output']>;
|
|
634
1758
|
/** Name of the project */
|
|
635
|
-
name
|
|
1759
|
+
name?: Maybe<Scalars['String']['output']>;
|
|
636
1760
|
/** The namespace where this project belongs to */
|
|
637
|
-
namespace
|
|
1761
|
+
namespace?: Maybe<Namespace>;
|
|
1762
|
+
/** The primary runtime for the project */
|
|
1763
|
+
primaryRuntime?: Maybe<Runtime>;
|
|
1764
|
+
/** Roles assigned to this project */
|
|
1765
|
+
roles?: Maybe<NamespaceRoleConnection>;
|
|
1766
|
+
/** Runtimes assigned to this project */
|
|
1767
|
+
runtimes?: Maybe<RuntimeConnection>;
|
|
1768
|
+
/** Slug of the project used in URLs to identify flows */
|
|
1769
|
+
slug?: Maybe<Scalars['String']['output']>;
|
|
638
1770
|
/** Time when this NamespaceProject was last updated */
|
|
639
|
-
updatedAt
|
|
1771
|
+
updatedAt?: Maybe<Scalars['Time']['output']>;
|
|
1772
|
+
/** Abilities for the current user on this NamespaceProject */
|
|
1773
|
+
userAbilities?: Maybe<NamespaceProjectUserAbilities>;
|
|
1774
|
+
}
|
|
1775
|
+
|
|
1776
|
+
|
|
1777
|
+
/** Represents a namespace project */
|
|
1778
|
+
export interface NamespaceProjectFlowArgs {
|
|
1779
|
+
id: Scalars['FlowID']['input'];
|
|
1780
|
+
}
|
|
1781
|
+
|
|
1782
|
+
|
|
1783
|
+
/** Represents a namespace project */
|
|
1784
|
+
export interface NamespaceProjectFlowsArgs {
|
|
1785
|
+
after?: InputMaybe<Scalars['String']['input']>;
|
|
1786
|
+
before?: InputMaybe<Scalars['String']['input']>;
|
|
1787
|
+
first?: InputMaybe<Scalars['Int']['input']>;
|
|
1788
|
+
last?: InputMaybe<Scalars['Int']['input']>;
|
|
1789
|
+
}
|
|
1790
|
+
|
|
1791
|
+
|
|
1792
|
+
/** Represents a namespace project */
|
|
1793
|
+
export interface NamespaceProjectRolesArgs {
|
|
1794
|
+
after?: InputMaybe<Scalars['String']['input']>;
|
|
1795
|
+
before?: InputMaybe<Scalars['String']['input']>;
|
|
1796
|
+
first?: InputMaybe<Scalars['Int']['input']>;
|
|
1797
|
+
last?: InputMaybe<Scalars['Int']['input']>;
|
|
1798
|
+
}
|
|
1799
|
+
|
|
1800
|
+
|
|
1801
|
+
/** Represents a namespace project */
|
|
1802
|
+
export interface NamespaceProjectRuntimesArgs {
|
|
1803
|
+
after?: InputMaybe<Scalars['String']['input']>;
|
|
1804
|
+
before?: InputMaybe<Scalars['String']['input']>;
|
|
1805
|
+
first?: InputMaybe<Scalars['Int']['input']>;
|
|
1806
|
+
last?: InputMaybe<Scalars['Int']['input']>;
|
|
640
1807
|
}
|
|
641
1808
|
|
|
642
1809
|
/** The connection type for NamespaceProject. */
|
|
643
1810
|
export interface NamespaceProjectConnection {
|
|
644
1811
|
__typename?: 'NamespaceProjectConnection';
|
|
645
1812
|
/** Total count of collection. */
|
|
646
|
-
count
|
|
1813
|
+
count?: Maybe<Scalars['Int']['output']>;
|
|
647
1814
|
/** A list of edges. */
|
|
648
1815
|
edges?: Maybe<Array<Maybe<NamespaceProjectEdge>>>;
|
|
649
1816
|
/** A list of nodes. */
|
|
650
1817
|
nodes?: Maybe<Array<Maybe<NamespaceProject>>>;
|
|
651
1818
|
/** Information to aid in pagination. */
|
|
652
|
-
pageInfo
|
|
1819
|
+
pageInfo?: Maybe<PageInfo>;
|
|
653
1820
|
}
|
|
654
1821
|
|
|
655
1822
|
/** An edge in a connection. */
|
|
656
1823
|
export interface NamespaceProjectEdge {
|
|
657
1824
|
__typename?: 'NamespaceProjectEdge';
|
|
658
1825
|
/** A cursor for use in pagination. */
|
|
659
|
-
cursor
|
|
1826
|
+
cursor?: Maybe<Scalars['String']['output']>;
|
|
660
1827
|
/** The item at the end of the edge. */
|
|
661
1828
|
node?: Maybe<NamespaceProject>;
|
|
662
1829
|
}
|
|
663
1830
|
|
|
1831
|
+
/** Abilities for the current user on this NamespaceProject */
|
|
1832
|
+
export interface NamespaceProjectUserAbilities {
|
|
1833
|
+
__typename?: 'NamespaceProjectUserAbilities';
|
|
1834
|
+
/** Shows if the current user has the `assign_project_runtimes` ability on this NamespaceProject */
|
|
1835
|
+
assignProjectRuntimes?: Maybe<Scalars['Boolean']['output']>;
|
|
1836
|
+
/** Shows if the current user has the `create_flow` ability on this NamespaceProject */
|
|
1837
|
+
createFlow?: Maybe<Scalars['Boolean']['output']>;
|
|
1838
|
+
/** Shows if the current user has the `delete_namespace_project` ability on this NamespaceProject */
|
|
1839
|
+
deleteNamespaceProject?: Maybe<Scalars['Boolean']['output']>;
|
|
1840
|
+
/** Shows if the current user has the `update_namespace_project` ability on this NamespaceProject */
|
|
1841
|
+
updateNamespaceProject?: Maybe<Scalars['Boolean']['output']>;
|
|
1842
|
+
}
|
|
1843
|
+
|
|
664
1844
|
/** Represents a namespace role. */
|
|
665
1845
|
export interface NamespaceRole {
|
|
666
1846
|
__typename?: 'NamespaceRole';
|
|
667
1847
|
/** The abilities the role is granted */
|
|
668
|
-
abilities
|
|
1848
|
+
abilities?: Maybe<Array<NamespaceRoleAbility>>;
|
|
669
1849
|
/** The projects this role is assigned to */
|
|
670
1850
|
assignedProjects?: Maybe<NamespaceProjectConnection>;
|
|
671
1851
|
/** Time when this NamespaceRole was created */
|
|
672
|
-
createdAt
|
|
1852
|
+
createdAt?: Maybe<Scalars['Time']['output']>;
|
|
673
1853
|
/** Global ID of this NamespaceRole */
|
|
674
|
-
id
|
|
1854
|
+
id?: Maybe<Scalars['NamespaceRoleID']['output']>;
|
|
1855
|
+
/** The members this role is assigned to */
|
|
1856
|
+
members?: Maybe<NamespaceMemberConnection>;
|
|
675
1857
|
/** The name of this role */
|
|
676
|
-
name
|
|
1858
|
+
name?: Maybe<Scalars['String']['output']>;
|
|
677
1859
|
/** The namespace where this role belongs to */
|
|
678
1860
|
namespace?: Maybe<Namespace>;
|
|
679
1861
|
/** Time when this NamespaceRole was last updated */
|
|
680
|
-
updatedAt
|
|
1862
|
+
updatedAt?: Maybe<Scalars['Time']['output']>;
|
|
1863
|
+
/** Abilities for the current user on this NamespaceRole */
|
|
1864
|
+
userAbilities?: Maybe<NamespaceRoleUserAbilities>;
|
|
681
1865
|
}
|
|
682
1866
|
|
|
683
1867
|
|
|
@@ -689,14 +1873,27 @@ export interface NamespaceRoleAssignedProjectsArgs {
|
|
|
689
1873
|
last?: InputMaybe<Scalars['Int']['input']>;
|
|
690
1874
|
}
|
|
691
1875
|
|
|
1876
|
+
|
|
1877
|
+
/** Represents a namespace role. */
|
|
1878
|
+
export interface NamespaceRoleMembersArgs {
|
|
1879
|
+
after?: InputMaybe<Scalars['String']['input']>;
|
|
1880
|
+
before?: InputMaybe<Scalars['String']['input']>;
|
|
1881
|
+
first?: InputMaybe<Scalars['Int']['input']>;
|
|
1882
|
+
last?: InputMaybe<Scalars['Int']['input']>;
|
|
1883
|
+
}
|
|
1884
|
+
|
|
692
1885
|
/** Represents abilities that can be granted to roles in namespaces. */
|
|
693
|
-
export enum NamespaceRoleAbility {
|
|
1886
|
+
export const enum NamespaceRoleAbility {
|
|
694
1887
|
/** Allows to change the roles of a namespace member */
|
|
695
1888
|
AssignMemberRoles = 'ASSIGN_MEMBER_ROLES',
|
|
1889
|
+
/** Allows to assign runtimes to a project in the namespace */
|
|
1890
|
+
AssignProjectRuntimes = 'ASSIGN_PROJECT_RUNTIMES',
|
|
696
1891
|
/** Allows to change the abilities of a namespace role */
|
|
697
1892
|
AssignRoleAbilities = 'ASSIGN_ROLE_ABILITIES',
|
|
698
1893
|
/** Allows to change the assigned projects of a namespace role */
|
|
699
1894
|
AssignRoleProjects = 'ASSIGN_ROLE_PROJECTS',
|
|
1895
|
+
/** Allows to create flows in a namespace project */
|
|
1896
|
+
CreateFlow = 'CREATE_FLOW',
|
|
700
1897
|
/** Allows to create a license for the namespace */
|
|
701
1898
|
CreateNamespaceLicense = 'CREATE_NAMESPACE_LICENSE',
|
|
702
1899
|
/** Allows to create a project in the namespace */
|
|
@@ -705,6 +1902,8 @@ export enum NamespaceRoleAbility {
|
|
|
705
1902
|
CreateNamespaceRole = 'CREATE_NAMESPACE_ROLE',
|
|
706
1903
|
/** Allows to create a runtime globally or for the namespace */
|
|
707
1904
|
CreateRuntime = 'CREATE_RUNTIME',
|
|
1905
|
+
/** Allows to delete flows in a namespace project */
|
|
1906
|
+
DeleteFlow = 'DELETE_FLOW',
|
|
708
1907
|
/** Allows to remove members of a namespace */
|
|
709
1908
|
DeleteMember = 'DELETE_MEMBER',
|
|
710
1909
|
/** Allows to delete the license of the namespace */
|
|
@@ -727,6 +1926,8 @@ export enum NamespaceRoleAbility {
|
|
|
727
1926
|
ReadNamespaceProject = 'READ_NAMESPACE_PROJECT',
|
|
728
1927
|
/** Allows to regenerate a runtime token */
|
|
729
1928
|
RotateRuntimeToken = 'ROTATE_RUNTIME_TOKEN',
|
|
1929
|
+
/** Allows to update flows in the project */
|
|
1930
|
+
UpdateFlow = 'UPDATE_FLOW',
|
|
730
1931
|
/** Allows to update the project of the namespace */
|
|
731
1932
|
UpdateNamespaceProject = 'UPDATE_NAMESPACE_PROJECT',
|
|
732
1933
|
/** Allows to update the namespace role */
|
|
@@ -741,24 +1942,52 @@ export enum NamespaceRoleAbility {
|
|
|
741
1942
|
export interface NamespaceRoleConnection {
|
|
742
1943
|
__typename?: 'NamespaceRoleConnection';
|
|
743
1944
|
/** Total count of collection. */
|
|
744
|
-
count
|
|
1945
|
+
count?: Maybe<Scalars['Int']['output']>;
|
|
745
1946
|
/** A list of edges. */
|
|
746
1947
|
edges?: Maybe<Array<Maybe<NamespaceRoleEdge>>>;
|
|
747
1948
|
/** A list of nodes. */
|
|
748
1949
|
nodes?: Maybe<Array<Maybe<NamespaceRole>>>;
|
|
749
1950
|
/** Information to aid in pagination. */
|
|
750
|
-
pageInfo
|
|
1951
|
+
pageInfo?: Maybe<PageInfo>;
|
|
751
1952
|
}
|
|
752
1953
|
|
|
753
1954
|
/** An edge in a connection. */
|
|
754
1955
|
export interface NamespaceRoleEdge {
|
|
755
1956
|
__typename?: 'NamespaceRoleEdge';
|
|
756
1957
|
/** A cursor for use in pagination. */
|
|
757
|
-
cursor
|
|
1958
|
+
cursor?: Maybe<Scalars['String']['output']>;
|
|
758
1959
|
/** The item at the end of the edge. */
|
|
759
1960
|
node?: Maybe<NamespaceRole>;
|
|
760
1961
|
}
|
|
761
1962
|
|
|
1963
|
+
/** Abilities for the current user on this NamespaceRole */
|
|
1964
|
+
export interface NamespaceRoleUserAbilities {
|
|
1965
|
+
__typename?: 'NamespaceRoleUserAbilities';
|
|
1966
|
+
/** Shows if the current user has the `assign_role_abilities` ability on this NamespaceRole */
|
|
1967
|
+
assignRoleAbilities?: Maybe<Scalars['Boolean']['output']>;
|
|
1968
|
+
/** Shows if the current user has the `assign_role_projects` ability on this NamespaceRole */
|
|
1969
|
+
assignRoleProjects?: Maybe<Scalars['Boolean']['output']>;
|
|
1970
|
+
/** Shows if the current user has the `delete_namespace_role` ability on this NamespaceRole */
|
|
1971
|
+
deleteNamespaceRole?: Maybe<Scalars['Boolean']['output']>;
|
|
1972
|
+
/** Shows if the current user has the `update_namespace_role` ability on this NamespaceRole */
|
|
1973
|
+
updateNamespaceRole?: Maybe<Scalars['Boolean']['output']>;
|
|
1974
|
+
}
|
|
1975
|
+
|
|
1976
|
+
/** Abilities for the current user on this Namespace */
|
|
1977
|
+
export interface NamespaceUserAbilities {
|
|
1978
|
+
__typename?: 'NamespaceUserAbilities';
|
|
1979
|
+
/** Shows if the current user has the `create_namespace_license` ability on this Namespace */
|
|
1980
|
+
createNamespaceLicense?: Maybe<Scalars['Boolean']['output']>;
|
|
1981
|
+
/** Shows if the current user has the `create_namespace_project` ability on this Namespace */
|
|
1982
|
+
createNamespaceProject?: Maybe<Scalars['Boolean']['output']>;
|
|
1983
|
+
/** Shows if the current user has the `create_namespace_role` ability on this Namespace */
|
|
1984
|
+
createNamespaceRole?: Maybe<Scalars['Boolean']['output']>;
|
|
1985
|
+
/** Shows if the current user has the `create_runtime` ability on this Namespace */
|
|
1986
|
+
createRuntime?: Maybe<Scalars['Boolean']['output']>;
|
|
1987
|
+
/** Shows if the current user has the `invite_member` ability on this Namespace */
|
|
1988
|
+
inviteMember?: Maybe<Scalars['Boolean']['output']>;
|
|
1989
|
+
}
|
|
1990
|
+
|
|
762
1991
|
/** Autogenerated input type of NamespacesLicensesCreate */
|
|
763
1992
|
export interface NamespacesLicensesCreateInput {
|
|
764
1993
|
/** A unique identifier for the client performing the mutation. */
|
|
@@ -775,7 +2004,7 @@ export interface NamespacesLicensesCreatePayload {
|
|
|
775
2004
|
/** A unique identifier for the client performing the mutation. */
|
|
776
2005
|
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
777
2006
|
/** Errors encountered during execution of the mutation. */
|
|
778
|
-
errors
|
|
2007
|
+
errors?: Maybe<Array<Error>>;
|
|
779
2008
|
/** The newly created license. */
|
|
780
2009
|
namespaceLicense?: Maybe<NamespaceLicense>;
|
|
781
2010
|
}
|
|
@@ -794,7 +2023,7 @@ export interface NamespacesLicensesDeletePayload {
|
|
|
794
2023
|
/** A unique identifier for the client performing the mutation. */
|
|
795
2024
|
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
796
2025
|
/** Errors encountered during execution of the mutation. */
|
|
797
|
-
errors
|
|
2026
|
+
errors?: Maybe<Array<Error>>;
|
|
798
2027
|
/** The deleted namespace license. */
|
|
799
2028
|
namespaceLicense?: Maybe<NamespaceLicense>;
|
|
800
2029
|
}
|
|
@@ -815,9 +2044,9 @@ export interface NamespacesMembersAssignRolesPayload {
|
|
|
815
2044
|
/** A unique identifier for the client performing the mutation. */
|
|
816
2045
|
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
817
2046
|
/** Errors encountered during execution of the mutation. */
|
|
818
|
-
errors
|
|
819
|
-
/** The
|
|
820
|
-
|
|
2047
|
+
errors?: Maybe<Array<Error>>;
|
|
2048
|
+
/** The member which was assigned the roles */
|
|
2049
|
+
member?: Maybe<NamespaceMember>;
|
|
821
2050
|
}
|
|
822
2051
|
|
|
823
2052
|
/** Autogenerated input type of NamespacesMembersDelete */
|
|
@@ -834,7 +2063,7 @@ export interface NamespacesMembersDeletePayload {
|
|
|
834
2063
|
/** A unique identifier for the client performing the mutation. */
|
|
835
2064
|
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
836
2065
|
/** Errors encountered during execution of the mutation. */
|
|
837
|
-
errors
|
|
2066
|
+
errors?: Maybe<Array<Error>>;
|
|
838
2067
|
/** The removed namespace member */
|
|
839
2068
|
namespaceMember?: Maybe<NamespaceMember>;
|
|
840
2069
|
}
|
|
@@ -855,21 +2084,44 @@ export interface NamespacesMembersInvitePayload {
|
|
|
855
2084
|
/** A unique identifier for the client performing the mutation. */
|
|
856
2085
|
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
857
2086
|
/** Errors encountered during execution of the mutation. */
|
|
858
|
-
errors
|
|
2087
|
+
errors?: Maybe<Array<Error>>;
|
|
859
2088
|
/** The newly created namespace member */
|
|
860
2089
|
namespaceMember?: Maybe<NamespaceMember>;
|
|
861
2090
|
}
|
|
862
2091
|
|
|
863
|
-
/** Autogenerated input type of
|
|
864
|
-
export interface
|
|
2092
|
+
/** Autogenerated input type of NamespacesProjectsAssignRuntimes */
|
|
2093
|
+
export interface NamespacesProjectsAssignRuntimesInput {
|
|
865
2094
|
/** A unique identifier for the client performing the mutation. */
|
|
866
2095
|
clientMutationId?: InputMaybe<Scalars['String']['input']>;
|
|
867
|
-
/**
|
|
868
|
-
|
|
869
|
-
/**
|
|
870
|
-
|
|
871
|
-
|
|
872
|
-
|
|
2096
|
+
/** ID of the project to assign runtimes to */
|
|
2097
|
+
namespaceProjectId: Scalars['NamespaceProjectID']['input'];
|
|
2098
|
+
/** The new runtimes assigned to the project */
|
|
2099
|
+
runtimeIds: Array<Scalars['RuntimeID']['input']>;
|
|
2100
|
+
}
|
|
2101
|
+
|
|
2102
|
+
/** Autogenerated return type of NamespacesProjectsAssignRuntimes. */
|
|
2103
|
+
export interface NamespacesProjectsAssignRuntimesPayload {
|
|
2104
|
+
__typename?: 'NamespacesProjectsAssignRuntimesPayload';
|
|
2105
|
+
/** A unique identifier for the client performing the mutation. */
|
|
2106
|
+
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
2107
|
+
/** Errors encountered during execution of the mutation. */
|
|
2108
|
+
errors?: Maybe<Array<Error>>;
|
|
2109
|
+
/** The updated project with assigned runtimes */
|
|
2110
|
+
namespaceProject?: Maybe<NamespaceProject>;
|
|
2111
|
+
}
|
|
2112
|
+
|
|
2113
|
+
/** Autogenerated input type of NamespacesProjectsCreate */
|
|
2114
|
+
export interface NamespacesProjectsCreateInput {
|
|
2115
|
+
/** A unique identifier for the client performing the mutation. */
|
|
2116
|
+
clientMutationId?: InputMaybe<Scalars['String']['input']>;
|
|
2117
|
+
/** Description for the new project. */
|
|
2118
|
+
description?: InputMaybe<Scalars['String']['input']>;
|
|
2119
|
+
/** Name for the new project. */
|
|
2120
|
+
name: Scalars['String']['input'];
|
|
2121
|
+
/** The id of the namespace which this project will belong to */
|
|
2122
|
+
namespaceId: Scalars['NamespaceID']['input'];
|
|
2123
|
+
/** Slug for the new project. */
|
|
2124
|
+
slug?: InputMaybe<Scalars['String']['input']>;
|
|
873
2125
|
}
|
|
874
2126
|
|
|
875
2127
|
/** Autogenerated return type of NamespacesProjectsCreate. */
|
|
@@ -878,7 +2130,7 @@ export interface NamespacesProjectsCreatePayload {
|
|
|
878
2130
|
/** A unique identifier for the client performing the mutation. */
|
|
879
2131
|
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
880
2132
|
/** Errors encountered during execution of the mutation. */
|
|
881
|
-
errors
|
|
2133
|
+
errors?: Maybe<Array<Error>>;
|
|
882
2134
|
/** The newly created project. */
|
|
883
2135
|
namespaceProject?: Maybe<NamespaceProject>;
|
|
884
2136
|
}
|
|
@@ -897,11 +2149,72 @@ export interface NamespacesProjectsDeletePayload {
|
|
|
897
2149
|
/** A unique identifier for the client performing the mutation. */
|
|
898
2150
|
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
899
2151
|
/** Errors encountered during execution of the mutation. */
|
|
900
|
-
errors
|
|
2152
|
+
errors?: Maybe<Array<Error>>;
|
|
901
2153
|
/** The deleted project. */
|
|
902
2154
|
namespaceProject?: Maybe<NamespaceProject>;
|
|
903
2155
|
}
|
|
904
2156
|
|
|
2157
|
+
/** Autogenerated input type of NamespacesProjectsFlowsCreate */
|
|
2158
|
+
export interface NamespacesProjectsFlowsCreateInput {
|
|
2159
|
+
/** A unique identifier for the client performing the mutation. */
|
|
2160
|
+
clientMutationId?: InputMaybe<Scalars['String']['input']>;
|
|
2161
|
+
/** The flow to create */
|
|
2162
|
+
flow: FlowInput;
|
|
2163
|
+
/** The ID of the project to which the flow belongs to */
|
|
2164
|
+
projectId: Scalars['NamespaceProjectID']['input'];
|
|
2165
|
+
}
|
|
2166
|
+
|
|
2167
|
+
/** Autogenerated return type of NamespacesProjectsFlowsCreate. */
|
|
2168
|
+
export interface NamespacesProjectsFlowsCreatePayload {
|
|
2169
|
+
__typename?: 'NamespacesProjectsFlowsCreatePayload';
|
|
2170
|
+
/** A unique identifier for the client performing the mutation. */
|
|
2171
|
+
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
2172
|
+
/** Errors encountered during execution of the mutation. */
|
|
2173
|
+
errors?: Maybe<Array<Error>>;
|
|
2174
|
+
/** The newly created flow. */
|
|
2175
|
+
flow?: Maybe<Flow>;
|
|
2176
|
+
}
|
|
2177
|
+
|
|
2178
|
+
/** Autogenerated input type of NamespacesProjectsFlowsDelete */
|
|
2179
|
+
export interface NamespacesProjectsFlowsDeleteInput {
|
|
2180
|
+
/** A unique identifier for the client performing the mutation. */
|
|
2181
|
+
clientMutationId?: InputMaybe<Scalars['String']['input']>;
|
|
2182
|
+
/** The id of the flow which will be deleted */
|
|
2183
|
+
flowId: Scalars['FlowID']['input'];
|
|
2184
|
+
}
|
|
2185
|
+
|
|
2186
|
+
/** Autogenerated return type of NamespacesProjectsFlowsDelete. */
|
|
2187
|
+
export interface NamespacesProjectsFlowsDeletePayload {
|
|
2188
|
+
__typename?: 'NamespacesProjectsFlowsDeletePayload';
|
|
2189
|
+
/** A unique identifier for the client performing the mutation. */
|
|
2190
|
+
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
2191
|
+
/** Errors encountered during execution of the mutation. */
|
|
2192
|
+
errors?: Maybe<Array<Error>>;
|
|
2193
|
+
/** The deleted flow. */
|
|
2194
|
+
flow?: Maybe<Flow>;
|
|
2195
|
+
}
|
|
2196
|
+
|
|
2197
|
+
/** Autogenerated input type of NamespacesProjectsFlowsUpdate */
|
|
2198
|
+
export interface NamespacesProjectsFlowsUpdateInput {
|
|
2199
|
+
/** A unique identifier for the client performing the mutation. */
|
|
2200
|
+
clientMutationId?: InputMaybe<Scalars['String']['input']>;
|
|
2201
|
+
/** The ID of the flow to update */
|
|
2202
|
+
flowId: Scalars['FlowID']['input'];
|
|
2203
|
+
/** The updated flow */
|
|
2204
|
+
flowInput: FlowInput;
|
|
2205
|
+
}
|
|
2206
|
+
|
|
2207
|
+
/** Autogenerated return type of NamespacesProjectsFlowsUpdate. */
|
|
2208
|
+
export interface NamespacesProjectsFlowsUpdatePayload {
|
|
2209
|
+
__typename?: 'NamespacesProjectsFlowsUpdatePayload';
|
|
2210
|
+
/** A unique identifier for the client performing the mutation. */
|
|
2211
|
+
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
2212
|
+
/** Errors encountered during execution of the mutation. */
|
|
2213
|
+
errors?: Maybe<Array<Error>>;
|
|
2214
|
+
/** The updated flow. */
|
|
2215
|
+
flow?: Maybe<Flow>;
|
|
2216
|
+
}
|
|
2217
|
+
|
|
905
2218
|
/** Autogenerated input type of NamespacesProjectsUpdate */
|
|
906
2219
|
export interface NamespacesProjectsUpdateInput {
|
|
907
2220
|
/** A unique identifier for the client performing the mutation. */
|
|
@@ -912,6 +2225,10 @@ export interface NamespacesProjectsUpdateInput {
|
|
|
912
2225
|
name?: InputMaybe<Scalars['String']['input']>;
|
|
913
2226
|
/** The id of the namespace project which will be updated */
|
|
914
2227
|
namespaceProjectId: Scalars['NamespaceProjectID']['input'];
|
|
2228
|
+
/** The primary runtime for the updated project. */
|
|
2229
|
+
primaryRuntimeId?: InputMaybe<Scalars['RuntimeID']['input']>;
|
|
2230
|
+
/** Slug for the updated project. */
|
|
2231
|
+
slug?: InputMaybe<Scalars['String']['input']>;
|
|
915
2232
|
}
|
|
916
2233
|
|
|
917
2234
|
/** Autogenerated return type of NamespacesProjectsUpdate. */
|
|
@@ -920,7 +2237,7 @@ export interface NamespacesProjectsUpdatePayload {
|
|
|
920
2237
|
/** A unique identifier for the client performing the mutation. */
|
|
921
2238
|
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
922
2239
|
/** Errors encountered during execution of the mutation. */
|
|
923
|
-
errors
|
|
2240
|
+
errors?: Maybe<Array<Error>>;
|
|
924
2241
|
/** The updated project. */
|
|
925
2242
|
namespaceProject?: Maybe<NamespaceProject>;
|
|
926
2243
|
}
|
|
@@ -943,7 +2260,7 @@ export interface NamespacesRolesAssignAbilitiesPayload {
|
|
|
943
2260
|
/** A unique identifier for the client performing the mutation. */
|
|
944
2261
|
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
945
2262
|
/** Errors encountered during execution of the mutation. */
|
|
946
|
-
errors
|
|
2263
|
+
errors?: Maybe<Array<Error>>;
|
|
947
2264
|
}
|
|
948
2265
|
|
|
949
2266
|
/** Autogenerated input type of NamespacesRolesAssignProjects */
|
|
@@ -962,7 +2279,7 @@ export interface NamespacesRolesAssignProjectsPayload {
|
|
|
962
2279
|
/** A unique identifier for the client performing the mutation. */
|
|
963
2280
|
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
964
2281
|
/** Errors encountered during execution of the mutation. */
|
|
965
|
-
errors
|
|
2282
|
+
errors?: Maybe<Array<Error>>;
|
|
966
2283
|
/** The now assigned projects */
|
|
967
2284
|
projects?: Maybe<Array<NamespaceProject>>;
|
|
968
2285
|
}
|
|
@@ -983,7 +2300,7 @@ export interface NamespacesRolesCreatePayload {
|
|
|
983
2300
|
/** A unique identifier for the client performing the mutation. */
|
|
984
2301
|
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
985
2302
|
/** Errors encountered during execution of the mutation. */
|
|
986
|
-
errors
|
|
2303
|
+
errors?: Maybe<Array<Error>>;
|
|
987
2304
|
/** The newly created namespace role */
|
|
988
2305
|
namespaceRole?: Maybe<NamespaceRole>;
|
|
989
2306
|
}
|
|
@@ -1002,7 +2319,7 @@ export interface NamespacesRolesDeletePayload {
|
|
|
1002
2319
|
/** A unique identifier for the client performing the mutation. */
|
|
1003
2320
|
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
1004
2321
|
/** Errors encountered during execution of the mutation. */
|
|
1005
|
-
errors
|
|
2322
|
+
errors?: Maybe<Array<Error>>;
|
|
1006
2323
|
/** The deleted namespace role */
|
|
1007
2324
|
namespaceRole?: Maybe<NamespaceRole>;
|
|
1008
2325
|
}
|
|
@@ -1023,7 +2340,7 @@ export interface NamespacesRolesUpdatePayload {
|
|
|
1023
2340
|
/** A unique identifier for the client performing the mutation. */
|
|
1024
2341
|
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
1025
2342
|
/** Errors encountered during execution of the mutation. */
|
|
1026
|
-
errors
|
|
2343
|
+
errors?: Maybe<Array<Error>>;
|
|
1027
2344
|
/** The updated namespace role. */
|
|
1028
2345
|
namespaceRole?: Maybe<NamespaceRole>;
|
|
1029
2346
|
}
|
|
@@ -1031,22 +2348,199 @@ export interface NamespacesRolesUpdatePayload {
|
|
|
1031
2348
|
/** An object with an ID. */
|
|
1032
2349
|
export interface Node {
|
|
1033
2350
|
/** ID of the object. */
|
|
1034
|
-
id
|
|
2351
|
+
id?: Maybe<Scalars['ID']['output']>;
|
|
2352
|
+
}
|
|
2353
|
+
|
|
2354
|
+
/** Represents a Node Function */
|
|
2355
|
+
export interface NodeFunction {
|
|
2356
|
+
__typename?: 'NodeFunction';
|
|
2357
|
+
/** Time when this NodeFunction was created */
|
|
2358
|
+
createdAt?: Maybe<Scalars['Time']['output']>;
|
|
2359
|
+
/** The definition of the Node Function */
|
|
2360
|
+
functionDefinition?: Maybe<FunctionDefinition>;
|
|
2361
|
+
/** Global ID of this NodeFunction */
|
|
2362
|
+
id?: Maybe<Scalars['NodeFunctionID']['output']>;
|
|
2363
|
+
/** The ID of the next Node Function in the flow */
|
|
2364
|
+
nextNodeId?: Maybe<Scalars['NodeFunctionID']['output']>;
|
|
2365
|
+
/** The parameters of the Node Function */
|
|
2366
|
+
parameters?: Maybe<NodeParameterConnection>;
|
|
2367
|
+
/** Time when this NodeFunction was last updated */
|
|
2368
|
+
updatedAt?: Maybe<Scalars['Time']['output']>;
|
|
2369
|
+
}
|
|
2370
|
+
|
|
2371
|
+
|
|
2372
|
+
/** Represents a Node Function */
|
|
2373
|
+
export interface NodeFunctionParametersArgs {
|
|
2374
|
+
after?: InputMaybe<Scalars['String']['input']>;
|
|
2375
|
+
before?: InputMaybe<Scalars['String']['input']>;
|
|
2376
|
+
first?: InputMaybe<Scalars['Int']['input']>;
|
|
2377
|
+
last?: InputMaybe<Scalars['Int']['input']>;
|
|
2378
|
+
}
|
|
2379
|
+
|
|
2380
|
+
/** The connection type for NodeFunction. */
|
|
2381
|
+
export interface NodeFunctionConnection {
|
|
2382
|
+
__typename?: 'NodeFunctionConnection';
|
|
2383
|
+
/** Total count of collection. */
|
|
2384
|
+
count?: Maybe<Scalars['Int']['output']>;
|
|
2385
|
+
/** A list of edges. */
|
|
2386
|
+
edges?: Maybe<Array<Maybe<NodeFunctionEdge>>>;
|
|
2387
|
+
/** A list of nodes. */
|
|
2388
|
+
nodes?: Maybe<Array<Maybe<NodeFunction>>>;
|
|
2389
|
+
/** Information to aid in pagination. */
|
|
2390
|
+
pageInfo?: Maybe<PageInfo>;
|
|
2391
|
+
}
|
|
2392
|
+
|
|
2393
|
+
/** An edge in a connection. */
|
|
2394
|
+
export interface NodeFunctionEdge {
|
|
2395
|
+
__typename?: 'NodeFunctionEdge';
|
|
2396
|
+
/** A cursor for use in pagination. */
|
|
2397
|
+
cursor?: Maybe<Scalars['String']['output']>;
|
|
2398
|
+
/** The item at the end of the edge. */
|
|
2399
|
+
node?: Maybe<NodeFunction>;
|
|
2400
|
+
}
|
|
2401
|
+
|
|
2402
|
+
/** Represents a Node Function id wrapper. */
|
|
2403
|
+
export interface NodeFunctionIdWrapper {
|
|
2404
|
+
__typename?: 'NodeFunctionIdWrapper';
|
|
2405
|
+
/** Global ID of this NodeFunctionIdWrapper */
|
|
2406
|
+
id?: Maybe<Scalars['NodeFunctionID']['output']>;
|
|
2407
|
+
}
|
|
2408
|
+
|
|
2409
|
+
/** Input type for a Node Function */
|
|
2410
|
+
export interface NodeFunctionInput {
|
|
2411
|
+
/** The identifier of the Node Function used to create/update the flow */
|
|
2412
|
+
id: Scalars['NodeFunctionID']['input'];
|
|
2413
|
+
/** The next Node Function in the flow */
|
|
2414
|
+
nextNodeId?: InputMaybe<Scalars['NodeFunctionID']['input']>;
|
|
2415
|
+
/** The parameters of the Node Function */
|
|
2416
|
+
parameters: Array<NodeParameterInput>;
|
|
2417
|
+
/** The identifier of the Runtime Function Definition */
|
|
2418
|
+
runtimeFunctionId: Scalars['RuntimeFunctionDefinitionID']['input'];
|
|
2419
|
+
}
|
|
2420
|
+
|
|
2421
|
+
/** Represents a Node parameter */
|
|
2422
|
+
export interface NodeParameter {
|
|
2423
|
+
__typename?: 'NodeParameter';
|
|
2424
|
+
/** Time when this NodeParameter was created */
|
|
2425
|
+
createdAt?: Maybe<Scalars['Time']['output']>;
|
|
2426
|
+
/** Global ID of this NodeParameter */
|
|
2427
|
+
id?: Maybe<Scalars['NodeParameterID']['output']>;
|
|
2428
|
+
/** The definition of the parameter */
|
|
2429
|
+
runtimeParameter?: Maybe<RuntimeParameterDefinition>;
|
|
2430
|
+
/** Time when this NodeParameter was last updated */
|
|
2431
|
+
updatedAt?: Maybe<Scalars['Time']['output']>;
|
|
2432
|
+
/** The value of the parameter */
|
|
2433
|
+
value?: Maybe<NodeParameterValue>;
|
|
2434
|
+
}
|
|
2435
|
+
|
|
2436
|
+
/** The connection type for NodeParameter. */
|
|
2437
|
+
export interface NodeParameterConnection {
|
|
2438
|
+
__typename?: 'NodeParameterConnection';
|
|
2439
|
+
/** Total count of collection. */
|
|
2440
|
+
count?: Maybe<Scalars['Int']['output']>;
|
|
2441
|
+
/** A list of edges. */
|
|
2442
|
+
edges?: Maybe<Array<Maybe<NodeParameterEdge>>>;
|
|
2443
|
+
/** A list of nodes. */
|
|
2444
|
+
nodes?: Maybe<Array<Maybe<NodeParameter>>>;
|
|
2445
|
+
/** Information to aid in pagination. */
|
|
2446
|
+
pageInfo?: Maybe<PageInfo>;
|
|
2447
|
+
}
|
|
2448
|
+
|
|
2449
|
+
/** An edge in a connection. */
|
|
2450
|
+
export interface NodeParameterEdge {
|
|
2451
|
+
__typename?: 'NodeParameterEdge';
|
|
2452
|
+
/** A cursor for use in pagination. */
|
|
2453
|
+
cursor?: Maybe<Scalars['String']['output']>;
|
|
2454
|
+
/** The item at the end of the edge. */
|
|
2455
|
+
node?: Maybe<NodeParameter>;
|
|
2456
|
+
}
|
|
2457
|
+
|
|
2458
|
+
/** Input type for Node parameter */
|
|
2459
|
+
export interface NodeParameterInput {
|
|
2460
|
+
/** The identifier of the Runtime Parameter Definition */
|
|
2461
|
+
runtimeParameterDefinitionId: Scalars['RuntimeParameterDefinitionID']['input'];
|
|
2462
|
+
/** The value of the parameter */
|
|
2463
|
+
value?: InputMaybe<NodeParameterValueInput>;
|
|
2464
|
+
}
|
|
2465
|
+
|
|
2466
|
+
/** Represents a parameter value for a node. */
|
|
2467
|
+
export type NodeParameterValue = LiteralValue | NodeFunctionIdWrapper | ReferenceValue;
|
|
2468
|
+
|
|
2469
|
+
/** Input type for parameter value */
|
|
2470
|
+
export interface NodeParameterValueInput {
|
|
2471
|
+
/** The literal value of the parameter */
|
|
2472
|
+
literalValue?: InputMaybe<Scalars['JSON']['input']>;
|
|
2473
|
+
/** The function value of the parameter as an id */
|
|
2474
|
+
nodeFunctionId?: InputMaybe<Scalars['NodeFunctionID']['input']>;
|
|
2475
|
+
/** The reference value of the parameter */
|
|
2476
|
+
referenceValue?: InputMaybe<ReferenceValueInput>;
|
|
2477
|
+
}
|
|
2478
|
+
|
|
2479
|
+
/** Represents an OIDC identity provider configuration */
|
|
2480
|
+
export interface OidcIdentityProviderConfig {
|
|
2481
|
+
__typename?: 'OidcIdentityProviderConfig';
|
|
2482
|
+
/** List of attribute statements for the OIDC identity provider */
|
|
2483
|
+
attributeStatements?: Maybe<Scalars['JSON']['output']>;
|
|
2484
|
+
/** The authorization URL for the OIDC identity provider */
|
|
2485
|
+
authorizationUrl?: Maybe<Scalars['String']['output']>;
|
|
2486
|
+
/** The client ID for the OIDC identity provider */
|
|
2487
|
+
clientId?: Maybe<Scalars['String']['output']>;
|
|
2488
|
+
/** The client secret for the OIDC identity provider */
|
|
2489
|
+
clientSecret?: Maybe<Scalars['String']['output']>;
|
|
2490
|
+
/** The name of the OIDC identity provider */
|
|
2491
|
+
providerName?: Maybe<Scalars['String']['output']>;
|
|
2492
|
+
/** The redirect URI for the OIDC identity provider */
|
|
2493
|
+
redirectUri?: Maybe<Scalars['String']['output']>;
|
|
2494
|
+
/** The user details URL for the OIDC identity provider */
|
|
2495
|
+
userDetailsUrl?: Maybe<Scalars['String']['output']>;
|
|
1035
2496
|
}
|
|
1036
2497
|
|
|
1037
2498
|
/** Represents a Organization */
|
|
1038
2499
|
export interface Organization {
|
|
1039
2500
|
__typename?: 'Organization';
|
|
1040
2501
|
/** Time when this Organization was created */
|
|
1041
|
-
createdAt
|
|
2502
|
+
createdAt?: Maybe<Scalars['Time']['output']>;
|
|
1042
2503
|
/** Global ID of this Organization */
|
|
1043
|
-
id
|
|
2504
|
+
id?: Maybe<Scalars['OrganizationID']['output']>;
|
|
1044
2505
|
/** Name of the organization */
|
|
1045
|
-
name
|
|
2506
|
+
name?: Maybe<Scalars['String']['output']>;
|
|
1046
2507
|
/** Namespace of this organization */
|
|
1047
|
-
namespace
|
|
2508
|
+
namespace?: Maybe<Namespace>;
|
|
1048
2509
|
/** Time when this Organization was last updated */
|
|
1049
|
-
updatedAt
|
|
2510
|
+
updatedAt?: Maybe<Scalars['Time']['output']>;
|
|
2511
|
+
/** Abilities for the current user on this Organization */
|
|
2512
|
+
userAbilities?: Maybe<OrganizationUserAbilities>;
|
|
2513
|
+
}
|
|
2514
|
+
|
|
2515
|
+
/** The connection type for Organization. */
|
|
2516
|
+
export interface OrganizationConnection {
|
|
2517
|
+
__typename?: 'OrganizationConnection';
|
|
2518
|
+
/** Total count of collection. */
|
|
2519
|
+
count?: Maybe<Scalars['Int']['output']>;
|
|
2520
|
+
/** A list of edges. */
|
|
2521
|
+
edges?: Maybe<Array<Maybe<OrganizationEdge>>>;
|
|
2522
|
+
/** A list of nodes. */
|
|
2523
|
+
nodes?: Maybe<Array<Maybe<Organization>>>;
|
|
2524
|
+
/** Information to aid in pagination. */
|
|
2525
|
+
pageInfo?: Maybe<PageInfo>;
|
|
2526
|
+
}
|
|
2527
|
+
|
|
2528
|
+
/** An edge in a connection. */
|
|
2529
|
+
export interface OrganizationEdge {
|
|
2530
|
+
__typename?: 'OrganizationEdge';
|
|
2531
|
+
/** A cursor for use in pagination. */
|
|
2532
|
+
cursor?: Maybe<Scalars['String']['output']>;
|
|
2533
|
+
/** The item at the end of the edge. */
|
|
2534
|
+
node?: Maybe<Organization>;
|
|
2535
|
+
}
|
|
2536
|
+
|
|
2537
|
+
/** Abilities for the current user on this Organization */
|
|
2538
|
+
export interface OrganizationUserAbilities {
|
|
2539
|
+
__typename?: 'OrganizationUserAbilities';
|
|
2540
|
+
/** Shows if the current user has the `delete_organization` ability on this Organization */
|
|
2541
|
+
deleteOrganization?: Maybe<Scalars['Boolean']['output']>;
|
|
2542
|
+
/** Shows if the current user has the `update_organization` ability on this Organization */
|
|
2543
|
+
updateOrganization?: Maybe<Scalars['Boolean']['output']>;
|
|
1050
2544
|
}
|
|
1051
2545
|
|
|
1052
2546
|
/** Autogenerated input type of OrganizationsCreate */
|
|
@@ -1063,7 +2557,7 @@ export interface OrganizationsCreatePayload {
|
|
|
1063
2557
|
/** A unique identifier for the client performing the mutation. */
|
|
1064
2558
|
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
1065
2559
|
/** Errors encountered during execution of the mutation. */
|
|
1066
|
-
errors
|
|
2560
|
+
errors?: Maybe<Array<Error>>;
|
|
1067
2561
|
/** The newly created organization. */
|
|
1068
2562
|
organization?: Maybe<Organization>;
|
|
1069
2563
|
}
|
|
@@ -1082,7 +2576,7 @@ export interface OrganizationsDeletePayload {
|
|
|
1082
2576
|
/** A unique identifier for the client performing the mutation. */
|
|
1083
2577
|
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
1084
2578
|
/** Errors encountered during execution of the mutation. */
|
|
1085
|
-
errors
|
|
2579
|
+
errors?: Maybe<Array<Error>>;
|
|
1086
2580
|
/** The deleted organization. */
|
|
1087
2581
|
organization?: Maybe<Organization>;
|
|
1088
2582
|
}
|
|
@@ -1103,7 +2597,7 @@ export interface OrganizationsUpdatePayload {
|
|
|
1103
2597
|
/** A unique identifier for the client performing the mutation. */
|
|
1104
2598
|
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
1105
2599
|
/** Errors encountered during execution of the mutation. */
|
|
1106
|
-
errors
|
|
2600
|
+
errors?: Maybe<Array<Error>>;
|
|
1107
2601
|
/** The updated organization. */
|
|
1108
2602
|
organization?: Maybe<Organization>;
|
|
1109
2603
|
}
|
|
@@ -1114,26 +2608,69 @@ export interface PageInfo {
|
|
|
1114
2608
|
/** When paginating forwards, the cursor to continue. */
|
|
1115
2609
|
endCursor?: Maybe<Scalars['String']['output']>;
|
|
1116
2610
|
/** When paginating forwards, are there more items? */
|
|
1117
|
-
hasNextPage
|
|
2611
|
+
hasNextPage?: Maybe<Scalars['Boolean']['output']>;
|
|
1118
2612
|
/** When paginating backwards, are there more items? */
|
|
1119
|
-
hasPreviousPage
|
|
2613
|
+
hasPreviousPage?: Maybe<Scalars['Boolean']['output']>;
|
|
1120
2614
|
/** When paginating backwards, the cursor to continue. */
|
|
1121
2615
|
startCursor?: Maybe<Scalars['String']['output']>;
|
|
1122
2616
|
}
|
|
1123
2617
|
|
|
2618
|
+
/** Represents a parameter definition */
|
|
2619
|
+
export interface ParameterDefinition {
|
|
2620
|
+
__typename?: 'ParameterDefinition';
|
|
2621
|
+
/** Time when this ParameterDefinition was created */
|
|
2622
|
+
createdAt?: Maybe<Scalars['Time']['output']>;
|
|
2623
|
+
/** Data type of the parameter */
|
|
2624
|
+
dataTypeIdentifier?: Maybe<DataTypeIdentifier>;
|
|
2625
|
+
/** Description of the parameter */
|
|
2626
|
+
descriptions?: Maybe<Array<Translation>>;
|
|
2627
|
+
/** Documentation of the parameter */
|
|
2628
|
+
documentations?: Maybe<Array<Translation>>;
|
|
2629
|
+
/** Global ID of this ParameterDefinition */
|
|
2630
|
+
id?: Maybe<Scalars['ParameterDefinitionID']['output']>;
|
|
2631
|
+
/** Identifier of the parameter */
|
|
2632
|
+
identifier?: Maybe<Scalars['String']['output']>;
|
|
2633
|
+
/** Name of the parameter */
|
|
2634
|
+
names?: Maybe<Array<Translation>>;
|
|
2635
|
+
/** Time when this ParameterDefinition was last updated */
|
|
2636
|
+
updatedAt?: Maybe<Scalars['Time']['output']>;
|
|
2637
|
+
}
|
|
2638
|
+
|
|
2639
|
+
/** The connection type for ParameterDefinition. */
|
|
2640
|
+
export interface ParameterDefinitionConnection {
|
|
2641
|
+
__typename?: 'ParameterDefinitionConnection';
|
|
2642
|
+
/** Total count of collection. */
|
|
2643
|
+
count?: Maybe<Scalars['Int']['output']>;
|
|
2644
|
+
/** A list of edges. */
|
|
2645
|
+
edges?: Maybe<Array<Maybe<ParameterDefinitionEdge>>>;
|
|
2646
|
+
/** A list of nodes. */
|
|
2647
|
+
nodes?: Maybe<Array<Maybe<ParameterDefinition>>>;
|
|
2648
|
+
/** Information to aid in pagination. */
|
|
2649
|
+
pageInfo?: Maybe<PageInfo>;
|
|
2650
|
+
}
|
|
2651
|
+
|
|
2652
|
+
/** An edge in a connection. */
|
|
2653
|
+
export interface ParameterDefinitionEdge {
|
|
2654
|
+
__typename?: 'ParameterDefinitionEdge';
|
|
2655
|
+
/** A cursor for use in pagination. */
|
|
2656
|
+
cursor?: Maybe<Scalars['String']['output']>;
|
|
2657
|
+
/** The item at the end of the edge. */
|
|
2658
|
+
node?: Maybe<ParameterDefinition>;
|
|
2659
|
+
}
|
|
2660
|
+
|
|
1124
2661
|
/** Root Query type */
|
|
1125
2662
|
export interface Query {
|
|
1126
2663
|
__typename?: 'Query';
|
|
1127
|
-
/** Get
|
|
1128
|
-
|
|
2664
|
+
/** Get application information */
|
|
2665
|
+
application?: Maybe<Application>;
|
|
1129
2666
|
/** Get the currently logged in authentication */
|
|
1130
2667
|
currentAuthentication?: Maybe<Authentication>;
|
|
1131
2668
|
/** Get the currently logged in user */
|
|
1132
2669
|
currentUser?: Maybe<User>;
|
|
1133
2670
|
/** Field available for use to test API access */
|
|
1134
|
-
echo
|
|
2671
|
+
echo?: Maybe<Scalars['String']['output']>;
|
|
1135
2672
|
/** Find runtimes */
|
|
1136
|
-
globalRuntimes
|
|
2673
|
+
globalRuntimes?: Maybe<RuntimeConnection>;
|
|
1137
2674
|
/** Find a namespace */
|
|
1138
2675
|
namespace?: Maybe<Namespace>;
|
|
1139
2676
|
/** Fetches an object given its ID */
|
|
@@ -1142,6 +2679,12 @@ export interface Query {
|
|
|
1142
2679
|
nodes?: Maybe<Array<Maybe<Node>>>;
|
|
1143
2680
|
/** Find a organization */
|
|
1144
2681
|
organization?: Maybe<Organization>;
|
|
2682
|
+
/** Find organizations */
|
|
2683
|
+
organizations?: Maybe<OrganizationConnection>;
|
|
2684
|
+
/** Find a user */
|
|
2685
|
+
user?: Maybe<User>;
|
|
2686
|
+
/** Find users */
|
|
2687
|
+
users?: Maybe<UserConnection>;
|
|
1145
2688
|
}
|
|
1146
2689
|
|
|
1147
2690
|
|
|
@@ -1184,25 +2727,122 @@ export interface QueryOrganizationArgs {
|
|
|
1184
2727
|
name?: InputMaybe<Scalars['String']['input']>;
|
|
1185
2728
|
}
|
|
1186
2729
|
|
|
2730
|
+
|
|
2731
|
+
/** Root Query type */
|
|
2732
|
+
export interface QueryOrganizationsArgs {
|
|
2733
|
+
after?: InputMaybe<Scalars['String']['input']>;
|
|
2734
|
+
before?: InputMaybe<Scalars['String']['input']>;
|
|
2735
|
+
first?: InputMaybe<Scalars['Int']['input']>;
|
|
2736
|
+
last?: InputMaybe<Scalars['Int']['input']>;
|
|
2737
|
+
}
|
|
2738
|
+
|
|
2739
|
+
|
|
2740
|
+
/** Root Query type */
|
|
2741
|
+
export interface QueryUserArgs {
|
|
2742
|
+
id?: InputMaybe<Scalars['UserID']['input']>;
|
|
2743
|
+
username?: InputMaybe<Scalars['String']['input']>;
|
|
2744
|
+
}
|
|
2745
|
+
|
|
2746
|
+
|
|
2747
|
+
/** Root Query type */
|
|
2748
|
+
export interface QueryUsersArgs {
|
|
2749
|
+
after?: InputMaybe<Scalars['String']['input']>;
|
|
2750
|
+
before?: InputMaybe<Scalars['String']['input']>;
|
|
2751
|
+
first?: InputMaybe<Scalars['Int']['input']>;
|
|
2752
|
+
last?: InputMaybe<Scalars['Int']['input']>;
|
|
2753
|
+
}
|
|
2754
|
+
|
|
2755
|
+
/** Represents a reference path in a flow */
|
|
2756
|
+
export interface ReferencePath {
|
|
2757
|
+
__typename?: 'ReferencePath';
|
|
2758
|
+
/** The array index of the referenced data by the path */
|
|
2759
|
+
arrayIndex?: Maybe<Scalars['Int']['output']>;
|
|
2760
|
+
/** Time when this ReferencePath was created */
|
|
2761
|
+
createdAt?: Maybe<Scalars['Time']['output']>;
|
|
2762
|
+
/** Global ID of this ReferencePath */
|
|
2763
|
+
id?: Maybe<Scalars['ReferencePathID']['output']>;
|
|
2764
|
+
/** The path to the reference in the flow */
|
|
2765
|
+
path?: Maybe<Scalars['String']['output']>;
|
|
2766
|
+
/** Time when this ReferencePath was last updated */
|
|
2767
|
+
updatedAt?: Maybe<Scalars['Time']['output']>;
|
|
2768
|
+
}
|
|
2769
|
+
|
|
2770
|
+
/** Input type for reference path */
|
|
2771
|
+
export interface ReferencePathInput {
|
|
2772
|
+
/** Array index if applicable */
|
|
2773
|
+
arrayIndex?: InputMaybe<Scalars['Int']['input']>;
|
|
2774
|
+
/** The path to the reference in the flow */
|
|
2775
|
+
path?: InputMaybe<Scalars['String']['input']>;
|
|
2776
|
+
}
|
|
2777
|
+
|
|
2778
|
+
/** Represents a reference value in the system. */
|
|
2779
|
+
export interface ReferenceValue {
|
|
2780
|
+
__typename?: 'ReferenceValue';
|
|
2781
|
+
/** Time when this ReferenceValue was created */
|
|
2782
|
+
createdAt?: Maybe<Scalars['Time']['output']>;
|
|
2783
|
+
/** The identifier of the data type this reference value belongs to. */
|
|
2784
|
+
dataTypeIdentifier?: Maybe<DataTypeIdentifier>;
|
|
2785
|
+
/** The depth of the reference value. */
|
|
2786
|
+
depth?: Maybe<Scalars['Int']['output']>;
|
|
2787
|
+
/** Global ID of this ReferenceValue */
|
|
2788
|
+
id?: Maybe<Scalars['ReferenceValueID']['output']>;
|
|
2789
|
+
/** The node of the reference value. */
|
|
2790
|
+
node?: Maybe<Scalars['Int']['output']>;
|
|
2791
|
+
/** The referenced value. */
|
|
2792
|
+
nodeFunctionId?: Maybe<Scalars['NodeFunctionID']['output']>;
|
|
2793
|
+
/** The paths associated with this reference value. */
|
|
2794
|
+
referencePath?: Maybe<Array<ReferencePath>>;
|
|
2795
|
+
/** The scope of the reference value. */
|
|
2796
|
+
scope?: Maybe<Array<Scalars['Int']['output']>>;
|
|
2797
|
+
/** Time when this ReferenceValue was last updated */
|
|
2798
|
+
updatedAt?: Maybe<Scalars['Time']['output']>;
|
|
2799
|
+
}
|
|
2800
|
+
|
|
2801
|
+
/** Input type for reference value */
|
|
2802
|
+
export interface ReferenceValueInput {
|
|
2803
|
+
/** The identifier of the data type this reference value belongs to */
|
|
2804
|
+
dataTypeIdentifier: DataTypeIdentifierInput;
|
|
2805
|
+
/** The depth of the reference value */
|
|
2806
|
+
depth: Scalars['Int']['input'];
|
|
2807
|
+
/** The node of the reference */
|
|
2808
|
+
node: Scalars['Int']['input'];
|
|
2809
|
+
/** The referenced value */
|
|
2810
|
+
nodeFunctionId: Scalars['NodeFunctionID']['input'];
|
|
2811
|
+
/** The paths associated with this reference value */
|
|
2812
|
+
referencePath: Array<ReferencePathInput>;
|
|
2813
|
+
/** The scope of the reference value */
|
|
2814
|
+
scope: Array<Scalars['Int']['input']>;
|
|
2815
|
+
}
|
|
2816
|
+
|
|
1187
2817
|
/** Represents a runtime */
|
|
1188
2818
|
export interface Runtime {
|
|
1189
2819
|
__typename?: 'Runtime';
|
|
1190
2820
|
/** Time when this Runtime was created */
|
|
1191
|
-
createdAt
|
|
2821
|
+
createdAt?: Maybe<Scalars['Time']['output']>;
|
|
1192
2822
|
/** DataTypes of the runtime */
|
|
1193
|
-
dataTypes
|
|
2823
|
+
dataTypes?: Maybe<DataTypeConnection>;
|
|
1194
2824
|
/** The description for the runtime if present */
|
|
1195
|
-
description
|
|
2825
|
+
description?: Maybe<Scalars['String']['output']>;
|
|
2826
|
+
/** FlowTypes of the runtime */
|
|
2827
|
+
flowTypes?: Maybe<FlowTypeConnection>;
|
|
2828
|
+
/** Function definitions of the runtime */
|
|
2829
|
+
functionDefinitions?: Maybe<FunctionDefinitionConnection>;
|
|
1196
2830
|
/** Global ID of this Runtime */
|
|
1197
|
-
id
|
|
2831
|
+
id?: Maybe<Scalars['RuntimeID']['output']>;
|
|
1198
2832
|
/** The name for the runtime */
|
|
1199
|
-
name
|
|
2833
|
+
name?: Maybe<Scalars['String']['output']>;
|
|
1200
2834
|
/** The parent namespace for the runtime */
|
|
1201
2835
|
namespace?: Maybe<Namespace>;
|
|
2836
|
+
/** Projects associated with the runtime */
|
|
2837
|
+
projects?: Maybe<NamespaceProjectConnection>;
|
|
2838
|
+
/** The status of the runtime */
|
|
2839
|
+
status?: Maybe<RuntimeStatusType>;
|
|
1202
2840
|
/** Token belonging to the runtime, only present on creation */
|
|
1203
2841
|
token?: Maybe<Scalars['String']['output']>;
|
|
1204
2842
|
/** Time when this Runtime was last updated */
|
|
1205
|
-
updatedAt
|
|
2843
|
+
updatedAt?: Maybe<Scalars['Time']['output']>;
|
|
2844
|
+
/** Abilities for the current user on this Runtime */
|
|
2845
|
+
userAbilities?: Maybe<RuntimeUserAbilities>;
|
|
1206
2846
|
}
|
|
1207
2847
|
|
|
1208
2848
|
|
|
@@ -1214,28 +2854,146 @@ export interface RuntimeDataTypesArgs {
|
|
|
1214
2854
|
last?: InputMaybe<Scalars['Int']['input']>;
|
|
1215
2855
|
}
|
|
1216
2856
|
|
|
2857
|
+
|
|
2858
|
+
/** Represents a runtime */
|
|
2859
|
+
export interface RuntimeFlowTypesArgs {
|
|
2860
|
+
after?: InputMaybe<Scalars['String']['input']>;
|
|
2861
|
+
before?: InputMaybe<Scalars['String']['input']>;
|
|
2862
|
+
first?: InputMaybe<Scalars['Int']['input']>;
|
|
2863
|
+
last?: InputMaybe<Scalars['Int']['input']>;
|
|
2864
|
+
}
|
|
2865
|
+
|
|
2866
|
+
|
|
2867
|
+
/** Represents a runtime */
|
|
2868
|
+
export interface RuntimeFunctionDefinitionsArgs {
|
|
2869
|
+
after?: InputMaybe<Scalars['String']['input']>;
|
|
2870
|
+
before?: InputMaybe<Scalars['String']['input']>;
|
|
2871
|
+
first?: InputMaybe<Scalars['Int']['input']>;
|
|
2872
|
+
last?: InputMaybe<Scalars['Int']['input']>;
|
|
2873
|
+
}
|
|
2874
|
+
|
|
2875
|
+
|
|
2876
|
+
/** Represents a runtime */
|
|
2877
|
+
export interface RuntimeProjectsArgs {
|
|
2878
|
+
after?: InputMaybe<Scalars['String']['input']>;
|
|
2879
|
+
before?: InputMaybe<Scalars['String']['input']>;
|
|
2880
|
+
first?: InputMaybe<Scalars['Int']['input']>;
|
|
2881
|
+
last?: InputMaybe<Scalars['Int']['input']>;
|
|
2882
|
+
}
|
|
2883
|
+
|
|
1217
2884
|
/** The connection type for Runtime. */
|
|
1218
2885
|
export interface RuntimeConnection {
|
|
1219
2886
|
__typename?: 'RuntimeConnection';
|
|
1220
2887
|
/** Total count of collection. */
|
|
1221
|
-
count
|
|
2888
|
+
count?: Maybe<Scalars['Int']['output']>;
|
|
1222
2889
|
/** A list of edges. */
|
|
1223
2890
|
edges?: Maybe<Array<Maybe<RuntimeEdge>>>;
|
|
1224
2891
|
/** A list of nodes. */
|
|
1225
2892
|
nodes?: Maybe<Array<Maybe<Runtime>>>;
|
|
1226
2893
|
/** Information to aid in pagination. */
|
|
1227
|
-
pageInfo
|
|
2894
|
+
pageInfo?: Maybe<PageInfo>;
|
|
1228
2895
|
}
|
|
1229
2896
|
|
|
1230
2897
|
/** An edge in a connection. */
|
|
1231
2898
|
export interface RuntimeEdge {
|
|
1232
2899
|
__typename?: 'RuntimeEdge';
|
|
1233
2900
|
/** A cursor for use in pagination. */
|
|
1234
|
-
cursor
|
|
2901
|
+
cursor?: Maybe<Scalars['String']['output']>;
|
|
1235
2902
|
/** The item at the end of the edge. */
|
|
1236
2903
|
node?: Maybe<Runtime>;
|
|
1237
2904
|
}
|
|
1238
2905
|
|
|
2906
|
+
/** Represents a runtime function definition */
|
|
2907
|
+
export interface RuntimeFunctionDefinition {
|
|
2908
|
+
__typename?: 'RuntimeFunctionDefinition';
|
|
2909
|
+
/** Time when this RuntimeFunctionDefinition was created */
|
|
2910
|
+
createdAt?: Maybe<Scalars['Time']['output']>;
|
|
2911
|
+
/** Function definitions of the runtime function definition */
|
|
2912
|
+
functionDefinitions?: Maybe<FunctionDefinitionConnection>;
|
|
2913
|
+
/** Global ID of this RuntimeFunctionDefinition */
|
|
2914
|
+
id?: Maybe<Scalars['RuntimeFunctionDefinitionID']['output']>;
|
|
2915
|
+
/** Identifier of the runtime function definition */
|
|
2916
|
+
identifier?: Maybe<Scalars['String']['output']>;
|
|
2917
|
+
/** The runtime this runtime function definition belongs to */
|
|
2918
|
+
runtime?: Maybe<Runtime>;
|
|
2919
|
+
/** Parameter definitions of the runtime function definition */
|
|
2920
|
+
runtimeParameterDefinitions?: Maybe<RuntimeParameterDefinitionConnection>;
|
|
2921
|
+
/** Time when this RuntimeFunctionDefinition was last updated */
|
|
2922
|
+
updatedAt?: Maybe<Scalars['Time']['output']>;
|
|
2923
|
+
}
|
|
2924
|
+
|
|
2925
|
+
|
|
2926
|
+
/** Represents a runtime function definition */
|
|
2927
|
+
export interface RuntimeFunctionDefinitionFunctionDefinitionsArgs {
|
|
2928
|
+
after?: InputMaybe<Scalars['String']['input']>;
|
|
2929
|
+
before?: InputMaybe<Scalars['String']['input']>;
|
|
2930
|
+
first?: InputMaybe<Scalars['Int']['input']>;
|
|
2931
|
+
last?: InputMaybe<Scalars['Int']['input']>;
|
|
2932
|
+
}
|
|
2933
|
+
|
|
2934
|
+
|
|
2935
|
+
/** Represents a runtime function definition */
|
|
2936
|
+
export interface RuntimeFunctionDefinitionRuntimeParameterDefinitionsArgs {
|
|
2937
|
+
after?: InputMaybe<Scalars['String']['input']>;
|
|
2938
|
+
before?: InputMaybe<Scalars['String']['input']>;
|
|
2939
|
+
first?: InputMaybe<Scalars['Int']['input']>;
|
|
2940
|
+
last?: InputMaybe<Scalars['Int']['input']>;
|
|
2941
|
+
}
|
|
2942
|
+
|
|
2943
|
+
/** Represents a runtime parameter definition */
|
|
2944
|
+
export interface RuntimeParameterDefinition {
|
|
2945
|
+
__typename?: 'RuntimeParameterDefinition';
|
|
2946
|
+
/** Time when this RuntimeParameterDefinition was created */
|
|
2947
|
+
createdAt?: Maybe<Scalars['Time']['output']>;
|
|
2948
|
+
/** Global ID of this RuntimeParameterDefinition */
|
|
2949
|
+
id?: Maybe<Scalars['RuntimeParameterDefinitionID']['output']>;
|
|
2950
|
+
/** Identifier of the runtime parameter definition */
|
|
2951
|
+
identifier?: Maybe<Scalars['String']['output']>;
|
|
2952
|
+
/** Time when this RuntimeParameterDefinition was last updated */
|
|
2953
|
+
updatedAt?: Maybe<Scalars['Time']['output']>;
|
|
2954
|
+
}
|
|
2955
|
+
|
|
2956
|
+
/** The connection type for RuntimeParameterDefinition. */
|
|
2957
|
+
export interface RuntimeParameterDefinitionConnection {
|
|
2958
|
+
__typename?: 'RuntimeParameterDefinitionConnection';
|
|
2959
|
+
/** Total count of collection. */
|
|
2960
|
+
count?: Maybe<Scalars['Int']['output']>;
|
|
2961
|
+
/** A list of edges. */
|
|
2962
|
+
edges?: Maybe<Array<Maybe<RuntimeParameterDefinitionEdge>>>;
|
|
2963
|
+
/** A list of nodes. */
|
|
2964
|
+
nodes?: Maybe<Array<Maybe<RuntimeParameterDefinition>>>;
|
|
2965
|
+
/** Information to aid in pagination. */
|
|
2966
|
+
pageInfo?: Maybe<PageInfo>;
|
|
2967
|
+
}
|
|
2968
|
+
|
|
2969
|
+
/** An edge in a connection. */
|
|
2970
|
+
export interface RuntimeParameterDefinitionEdge {
|
|
2971
|
+
__typename?: 'RuntimeParameterDefinitionEdge';
|
|
2972
|
+
/** A cursor for use in pagination. */
|
|
2973
|
+
cursor?: Maybe<Scalars['String']['output']>;
|
|
2974
|
+
/** The item at the end of the edge. */
|
|
2975
|
+
node?: Maybe<RuntimeParameterDefinition>;
|
|
2976
|
+
}
|
|
2977
|
+
|
|
2978
|
+
/** Represent all available types of statuses of a runtime */
|
|
2979
|
+
export const enum RuntimeStatusType {
|
|
2980
|
+
/** No problem with connection, everything works as expected */
|
|
2981
|
+
Connected = 'CONNECTED',
|
|
2982
|
+
/** The runtime is disconnected, cause unknown */
|
|
2983
|
+
Disconnected = 'DISCONNECTED'
|
|
2984
|
+
}
|
|
2985
|
+
|
|
2986
|
+
/** Abilities for the current user on this Runtime */
|
|
2987
|
+
export interface RuntimeUserAbilities {
|
|
2988
|
+
__typename?: 'RuntimeUserAbilities';
|
|
2989
|
+
/** Shows if the current user has the `delete_runtime` ability on this Runtime */
|
|
2990
|
+
deleteRuntime?: Maybe<Scalars['Boolean']['output']>;
|
|
2991
|
+
/** Shows if the current user has the `rotate_runtime_token` ability on this Runtime */
|
|
2992
|
+
rotateRuntimeToken?: Maybe<Scalars['Boolean']['output']>;
|
|
2993
|
+
/** Shows if the current user has the `update_runtime` ability on this Runtime */
|
|
2994
|
+
updateRuntime?: Maybe<Scalars['Boolean']['output']>;
|
|
2995
|
+
}
|
|
2996
|
+
|
|
1239
2997
|
/** Autogenerated input type of RuntimesCreate */
|
|
1240
2998
|
export interface RuntimesCreateInput {
|
|
1241
2999
|
/** A unique identifier for the client performing the mutation. */
|
|
@@ -1254,7 +3012,7 @@ export interface RuntimesCreatePayload {
|
|
|
1254
3012
|
/** A unique identifier for the client performing the mutation. */
|
|
1255
3013
|
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
1256
3014
|
/** Errors encountered during execution of the mutation. */
|
|
1257
|
-
errors
|
|
3015
|
+
errors?: Maybe<Array<Error>>;
|
|
1258
3016
|
/** The newly created runtime. */
|
|
1259
3017
|
runtime?: Maybe<Runtime>;
|
|
1260
3018
|
}
|
|
@@ -1273,7 +3031,7 @@ export interface RuntimesDeletePayload {
|
|
|
1273
3031
|
/** A unique identifier for the client performing the mutation. */
|
|
1274
3032
|
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
1275
3033
|
/** Errors encountered during execution of the mutation. */
|
|
1276
|
-
errors
|
|
3034
|
+
errors?: Maybe<Array<Error>>;
|
|
1277
3035
|
/** The updated organization. */
|
|
1278
3036
|
runtime?: Maybe<Runtime>;
|
|
1279
3037
|
}
|
|
@@ -1292,7 +3050,7 @@ export interface RuntimesRotateTokenPayload {
|
|
|
1292
3050
|
/** A unique identifier for the client performing the mutation. */
|
|
1293
3051
|
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
1294
3052
|
/** Errors encountered during execution of the mutation. */
|
|
1295
|
-
errors
|
|
3053
|
+
errors?: Maybe<Array<Error>>;
|
|
1296
3054
|
/** The updated runtime. */
|
|
1297
3055
|
runtime?: Maybe<Runtime>;
|
|
1298
3056
|
}
|
|
@@ -1315,36 +3073,79 @@ export interface RuntimesUpdatePayload {
|
|
|
1315
3073
|
/** A unique identifier for the client performing the mutation. */
|
|
1316
3074
|
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
1317
3075
|
/** Errors encountered during execution of the mutation. */
|
|
1318
|
-
errors
|
|
3076
|
+
errors?: Maybe<Array<Error>>;
|
|
1319
3077
|
/** The updated runtime. */
|
|
1320
3078
|
runtime?: Maybe<Runtime>;
|
|
1321
3079
|
}
|
|
1322
3080
|
|
|
3081
|
+
/** Represents the configuration for a SAML identity provider. */
|
|
3082
|
+
export interface SamlIdentityProviderConfig {
|
|
3083
|
+
__typename?: 'SamlIdentityProviderConfig';
|
|
3084
|
+
/** List of attribute statements for the SAML identity provider */
|
|
3085
|
+
attributeStatements?: Maybe<Scalars['JSON']['output']>;
|
|
3086
|
+
/** The metadata url to fetch the metadatas (replacement for settings) */
|
|
3087
|
+
metadataUrl?: Maybe<Scalars['String']['output']>;
|
|
3088
|
+
/** The name of the SAML identity provider */
|
|
3089
|
+
providerName?: Maybe<Scalars['String']['output']>;
|
|
3090
|
+
/** The SAML response settings for the identity provider */
|
|
3091
|
+
responseSettings?: Maybe<Scalars['JSON']['output']>;
|
|
3092
|
+
/** The SAML settings for the identity provider */
|
|
3093
|
+
settings?: Maybe<Scalars['JSON']['output']>;
|
|
3094
|
+
}
|
|
3095
|
+
|
|
3096
|
+
/** Represents a translation */
|
|
3097
|
+
export interface Translation {
|
|
3098
|
+
__typename?: 'Translation';
|
|
3099
|
+
/** Code of the translation */
|
|
3100
|
+
code?: Maybe<Scalars['String']['output']>;
|
|
3101
|
+
/** Content of the translation */
|
|
3102
|
+
content?: Maybe<Scalars['String']['output']>;
|
|
3103
|
+
}
|
|
3104
|
+
|
|
1323
3105
|
/** Represents a user */
|
|
1324
3106
|
export interface User {
|
|
1325
3107
|
__typename?: 'User';
|
|
1326
3108
|
/** Global admin status of the user */
|
|
1327
|
-
admin
|
|
3109
|
+
admin?: Maybe<Scalars['Boolean']['output']>;
|
|
1328
3110
|
/** The avatar if present of the user */
|
|
1329
3111
|
avatarPath?: Maybe<Scalars['String']['output']>;
|
|
1330
3112
|
/** Time when this User was created */
|
|
1331
|
-
createdAt
|
|
3113
|
+
createdAt?: Maybe<Scalars['Time']['output']>;
|
|
1332
3114
|
/** Email of the user */
|
|
1333
|
-
email
|
|
3115
|
+
email?: Maybe<Scalars['String']['output']>;
|
|
3116
|
+
/** Email verification date of the user if present */
|
|
3117
|
+
emailVerifiedAt?: Maybe<Scalars['Time']['output']>;
|
|
1334
3118
|
/** Firstname of the user */
|
|
1335
|
-
firstname
|
|
3119
|
+
firstname?: Maybe<Scalars['String']['output']>;
|
|
1336
3120
|
/** Global ID of this User */
|
|
1337
|
-
id
|
|
3121
|
+
id?: Maybe<Scalars['UserID']['output']>;
|
|
3122
|
+
/** Identities of this user */
|
|
3123
|
+
identities?: Maybe<UserIdentityConnection>;
|
|
1338
3124
|
/** Lastname of the user */
|
|
1339
|
-
lastname
|
|
3125
|
+
lastname?: Maybe<Scalars['String']['output']>;
|
|
3126
|
+
/** Multi-factor authentication status of this user */
|
|
3127
|
+
mfaStatus?: Maybe<MfaStatus>;
|
|
1340
3128
|
/** Namespace of this user */
|
|
1341
3129
|
namespace?: Maybe<Namespace>;
|
|
1342
3130
|
/** Namespace Memberships of this user */
|
|
1343
|
-
namespaceMemberships
|
|
3131
|
+
namespaceMemberships?: Maybe<NamespaceMemberConnection>;
|
|
3132
|
+
/** Sessions of this user */
|
|
3133
|
+
sessions?: Maybe<UserSessionConnection>;
|
|
1344
3134
|
/** Time when this User was last updated */
|
|
1345
|
-
updatedAt
|
|
3135
|
+
updatedAt?: Maybe<Scalars['Time']['output']>;
|
|
3136
|
+
/** Abilities for the current user on this User */
|
|
3137
|
+
userAbilities?: Maybe<UserUserAbilities>;
|
|
1346
3138
|
/** Username of the user */
|
|
1347
|
-
username
|
|
3139
|
+
username?: Maybe<Scalars['String']['output']>;
|
|
3140
|
+
}
|
|
3141
|
+
|
|
3142
|
+
|
|
3143
|
+
/** Represents a user */
|
|
3144
|
+
export interface UserIdentitiesArgs {
|
|
3145
|
+
after?: InputMaybe<Scalars['String']['input']>;
|
|
3146
|
+
before?: InputMaybe<Scalars['String']['input']>;
|
|
3147
|
+
first?: InputMaybe<Scalars['Int']['input']>;
|
|
3148
|
+
last?: InputMaybe<Scalars['Int']['input']>;
|
|
1348
3149
|
}
|
|
1349
3150
|
|
|
1350
3151
|
|
|
@@ -1356,38 +3157,200 @@ export interface UserNamespaceMembershipsArgs {
|
|
|
1356
3157
|
last?: InputMaybe<Scalars['Int']['input']>;
|
|
1357
3158
|
}
|
|
1358
3159
|
|
|
3160
|
+
|
|
3161
|
+
/** Represents a user */
|
|
3162
|
+
export interface UserSessionsArgs {
|
|
3163
|
+
after?: InputMaybe<Scalars['String']['input']>;
|
|
3164
|
+
before?: InputMaybe<Scalars['String']['input']>;
|
|
3165
|
+
first?: InputMaybe<Scalars['Int']['input']>;
|
|
3166
|
+
last?: InputMaybe<Scalars['Int']['input']>;
|
|
3167
|
+
}
|
|
3168
|
+
|
|
3169
|
+
/** The connection type for User. */
|
|
3170
|
+
export interface UserConnection {
|
|
3171
|
+
__typename?: 'UserConnection';
|
|
3172
|
+
/** Total count of collection. */
|
|
3173
|
+
count?: Maybe<Scalars['Int']['output']>;
|
|
3174
|
+
/** A list of edges. */
|
|
3175
|
+
edges?: Maybe<Array<Maybe<UserEdge>>>;
|
|
3176
|
+
/** A list of nodes. */
|
|
3177
|
+
nodes?: Maybe<Array<Maybe<User>>>;
|
|
3178
|
+
/** Information to aid in pagination. */
|
|
3179
|
+
pageInfo?: Maybe<PageInfo>;
|
|
3180
|
+
}
|
|
3181
|
+
|
|
3182
|
+
/** An edge in a connection. */
|
|
3183
|
+
export interface UserEdge {
|
|
3184
|
+
__typename?: 'UserEdge';
|
|
3185
|
+
/** A cursor for use in pagination. */
|
|
3186
|
+
cursor?: Maybe<Scalars['String']['output']>;
|
|
3187
|
+
/** The item at the end of the edge. */
|
|
3188
|
+
node?: Maybe<User>;
|
|
3189
|
+
}
|
|
3190
|
+
|
|
1359
3191
|
/** Represents an external user identity */
|
|
1360
3192
|
export interface UserIdentity {
|
|
1361
3193
|
__typename?: 'UserIdentity';
|
|
1362
3194
|
/** Time when this UserIdentity was created */
|
|
1363
|
-
createdAt
|
|
3195
|
+
createdAt?: Maybe<Scalars['Time']['output']>;
|
|
1364
3196
|
/** Global ID of this UserIdentity */
|
|
1365
|
-
id
|
|
3197
|
+
id?: Maybe<Scalars['UserIdentityID']['output']>;
|
|
1366
3198
|
/** The description for the runtime if present */
|
|
1367
|
-
identifier
|
|
3199
|
+
identifier?: Maybe<Scalars['String']['output']>;
|
|
1368
3200
|
/** The name for the runtime */
|
|
1369
|
-
providerId
|
|
3201
|
+
providerId?: Maybe<Scalars['String']['output']>;
|
|
1370
3202
|
/** Time when this UserIdentity was last updated */
|
|
1371
|
-
updatedAt
|
|
3203
|
+
updatedAt?: Maybe<Scalars['Time']['output']>;
|
|
1372
3204
|
/** The correlating user of the identity */
|
|
1373
|
-
user
|
|
3205
|
+
user?: Maybe<User>;
|
|
3206
|
+
}
|
|
3207
|
+
|
|
3208
|
+
/** The connection type for UserIdentity. */
|
|
3209
|
+
export interface UserIdentityConnection {
|
|
3210
|
+
__typename?: 'UserIdentityConnection';
|
|
3211
|
+
/** Total count of collection. */
|
|
3212
|
+
count?: Maybe<Scalars['Int']['output']>;
|
|
3213
|
+
/** A list of edges. */
|
|
3214
|
+
edges?: Maybe<Array<Maybe<UserIdentityEdge>>>;
|
|
3215
|
+
/** A list of nodes. */
|
|
3216
|
+
nodes?: Maybe<Array<Maybe<UserIdentity>>>;
|
|
3217
|
+
/** Information to aid in pagination. */
|
|
3218
|
+
pageInfo?: Maybe<PageInfo>;
|
|
3219
|
+
}
|
|
3220
|
+
|
|
3221
|
+
/** An edge in a connection. */
|
|
3222
|
+
export interface UserIdentityEdge {
|
|
3223
|
+
__typename?: 'UserIdentityEdge';
|
|
3224
|
+
/** A cursor for use in pagination. */
|
|
3225
|
+
cursor?: Maybe<Scalars['String']['output']>;
|
|
3226
|
+
/** The item at the end of the edge. */
|
|
3227
|
+
node?: Maybe<UserIdentity>;
|
|
1374
3228
|
}
|
|
1375
3229
|
|
|
1376
3230
|
/** Represents a user session */
|
|
1377
3231
|
export interface UserSession {
|
|
1378
3232
|
__typename?: 'UserSession';
|
|
1379
3233
|
/** Whether or not the session is active and can be used */
|
|
1380
|
-
active
|
|
3234
|
+
active?: Maybe<Scalars['Boolean']['output']>;
|
|
1381
3235
|
/** Time when this UserSession was created */
|
|
1382
|
-
createdAt
|
|
3236
|
+
createdAt?: Maybe<Scalars['Time']['output']>;
|
|
1383
3237
|
/** Global ID of this UserSession */
|
|
1384
|
-
id
|
|
3238
|
+
id?: Maybe<Scalars['UserSessionID']['output']>;
|
|
1385
3239
|
/** Token belonging to the session, only present on creation */
|
|
1386
3240
|
token?: Maybe<Scalars['String']['output']>;
|
|
1387
3241
|
/** Time when this UserSession was last updated */
|
|
1388
|
-
updatedAt
|
|
3242
|
+
updatedAt?: Maybe<Scalars['Time']['output']>;
|
|
1389
3243
|
/** User that belongs to the session */
|
|
1390
|
-
user
|
|
3244
|
+
user?: Maybe<User>;
|
|
3245
|
+
/** Abilities for the current user on this UserSession */
|
|
3246
|
+
userAbilities?: Maybe<UserSessionUserAbilities>;
|
|
3247
|
+
}
|
|
3248
|
+
|
|
3249
|
+
/** The connection type for UserSession. */
|
|
3250
|
+
export interface UserSessionConnection {
|
|
3251
|
+
__typename?: 'UserSessionConnection';
|
|
3252
|
+
/** Total count of collection. */
|
|
3253
|
+
count?: Maybe<Scalars['Int']['output']>;
|
|
3254
|
+
/** A list of edges. */
|
|
3255
|
+
edges?: Maybe<Array<Maybe<UserSessionEdge>>>;
|
|
3256
|
+
/** A list of nodes. */
|
|
3257
|
+
nodes?: Maybe<Array<Maybe<UserSession>>>;
|
|
3258
|
+
/** Information to aid in pagination. */
|
|
3259
|
+
pageInfo?: Maybe<PageInfo>;
|
|
3260
|
+
}
|
|
3261
|
+
|
|
3262
|
+
/** An edge in a connection. */
|
|
3263
|
+
export interface UserSessionEdge {
|
|
3264
|
+
__typename?: 'UserSessionEdge';
|
|
3265
|
+
/** A cursor for use in pagination. */
|
|
3266
|
+
cursor?: Maybe<Scalars['String']['output']>;
|
|
3267
|
+
/** The item at the end of the edge. */
|
|
3268
|
+
node?: Maybe<UserSession>;
|
|
3269
|
+
}
|
|
3270
|
+
|
|
3271
|
+
/** Abilities for the current user on this UserSession */
|
|
3272
|
+
export interface UserSessionUserAbilities {
|
|
3273
|
+
__typename?: 'UserSessionUserAbilities';
|
|
3274
|
+
/** Shows if the current user has the `logout_session` ability on this UserSession */
|
|
3275
|
+
logoutSession?: Maybe<Scalars['Boolean']['output']>;
|
|
3276
|
+
}
|
|
3277
|
+
|
|
3278
|
+
/** Abilities for the current user on this User */
|
|
3279
|
+
export interface UserUserAbilities {
|
|
3280
|
+
__typename?: 'UserUserAbilities';
|
|
3281
|
+
/** Shows if the current user has the `manage_mfa` ability on this User */
|
|
3282
|
+
manageMfa?: Maybe<Scalars['Boolean']['output']>;
|
|
3283
|
+
/** Shows if the current user has the `update_user` ability on this User */
|
|
3284
|
+
updateUser?: Maybe<Scalars['Boolean']['output']>;
|
|
3285
|
+
}
|
|
3286
|
+
|
|
3287
|
+
/** Autogenerated input type of UsersCreate */
|
|
3288
|
+
export interface UsersCreateInput {
|
|
3289
|
+
/** Admin status for the user. */
|
|
3290
|
+
admin?: InputMaybe<Scalars['Boolean']['input']>;
|
|
3291
|
+
/** A unique identifier for the client performing the mutation. */
|
|
3292
|
+
clientMutationId?: InputMaybe<Scalars['String']['input']>;
|
|
3293
|
+
/** Email for the user. */
|
|
3294
|
+
email: Scalars['String']['input'];
|
|
3295
|
+
/** Firstname for the user. */
|
|
3296
|
+
firstname?: InputMaybe<Scalars['String']['input']>;
|
|
3297
|
+
/** Lastname for the user. */
|
|
3298
|
+
lastname?: InputMaybe<Scalars['String']['input']>;
|
|
3299
|
+
/** Password for the user. */
|
|
3300
|
+
password: Scalars['String']['input'];
|
|
3301
|
+
/** Password repeat for the user to check for typos. */
|
|
3302
|
+
passwordRepeat: Scalars['String']['input'];
|
|
3303
|
+
/** Username for the user. */
|
|
3304
|
+
username: Scalars['String']['input'];
|
|
3305
|
+
}
|
|
3306
|
+
|
|
3307
|
+
/** Autogenerated return type of UsersCreate. */
|
|
3308
|
+
export interface UsersCreatePayload {
|
|
3309
|
+
__typename?: 'UsersCreatePayload';
|
|
3310
|
+
/** A unique identifier for the client performing the mutation. */
|
|
3311
|
+
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
3312
|
+
/** Errors encountered during execution of the mutation. */
|
|
3313
|
+
errors?: Maybe<Array<Error>>;
|
|
3314
|
+
/** The created user. */
|
|
3315
|
+
user?: Maybe<User>;
|
|
3316
|
+
}
|
|
3317
|
+
|
|
3318
|
+
/** Autogenerated input type of UsersDelete */
|
|
3319
|
+
export interface UsersDeleteInput {
|
|
3320
|
+
/** A unique identifier for the client performing the mutation. */
|
|
3321
|
+
clientMutationId?: InputMaybe<Scalars['String']['input']>;
|
|
3322
|
+
/** The user to delete. */
|
|
3323
|
+
userId: Scalars['UserID']['input'];
|
|
3324
|
+
}
|
|
3325
|
+
|
|
3326
|
+
/** Autogenerated return type of UsersDelete. */
|
|
3327
|
+
export interface UsersDeletePayload {
|
|
3328
|
+
__typename?: 'UsersDeletePayload';
|
|
3329
|
+
/** A unique identifier for the client performing the mutation. */
|
|
3330
|
+
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
3331
|
+
/** Errors encountered during execution of the mutation. */
|
|
3332
|
+
errors?: Maybe<Array<Error>>;
|
|
3333
|
+
/** The deleted user. */
|
|
3334
|
+
user?: Maybe<User>;
|
|
3335
|
+
}
|
|
3336
|
+
|
|
3337
|
+
/** Autogenerated input type of UsersEmailVerification */
|
|
3338
|
+
export interface UsersEmailVerificationInput {
|
|
3339
|
+
/** A unique identifier for the client performing the mutation. */
|
|
3340
|
+
clientMutationId?: InputMaybe<Scalars['String']['input']>;
|
|
3341
|
+
/** The email verification token */
|
|
3342
|
+
token: Scalars['String']['input'];
|
|
3343
|
+
}
|
|
3344
|
+
|
|
3345
|
+
/** Autogenerated return type of UsersEmailVerification. */
|
|
3346
|
+
export interface UsersEmailVerificationPayload {
|
|
3347
|
+
__typename?: 'UsersEmailVerificationPayload';
|
|
3348
|
+
/** A unique identifier for the client performing the mutation. */
|
|
3349
|
+
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
3350
|
+
/** Errors encountered during execution of the mutation. */
|
|
3351
|
+
errors?: Maybe<Array<Error>>;
|
|
3352
|
+
/** The user whose email was verified */
|
|
3353
|
+
user?: Maybe<User>;
|
|
1391
3354
|
}
|
|
1392
3355
|
|
|
1393
3356
|
/** Autogenerated input type of UsersIdentityLink */
|
|
@@ -1406,7 +3369,7 @@ export interface UsersIdentityLinkPayload {
|
|
|
1406
3369
|
/** A unique identifier for the client performing the mutation. */
|
|
1407
3370
|
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
1408
3371
|
/** Errors encountered during execution of the mutation. */
|
|
1409
|
-
errors
|
|
3372
|
+
errors?: Maybe<Array<Error>>;
|
|
1410
3373
|
/** The created user identity */
|
|
1411
3374
|
userIdentity?: Maybe<UserIdentity>;
|
|
1412
3375
|
}
|
|
@@ -1427,7 +3390,7 @@ export interface UsersIdentityLoginPayload {
|
|
|
1427
3390
|
/** A unique identifier for the client performing the mutation. */
|
|
1428
3391
|
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
1429
3392
|
/** Errors encountered during execution of the mutation. */
|
|
1430
|
-
errors
|
|
3393
|
+
errors?: Maybe<Array<Error>>;
|
|
1431
3394
|
/** The created user session */
|
|
1432
3395
|
userSession?: Maybe<UserSession>;
|
|
1433
3396
|
}
|
|
@@ -1448,7 +3411,7 @@ export interface UsersIdentityRegisterPayload {
|
|
|
1448
3411
|
/** A unique identifier for the client performing the mutation. */
|
|
1449
3412
|
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
1450
3413
|
/** Errors encountered during execution of the mutation. */
|
|
1451
|
-
errors
|
|
3414
|
+
errors?: Maybe<Array<Error>>;
|
|
1452
3415
|
/** The created users session */
|
|
1453
3416
|
userSession?: Maybe<UserSession>;
|
|
1454
3417
|
}
|
|
@@ -1467,7 +3430,7 @@ export interface UsersIdentityUnlinkPayload {
|
|
|
1467
3430
|
/** A unique identifier for the client performing the mutation. */
|
|
1468
3431
|
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
1469
3432
|
/** Errors encountered during execution of the mutation. */
|
|
1470
|
-
errors
|
|
3433
|
+
errors?: Maybe<Array<Error>>;
|
|
1471
3434
|
/** The removed identity */
|
|
1472
3435
|
userIdentity?: Maybe<UserIdentity>;
|
|
1473
3436
|
}
|
|
@@ -1492,7 +3455,7 @@ export interface UsersLoginPayload {
|
|
|
1492
3455
|
/** A unique identifier for the client performing the mutation. */
|
|
1493
3456
|
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
1494
3457
|
/** Errors encountered during execution of the mutation. */
|
|
1495
|
-
errors
|
|
3458
|
+
errors?: Maybe<Array<Error>>;
|
|
1496
3459
|
/** The created user session */
|
|
1497
3460
|
userSession?: Maybe<UserSession>;
|
|
1498
3461
|
}
|
|
@@ -1511,7 +3474,7 @@ export interface UsersLogoutPayload {
|
|
|
1511
3474
|
/** A unique identifier for the client performing the mutation. */
|
|
1512
3475
|
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
1513
3476
|
/** Errors encountered during execution of the mutation. */
|
|
1514
|
-
errors
|
|
3477
|
+
errors?: Maybe<Array<Error>>;
|
|
1515
3478
|
/** The logged out user session */
|
|
1516
3479
|
userSession?: Maybe<UserSession>;
|
|
1517
3480
|
}
|
|
@@ -1530,7 +3493,7 @@ export interface UsersMfaBackupCodesRotatePayload {
|
|
|
1530
3493
|
/** The newly rotated backup codes. */
|
|
1531
3494
|
codes?: Maybe<Array<Scalars['String']['output']>>;
|
|
1532
3495
|
/** Errors encountered during execution of the mutation. */
|
|
1533
|
-
errors
|
|
3496
|
+
errors?: Maybe<Array<Error>>;
|
|
1534
3497
|
}
|
|
1535
3498
|
|
|
1536
3499
|
/** Autogenerated input type of UsersMfaTotpGenerateSecret */
|
|
@@ -1545,7 +3508,7 @@ export interface UsersMfaTotpGenerateSecretPayload {
|
|
|
1545
3508
|
/** A unique identifier for the client performing the mutation. */
|
|
1546
3509
|
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
1547
3510
|
/** Errors encountered during execution of the mutation. */
|
|
1548
|
-
errors
|
|
3511
|
+
errors?: Maybe<Array<Error>>;
|
|
1549
3512
|
/** The created and signed secret */
|
|
1550
3513
|
secret?: Maybe<Scalars['String']['output']>;
|
|
1551
3514
|
}
|
|
@@ -1569,11 +3532,53 @@ export interface UsersMfaTotpValidateSecretPayload {
|
|
|
1569
3532
|
/** A unique identifier for the client performing the mutation. */
|
|
1570
3533
|
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
1571
3534
|
/** Errors encountered during execution of the mutation. */
|
|
1572
|
-
errors
|
|
3535
|
+
errors?: Maybe<Array<Error>>;
|
|
1573
3536
|
/** The modified user */
|
|
1574
3537
|
user?: Maybe<User>;
|
|
1575
3538
|
}
|
|
1576
3539
|
|
|
3540
|
+
/** Autogenerated input type of UsersPasswordReset */
|
|
3541
|
+
export interface UsersPasswordResetInput {
|
|
3542
|
+
/** A unique identifier for the client performing the mutation. */
|
|
3543
|
+
clientMutationId?: InputMaybe<Scalars['String']['input']>;
|
|
3544
|
+
/** The new password to set for the user */
|
|
3545
|
+
newPassword: Scalars['String']['input'];
|
|
3546
|
+
/** The confirmation of the new password to set for the user needs to be the same as the new password */
|
|
3547
|
+
newPasswordConfirmation: Scalars['String']['input'];
|
|
3548
|
+
/** The password reset token sent to the user email */
|
|
3549
|
+
resetToken: Scalars['String']['input'];
|
|
3550
|
+
}
|
|
3551
|
+
|
|
3552
|
+
/** Autogenerated return type of UsersPasswordReset. */
|
|
3553
|
+
export interface UsersPasswordResetPayload {
|
|
3554
|
+
__typename?: 'UsersPasswordResetPayload';
|
|
3555
|
+
/** A unique identifier for the client performing the mutation. */
|
|
3556
|
+
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
3557
|
+
/** Errors encountered during execution of the mutation. */
|
|
3558
|
+
errors?: Maybe<Array<Error>>;
|
|
3559
|
+
/** A message indicating the result of the password reset request */
|
|
3560
|
+
message?: Maybe<Scalars['String']['output']>;
|
|
3561
|
+
}
|
|
3562
|
+
|
|
3563
|
+
/** Autogenerated input type of UsersPasswordResetRequest */
|
|
3564
|
+
export interface UsersPasswordResetRequestInput {
|
|
3565
|
+
/** A unique identifier for the client performing the mutation. */
|
|
3566
|
+
clientMutationId?: InputMaybe<Scalars['String']['input']>;
|
|
3567
|
+
/** Email of the user to reset the password */
|
|
3568
|
+
email: Scalars['String']['input'];
|
|
3569
|
+
}
|
|
3570
|
+
|
|
3571
|
+
/** Autogenerated return type of UsersPasswordResetRequest. */
|
|
3572
|
+
export interface UsersPasswordResetRequestPayload {
|
|
3573
|
+
__typename?: 'UsersPasswordResetRequestPayload';
|
|
3574
|
+
/** A unique identifier for the client performing the mutation. */
|
|
3575
|
+
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
3576
|
+
/** Errors encountered during execution of the mutation. */
|
|
3577
|
+
errors?: Maybe<Array<Error>>;
|
|
3578
|
+
/** A message indicating the result of the password reset request */
|
|
3579
|
+
message?: Maybe<Scalars['String']['output']>;
|
|
3580
|
+
}
|
|
3581
|
+
|
|
1577
3582
|
/** Autogenerated input type of UsersRegister */
|
|
1578
3583
|
export interface UsersRegisterInput {
|
|
1579
3584
|
/** A unique identifier for the client performing the mutation. */
|
|
@@ -1582,6 +3587,8 @@ export interface UsersRegisterInput {
|
|
|
1582
3587
|
email: Scalars['String']['input'];
|
|
1583
3588
|
/** Password of the user */
|
|
1584
3589
|
password: Scalars['String']['input'];
|
|
3590
|
+
/** The repeated password of the user to check for typos */
|
|
3591
|
+
passwordRepeat: Scalars['String']['input'];
|
|
1585
3592
|
/** Username of the user */
|
|
1586
3593
|
username: Scalars['String']['input'];
|
|
1587
3594
|
}
|
|
@@ -1592,7 +3599,7 @@ export interface UsersRegisterPayload {
|
|
|
1592
3599
|
/** A unique identifier for the client performing the mutation. */
|
|
1593
3600
|
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
1594
3601
|
/** Errors encountered during execution of the mutation. */
|
|
1595
|
-
errors
|
|
3602
|
+
errors?: Maybe<Array<Error>>;
|
|
1596
3603
|
/** The created users session */
|
|
1597
3604
|
userSession?: Maybe<UserSession>;
|
|
1598
3605
|
}
|
|
@@ -1609,6 +3616,12 @@ export interface UsersUpdateInput {
|
|
|
1609
3616
|
firstname?: InputMaybe<Scalars['String']['input']>;
|
|
1610
3617
|
/** New lastname for the user. */
|
|
1611
3618
|
lastname?: InputMaybe<Scalars['String']['input']>;
|
|
3619
|
+
/** The data of the mfa validation */
|
|
3620
|
+
mfa?: InputMaybe<MfaInput>;
|
|
3621
|
+
/** New password for the user. */
|
|
3622
|
+
password?: InputMaybe<Scalars['String']['input']>;
|
|
3623
|
+
/** New password repeat for the user to check for typos, required if password is set. */
|
|
3624
|
+
passwordRepeat?: InputMaybe<Scalars['String']['input']>;
|
|
1612
3625
|
/** ID of the user to update. */
|
|
1613
3626
|
userId: Scalars['UserID']['input'];
|
|
1614
3627
|
/** New username for the user. */
|
|
@@ -1621,7 +3634,7 @@ export interface UsersUpdatePayload {
|
|
|
1621
3634
|
/** A unique identifier for the client performing the mutation. */
|
|
1622
3635
|
clientMutationId?: Maybe<Scalars['String']['output']>;
|
|
1623
3636
|
/** Errors encountered during execution of the mutation. */
|
|
1624
|
-
errors
|
|
3637
|
+
errors?: Maybe<Array<Error>>;
|
|
1625
3638
|
/** The updated user. */
|
|
1626
3639
|
user?: Maybe<User>;
|
|
1627
3640
|
}
|