@code0-tech/sagittarius-graphql-types 0.0.0-a395eea54741fc1bb9649341ff6f082cc1c3e67e → 0.0.0-f91466f0f343596ad170e7e5c5316a70b072594d

package/index.d.ts

@@ -1,10 +1,10 @@
 export type Maybe<T> = T | null;
 export type InputMaybe<T> = Maybe<T>;
-export type Exact<T extends { [key: string]: unknown }> = { [K in keyof T]: T[K] }
-export type MakeOptional<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]?: Maybe<T[SubKey]> }
-export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]: Maybe<T[SubKey]> }
-export type MakeEmpty<T extends { [key: string]: unknown }, K extends keyof T> = { [_ in K]?: never }
-export type Incremental<T> = T | { [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never }
+export type Exact<T extends { [key: string]: unknown }> = { [K in keyof T]: T[K] };
+export type MakeOptional<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]?: Maybe<T[SubKey]> };
+export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]: Maybe<T[SubKey]> };
+export type MakeEmpty<T extends { [key: string]: unknown }, K extends keyof T> = { [_ in K]?: never };
+export type Incremental<T> = T | { [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never };
 /** All built-in and custom scalars, mapped to their actual values */
 export interface Scalars {
   ID: { input: `gid://sagittarius//${number}`; output: `gid://sagittarius//${number}`; }
@@ -12,36 +12,67 @@ export interface Scalars {
   Boolean: { input: boolean; output: boolean; }
   Int: { input: number; output: number; }
   Float: { input: number; output: number; }
+  /** A unique identifier for all DataType entities of the application */
   DataTypeID: { input: `gid://sagittarius/DataType/${number}`; output: `gid://sagittarius/DataType/${number}`; }
+  /** A unique identifier for all DataTypeIdentifier entities of the application */
   DataTypeIdentifierID: { input: `gid://sagittarius/DataTypeIdentifier/${number}`; output: `gid://sagittarius/DataTypeIdentifier/${number}`; }
+  /** A unique identifier for all DataTypeRule entities of the application */
   DataTypeRuleID: { input: `gid://sagittarius/DataTypeRule/${number}`; output: `gid://sagittarius/DataTypeRule/${number}`; }
+  /** A unique identifier for all Flow entities of the application */
   FlowID: { input: `gid://sagittarius/Flow/${number}`; output: `gid://sagittarius/Flow/${number}`; }
+  /** A unique identifier for all FlowSetting entities of the application */
   FlowSettingID: { input: `gid://sagittarius/FlowSetting/${number}`; output: `gid://sagittarius/FlowSetting/${number}`; }
+  /** A unique identifier for all FlowType entities of the application */
   FlowTypeID: { input: `gid://sagittarius/FlowType/${number}`; output: `gid://sagittarius/FlowType/${number}`; }
+  /** A unique identifier for all FlowTypeSetting entities of the application */
   FlowTypeSettingID: { input: `gid://sagittarius/FlowTypeSetting/${number}`; output: `gid://sagittarius/FlowTypeSetting/${number}`; }
-  FunctionDefinitionID: { input: `gid://sagittarius/FunctionDefinition/${number}`; output: `gid://sagittarius/FunctionDefinition/${number}`; }
-  GenericCombinationStrategyID: { input: `gid://sagittarius/GenericCombinationStrategy/${number}`; output: `gid://sagittarius/GenericCombinationStrategy/${number}`; }
+  /** A unique identifier for all GenericMapper entities of the application */
   GenericMapperID: { input: `gid://sagittarius/GenericMapper/${number}`; output: `gid://sagittarius/GenericMapper/${number}`; }
+  /** A unique identifier for all GenericType entities of the application */
   GenericTypeID: { input: `gid://sagittarius/GenericType/${number}`; output: `gid://sagittarius/GenericType/${number}`; }
+  /** Represents untyped JSON */
   JSON: { input: any; output: any; }
+  /** A unique identifier for all Namespace entities of the application */
   NamespaceID: { input: `gid://sagittarius/Namespace/${number}`; output: `gid://sagittarius/Namespace/${number}`; }
+  /** A unique identifier for all NamespaceLicense entities of the application */
   NamespaceLicenseID: { input: `gid://sagittarius/NamespaceLicense/${number}`; output: `gid://sagittarius/NamespaceLicense/${number}`; }
+  /** A unique identifier for all NamespaceMember entities of the application */
   NamespaceMemberID: { input: `gid://sagittarius/NamespaceMember/${number}`; output: `gid://sagittarius/NamespaceMember/${number}`; }
+  /** A unique identifier for all NamespaceMemberRole entities of the application */
   NamespaceMemberRoleID: { input: `gid://sagittarius/NamespaceMemberRole/${number}`; output: `gid://sagittarius/NamespaceMemberRole/${number}`; }
+  /** A unique identifier for all NamespaceProject entities of the application */
   NamespaceProjectID: { input: `gid://sagittarius/NamespaceProject/${number}`; output: `gid://sagittarius/NamespaceProject/${number}`; }
+  /** A unique identifier for all NamespaceRole entities of the application */
   NamespaceRoleID: { input: `gid://sagittarius/NamespaceRole/${number}`; output: `gid://sagittarius/NamespaceRole/${number}`; }
+  /** A unique identifier for all NodeFunction entities of the application */
   NodeFunctionID: { input: `gid://sagittarius/NodeFunction/${number}`; output: `gid://sagittarius/NodeFunction/${number}`; }
+  /** A unique identifier for all NodeParameter entities of the application */
   NodeParameterID: { input: `gid://sagittarius/NodeParameter/${number}`; output: `gid://sagittarius/NodeParameter/${number}`; }
+  /** A unique identifier for all Organization entities of the application */
   OrganizationID: { input: `gid://sagittarius/Organization/${number}`; output: `gid://sagittarius/Organization/${number}`; }
-  ParameterDefinitionID: { input: `gid://sagittarius/ParameterDefinition/${number}`; output: `gid://sagittarius/ParameterDefinition/${number}`; }
+  /** A unique identifier for all ReferencePath entities of the application */
   ReferencePathID: { input: `gid://sagittarius/ReferencePath/${number}`; output: `gid://sagittarius/ReferencePath/${number}`; }
+  /** A unique identifier for all ReferenceValue entities of the application */
   ReferenceValueID: { input: `gid://sagittarius/ReferenceValue/${number}`; output: `gid://sagittarius/ReferenceValue/${number}`; }
+  /** A unique identifier for all RuntimeFunctionDefinition entities of the application */
   RuntimeFunctionDefinitionID: { input: `gid://sagittarius/RuntimeFunctionDefinition/${number}`; output: `gid://sagittarius/RuntimeFunctionDefinition/${number}`; }
+  /** A unique identifier for all Runtime entities of the application */
   RuntimeID: { input: `gid://sagittarius/Runtime/${number}`; output: `gid://sagittarius/Runtime/${number}`; }
+  /** A unique identifier for all RuntimeParameterDefinition entities of the application */
   RuntimeParameterDefinitionID: { input: `gid://sagittarius/RuntimeParameterDefinition/${number}`; output: `gid://sagittarius/RuntimeParameterDefinition/${number}`; }
+  /**
+   * Time represented in ISO 8601.
+   *
+   * For example: "2023-12-15T17:31:00Z".
+   */
   Time: { input: string; output: string; }
+  /** A unique identifier for all Types::FlowType entities of the application */
+  TypesFlowTypeID: { input: `gid://sagittarius/TypesFlowType/${number}`; output: `gid://sagittarius/TypesFlowType/${number}`; }
+  /** A unique identifier for all User entities of the application */
   UserID: { input: `gid://sagittarius/User/${number}`; output: `gid://sagittarius/User/${number}`; }
+  /** A unique identifier for all UserIdentity entities of the application */
   UserIdentityID: { input: `gid://sagittarius/UserIdentity/${number}`; output: `gid://sagittarius/UserIdentity/${number}`; }
+  /** A unique identifier for all UserSession entities of the application */
   UserSessionID: { input: `gid://sagittarius/UserSession/${number}`; output: `gid://sagittarius/UserSession/${number}`; }
 }
 
@@ -49,72 +80,26 @@ export interface Scalars {
 export interface ActiveModelError {
   __typename?: 'ActiveModelError';
   /** The affected attribute on the model */
-  attribute?: Maybe<Scalars['String']['output']>;
+  attribute: Scalars['String']['output'];
   /** The validation type that failed for the attribute */
-  type?: Maybe<Scalars['String']['output']>;
-}
-
-/** Represents the application instance */
-export interface Application {
-  __typename?: 'Application';
-  /** URL to the legal notice page */
-  legalNoticeUrl?: Maybe<Scalars['String']['output']>;
-  /** Metadata about the application */
-  metadata?: Maybe<Metadata>;
-  /** URL to the privacy policy page */
-  privacyUrl?: Maybe<Scalars['String']['output']>;
-  /** Global application settings */
-  settings?: Maybe<ApplicationSettings>;
-  /** URL to the terms and conditions page */
-  termsAndConditionsUrl?: Maybe<Scalars['String']['output']>;
-  /** Abilities for the current user on this Application */
-  userAbilities?: Maybe<ApplicationUserAbilities>;
+  type: Scalars['String']['output'];
 }
 
 /** Represents the application settings */
 export interface ApplicationSettings {
   __typename?: 'ApplicationSettings';
-  /** Shows if admin status can be queried by non-administrators */
-  adminStatusVisible?: Maybe<Scalars['Boolean']['output']>;
-  /** List of configured identity providers */
-  identityProviders?: Maybe<IdentityProviderConnection>;
-  /** URL to the legal notice page */
-  legalNoticeUrl?: Maybe<Scalars['String']['output']>;
   /** Shows if organization creation is restricted to administrators */
-  organizationCreationRestricted?: Maybe<Scalars['Boolean']['output']>;
-  /** URL to the privacy policy page */
-  privacyUrl?: Maybe<Scalars['String']['output']>;
-  /** URL to the terms and conditions page */
-  termsAndConditionsUrl?: Maybe<Scalars['String']['output']>;
+  organizationCreationRestricted: Scalars['Boolean']['output'];
   /** Shows if user registration is enabled */
-  userRegistrationEnabled?: Maybe<Scalars['Boolean']['output']>;
-}
-
-
-/** Represents the application settings */
-export interface ApplicationSettingsIdentityProvidersArgs {
-  after?: InputMaybe<Scalars['String']['input']>;
-  before?: InputMaybe<Scalars['String']['input']>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
+  userRegistrationEnabled: Scalars['Boolean']['output'];
 }
 
 /** Autogenerated input type of ApplicationSettingsUpdate */
 export interface ApplicationSettingsUpdateInput {
-  /** Set if admin status can be queried by non-administrators. */
-  adminStatusVisible?: InputMaybe<Scalars['Boolean']['input']>;
   /** A unique identifier for the client performing the mutation. */
   clientMutationId?: InputMaybe<Scalars['String']['input']>;
-  /** Set the list of configured identity providers. */
-  identityProviders?: InputMaybe<Array<IdentityProviderInput>>;
-  /** Set the URL to the legal notice page. */
-  legalNoticeUrl?: InputMaybe<Scalars['String']['input']>;
   /** Set if organization creation is restricted to administrators. */
   organizationCreationRestricted?: InputMaybe<Scalars['Boolean']['input']>;
-  /** Set the URL to the privacy policy page. */
-  privacyUrl?: InputMaybe<Scalars['String']['input']>;
-  /** Set the URL to the terms and conditions page. */
-  termsAndConditionsUrl?: InputMaybe<Scalars['String']['input']>;
   /** Set if user registration is enabled. */
   userRegistrationEnabled?: InputMaybe<Scalars['Boolean']['input']>;
 }
@@ -127,54 +112,63 @@ export interface ApplicationSettingsUpdatePayload {
   /** A unique identifier for the client performing the mutation. */
   clientMutationId?: Maybe<Scalars['String']['output']>;
   /** Errors encountered during execution of the mutation. */
-  errors?: Maybe<Array<Error>>;
-}
-
-/** Abilities for the current user on this Application */
-export interface ApplicationUserAbilities {
-  __typename?: 'ApplicationUserAbilities';
-  /** Shows if the current user has the `create_organization` ability on this Application */
-  createOrganization?: Maybe<Scalars['Boolean']['output']>;
-  /** Shows if the current user has the `create_runtime` ability on this Application */
-  createRuntime?: Maybe<Scalars['Boolean']['output']>;
-  /** Shows if the current user has the `delete_runtime` ability on this Application */
-  deleteRuntime?: Maybe<Scalars['Boolean']['output']>;
-  /** Shows if the current user has the `rotate_runtime_token` ability on this Application */
-  rotateRuntimeToken?: Maybe<Scalars['Boolean']['output']>;
-  /** Shows if the current user has the `update_application_setting` ability on this Application */
-  updateApplicationSetting?: Maybe<Scalars['Boolean']['output']>;
-  /** Shows if the current user has the `update_runtime` ability on this Application */
-  updateRuntime?: Maybe<Scalars['Boolean']['output']>;
+  errors: Array<Error>;
 }
 
 /** Objects that can present an authentication */
 export type Authentication = UserSession;
 
+/** Represents a rule that can be applied to a data type. */
+export type Config = ContainsKeyConfig | ContainsTypeConfig | InputTypesConfig | ItemOfCollectionConfig | NumberRangeConfig | RegexConfig | ReturnTypeConfig;
+
+/** Represents a rule that can be applied to a data type. */
+export interface ContainsKeyConfig {
+  __typename?: 'ContainsKeyConfig';
+  /** The identifier of the data type this rule belongs to */
+  dataTypeIdentifier: DataTypeIdentifier;
+  /** The key of the rule */
+  key: Scalars['String']['output'];
+}
+
+/** Represents a rule that can be applied to a data type. */
+export interface ContainsTypeConfig {
+  __typename?: 'ContainsTypeConfig';
+  /** The identifier of the data type this rule belongs to */
+  dataTypeIdentifier: DataTypeIdentifier;
+}
+
 /** Represents a DataType */
 export interface DataType {
   __typename?: 'DataType';
-  /** Name of the function */
-  aliases?: Maybe<Array<Translation>>;
   /** Time when this DataType was created */
-  createdAt?: Maybe<Scalars['Time']['output']>;
-  /** Display message of the function */
-  displayMessages?: Maybe<Array<Translation>>;
+  createdAt: Scalars['Time']['output'];
   /** Generic keys of the datatype */
   genericKeys?: Maybe<Array<Scalars['String']['output']>>;
   /** Global ID of this DataType */
-  id?: Maybe<Scalars['DataTypeID']['output']>;
+  id: Scalars['DataTypeID']['output'];
   /** The identifier scoped to the namespace */
-  identifier?: Maybe<Scalars['String']['output']>;
+  identifier: Scalars['String']['output'];
   /** Names of the flow type setting */
-  name?: Maybe<Array<Translation>>;
+  name: TranslationConnection;
+  /** The namespace where this datatype belongs to */
+  namespace?: Maybe<Namespace>;
+  /** The parent datatype */
+  parent?: Maybe<DataTypeIdentifier>;
   /** Rules of the datatype */
-  rules?: Maybe<DataTypeRuleConnection>;
-  /** The runtime where this datatype belongs to */
-  runtime?: Maybe<Runtime>;
+  rules: DataTypeRuleConnection;
   /** Time when this DataType was last updated */
-  updatedAt?: Maybe<Scalars['Time']['output']>;
+  updatedAt: Scalars['Time']['output'];
   /** The type of the datatype */
-  variant?: Maybe<DataTypeVariant>;
+  variant: DataTypeVariant;
+}
+
+
+/** Represents a DataType */
+export interface DataTypeNameArgs {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
 }
 
 
@@ -190,20 +184,20 @@ export interface DataTypeRulesArgs {
 export interface DataTypeConnection {
   __typename?: 'DataTypeConnection';
   /** Total count of collection. */
-  count?: Maybe<Scalars['Int']['output']>;
+  count: Scalars['Int']['output'];
   /** A list of edges. */
   edges?: Maybe<Array<Maybe<DataTypeEdge>>>;
   /** A list of nodes. */
   nodes?: Maybe<Array<Maybe<DataType>>>;
   /** Information to aid in pagination. */
-  pageInfo?: Maybe<PageInfo>;
+  pageInfo: PageInfo;
 }
 
 /** An edge in a connection. */
 export interface DataTypeEdge {
   __typename?: 'DataTypeEdge';
   /** A cursor for use in pagination. */
-  cursor?: Maybe<Scalars['String']['output']>;
+  cursor: Scalars['String']['output'];
   /** The item at the end of the edge. */
   node?: Maybe<DataType>;
 }
@@ -212,7 +206,7 @@ export interface DataTypeEdge {
 export interface DataTypeIdentifier {
   __typename?: 'DataTypeIdentifier';
   /** Time when this DataTypeIdentifier was created */
-  createdAt?: Maybe<Scalars['Time']['output']>;
+  createdAt: Scalars['Time']['output'];
   /** The data type of the data type identifier. */
   dataType?: Maybe<DataType>;
   /** The generic key of the data type identifier. */
@@ -220,9 +214,9 @@ export interface DataTypeIdentifier {
   /** The generic type of the data type identifier. */
   genericType?: Maybe<GenericType>;
   /** Global ID of this DataTypeIdentifier */
-  id?: Maybe<Scalars['DataTypeIdentifierID']['output']>;
+  id: Scalars['DataTypeIdentifierID']['output'];
   /** Time when this DataTypeIdentifier was last updated */
-  updatedAt?: Maybe<Scalars['Time']['output']>;
+  updatedAt: Scalars['Time']['output'];
 }
 
 /** Input type for data type identifier */
@@ -239,127 +233,51 @@ export interface DataTypeIdentifierInput {
 export interface DataTypeRule {
   __typename?: 'DataTypeRule';
   /** The configuration of the rule */
-  config?: Maybe<DataTypeRulesConfig>;
+  config: Config;
   /** Time when this DataTypeRule was created */
-  createdAt?: Maybe<Scalars['Time']['output']>;
+  createdAt: Scalars['Time']['output'];
   /** Global ID of this DataTypeRule */
-  id?: Maybe<Scalars['DataTypeRuleID']['output']>;
+  id: Scalars['DataTypeRuleID']['output'];
   /** Time when this DataTypeRule was last updated */
-  updatedAt?: Maybe<Scalars['Time']['output']>;
+  updatedAt: Scalars['Time']['output'];
   /** The type of the rule */
-  variant?: Maybe<DataTypeRulesVariant>;
+  variant: DataTypeRulesDataTypeRuleVariant;
 }
 
 /** The connection type for DataTypeRule. */
 export interface DataTypeRuleConnection {
   __typename?: 'DataTypeRuleConnection';
   /** Total count of collection. */
-  count?: Maybe<Scalars['Int']['output']>;
+  count: Scalars['Int']['output'];
   /** A list of edges. */
   edges?: Maybe<Array<Maybe<DataTypeRuleEdge>>>;
   /** A list of nodes. */
   nodes?: Maybe<Array<Maybe<DataTypeRule>>>;
   /** Information to aid in pagination. */
-  pageInfo?: Maybe<PageInfo>;
+  pageInfo: PageInfo;
 }
 
 /** An edge in a connection. */
 export interface DataTypeRuleEdge {
   __typename?: 'DataTypeRuleEdge';
   /** A cursor for use in pagination. */
-  cursor?: Maybe<Scalars['String']['output']>;
+  cursor: Scalars['String']['output'];
   /** The item at the end of the edge. */
   node?: Maybe<DataTypeRule>;
 }
 
-/** Represents a rule that can be applied to a data type. */
-export type DataTypeRulesConfig = DataTypeRulesContainsKeyConfig | DataTypeRulesContainsTypeConfig | DataTypeRulesInputTypesConfig | DataTypeRulesItemOfCollectionConfig | DataTypeRulesNumberRangeConfig | DataTypeRulesParentTypeConfig | DataTypeRulesRegexConfig | DataTypeRulesReturnTypeConfig;
-
-/** Represents a rule that can be applied to a data type. */
-export interface DataTypeRulesContainsKeyConfig {
-  __typename?: 'DataTypeRulesContainsKeyConfig';
-  /** The identifier of the data type this rule belongs to */
-  dataTypeIdentifier?: Maybe<DataTypeIdentifier>;
-  /** The key of the rule */
-  key?: Maybe<Scalars['String']['output']>;
-}
-
-/** Represents a rule that can be applied to a data type. */
-export interface DataTypeRulesContainsTypeConfig {
-  __typename?: 'DataTypeRulesContainsTypeConfig';
-  /** The identifier of the data type this rule belongs to */
-  dataTypeIdentifier?: Maybe<DataTypeIdentifier>;
-}
-
-/** Represents a subtype of input type configuration for a input data type. */
-export interface DataTypeRulesInputTypeConfig {
-  __typename?: 'DataTypeRulesInputTypeConfig';
-  /** The identifier of the data type this input type belongs to */
-  dataTypeIdentifier?: Maybe<DataTypeIdentifier>;
-  /** The input identifier that this configuration applies to */
-  inputIdentifier?: Maybe<Scalars['String']['output']>;
-}
-
-/** Represents a rule that can be applied to a data type. */
-export interface DataTypeRulesInputTypesConfig {
-  __typename?: 'DataTypeRulesInputTypesConfig';
-  /** The input types that can be used in this data type rule */
-  inputTypes?: Maybe<Array<DataTypeRulesInputTypeConfig>>;
-}
-
-/** Represents a rule that can be applied to a data type. */
-export interface DataTypeRulesItemOfCollectionConfig {
-  __typename?: 'DataTypeRulesItemOfCollectionConfig';
-  /** The items that can be configured for this rule. */
-  items?: Maybe<Array<Scalars['JSON']['output']>>;
-}
-
-/** Represents a rule that can be applied to a data type. */
-export interface DataTypeRulesNumberRangeConfig {
-  __typename?: 'DataTypeRulesNumberRangeConfig';
-  /** The minimum value of the range */
-  from?: Maybe<Scalars['Int']['output']>;
-  /** The step value for the range, if applicable */
-  steps?: Maybe<Scalars['Int']['output']>;
-  /** The maximum value of the range */
-  to?: Maybe<Scalars['Int']['output']>;
-}
-
-/** Represents a rule that can be applied to a data type. */
-export interface DataTypeRulesParentTypeConfig {
-  __typename?: 'DataTypeRulesParentTypeConfig';
-  /** The data type identifier for the parent type. */
-  dataTypeIdentifier?: Maybe<DataTypeIdentifier>;
-}
-
-/** Represents a rule that can be applied to a data type. */
-export interface DataTypeRulesRegexConfig {
-  __typename?: 'DataTypeRulesRegexConfig';
-  /** The regex pattern to match against the data type value. */
-  pattern?: Maybe<Scalars['String']['output']>;
-}
-
-/** Represents a rule that can be applied to a data type. */
-export interface DataTypeRulesReturnTypeConfig {
-  __typename?: 'DataTypeRulesReturnTypeConfig';
-  /** The data type identifier for the return type. */
-  dataTypeIdentifier?: Maybe<DataTypeIdentifier>;
-}
-
 /** The type of rule that can be applied to a data type. */
-export const enum DataTypeRulesVariant {
+export enum DataTypeRulesDataTypeRuleVariant {
   /** The rule checks if a key is present in the data type. */
   ContainsKey = 'CONTAINS_KEY',
   /** The rule checks if a specific type is present in the data type. */
   ContainsType = 'CONTAINS_TYPE',
   /** The rule checks if the data type matches a specific input type. */
-  InputTypes = 'INPUT_TYPES',
+  InputType = 'INPUT_TYPE',
   /** The rule checks if an item is part of a collection in the data type. */
   ItemOfCollection = 'ITEM_OF_COLLECTION',
   /** The rule checks if a number falls within a specified range. */
   NumberRange = 'NUMBER_RANGE',
-  /** The rule checks if the data type is a child of a specific parent type. */
-  ParentType = 'PARENT_TYPE',
   /** The rule checks if a string matches a specified regular expression. */
   Regex = 'REGEX',
   /** The rule checks if the data type matches a specific return type. */
@@ -367,7 +285,7 @@ export const enum DataTypeRulesVariant {
 }
 
 /** Represent all available types of a datatype */
-export const enum DataTypeVariant {
+export enum DataTypeVariant {
   /** Represents an array */
   Array = 'ARRAY',
   /** Represents an data type containing a data type */
@@ -384,9 +302,6 @@ export const enum DataTypeVariant {
   Type = 'TYPE'
 }
 
-/** Represents a detailed error with either a message or an active model error */
-export type DetailedError = ActiveModelError | FlowValidationError | MessageError;
-
 /** Autogenerated input type of Echo */
 export interface EchoInput {
   /** A unique identifier for the client performing the mutation. */
@@ -401,265 +316,41 @@ export interface EchoPayload {
   /** A unique identifier for the client performing the mutation. */
   clientMutationId?: Maybe<Scalars['String']['output']>;
   /** Errors encountered during execution of the mutation. */
-  errors?: Maybe<Array<Error>>;
+  errors: Array<Error>;
   /** Message returned to the user. */
   message?: Maybe<Scalars['String']['output']>;
 }
 
 /** Objects that can present an error */
-export interface Error {
-  __typename?: 'Error';
-  /** Detailed validation errors if applicable */
-  details?: Maybe<Array<DetailedError>>;
-  /** The code representing the error type */
-  errorCode?: Maybe<ErrorCodeEnum>;
-}
-
-/** Represents the available error responses */
-export const enum ErrorCodeEnum {
-  /** This action would remove the last administrative role */
-  CannotDeleteLastAdminRole = 'CANNOT_DELETE_LAST_ADMIN_ROLE',
-  /** Only administrators can modify admin status of users */
-  CannotModifyAdmin = 'CANNOT_MODIFY_ADMIN',
-  /** Users cannot modify their own admin status */
-  CannotModifyOwnAdmin = 'CANNOT_MODIFY_OWN_ADMIN',
-  /** This action would remove the last administrator */
-  CannotRemoveLastAdministrator = 'CANNOT_REMOVE_LAST_ADMINISTRATOR',
-  /** This action would remove the last administrative ability */
-  CannotRemoveLastAdminAbility = 'CANNOT_REMOVE_LAST_ADMIN_ABILITY',
-  /** The data type identifier with the given identifier was not found */
-  DataTypeIdentifierNotFound = 'DATA_TYPE_IDENTIFIER_NOT_FOUND',
-  /** The data type with the given identifier was not found */
-  DataTypeNotFound = 'DATA_TYPE_NOT_FOUND',
-  /** Failed to send the email verification */
-  EmailVerificationSendFailed = 'EMAIL_VERIFICATION_SEND_FAILED',
-  /** This external identity does not exist */
-  ExternalIdentityDoesNotExist = 'EXTERNAL_IDENTITY_DOES_NOT_EXIST',
-  /** The old backup codes could not be deleted */
-  FailedToInvalidateOldBackupCodes = 'FAILED_TO_INVALIDATE_OLD_BACKUP_CODES',
-  /** Failed to reset the user password */
-  FailedToResetPassword = 'FAILED_TO_RESET_PASSWORD',
-  /** The new backup codes could not be saved */
-  FailedToSaveValidBackupCode = 'FAILED_TO_SAVE_VALID_BACKUP_CODE',
-  /** The flow with the given identifier was not found */
-  FlowNotFound = 'FLOW_NOT_FOUND',
-  /** The flow type with the given identifier was not found */
-  FlowTypeNotFound = 'FLOW_TYPE_NOT_FOUND',
-  /** The flow validation has failed */
-  FlowValidationFailed = 'FLOW_VALIDATION_FAILED',
-  /** The id for the function value node does not exist */
-  FunctionValueNotFound = 'FUNCTION_VALUE_NOT_FOUND',
-  /** The given key was not found in the data type */
-  GenericKeyNotFound = 'GENERIC_KEY_NOT_FOUND',
-  /** The external identity with the given identifier was not found */
-  IdentityNotFound = 'IDENTITY_NOT_FOUND',
-  /** Failed to validate the external identity */
-  IdentityValidationFailed = 'IDENTITY_VALIDATION_FAILED',
-  /** Resources are from different namespaces */
-  InconsistentNamespace = 'INCONSISTENT_NAMESPACE',
-  /** The attachment is invalid because of active model errors */
-  InvalidAttachment = 'INVALID_ATTACHMENT',
-  /** The data type is invalid because of active model errors */
-  InvalidDataType = 'INVALID_DATA_TYPE',
-  /** This external identity is invalid */
-  InvalidExternalIdentity = 'INVALID_EXTERNAL_IDENTITY',
-  /** The flow is invalid because of active model errors */
-  InvalidFlow = 'INVALID_FLOW',
-  /** The flow setting is invalid because of active model errors */
-  InvalidFlowSetting = 'INVALID_FLOW_SETTING',
-  /** The flow type is invalid because of active model errors */
-  InvalidFlowType = 'INVALID_FLOW_TYPE',
-  /** The generic mapper is invalid because of active model errors */
-  InvalidGenericMapper = 'INVALID_GENERIC_MAPPER',
-  /** Invalid login data provided */
-  InvalidLoginData = 'INVALID_LOGIN_DATA',
-  /** The namespace license is invalid because of active model errors */
-  InvalidNamespaceLicense = 'INVALID_NAMESPACE_LICENSE',
-  /** The namespace member is invalid because of active model errors */
-  InvalidNamespaceMember = 'INVALID_NAMESPACE_MEMBER',
-  /** The namespace project is invalid because of active model errors */
-  InvalidNamespaceProject = 'INVALID_NAMESPACE_PROJECT',
-  /** The namespace role is invalid because of active model errors */
-  InvalidNamespaceRole = 'INVALID_NAMESPACE_ROLE',
-  /** The node function is invalid */
-  InvalidNodeFunction = 'INVALID_NODE_FUNCTION',
-  /** The node parameter is invalid */
-  InvalidNodeParameter = 'INVALID_NODE_PARAMETER',
-  /** The organization is invalid because of active model errors */
-  InvalidOrganization = 'INVALID_ORGANIZATION',
-  /** The provided password repeat does not match the password */
-  InvalidPasswordRepeat = 'INVALID_PASSWORD_REPEAT',
-  /** The runtime is invalid because of active model errors */
-  InvalidRuntime = 'INVALID_RUNTIME',
-  /** The runtime function definition is invalid */
-  InvalidRuntimeFunctionDefinition = 'INVALID_RUNTIME_FUNCTION_DEFINITION',
-  /** The runtime function ID is invalid */
-  InvalidRuntimeFunctionId = 'INVALID_RUNTIME_FUNCTION_ID',
-  /** The runtime parameter definition is invalid */
-  InvalidRuntimeParameterDefinition = 'INVALID_RUNTIME_PARAMETER_DEFINITION',
-  /** The runtime parameter ID is invalid */
-  InvalidRuntimeParameterId = 'INVALID_RUNTIME_PARAMETER_ID',
-  /** Invalid setting provided */
-  InvalidSetting = 'INVALID_SETTING',
-  /** The TOTP secret is invalid or cannot be verified */
-  InvalidTotpSecret = 'INVALID_TOTP_SECRET',
-  /** The user is invalid because of active model errors */
-  InvalidUser = 'INVALID_USER',
-  /** The user identity is invalid because of active model errors */
-  InvalidUserIdentity = 'INVALID_USER_IDENTITY',
-  /** The user session is invalid because of active model errors */
-  InvalidUserSession = 'INVALID_USER_SESSION',
-  /** Invalid verification code provided */
-  InvalidVerificationCode = 'INVALID_VERIFICATION_CODE',
-  /** The namespace license with the given identifier was not found */
-  LicenseNotFound = 'LICENSE_NOT_FOUND',
-  /** Failed to load user identity from external provider */
-  LoadingIdentityFailed = 'LOADING_IDENTITY_FAILED',
-  /** Invalid MFA data provided */
-  MfaFailed = 'MFA_FAILED',
-  /** MFA is required */
-  MfaRequired = 'MFA_REQUIRED',
-  /** The primary runtime has more definitions than this one */
-  MissingDefinition = 'MISSING_DEFINITION',
-  /** This external identity is missing data */
-  MissingIdentityData = 'MISSING_IDENTITY_DATA',
-  /** Not all required parameters are present */
-  MissingParameter = 'MISSING_PARAMETER',
-  /** The user is not permitted to perform this operation */
-  MissingPermission = 'MISSING_PERMISSION',
-  /** The project is missing a primary runtime */
-  MissingPrimaryRuntime = 'MISSING_PRIMARY_RUNTIME',
-  /** The namespace member with the given identifier was not found */
-  NamespaceMemberNotFound = 'NAMESPACE_MEMBER_NOT_FOUND',
-  /** The namespace with the given identifier was not found */
-  NamespaceNotFound = 'NAMESPACE_NOT_FOUND',
-  /** The namespace project with the given identifier was not found */
-  NamespaceProjectNotFound = 'NAMESPACE_PROJECT_NOT_FOUND',
-  /** The namespace role with the given identifier was not found */
-  NamespaceRoleNotFound = 'NAMESPACE_ROLE_NOT_FOUND',
-  /** The node with this id does not exist */
-  NodeNotFound = 'NODE_NOT_FOUND',
-  /** No data type identifier could be found for the given generic key */
-  NoDatatypeIdentifierForGenericKey = 'NO_DATATYPE_IDENTIFIER_FOR_GENERIC_KEY',
-  /** No data type could be found for the given identifier */
-  NoDataTypeForIdentifier = 'NO_DATA_TYPE_FOR_IDENTIFIER',
-  /** There are no free license seats to complete this operation */
-  NoFreeLicenseSeats = 'NO_FREE_LICENSE_SEATS',
-  /** No generic type could be found for the given identifier */
-  NoGenericTypeForIdentifier = 'NO_GENERIC_TYPE_FOR_IDENTIFIER',
-  /** The project does not have a primary runtime */
-  NoPrimaryRuntime = 'NO_PRIMARY_RUNTIME',
-  /** The organization with the given identifier was not found */
-  OrganizationNotFound = 'ORGANIZATION_NOT_FOUND',
-  /** The primary runtime has a newer definition than this one */
-  OutdatedDefinition = 'OUTDATED_DEFINITION',
-  /** @deprecated Outdated concept */
-  PrimaryLevelNotFound = 'PRIMARY_LEVEL_NOT_FOUND',
-  /** The namespace project with the given identifier was not found */
-  ProjectNotFound = 'PROJECT_NOT_FOUND',
-  /** A referenced value could not be found */
-  ReferencedValueNotFound = 'REFERENCED_VALUE_NOT_FOUND',
-  /** Self-registration is disabled */
-  RegistrationDisabled = 'REGISTRATION_DISABLED',
-  /** Resources are from different runtimes */
-  RuntimeMismatch = 'RUNTIME_MISMATCH',
-  /** The runtime with the given identifier was not found */
-  RuntimeNotFound = 'RUNTIME_NOT_FOUND',
-  /** @deprecated Outdated concept */
-  SecondaryLevelNotFound = 'SECONDARY_LEVEL_NOT_FOUND',
-  /** @deprecated Outdated concept */
-  TertiaryLevelExceedsParameters = 'TERTIARY_LEVEL_EXCEEDS_PARAMETERS',
-  /** This user already has TOTP set up */
-  TotpSecretAlreadySet = 'TOTP_SECRET_ALREADY_SET',
-  /** The user is not permitted to modify this field */
-  UnmodifiableField = 'UNMODIFIABLE_FIELD',
-  /** The user with the given identifier was not found */
-  UserNotFound = 'USER_NOT_FOUND',
-  /** The user session with the given identifier was not found */
-  UserSessionNotFound = 'USER_SESSION_NOT_FOUND',
-  /** Invalid TOTP code provided */
-  WrongTotp = 'WRONG_TOTP'
-}
+export type Error = ActiveModelError | MessageError;
 
 /** Represents a flow */
 export interface Flow {
   __typename?: 'Flow';
   /** Time when this Flow was created */
-  createdAt?: Maybe<Scalars['Time']['output']>;
+  createdAt: Scalars['Time']['output'];
   /** Global ID of this Flow */
-  id?: Maybe<Scalars['FlowID']['output']>;
+  id: Scalars['FlowID']['output'];
   /** The input data type of the flow */
   inputType?: Maybe<DataType>;
-  /** Name of the flow */
-  name?: Maybe<Scalars['String']['output']>;
-  /** Nodes of the flow */
-  nodes?: Maybe<NodeFunctionConnection>;
-  /** The project the flow belongs to */
-  project?: Maybe<NamespaceProject>;
   /** The return data type of the flow */
   returnType?: Maybe<DataType>;
   /** The settings of the flow */
-  settings?: Maybe<FlowSettingConnection>;
-  /** The ID of the starting node of the flow */
-  startingNodeId?: Maybe<Scalars['NodeFunctionID']['output']>;
+  settings?: Maybe<Array<FlowSetting>>;
+  /** The starting node of the flow */
+  startingNode: NodeFunction;
   /** The flow type of the flow */
-  type?: Maybe<FlowType>;
+  type: FlowType;
   /** Time when this Flow was last updated */
-  updatedAt?: Maybe<Scalars['Time']['output']>;
-  /** Abilities for the current user on this Flow */
-  userAbilities?: Maybe<FlowUserAbilities>;
-}
-
-
-/** Represents a flow */
-export interface FlowNodesArgs {
-  after?: InputMaybe<Scalars['String']['input']>;
-  before?: InputMaybe<Scalars['String']['input']>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-}
-
-
-/** Represents a flow */
-export interface FlowSettingsArgs {
-  after?: InputMaybe<Scalars['String']['input']>;
-  before?: InputMaybe<Scalars['String']['input']>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-}
-
-/** The connection type for Flow. */
-export interface FlowConnection {
-  __typename?: 'FlowConnection';
-  /** Total count of collection. */
-  count?: Maybe<Scalars['Int']['output']>;
-  /** A list of edges. */
-  edges?: Maybe<Array<Maybe<FlowEdge>>>;
-  /** A list of nodes. */
-  nodes?: Maybe<Array<Maybe<Flow>>>;
-  /** Information to aid in pagination. */
-  pageInfo?: Maybe<PageInfo>;
-}
-
-/** An edge in a connection. */
-export interface FlowEdge {
-  __typename?: 'FlowEdge';
-  /** A cursor for use in pagination. */
-  cursor?: Maybe<Scalars['String']['output']>;
-  /** The item at the end of the edge. */
-  node?: Maybe<Flow>;
+  updatedAt: Scalars['Time']['output'];
 }
 
 /** Input type for creating or updating a flow */
 export interface FlowInput {
-  /** The name of the flow */
-  name: Scalars['String']['input'];
-  /** The node functions of the flow */
-  nodes: Array<NodeFunctionInput>;
   /** The settings of the flow */
   settings?: InputMaybe<Array<FlowSettingInput>>;
   /** The starting node of the flow */
-  startingNodeId: Scalars['NodeFunctionID']['input'];
+  startingNode: NodeFunctionInput;
   /** The identifier of the flow type */
   type: Scalars['FlowTypeID']['input'];
 }
@@ -668,96 +359,86 @@ export interface FlowInput {
 export interface FlowSetting {
   __typename?: 'FlowSetting';
   /** Time when this FlowSetting was created */
-  createdAt?: Maybe<Scalars['Time']['output']>;
+  createdAt: Scalars['Time']['output'];
   /** The identifier of the flow setting */
-  flowSettingIdentifier?: Maybe<Scalars['String']['output']>;
+  flowSettingId: Scalars['String']['output'];
   /** Global ID of this FlowSetting */
-  id?: Maybe<Scalars['FlowSettingID']['output']>;
+  id: Scalars['FlowSettingID']['output'];
   /** Time when this FlowSetting was last updated */
-  updatedAt?: Maybe<Scalars['Time']['output']>;
+  updatedAt: Scalars['Time']['output'];
   /** The value of the flow setting */
-  value?: Maybe<Scalars['JSON']['output']>;
-}
-
-/** The connection type for FlowSetting. */
-export interface FlowSettingConnection {
-  __typename?: 'FlowSettingConnection';
-  /** Total count of collection. */
-  count?: Maybe<Scalars['Int']['output']>;
-  /** A list of edges. */
-  edges?: Maybe<Array<Maybe<FlowSettingEdge>>>;
-  /** A list of nodes. */
-  nodes?: Maybe<Array<Maybe<FlowSetting>>>;
-  /** Information to aid in pagination. */
-  pageInfo?: Maybe<PageInfo>;
-}
-
-/** An edge in a connection. */
-export interface FlowSettingEdge {
-  __typename?: 'FlowSettingEdge';
-  /** A cursor for use in pagination. */
-  cursor?: Maybe<Scalars['String']['output']>;
-  /** The item at the end of the edge. */
-  node?: Maybe<FlowSetting>;
+  value: Scalars['JSON']['output'];
 }
 
 /** Input type for flow settings */
 export interface FlowSettingInput {
   /** The identifier (not database id) of the flow setting */
-  flowSettingIdentifier: Scalars['String']['input'];
+  flowSettingId: Scalars['String']['input'];
   /** The value of the flow setting */
-  value: Scalars['JSON']['input'];
+  object: Scalars['JSON']['input'];
 }
 
 /** Represents a flow type */
 export interface FlowType {
   __typename?: 'FlowType';
-  /** Name of the function */
-  aliases?: Maybe<Array<Translation>>;
   /** Time when this FlowType was created */
-  createdAt?: Maybe<Scalars['Time']['output']>;
+  createdAt: Scalars['Time']['output'];
   /** Descriptions of the flow type */
-  descriptions?: Maybe<Array<Translation>>;
-  /** Display message of the function */
-  displayMessages?: Maybe<Array<Translation>>;
+  descriptions?: Maybe<TranslationConnection>;
   /** Editable status of the flow type */
-  editable?: Maybe<Scalars['Boolean']['output']>;
+  editable: Scalars['Boolean']['output'];
   /** Flow type settings of the flow type */
-  flowTypeSettings?: Maybe<Array<FlowTypeSetting>>;
+  flowTypeSettings: Array<FlowTypeSetting>;
   /** Global ID of this FlowType */
-  id?: Maybe<Scalars['FlowTypeID']['output']>;
+  id: Scalars['TypesFlowTypeID']['output'];
   /** Identifier of the flow type */
-  identifier?: Maybe<Scalars['String']['output']>;
+  identifier: Scalars['String']['output'];
   /** Input type of the flow type */
   inputType?: Maybe<DataType>;
   /** Names of the flow type */
-  names?: Maybe<Array<Translation>>;
+  names?: Maybe<TranslationConnection>;
   /** Return type of the flow type */
   returnType?: Maybe<DataType>;
-  /** Runtime of the flow type */
-  runtime?: Maybe<Runtime>;
   /** Time when this FlowType was last updated */
-  updatedAt?: Maybe<Scalars['Time']['output']>;
+  updatedAt: Scalars['Time']['output'];
+}
+
+
+/** Represents a flow type */
+export interface FlowTypeDescriptionsArgs {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+}
+
+
+/** Represents a flow type */
+export interface FlowTypeNamesArgs {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
 }
 
 /** The connection type for FlowType. */
 export interface FlowTypeConnection {
   __typename?: 'FlowTypeConnection';
   /** Total count of collection. */
-  count?: Maybe<Scalars['Int']['output']>;
+  count: Scalars['Int']['output'];
   /** A list of edges. */
   edges?: Maybe<Array<Maybe<FlowTypeEdge>>>;
   /** A list of nodes. */
   nodes?: Maybe<Array<Maybe<FlowType>>>;
   /** Information to aid in pagination. */
-  pageInfo?: Maybe<PageInfo>;
+  pageInfo: PageInfo;
 }
 
 /** An edge in a connection. */
 export interface FlowTypeEdge {
   __typename?: 'FlowTypeEdge';
   /** A cursor for use in pagination. */
-  cursor?: Maybe<Scalars['String']['output']>;
+  cursor: Scalars['String']['output'];
   /** The item at the end of the edge. */
   node?: Maybe<FlowType>;
 }
@@ -766,185 +447,62 @@ export interface FlowTypeEdge {
 export interface FlowTypeSetting {
   __typename?: 'FlowTypeSetting';
   /** Time when this FlowTypeSetting was created */
-  createdAt?: Maybe<Scalars['Time']['output']>;
+  createdAt: Scalars['Time']['output'];
   /** Data type of the flow type setting */
   dataType?: Maybe<DataType>;
   /** Descriptions of the flow type setting */
-  descriptions?: Maybe<Array<Translation>>;
+  descriptions: TranslationConnection;
   /** Flow type of the flow type setting */
   flowType?: Maybe<FlowType>;
   /** Global ID of this FlowTypeSetting */
-  id?: Maybe<Scalars['FlowTypeSettingID']['output']>;
+  id: Scalars['FlowTypeSettingID']['output'];
   /** Identifier of the flow type setting */
-  identifier?: Maybe<Scalars['String']['output']>;
+  identifier: Scalars['String']['output'];
   /** Names of the flow type setting */
-  names?: Maybe<Array<Translation>>;
+  names: TranslationConnection;
   /** Unique status of the flow type setting */
-  unique?: Maybe<Scalars['Boolean']['output']>;
+  unique: Scalars['Boolean']['output'];
   /** Time when this FlowTypeSetting was last updated */
-  updatedAt?: Maybe<Scalars['Time']['output']>;
-}
-
-/** Abilities for the current user on this Flow */
-export interface FlowUserAbilities {
-  __typename?: 'FlowUserAbilities';
-  /** Shows if the current user has the `delete_flow` ability on this Flow */
-  deleteFlow?: Maybe<Scalars['Boolean']['output']>;
-}
-
-/** Represents a flow validation error */
-export interface FlowValidationError {
-  __typename?: 'FlowValidationError';
-  /** Additional details about the validation error */
-  details?: Maybe<ActiveModelError>;
-  /** The code representing the validation error type */
-  errorCode?: Maybe<FlowValidationErrorCodeEnum>;
-  /** The severity of the validation error */
-  severity?: Maybe<FlowValidationSeverityEnum>;
-}
-
-/** Represents the available error responses */
-export const enum FlowValidationErrorCodeEnum {
-  /** The generic key for the data type identifier was not found. */
-  DataTypeIdentifierGenericKeyNotFound = 'DATA_TYPE_IDENTIFIER_GENERIC_KEY_NOT_FOUND',
-  /** The data type identifier runtime does not match the flow type runtime. */
-  DataTypeIdentifierRuntimeMismatch = 'DATA_TYPE_IDENTIFIER_RUNTIME_MISMATCH',
-  /** The data type rule model is invalid. */
-  DataTypeRuleModelInvalid = 'DATA_TYPE_RULE_MODEL_INVALID',
-  /** The data type runtime does not match the flow type runtime. */
-  DataTypeRuntimeMismatch = 'DATA_TYPE_RUNTIME_MISMATCH',
-  /** The flow setting model is invalid. */
-  FlowSettingModelInvalid = 'FLOW_SETTING_MODEL_INVALID',
-  /** The flow type runtime does not match the project primary runtime. */
-  FlowTypeRuntimeMismatch = 'FLOW_TYPE_RUNTIME_MISMATCH',
-  /** The node function runtime does not match the project primary runtime. */
-  NodeFunctionRuntimeMismatch = 'NODE_FUNCTION_RUNTIME_MISMATCH',
-  /** The project does not have a primary runtime set. */
-  NoPrimaryRuntime = 'NO_PRIMARY_RUNTIME'
-}
-
-/** Represents the severity of a flow validation error */
-export const enum FlowValidationSeverityEnum {
-  /** A blocking validation error */
-  Error = 'ERROR',
-  /** A minor typographical issue can also be blocking */
-  Typo = 'TYPO',
-  /** A non-blocking validation warning */
-  Warning = 'WARNING',
-  /** A weak validation issue that may not need to be addressed */
-  Weak = 'WEAK'
-}
-
-/** Represents a function definition */
-export interface FunctionDefinition {
-  __typename?: 'FunctionDefinition';
-  /** Name of the function */
-  aliases?: Maybe<Array<Translation>>;
-  /** Time when this FunctionDefinition was created */
-  createdAt?: Maybe<Scalars['Time']['output']>;
-  /** Deprecation message of the function */
-  deprecationMessages?: Maybe<Array<Translation>>;
-  /** Description of the function */
-  descriptions?: Maybe<Array<Translation>>;
-  /** Display message of the function */
-  displayMessages?: Maybe<Array<Translation>>;
-  /** Documentation of the function */
-  documentations?: Maybe<Array<Translation>>;
-  /** Generic keys of the function */
-  genericKeys?: Maybe<Array<Scalars['String']['output']>>;
-  /** Global ID of this FunctionDefinition */
-  id?: Maybe<Scalars['FunctionDefinitionID']['output']>;
-  /** Identifier of the function */
-  identifier?: Maybe<Scalars['String']['output']>;
-  /** Name of the function */
-  names?: Maybe<Array<Translation>>;
-  /** Parameters of the function */
-  parameterDefinitions?: Maybe<ParameterDefinitionConnection>;
-  /** Return type of the function */
-  returnType?: Maybe<DataTypeIdentifier>;
-  /** Runtime function definition */
-  runtimeFunctionDefinition?: Maybe<RuntimeFunctionDefinition>;
-  /** Indicates if the function can throw an error */
-  throwsError?: Maybe<Scalars['Boolean']['output']>;
-  /** Time when this FunctionDefinition was last updated */
-  updatedAt?: Maybe<Scalars['Time']['output']>;
-}
-
-
-/** Represents a function definition */
-export interface FunctionDefinitionParameterDefinitionsArgs {
+  updatedAt: Scalars['Time']['output'];
+}
+
+
+/** Represents a flow type setting */
+export interface FlowTypeSettingDescriptionsArgs {
   after?: InputMaybe<Scalars['String']['input']>;
   before?: InputMaybe<Scalars['String']['input']>;
   first?: InputMaybe<Scalars['Int']['input']>;
   last?: InputMaybe<Scalars['Int']['input']>;
 }
 
-/** The connection type for FunctionDefinition. */
-export interface FunctionDefinitionConnection {
-  __typename?: 'FunctionDefinitionConnection';
-  /** Total count of collection. */
-  count?: Maybe<Scalars['Int']['output']>;
-  /** A list of edges. */
-  edges?: Maybe<Array<Maybe<FunctionDefinitionEdge>>>;
-  /** A list of nodes. */
-  nodes?: Maybe<Array<Maybe<FunctionDefinition>>>;
-  /** Information to aid in pagination. */
-  pageInfo?: Maybe<PageInfo>;
-}
-
-/** An edge in a connection. */
-export interface FunctionDefinitionEdge {
-  __typename?: 'FunctionDefinitionEdge';
-  /** A cursor for use in pagination. */
-  cursor?: Maybe<Scalars['String']['output']>;
-  /** The item at the end of the edge. */
-  node?: Maybe<FunctionDefinition>;
-}
-
-/** Represents a combination strategy with AND/OR logic used by a generic mapper. */
-export interface GenericCombinationStrategy {
-  __typename?: 'GenericCombinationStrategy';
-  /** Time when this GenericCombinationStrategy was created */
-  createdAt?: Maybe<Scalars['Time']['output']>;
-  /** The associated generic mapper, if any. */
-  genericMapper?: Maybe<GenericMapper>;
-  /** Global ID of this GenericCombinationStrategy */
-  id?: Maybe<Scalars['GenericCombinationStrategyID']['output']>;
-  /** The combination type ('AND' or 'OR'). */
-  type?: Maybe<GenericCombinationStrategyType>;
-  /** Time when this GenericCombinationStrategy was last updated */
-  updatedAt?: Maybe<Scalars['Time']['output']>;
-}
 
-/** The available combination strategy types. */
-export const enum GenericCombinationStrategyType {
-  /** Represents a logical AND combination. */
-  And = 'AND',
-  /** Represents a logical OR combination. */
-  Or = 'OR'
+/** Represents a flow type setting */
+export interface FlowTypeSettingNamesArgs {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
 }
 
 /** Represents a mapping between a source data type and a target key for generic values. */
 export interface GenericMapper {
   __typename?: 'GenericMapper';
   /** Time when this GenericMapper was created */
-  createdAt?: Maybe<Scalars['Time']['output']>;
-  /** Combination strategies associated with this generic mapper. */
-  genericCombinationStrategies?: Maybe<Array<GenericCombinationStrategy>>;
+  createdAt: Scalars['Time']['output'];
   /** Global ID of this GenericMapper */
-  id?: Maybe<Scalars['GenericMapperID']['output']>;
+  id: Scalars['GenericMapperID']['output'];
   /** The source data type identifier. */
-  sourceDataTypeIdentifiers?: Maybe<Array<DataTypeIdentifier>>;
+  source: DataTypeIdentifier;
   /** The target key for the generic value. */
-  target?: Maybe<Scalars['String']['output']>;
+  target: Scalars['String']['output'];
   /** Time when this GenericMapper was last updated */
-  updatedAt?: Maybe<Scalars['Time']['output']>;
+  updatedAt: Scalars['Time']['output'];
 }
 
 /** Input type for generic mappers */
 export interface GenericMapperInput {
   /** The source data type identifier for the mapper */
-  sourceDataTypeIdentifiers: Array<DataTypeIdentifierInput>;
+  sources: Array<DataTypeIdentifierInput>;
   /** The target data type identifier for the mapper */
   target: Scalars['String']['input'];
 }
@@ -953,15 +511,15 @@ export interface GenericMapperInput {
 export interface GenericType {
   __typename?: 'GenericType';
   /** Time when this GenericType was created */
-  createdAt?: Maybe<Scalars['Time']['output']>;
+  createdAt: Scalars['Time']['output'];
   /** The data type associated with this generic type. */
-  dataType?: Maybe<DataType>;
+  dataType: DataType;
   /** The mappers associated with this generic type. */
-  genericMappers?: Maybe<Array<GenericMapper>>;
+  genericMappers: Array<GenericMapper>;
   /** Global ID of this GenericType */
-  id?: Maybe<Scalars['GenericTypeID']['output']>;
+  id: Scalars['GenericTypeID']['output'];
   /** Time when this GenericType was last updated */
-  updatedAt?: Maybe<Scalars['Time']['output']>;
+  updatedAt: Scalars['Time']['output'];
 }
 
 /** Input type for generic type operations. */
@@ -978,119 +536,45 @@ export interface IdentityInput {
   code?: InputMaybe<Scalars['String']['input']>;
 }
 
-/** Represents an identity provider configuration. */
-export interface IdentityProvider {
-  __typename?: 'IdentityProvider';
-  /** Configuration details of the identity provider. */
-  config?: Maybe<IdentityProviderConfig>;
-  /** Unique identifier of the identity provider. */
-  id?: Maybe<Scalars['String']['output']>;
-  /** Type of the identity provider. */
-  type?: Maybe<IdentityProviderType>;
-}
-
-/** Represents the configuration of an identity provider. */
-export type IdentityProviderConfig = OidcIdentityProviderConfig | SamlIdentityProviderConfig;
-
-/** Input for identity provider configuration. Contains fields for both OIDC and SAML. */
-export interface IdentityProviderConfigInput {
-  /** List of attribute statements for the identity provider */
-  attributeStatements?: InputMaybe<Scalars['JSON']['input']>;
-  /** The authorization URL for the OIDC identity provider */
-  authorizationUrl?: InputMaybe<Scalars['String']['input']>;
-  /** The client ID for the OIDC identity provider */
-  clientId?: InputMaybe<Scalars['String']['input']>;
-  /** The client secret for the OIDC identity provider */
-  clientSecret?: InputMaybe<Scalars['String']['input']>;
-  /** Optional metadata URL to fetch metadata (alternative to settings) */
-  metadataUrl?: InputMaybe<Scalars['String']['input']>;
-  /** The name of the identity provider */
-  providerName?: InputMaybe<Scalars['String']['input']>;
-  /** The redirect URI for the OIDC identity provider */
-  redirectUri?: InputMaybe<Scalars['String']['input']>;
-  /** The SAML response settings for the identity provider */
-  responseSettings?: InputMaybe<Scalars['JSON']['input']>;
-  /** The SAML settings for the identity provider */
-  settings?: InputMaybe<Scalars['JSON']['input']>;
-  /** The user details URL for the OIDC identity provider */
-  userDetailsUrl?: InputMaybe<Scalars['String']['input']>;
-}
-
-/** The connection type for IdentityProvider. */
-export interface IdentityProviderConnection {
-  __typename?: 'IdentityProviderConnection';
-  /** Total count of collection. */
-  count?: Maybe<Scalars['Int']['output']>;
-  /** A list of edges. */
-  edges?: Maybe<Array<Maybe<IdentityProviderEdge>>>;
-  /** A list of nodes. */
-  nodes?: Maybe<Array<Maybe<IdentityProvider>>>;
-  /** Information to aid in pagination. */
-  pageInfo?: Maybe<PageInfo>;
+/** Represents a subtype of input type configuration for a input data type. */
+export interface InputTypeConfig {
+  __typename?: 'InputTypeConfig';
+  /** The identifier of the data type this input type belongs to */
+  dataTypeIdentifier: DataTypeIdentifier;
+  /** The input data type that this configuration applies to */
+  inputType: DataType;
 }
 
-/** An edge in a connection. */
-export interface IdentityProviderEdge {
-  __typename?: 'IdentityProviderEdge';
-  /** A cursor for use in pagination. */
-  cursor?: Maybe<Scalars['String']['output']>;
-  /** The item at the end of the edge. */
-  node?: Maybe<IdentityProvider>;
-}
-
-/** Input for creating or updating an identity provider */
-export interface IdentityProviderInput {
-  /** Configuration for the identity provider */
-  config: IdentityProviderConfigInput;
-  /** Unique identifier of the identity provider */
-  id: Scalars['String']['input'];
-  /** Type of the identity provider */
-  type: IdentityProviderType;
-}
-
-/** The available identity provider types. */
-export const enum IdentityProviderType {
-  /** Identity provider of type discord */
-  Discord = 'DISCORD',
-  /** Identity provider of type github */
-  Github = 'GITHUB',
-  /** Identity provider of type gitlab */
-  Gitlab = 'GITLAB',
-  /** Identity provider of type google */
-  Google = 'GOOGLE',
-  /** Identity provider of type microsoft */
-  Microsoft = 'MICROSOFT',
-  /** Identity provider of type oidc */
-  Oidc = 'OIDC',
-  /** Identity provider of type saml */
-  Saml = 'SAML'
+/** Represents a rule that can be applied to a data type. */
+export interface InputTypesConfig {
+  __typename?: 'InputTypesConfig';
+  /** The input types that can be used in this data type rule */
+  inputTypes: Array<InputTypeConfig>;
+}
+
+/** Represents a rule that can be applied to a data type. */
+export interface ItemOfCollectionConfig {
+  __typename?: 'ItemOfCollectionConfig';
+  /** The items that can be configured for this rule. */
+  items?: Maybe<Array<Scalars['JSON']['output']>>;
 }
 
 /** Represents a literal value, such as a string or number. */
 export interface LiteralValue {
   __typename?: 'LiteralValue';
   /** Time when this LiteralValue was created */
-  createdAt?: Maybe<Scalars['Time']['output']>;
+  createdAt: Scalars['Time']['output'];
   /** Time when this LiteralValue was last updated */
-  updatedAt?: Maybe<Scalars['Time']['output']>;
+  updatedAt: Scalars['Time']['output'];
   /** The literal value itself as JSON. */
-  value?: Maybe<Scalars['JSON']['output']>;
+  value: Scalars['JSON']['output'];
 }
 
 /** Represents an error message */
 export interface MessageError {
   __typename?: 'MessageError';
   /** The message provided from the error */
-  message?: Maybe<Scalars['String']['output']>;
-}
-
-/** Application metadata */
-export interface Metadata {
-  __typename?: 'Metadata';
-  /** List of loaded extensions */
-  extensions?: Maybe<Array<Scalars['String']['output']>>;
-  /** Application version */
-  version?: Maybe<Scalars['String']['output']>;
+  message: Scalars['String']['output'];
 }
 
 /** Represents the input for mfa authentication */
@@ -1101,19 +585,8 @@ export interface MfaInput {
   value: Scalars['String']['input'];
 }
 
-/** Represents the MFA status of a user */
-export interface MfaStatus {
-  __typename?: 'MfaStatus';
-  /** The number of backup codes remaining for the user. */
-  backupCodesCount?: Maybe<Scalars['Int']['output']>;
-  /** Indicates whether MFA is enabled for the user. */
-  enabled?: Maybe<Scalars['Boolean']['output']>;
-  /** Indicates whether TOTP MFA is enabled for the user. */
-  totpEnabled?: Maybe<Scalars['Boolean']['output']>;
-}
-
 /** Represent all available types to authenticate with mfa */
-export const enum MfaType {
+export enum MfaType {
   /** Single use backup code */
   BackupCode = 'BACKUP_CODE',
   /** Time based onetime password */
@@ -1130,12 +603,11 @@ export interface Mutation {
    *
    * This is expected to be used for testing of endpoints, to verify
    * that a user has mutation access.
-   *
    */
   echo?: Maybe<EchoPayload>;
-  /** (EE only) Create a new namespace license. */
+  /** Create a new namespace license. */
   namespacesLicensesCreate?: Maybe<NamespacesLicensesCreatePayload>;
-  /** (EE only) Deletes an namespace license. */
+  /** Deletes an namespace license. */
   namespacesLicensesDelete?: Maybe<NamespacesLicensesDeletePayload>;
   /** Update the roles a member is assigned to. */
   namespacesMembersAssignRoles?: Maybe<NamespacesMembersAssignRolesPayload>;
@@ -1153,8 +625,6 @@ export interface Mutation {
   namespacesProjectsFlowsCreate?: Maybe<NamespacesProjectsFlowsCreatePayload>;
   /** Deletes a namespace project. */
   namespacesProjectsFlowsDelete?: Maybe<NamespacesProjectsFlowsDeletePayload>;
-  /** Update an existing flow. */
-  namespacesProjectsFlowsUpdate?: Maybe<NamespacesProjectsFlowsUpdatePayload>;
   /** Updates a namespace project. */
   namespacesProjectsUpdate?: Maybe<NamespacesProjectsUpdatePayload>;
   /** Update the abilities a role is granted. */
@@ -1181,12 +651,6 @@ export interface Mutation {
   runtimesRotateToken?: Maybe<RuntimesRotateTokenPayload>;
   /** Update an existing runtime. */
   runtimesUpdate?: Maybe<RuntimesUpdatePayload>;
-  /** Admin-create a user. */
-  usersCreate?: Maybe<UsersCreatePayload>;
-  /** Delete an existing user. */
-  usersDelete?: Maybe<UsersDeletePayload>;
-  /** Verify your email when changing it or signing up */
-  usersEmailVerification?: Maybe<UsersEmailVerificationPayload>;
   /** Links an external identity to an existing user */
   usersIdentityLink?: Maybe<UsersIdentityLinkPayload>;
   /** Login to an existing user via an external identity */
@@ -1205,10 +669,6 @@ export interface Mutation {
   usersMfaTotpGenerateSecret?: Maybe<UsersMfaTotpGenerateSecretPayload>;
   /** Validates a TOTP value for the given secret and enables TOTP MFA for the user */
   usersMfaTotpValidateSecret?: Maybe<UsersMfaTotpValidateSecretPayload>;
-  /** Reset the password using a reset token */
-  usersPasswordReset?: Maybe<UsersPasswordResetPayload>;
-  /** Request an password reset */
-  usersPasswordResetRequest?: Maybe<UsersPasswordResetRequestPayload>;
   /** Register a new user */
   usersRegister?: Maybe<UsersRegisterPayload>;
   /** Update an existing user. */
@@ -1288,12 +748,6 @@ export interface MutationNamespacesProjectsFlowsDeleteArgs {
 }
 
 
-/** Root Mutation type */
-export interface MutationNamespacesProjectsFlowsUpdateArgs {
-  input: NamespacesProjectsFlowsUpdateInput;
-}
-
-
 /** Root Mutation type */
 export interface MutationNamespacesProjectsUpdateArgs {
   input: NamespacesProjectsUpdateInput;
@@ -1372,24 +826,6 @@ export interface MutationRuntimesUpdateArgs {
 }
 
 
-/** Root Mutation type */
-export interface MutationUsersCreateArgs {
-  input: UsersCreateInput;
-}
-
-
-/** Root Mutation type */
-export interface MutationUsersDeleteArgs {
-  input: UsersDeleteInput;
-}
-
-
-/** Root Mutation type */
-export interface MutationUsersEmailVerificationArgs {
-  input: UsersEmailVerificationInput;
-}
-
-
 /** Root Mutation type */
 export interface MutationUsersIdentityLinkArgs {
   input: UsersIdentityLinkInput;
@@ -1444,18 +880,6 @@ export interface MutationUsersMfaTotpValidateSecretArgs {
 }
 
 
-/** Root Mutation type */
-export interface MutationUsersPasswordResetArgs {
-  input: UsersPasswordResetInput;
-}
-
-
-/** Root Mutation type */
-export interface MutationUsersPasswordResetRequestArgs {
-  input: UsersPasswordResetRequestInput;
-}
-
-
 /** Root Mutation type */
 export interface MutationUsersRegisterArgs {
   input: UsersRegisterInput;
@@ -1471,29 +895,23 @@ export interface MutationUsersUpdateArgs {
 export interface Namespace {
   __typename?: 'Namespace';
   /** Time when this Namespace was created */
-  createdAt?: Maybe<Scalars['Time']['output']>;
-  /** (EE only) Currently active license of the namespace */
-  currentNamespaceLicense?: Maybe<NamespaceLicense>;
+  createdAt: Scalars['Time']['output'];
   /** Global ID of this Namespace */
-  id?: Maybe<Scalars['NamespaceID']['output']>;
+  id: Scalars['NamespaceID']['output'];
   /** Members of the namespace */
-  members?: Maybe<NamespaceMemberConnection>;
-  /** (EE only) Licenses of the namespace */
-  namespaceLicenses?: Maybe<NamespaceLicenseConnection>;
+  members: NamespaceMemberConnection;
+  /** Licenses of the namespace */
+  namespaceLicenses: NamespaceLicenseConnection;
   /** Parent of this namespace */
-  parent?: Maybe<NamespaceParent>;
-  /** Query a project by its id */
-  project?: Maybe<NamespaceProject>;
+  parent: NamespaceParent;
   /** Projects of the namespace */
-  projects?: Maybe<NamespaceProjectConnection>;
+  projects: NamespaceProjectConnection;
   /** Roles of the namespace */
-  roles?: Maybe<NamespaceRoleConnection>;
+  roles: NamespaceRoleConnection;
   /** Runtime of the namespace */
-  runtimes?: Maybe<RuntimeConnection>;
+  runtimes: RuntimeConnection;
   /** Time when this Namespace was last updated */
-  updatedAt?: Maybe<Scalars['Time']['output']>;
-  /** Abilities for the current user on this Namespace */
-  userAbilities?: Maybe<NamespaceUserAbilities>;
+  updatedAt: Scalars['Time']['output'];
 }
 
 
@@ -1515,12 +933,6 @@ export interface NamespaceNamespaceLicensesArgs {
 }
 
 
-/** Represents a Namespace */
-export interface NamespaceProjectArgs {
-  id: Scalars['NamespaceProjectID']['input'];
-}
-
-
 /** Represents a Namespace */
 export interface NamespaceProjectsArgs {
   after?: InputMaybe<Scalars['String']['input']>;
@@ -1547,113 +959,74 @@ export interface NamespaceRuntimesArgs {
   last?: InputMaybe<Scalars['Int']['input']>;
 }
 
-/** (EE only) Represents a Namespace License */
+/** Represents a Namespace License */
 export interface NamespaceLicense {
   __typename?: 'NamespaceLicense';
   /** Time when this NamespaceLicense was created */
-  createdAt?: Maybe<Scalars['Time']['output']>;
-  /** The end date of the license */
-  endDate?: Maybe<Scalars['Time']['output']>;
+  createdAt: Scalars['Time']['output'];
   /** Global ID of this NamespaceLicense */
-  id?: Maybe<Scalars['NamespaceLicenseID']['output']>;
-  /** The licensee information */
-  licensee?: Maybe<Scalars['JSON']['output']>;
+  id: Scalars['NamespaceLicenseID']['output'];
   /** The namespace the license belongs to */
-  namespace?: Maybe<Namespace>;
-  /** The start date of the license */
-  startDate?: Maybe<Scalars['Time']['output']>;
+  namespace: Namespace;
   /** Time when this NamespaceLicense was last updated */
-  updatedAt?: Maybe<Scalars['Time']['output']>;
-  /** Abilities for the current user on this NamespaceLicense */
-  userAbilities?: Maybe<NamespaceLicenseUserAbilities>;
+  updatedAt: Scalars['Time']['output'];
 }
 
 /** The connection type for NamespaceLicense. */
 export interface NamespaceLicenseConnection {
   __typename?: 'NamespaceLicenseConnection';
   /** Total count of collection. */
-  count?: Maybe<Scalars['Int']['output']>;
+  count: Scalars['Int']['output'];
   /** A list of edges. */
   edges?: Maybe<Array<Maybe<NamespaceLicenseEdge>>>;
   /** A list of nodes. */
   nodes?: Maybe<Array<Maybe<NamespaceLicense>>>;
   /** Information to aid in pagination. */
-  pageInfo?: Maybe<PageInfo>;
+  pageInfo: PageInfo;
 }
 
 /** An edge in a connection. */
 export interface NamespaceLicenseEdge {
   __typename?: 'NamespaceLicenseEdge';
   /** A cursor for use in pagination. */
-  cursor?: Maybe<Scalars['String']['output']>;
+  cursor: Scalars['String']['output'];
   /** The item at the end of the edge. */
   node?: Maybe<NamespaceLicense>;
 }
 
-/** Abilities for the current user on this NamespaceLicense */
-export interface NamespaceLicenseUserAbilities {
-  __typename?: 'NamespaceLicenseUserAbilities';
-  /** Shows if the current user has the `delete_namespace_license` ability on this NamespaceLicense */
-  deleteNamespaceLicense?: Maybe<Scalars['Boolean']['output']>;
-}
-
 /** Represents a namespace member */
 export interface NamespaceMember {
   __typename?: 'NamespaceMember';
   /** Time when this NamespaceMember was created */
-  createdAt?: Maybe<Scalars['Time']['output']>;
+  createdAt: Scalars['Time']['output'];
   /** Global ID of this NamespaceMember */
-  id?: Maybe<Scalars['NamespaceMemberID']['output']>;
-  /** Memberroles of the member */
-  memberRoles?: Maybe<NamespaceMemberRoleConnection>;
+  id: Scalars['NamespaceMemberID']['output'];
   /** Namespace this member belongs to */
-  namespace?: Maybe<Namespace>;
-  /** Roles of the member */
-  roles?: Maybe<NamespaceRoleConnection>;
+  namespace: Namespace;
   /** Time when this NamespaceMember was last updated */
-  updatedAt?: Maybe<Scalars['Time']['output']>;
+  updatedAt: Scalars['Time']['output'];
   /** User this member belongs to */
-  user?: Maybe<User>;
-  /** Abilities for the current user on this NamespaceMember */
-  userAbilities?: Maybe<NamespaceMemberUserAbilities>;
-}
-
-
-/** Represents a namespace member */
-export interface NamespaceMemberMemberRolesArgs {
-  after?: InputMaybe<Scalars['String']['input']>;
-  before?: InputMaybe<Scalars['String']['input']>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-}
-
-
-/** Represents a namespace member */
-export interface NamespaceMemberRolesArgs {
-  after?: InputMaybe<Scalars['String']['input']>;
-  before?: InputMaybe<Scalars['String']['input']>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
+  user: User;
 }
 
 /** The connection type for NamespaceMember. */
 export interface NamespaceMemberConnection {
   __typename?: 'NamespaceMemberConnection';
   /** Total count of collection. */
-  count?: Maybe<Scalars['Int']['output']>;
+  count: Scalars['Int']['output'];
   /** A list of edges. */
   edges?: Maybe<Array<Maybe<NamespaceMemberEdge>>>;
   /** A list of nodes. */
   nodes?: Maybe<Array<Maybe<NamespaceMember>>>;
   /** Information to aid in pagination. */
-  pageInfo?: Maybe<PageInfo>;
+  pageInfo: PageInfo;
 }
 
 /** An edge in a connection. */
 export interface NamespaceMemberEdge {
   __typename?: 'NamespaceMemberEdge';
   /** A cursor for use in pagination. */
-  cursor?: Maybe<Scalars['String']['output']>;
+  cursor: Scalars['String']['output'];
   /** The item at the end of the edge. */
   node?: Maybe<NamespaceMember>;
 }
@@ -1662,104 +1035,39 @@ export interface NamespaceMemberEdge {
 export interface NamespaceMemberRole {
   __typename?: 'NamespaceMemberRole';
   /** Time when this NamespaceMemberRole was created */
-  createdAt?: Maybe<Scalars['Time']['output']>;
+  createdAt: Scalars['Time']['output'];
   /** Global ID of this NamespaceMemberRole */
-  id?: Maybe<Scalars['NamespaceMemberRoleID']['output']>;
+  id: Scalars['NamespaceMemberRoleID']['output'];
   /** The member the role is assigned to */
   member?: Maybe<NamespaceMember>;
   /** The assigned role */
   role?: Maybe<NamespaceRole>;
   /** Time when this NamespaceMemberRole was last updated */
-  updatedAt?: Maybe<Scalars['Time']['output']>;
-}
-
-/** The connection type for NamespaceMemberRole. */
-export interface NamespaceMemberRoleConnection {
-  __typename?: 'NamespaceMemberRoleConnection';
-  /** Total count of collection. */
-  count?: Maybe<Scalars['Int']['output']>;
-  /** A list of edges. */
-  edges?: Maybe<Array<Maybe<NamespaceMemberRoleEdge>>>;
-  /** A list of nodes. */
-  nodes?: Maybe<Array<Maybe<NamespaceMemberRole>>>;
-  /** Information to aid in pagination. */
-  pageInfo?: Maybe<PageInfo>;
-}
-
-/** An edge in a connection. */
-export interface NamespaceMemberRoleEdge {
-  __typename?: 'NamespaceMemberRoleEdge';
-  /** A cursor for use in pagination. */
-  cursor?: Maybe<Scalars['String']['output']>;
-  /** The item at the end of the edge. */
-  node?: Maybe<NamespaceMemberRole>;
-}
-
-/** Abilities for the current user on this NamespaceMember */
-export interface NamespaceMemberUserAbilities {
-  __typename?: 'NamespaceMemberUserAbilities';
-  /** Shows if the current user has the `assign_member_roles` ability on this NamespaceMember */
-  assignMemberRoles?: Maybe<Scalars['Boolean']['output']>;
-  /** Shows if the current user has the `delete_member` ability on this NamespaceMember */
-  deleteMember?: Maybe<Scalars['Boolean']['output']>;
+  updatedAt: Scalars['Time']['output'];
 }
 
 /** Objects that can present a namespace */
-export type NamespaceParent = Organization | User;
+export type NamespaceParent = Organization;
 
 /** Represents a namespace project */
 export interface NamespaceProject {
   __typename?: 'NamespaceProject';
   /** Time when this NamespaceProject was created */
-  createdAt?: Maybe<Scalars['Time']['output']>;
+  createdAt: Scalars['Time']['output'];
   /** Description of the project */
-  description?: Maybe<Scalars['String']['output']>;
-  /** Fetches an flow given by its ID */
-  flow?: Maybe<Flow>;
-  /** Fetches all flows in this project */
-  flows?: Maybe<FlowConnection>;
+  description: Scalars['String']['output'];
   /** Global ID of this NamespaceProject */
-  id?: Maybe<Scalars['NamespaceProjectID']['output']>;
+  id: Scalars['NamespaceProjectID']['output'];
   /** Name of the project */
-  name?: Maybe<Scalars['String']['output']>;
+  name: Scalars['String']['output'];
   /** The namespace where this project belongs to */
-  namespace?: Maybe<Namespace>;
+  namespace: Namespace;
   /** The primary runtime for the project */
   primaryRuntime?: Maybe<Runtime>;
-  /** Roles assigned to this project */
-  roles?: Maybe<NamespaceRoleConnection>;
   /** Runtimes assigned to this project */
-  runtimes?: Maybe<RuntimeConnection>;
-  /** Slug of the project used in URLs to identify flows */
-  slug?: Maybe<Scalars['String']['output']>;
+  runtimes: RuntimeConnection;
   /** Time when this NamespaceProject was last updated */
-  updatedAt?: Maybe<Scalars['Time']['output']>;
-  /** Abilities for the current user on this NamespaceProject */
-  userAbilities?: Maybe<NamespaceProjectUserAbilities>;
-}
-
-
-/** Represents a namespace project */
-export interface NamespaceProjectFlowArgs {
-  id: Scalars['FlowID']['input'];
-}
-
-
-/** Represents a namespace project */
-export interface NamespaceProjectFlowsArgs {
-  after?: InputMaybe<Scalars['String']['input']>;
-  before?: InputMaybe<Scalars['String']['input']>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-}
-
-
-/** Represents a namespace project */
-export interface NamespaceProjectRolesArgs {
-  after?: InputMaybe<Scalars['String']['input']>;
-  before?: InputMaybe<Scalars['String']['input']>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
+  updatedAt: Scalars['Time']['output'];
 }
 
 
@@ -1775,58 +1083,41 @@ export interface NamespaceProjectRuntimesArgs {
 export interface NamespaceProjectConnection {
   __typename?: 'NamespaceProjectConnection';
   /** Total count of collection. */
-  count?: Maybe<Scalars['Int']['output']>;
+  count: Scalars['Int']['output'];
   /** A list of edges. */
   edges?: Maybe<Array<Maybe<NamespaceProjectEdge>>>;
   /** A list of nodes. */
   nodes?: Maybe<Array<Maybe<NamespaceProject>>>;
   /** Information to aid in pagination. */
-  pageInfo?: Maybe<PageInfo>;
+  pageInfo: PageInfo;
 }
 
 /** An edge in a connection. */
 export interface NamespaceProjectEdge {
   __typename?: 'NamespaceProjectEdge';
   /** A cursor for use in pagination. */
-  cursor?: Maybe<Scalars['String']['output']>;
+  cursor: Scalars['String']['output'];
   /** The item at the end of the edge. */
   node?: Maybe<NamespaceProject>;
 }
 
-/** Abilities for the current user on this NamespaceProject */
-export interface NamespaceProjectUserAbilities {
-  __typename?: 'NamespaceProjectUserAbilities';
-  /** Shows if the current user has the `assign_project_runtimes` ability on this NamespaceProject */
-  assignProjectRuntimes?: Maybe<Scalars['Boolean']['output']>;
-  /** Shows if the current user has the `create_flow` ability on this NamespaceProject */
-  createFlow?: Maybe<Scalars['Boolean']['output']>;
-  /** Shows if the current user has the `delete_namespace_project` ability on this NamespaceProject */
-  deleteNamespaceProject?: Maybe<Scalars['Boolean']['output']>;
-  /** Shows if the current user has the `update_namespace_project` ability on this NamespaceProject */
-  updateNamespaceProject?: Maybe<Scalars['Boolean']['output']>;
-}
-
 /** Represents a namespace role. */
 export interface NamespaceRole {
   __typename?: 'NamespaceRole';
   /** The abilities the role is granted */
-  abilities?: Maybe<Array<NamespaceRoleAbility>>;
+  abilities: Array<NamespaceRoleAbility>;
   /** The projects this role is assigned to */
   assignedProjects?: Maybe<NamespaceProjectConnection>;
   /** Time when this NamespaceRole was created */
-  createdAt?: Maybe<Scalars['Time']['output']>;
+  createdAt: Scalars['Time']['output'];
   /** Global ID of this NamespaceRole */
-  id?: Maybe<Scalars['NamespaceRoleID']['output']>;
-  /** The members this role is assigned to */
-  members?: Maybe<NamespaceMemberConnection>;
+  id: Scalars['NamespaceRoleID']['output'];
   /** The name of this role */
-  name?: Maybe<Scalars['String']['output']>;
+  name: Scalars['String']['output'];
   /** The namespace where this role belongs to */
   namespace?: Maybe<Namespace>;
   /** Time when this NamespaceRole was last updated */
-  updatedAt?: Maybe<Scalars['Time']['output']>;
-  /** Abilities for the current user on this NamespaceRole */
-  userAbilities?: Maybe<NamespaceRoleUserAbilities>;
+  updatedAt: Scalars['Time']['output'];
 }
 
 
@@ -1838,17 +1129,8 @@ export interface NamespaceRoleAssignedProjectsArgs {
   last?: InputMaybe<Scalars['Int']['input']>;
 }
 
-
-/** Represents a namespace role. */
-export interface NamespaceRoleMembersArgs {
-  after?: InputMaybe<Scalars['String']['input']>;
-  before?: InputMaybe<Scalars['String']['input']>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-}
-
 /** Represents abilities that can be granted to roles in namespaces. */
-export const enum NamespaceRoleAbility {
+export enum NamespaceRoleAbility {
   /** Allows to change the roles of a namespace member */
   AssignMemberRoles = 'ASSIGN_MEMBER_ROLES',
   /** Allows to assign runtimes to a project in the namespace */
@@ -1858,7 +1140,7 @@ export const enum NamespaceRoleAbility {
   /** Allows to change the assigned projects of a namespace role */
   AssignRoleProjects = 'ASSIGN_ROLE_PROJECTS',
   /** Allows to create flows in a namespace project */
-  CreateFlow = 'CREATE_FLOW',
+  CreateFlows = 'CREATE_FLOWS',
   /** Allows to create a license for the namespace */
   CreateNamespaceLicense = 'CREATE_NAMESPACE_LICENSE',
   /** Allows to create a project in the namespace */
@@ -1868,7 +1150,7 @@ export const enum NamespaceRoleAbility {
   /** Allows to create a runtime globally or for the namespace */
   CreateRuntime = 'CREATE_RUNTIME',
   /** Allows to delete flows in a namespace project */
-  DeleteFlow = 'DELETE_FLOW',
+  DeleteFlows = 'DELETE_FLOWS',
   /** Allows to remove members of a namespace */
   DeleteMember = 'DELETE_MEMBER',
   /** Allows to delete the license of the namespace */
@@ -1892,7 +1174,7 @@ export const enum NamespaceRoleAbility {
   /** Allows to regenerate a runtime token */
   RotateRuntimeToken = 'ROTATE_RUNTIME_TOKEN',
   /** Allows to update flows in the project */
-  UpdateFlow = 'UPDATE_FLOW',
+  UpdateFlows = 'UPDATE_FLOWS',
   /** Allows to update the project of the namespace */
   UpdateNamespaceProject = 'UPDATE_NAMESPACE_PROJECT',
   /** Allows to update the namespace role */
@@ -1907,52 +1189,24 @@ export const enum NamespaceRoleAbility {
 export interface NamespaceRoleConnection {
   __typename?: 'NamespaceRoleConnection';
   /** Total count of collection. */
-  count?: Maybe<Scalars['Int']['output']>;
+  count: Scalars['Int']['output'];
   /** A list of edges. */
   edges?: Maybe<Array<Maybe<NamespaceRoleEdge>>>;
   /** A list of nodes. */
   nodes?: Maybe<Array<Maybe<NamespaceRole>>>;
   /** Information to aid in pagination. */
-  pageInfo?: Maybe<PageInfo>;
+  pageInfo: PageInfo;
 }
 
 /** An edge in a connection. */
 export interface NamespaceRoleEdge {
   __typename?: 'NamespaceRoleEdge';
   /** A cursor for use in pagination. */
-  cursor?: Maybe<Scalars['String']['output']>;
+  cursor: Scalars['String']['output'];
   /** The item at the end of the edge. */
   node?: Maybe<NamespaceRole>;
 }
 
-/** Abilities for the current user on this NamespaceRole */
-export interface NamespaceRoleUserAbilities {
-  __typename?: 'NamespaceRoleUserAbilities';
-  /** Shows if the current user has the `assign_role_abilities` ability on this NamespaceRole */
-  assignRoleAbilities?: Maybe<Scalars['Boolean']['output']>;
-  /** Shows if the current user has the `assign_role_projects` ability on this NamespaceRole */
-  assignRoleProjects?: Maybe<Scalars['Boolean']['output']>;
-  /** Shows if the current user has the `delete_namespace_role` ability on this NamespaceRole */
-  deleteNamespaceRole?: Maybe<Scalars['Boolean']['output']>;
-  /** Shows if the current user has the `update_namespace_role` ability on this NamespaceRole */
-  updateNamespaceRole?: Maybe<Scalars['Boolean']['output']>;
-}
-
-/** Abilities for the current user on this Namespace */
-export interface NamespaceUserAbilities {
-  __typename?: 'NamespaceUserAbilities';
-  /** Shows if the current user has the `create_namespace_license` ability on this Namespace */
-  createNamespaceLicense?: Maybe<Scalars['Boolean']['output']>;
-  /** Shows if the current user has the `create_namespace_project` ability on this Namespace */
-  createNamespaceProject?: Maybe<Scalars['Boolean']['output']>;
-  /** Shows if the current user has the `create_namespace_role` ability on this Namespace */
-  createNamespaceRole?: Maybe<Scalars['Boolean']['output']>;
-  /** Shows if the current user has the `create_runtime` ability on this Namespace */
-  createRuntime?: Maybe<Scalars['Boolean']['output']>;
-  /** Shows if the current user has the `invite_member` ability on this Namespace */
-  inviteMember?: Maybe<Scalars['Boolean']['output']>;
-}
-
 /** Autogenerated input type of NamespacesLicensesCreate */
 export interface NamespacesLicensesCreateInput {
   /** A unique identifier for the client performing the mutation. */
@@ -1969,7 +1223,7 @@ export interface NamespacesLicensesCreatePayload {
   /** A unique identifier for the client performing the mutation. */
   clientMutationId?: Maybe<Scalars['String']['output']>;
   /** Errors encountered during execution of the mutation. */
-  errors?: Maybe<Array<Error>>;
+  errors: Array<Error>;
   /** The newly created license. */
   namespaceLicense?: Maybe<NamespaceLicense>;
 }
@@ -1988,7 +1242,7 @@ export interface NamespacesLicensesDeletePayload {
   /** A unique identifier for the client performing the mutation. */
   clientMutationId?: Maybe<Scalars['String']['output']>;
   /** Errors encountered during execution of the mutation. */
-  errors?: Maybe<Array<Error>>;
+  errors: Array<Error>;
   /** The deleted namespace license. */
   namespaceLicense?: Maybe<NamespaceLicense>;
 }
@@ -2009,9 +1263,9 @@ export interface NamespacesMembersAssignRolesPayload {
   /** A unique identifier for the client performing the mutation. */
   clientMutationId?: Maybe<Scalars['String']['output']>;
   /** Errors encountered during execution of the mutation. */
-  errors?: Maybe<Array<Error>>;
-  /** The member which was assigned the roles */
-  member?: Maybe<NamespaceMember>;
+  errors: Array<Error>;
+  /** The roles the member is now assigned to */
+  namespaceMemberRoles?: Maybe<Array<NamespaceMemberRole>>;
 }
 
 /** Autogenerated input type of NamespacesMembersDelete */
@@ -2028,7 +1282,7 @@ export interface NamespacesMembersDeletePayload {
   /** A unique identifier for the client performing the mutation. */
   clientMutationId?: Maybe<Scalars['String']['output']>;
   /** Errors encountered during execution of the mutation. */
-  errors?: Maybe<Array<Error>>;
+  errors: Array<Error>;
   /** The removed namespace member */
   namespaceMember?: Maybe<NamespaceMember>;
 }
@@ -2049,7 +1303,7 @@ export interface NamespacesMembersInvitePayload {
   /** A unique identifier for the client performing the mutation. */
   clientMutationId?: Maybe<Scalars['String']['output']>;
   /** Errors encountered during execution of the mutation. */
-  errors?: Maybe<Array<Error>>;
+  errors: Array<Error>;
   /** The newly created namespace member */
   namespaceMember?: Maybe<NamespaceMember>;
 }
@@ -2070,7 +1324,7 @@ export interface NamespacesProjectsAssignRuntimesPayload {
   /** A unique identifier for the client performing the mutation. */
   clientMutationId?: Maybe<Scalars['String']['output']>;
   /** Errors encountered during execution of the mutation. */
-  errors?: Maybe<Array<Error>>;
+  errors: Array<Error>;
   /** The updated project with assigned runtimes */
   namespaceProject?: Maybe<NamespaceProject>;
 }
@@ -2085,8 +1339,6 @@ export interface NamespacesProjectsCreateInput {
   name: Scalars['String']['input'];
   /** The id of the namespace which this project will belong to */
   namespaceId: Scalars['NamespaceID']['input'];
-  /** Slug for the new project. */
-  slug?: InputMaybe<Scalars['String']['input']>;
 }
 
 /** Autogenerated return type of NamespacesProjectsCreate. */
@@ -2095,7 +1347,7 @@ export interface NamespacesProjectsCreatePayload {
   /** A unique identifier for the client performing the mutation. */
   clientMutationId?: Maybe<Scalars['String']['output']>;
   /** Errors encountered during execution of the mutation. */
-  errors?: Maybe<Array<Error>>;
+  errors: Array<Error>;
   /** The newly created project. */
   namespaceProject?: Maybe<NamespaceProject>;
 }
@@ -2114,7 +1366,7 @@ export interface NamespacesProjectsDeletePayload {
   /** A unique identifier for the client performing the mutation. */
   clientMutationId?: Maybe<Scalars['String']['output']>;
   /** Errors encountered during execution of the mutation. */
-  errors?: Maybe<Array<Error>>;
+  errors: Array<Error>;
   /** The deleted project. */
   namespaceProject?: Maybe<NamespaceProject>;
 }
@@ -2135,7 +1387,7 @@ export interface NamespacesProjectsFlowsCreatePayload {
   /** A unique identifier for the client performing the mutation. */
   clientMutationId?: Maybe<Scalars['String']['output']>;
   /** Errors encountered during execution of the mutation. */
-  errors?: Maybe<Array<Error>>;
+  errors: Array<Error>;
   /** The newly created flow. */
   flow?: Maybe<Flow>;
 }
@@ -2154,32 +1406,11 @@ export interface NamespacesProjectsFlowsDeletePayload {
   /** A unique identifier for the client performing the mutation. */
   clientMutationId?: Maybe<Scalars['String']['output']>;
   /** Errors encountered during execution of the mutation. */
-  errors?: Maybe<Array<Error>>;
+  errors: Array<Error>;
   /** The deleted flow. */
   flow?: Maybe<Flow>;
 }
 
-/** Autogenerated input type of NamespacesProjectsFlowsUpdate */
-export interface NamespacesProjectsFlowsUpdateInput {
-  /** A unique identifier for the client performing the mutation. */
-  clientMutationId?: InputMaybe<Scalars['String']['input']>;
-  /** The ID of the flow to update */
-  flowId: Scalars['FlowID']['input'];
-  /** The updated flow */
-  flowInput: FlowInput;
-}
-
-/** Autogenerated return type of NamespacesProjectsFlowsUpdate. */
-export interface NamespacesProjectsFlowsUpdatePayload {
-  __typename?: 'NamespacesProjectsFlowsUpdatePayload';
-  /** A unique identifier for the client performing the mutation. */
-  clientMutationId?: Maybe<Scalars['String']['output']>;
-  /** Errors encountered during execution of the mutation. */
-  errors?: Maybe<Array<Error>>;
-  /** The updated flow. */
-  flow?: Maybe<Flow>;
-}
-
 /** Autogenerated input type of NamespacesProjectsUpdate */
 export interface NamespacesProjectsUpdateInput {
   /** A unique identifier for the client performing the mutation. */
@@ -2192,8 +1423,6 @@ export interface NamespacesProjectsUpdateInput {
   namespaceProjectId: Scalars['NamespaceProjectID']['input'];
   /** The primary runtime for the updated project. */
   primaryRuntimeId?: InputMaybe<Scalars['RuntimeID']['input']>;
-  /** Slug for the updated project. */
-  slug?: InputMaybe<Scalars['String']['input']>;
 }
 
 /** Autogenerated return type of NamespacesProjectsUpdate. */
@@ -2202,7 +1431,7 @@ export interface NamespacesProjectsUpdatePayload {
   /** A unique identifier for the client performing the mutation. */
   clientMutationId?: Maybe<Scalars['String']['output']>;
   /** Errors encountered during execution of the mutation. */
-  errors?: Maybe<Array<Error>>;
+  errors: Array<Error>;
   /** The updated project. */
   namespaceProject?: Maybe<NamespaceProject>;
 }
@@ -2225,7 +1454,7 @@ export interface NamespacesRolesAssignAbilitiesPayload {
   /** A unique identifier for the client performing the mutation. */
   clientMutationId?: Maybe<Scalars['String']['output']>;
   /** Errors encountered during execution of the mutation. */
-  errors?: Maybe<Array<Error>>;
+  errors: Array<Error>;
 }
 
 /** Autogenerated input type of NamespacesRolesAssignProjects */
@@ -2244,7 +1473,7 @@ export interface NamespacesRolesAssignProjectsPayload {
   /** A unique identifier for the client performing the mutation. */
   clientMutationId?: Maybe<Scalars['String']['output']>;
   /** Errors encountered during execution of the mutation. */
-  errors?: Maybe<Array<Error>>;
+  errors: Array<Error>;
   /** The now assigned projects */
   projects?: Maybe<Array<NamespaceProject>>;
 }
@@ -2265,7 +1494,7 @@ export interface NamespacesRolesCreatePayload {
   /** A unique identifier for the client performing the mutation. */
   clientMutationId?: Maybe<Scalars['String']['output']>;
   /** Errors encountered during execution of the mutation. */
-  errors?: Maybe<Array<Error>>;
+  errors: Array<Error>;
   /** The newly created namespace role */
   namespaceRole?: Maybe<NamespaceRole>;
 }
@@ -2284,7 +1513,7 @@ export interface NamespacesRolesDeletePayload {
   /** A unique identifier for the client performing the mutation. */
   clientMutationId?: Maybe<Scalars['String']['output']>;
   /** Errors encountered during execution of the mutation. */
-  errors?: Maybe<Array<Error>>;
+  errors: Array<Error>;
   /** The deleted namespace role */
   namespaceRole?: Maybe<NamespaceRole>;
 }
@@ -2305,7 +1534,7 @@ export interface NamespacesRolesUpdatePayload {
   /** A unique identifier for the client performing the mutation. */
   clientMutationId?: Maybe<Scalars['String']['output']>;
   /** Errors encountered during execution of the mutation. */
-  errors?: Maybe<Array<Error>>;
+  errors: Array<Error>;
   /** The updated namespace role. */
   namespaceRole?: Maybe<NamespaceRole>;
 }
@@ -2313,24 +1542,24 @@ export interface NamespacesRolesUpdatePayload {
 /** An object with an ID. */
 export interface Node {
   /** ID of the object. */
-  id?: Maybe<Scalars['ID']['output']>;
+  id: Scalars['ID']['output'];
 }
 
 /** Represents a Node Function */
 export interface NodeFunction {
   __typename?: 'NodeFunction';
   /** Time when this NodeFunction was created */
-  createdAt?: Maybe<Scalars['Time']['output']>;
-  /** The definition of the Node Function */
-  functionDefinition?: Maybe<FunctionDefinition>;
+  createdAt: Scalars['Time']['output'];
   /** Global ID of this NodeFunction */
-  id?: Maybe<Scalars['NodeFunctionID']['output']>;
-  /** The ID of the next Node Function in the flow */
-  nextNodeId?: Maybe<Scalars['NodeFunctionID']['output']>;
+  id: Scalars['NodeFunctionID']['output'];
+  /** The next Node Function in the flow */
+  nextNode?: Maybe<NodeFunction>;
   /** The parameters of the Node Function */
-  parameters?: Maybe<NodeParameterConnection>;
+  parameters: NodeParameterConnection;
+  /** The definition of the Node Function */
+  runtimeFunction: RuntimeFunctionDefinition;
   /** Time when this NodeFunction was last updated */
-  updatedAt?: Maybe<Scalars['Time']['output']>;
+  updatedAt: Scalars['Time']['output'];
 }
 
 
@@ -2342,41 +1571,10 @@ export interface NodeFunctionParametersArgs {
   last?: InputMaybe<Scalars['Int']['input']>;
 }
 
-/** The connection type for NodeFunction. */
-export interface NodeFunctionConnection {
-  __typename?: 'NodeFunctionConnection';
-  /** Total count of collection. */
-  count?: Maybe<Scalars['Int']['output']>;
-  /** A list of edges. */
-  edges?: Maybe<Array<Maybe<NodeFunctionEdge>>>;
-  /** A list of nodes. */
-  nodes?: Maybe<Array<Maybe<NodeFunction>>>;
-  /** Information to aid in pagination. */
-  pageInfo?: Maybe<PageInfo>;
-}
-
-/** An edge in a connection. */
-export interface NodeFunctionEdge {
-  __typename?: 'NodeFunctionEdge';
-  /** A cursor for use in pagination. */
-  cursor?: Maybe<Scalars['String']['output']>;
-  /** The item at the end of the edge. */
-  node?: Maybe<NodeFunction>;
-}
-
-/** Represents a Node Function id wrapper. */
-export interface NodeFunctionIdWrapper {
-  __typename?: 'NodeFunctionIdWrapper';
-  /** Global ID of this NodeFunctionIdWrapper */
-  id?: Maybe<Scalars['NodeFunctionID']['output']>;
-}
-
 /** Input type for a Node Function */
 export interface NodeFunctionInput {
-  /** The identifier of the Node Function used to create/update the flow */
-  id: Scalars['NodeFunctionID']['input'];
   /** The next Node Function in the flow */
-  nextNodeId?: InputMaybe<Scalars['NodeFunctionID']['input']>;
+  nextNode?: InputMaybe<NodeFunctionInput>;
   /** The parameters of the Node Function */
   parameters: Array<NodeParameterInput>;
   /** The identifier of the Runtime Function Definition */
@@ -2387,13 +1585,13 @@ export interface NodeFunctionInput {
 export interface NodeParameter {
   __typename?: 'NodeParameter';
   /** Time when this NodeParameter was created */
-  createdAt?: Maybe<Scalars['Time']['output']>;
+  createdAt: Scalars['Time']['output'];
   /** Global ID of this NodeParameter */
-  id?: Maybe<Scalars['NodeParameterID']['output']>;
+  id: Scalars['NodeParameterID']['output'];
   /** The definition of the parameter */
-  runtimeParameter?: Maybe<RuntimeParameterDefinition>;
+  runtimeParameter: RuntimeParameterDefinition;
   /** Time when this NodeParameter was last updated */
-  updatedAt?: Maybe<Scalars['Time']['output']>;
+  updatedAt: Scalars['Time']['output'];
   /** The value of the parameter */
   value?: Maybe<NodeParameterValue>;
 }
@@ -2402,20 +1600,20 @@ export interface NodeParameter {
 export interface NodeParameterConnection {
   __typename?: 'NodeParameterConnection';
   /** Total count of collection. */
-  count?: Maybe<Scalars['Int']['output']>;
+  count: Scalars['Int']['output'];
   /** A list of edges. */
   edges?: Maybe<Array<Maybe<NodeParameterEdge>>>;
   /** A list of nodes. */
   nodes?: Maybe<Array<Maybe<NodeParameter>>>;
   /** Information to aid in pagination. */
-  pageInfo?: Maybe<PageInfo>;
+  pageInfo: PageInfo;
 }
 
 /** An edge in a connection. */
 export interface NodeParameterEdge {
   __typename?: 'NodeParameterEdge';
   /** A cursor for use in pagination. */
-  cursor?: Maybe<Scalars['String']['output']>;
+  cursor: Scalars['String']['output'];
   /** The item at the end of the edge. */
   node?: Maybe<NodeParameter>;
 }
@@ -2429,83 +1627,42 @@ export interface NodeParameterInput {
 }
 
 /** Represents a parameter value for a node. */
-export type NodeParameterValue = LiteralValue | NodeFunctionIdWrapper | ReferenceValue;
+export type NodeParameterValue = LiteralValue | NodeFunction | ReferenceValue;
 
 /** Input type for parameter value */
 export interface NodeParameterValueInput {
+  /** The function value of the parameter */
+  functionValue?: InputMaybe<NodeFunctionInput>;
   /** The literal value of the parameter */
   literalValue?: InputMaybe<Scalars['JSON']['input']>;
-  /** The function value of the parameter as an id */
-  nodeFunctionId?: InputMaybe<Scalars['NodeFunctionID']['input']>;
   /** The reference value of the parameter */
   referenceValue?: InputMaybe<ReferenceValueInput>;
 }
 
-/** Represents an OIDC identity provider configuration */
-export interface OidcIdentityProviderConfig {
-  __typename?: 'OidcIdentityProviderConfig';
-  /** List of attribute statements for the OIDC identity provider */
-  attributeStatements?: Maybe<Scalars['JSON']['output']>;
-  /** The authorization URL for the OIDC identity provider */
-  authorizationUrl?: Maybe<Scalars['String']['output']>;
-  /** The client ID for the OIDC identity provider */
-  clientId?: Maybe<Scalars['String']['output']>;
-  /** The client secret for the OIDC identity provider */
-  clientSecret?: Maybe<Scalars['String']['output']>;
-  /** The name of the OIDC identity provider */
-  providerName?: Maybe<Scalars['String']['output']>;
-  /** The redirect URI for the OIDC identity provider */
-  redirectUri?: Maybe<Scalars['String']['output']>;
-  /** The user details URL for the OIDC identity provider */
-  userDetailsUrl?: Maybe<Scalars['String']['output']>;
+/** Represents a rule that can be applied to a data type. */
+export interface NumberRangeConfig {
+  __typename?: 'NumberRangeConfig';
+  /** The minimum value of the range */
+  from: Scalars['Int']['output'];
+  /** The step value for the range, if applicable */
+  steps?: Maybe<Scalars['Int']['output']>;
+  /** The maximum value of the range */
+  to: Scalars['Int']['output'];
 }
 
 /** Represents a Organization */
 export interface Organization {
   __typename?: 'Organization';
   /** Time when this Organization was created */
-  createdAt?: Maybe<Scalars['Time']['output']>;
+  createdAt: Scalars['Time']['output'];
   /** Global ID of this Organization */
-  id?: Maybe<Scalars['OrganizationID']['output']>;
+  id: Scalars['OrganizationID']['output'];
   /** Name of the organization */
-  name?: Maybe<Scalars['String']['output']>;
+  name: Scalars['String']['output'];
   /** Namespace of this organization */
-  namespace?: Maybe<Namespace>;
+  namespace: Namespace;
   /** Time when this Organization was last updated */
-  updatedAt?: Maybe<Scalars['Time']['output']>;
-  /** Abilities for the current user on this Organization */
-  userAbilities?: Maybe<OrganizationUserAbilities>;
-}
-
-/** The connection type for Organization. */
-export interface OrganizationConnection {
-  __typename?: 'OrganizationConnection';
-  /** Total count of collection. */
-  count?: Maybe<Scalars['Int']['output']>;
-  /** A list of edges. */
-  edges?: Maybe<Array<Maybe<OrganizationEdge>>>;
-  /** A list of nodes. */
-  nodes?: Maybe<Array<Maybe<Organization>>>;
-  /** Information to aid in pagination. */
-  pageInfo?: Maybe<PageInfo>;
-}
-
-/** An edge in a connection. */
-export interface OrganizationEdge {
-  __typename?: 'OrganizationEdge';
-  /** A cursor for use in pagination. */
-  cursor?: Maybe<Scalars['String']['output']>;
-  /** The item at the end of the edge. */
-  node?: Maybe<Organization>;
-}
-
-/** Abilities for the current user on this Organization */
-export interface OrganizationUserAbilities {
-  __typename?: 'OrganizationUserAbilities';
-  /** Shows if the current user has the `delete_organization` ability on this Organization */
-  deleteOrganization?: Maybe<Scalars['Boolean']['output']>;
-  /** Shows if the current user has the `update_organization` ability on this Organization */
-  updateOrganization?: Maybe<Scalars['Boolean']['output']>;
+  updatedAt: Scalars['Time']['output'];
 }
 
 /** Autogenerated input type of OrganizationsCreate */
@@ -2522,7 +1679,7 @@ export interface OrganizationsCreatePayload {
   /** A unique identifier for the client performing the mutation. */
   clientMutationId?: Maybe<Scalars['String']['output']>;
   /** Errors encountered during execution of the mutation. */
-  errors?: Maybe<Array<Error>>;
+  errors: Array<Error>;
   /** The newly created organization. */
   organization?: Maybe<Organization>;
 }
@@ -2541,7 +1698,7 @@ export interface OrganizationsDeletePayload {
   /** A unique identifier for the client performing the mutation. */
   clientMutationId?: Maybe<Scalars['String']['output']>;
   /** Errors encountered during execution of the mutation. */
-  errors?: Maybe<Array<Error>>;
+  errors: Array<Error>;
   /** The deleted organization. */
   organization?: Maybe<Organization>;
 }
@@ -2562,7 +1719,7 @@ export interface OrganizationsUpdatePayload {
   /** A unique identifier for the client performing the mutation. */
   clientMutationId?: Maybe<Scalars['String']['output']>;
   /** Errors encountered during execution of the mutation. */
-  errors?: Maybe<Array<Error>>;
+  errors: Array<Error>;
   /** The updated organization. */
   organization?: Maybe<Organization>;
 }
@@ -2573,69 +1730,26 @@ export interface PageInfo {
   /** When paginating forwards, the cursor to continue. */
   endCursor?: Maybe<Scalars['String']['output']>;
   /** When paginating forwards, are there more items? */
-  hasNextPage?: Maybe<Scalars['Boolean']['output']>;
+  hasNextPage: Scalars['Boolean']['output'];
   /** When paginating backwards, are there more items? */
-  hasPreviousPage?: Maybe<Scalars['Boolean']['output']>;
+  hasPreviousPage: Scalars['Boolean']['output'];
   /** When paginating backwards, the cursor to continue. */
   startCursor?: Maybe<Scalars['String']['output']>;
 }
 
-/** Represents a parameter definition */
-export interface ParameterDefinition {
-  __typename?: 'ParameterDefinition';
-  /** Time when this ParameterDefinition was created */
-  createdAt?: Maybe<Scalars['Time']['output']>;
-  /** Data type of the parameter */
-  dataTypeIdentifier?: Maybe<DataTypeIdentifier>;
-  /** Description of the parameter */
-  descriptions?: Maybe<Array<Translation>>;
-  /** Documentation of the parameter */
-  documentations?: Maybe<Array<Translation>>;
-  /** Global ID of this ParameterDefinition */
-  id?: Maybe<Scalars['ParameterDefinitionID']['output']>;
-  /** Identifier of the parameter */
-  identifier?: Maybe<Scalars['String']['output']>;
-  /** Name of the parameter */
-  names?: Maybe<Array<Translation>>;
-  /** Time when this ParameterDefinition was last updated */
-  updatedAt?: Maybe<Scalars['Time']['output']>;
-}
-
-/** The connection type for ParameterDefinition. */
-export interface ParameterDefinitionConnection {
-  __typename?: 'ParameterDefinitionConnection';
-  /** Total count of collection. */
-  count?: Maybe<Scalars['Int']['output']>;
-  /** A list of edges. */
-  edges?: Maybe<Array<Maybe<ParameterDefinitionEdge>>>;
-  /** A list of nodes. */
-  nodes?: Maybe<Array<Maybe<ParameterDefinition>>>;
-  /** Information to aid in pagination. */
-  pageInfo?: Maybe<PageInfo>;
-}
-
-/** An edge in a connection. */
-export interface ParameterDefinitionEdge {
-  __typename?: 'ParameterDefinitionEdge';
-  /** A cursor for use in pagination. */
-  cursor?: Maybe<Scalars['String']['output']>;
-  /** The item at the end of the edge. */
-  node?: Maybe<ParameterDefinition>;
-}
-
 /** Root Query type */
 export interface Query {
   __typename?: 'Query';
-  /** Get application information */
-  application?: Maybe<Application>;
+  /** Get global application settings */
+  applicationSettings?: Maybe<ApplicationSettings>;
   /** Get the currently logged in authentication */
   currentAuthentication?: Maybe<Authentication>;
   /** Get the currently logged in user */
   currentUser?: Maybe<User>;
   /** Field available for use to test API access */
-  echo?: Maybe<Scalars['String']['output']>;
+  echo: Scalars['String']['output'];
   /** Find runtimes */
-  globalRuntimes?: Maybe<RuntimeConnection>;
+  globalRuntimes: RuntimeConnection;
   /** Find a namespace */
   namespace?: Maybe<Namespace>;
   /** Fetches an object given its ID */
@@ -2644,12 +1758,8 @@ export interface Query {
   nodes?: Maybe<Array<Maybe<Node>>>;
   /** Find a organization */
   organization?: Maybe<Organization>;
-  /** Find organizations */
-  organizations?: Maybe<OrganizationConnection>;
-  /** Find a user */
-  user?: Maybe<User>;
   /** Find users */
-  users?: Maybe<UserConnection>;
+  users: UserConnection;
 }
 
 
@@ -2693,22 +1803,6 @@ export interface QueryOrganizationArgs {
 }
 
 
-/** Root Query type */
-export interface QueryOrganizationsArgs {
-  after?: InputMaybe<Scalars['String']['input']>;
-  before?: InputMaybe<Scalars['String']['input']>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-}
-
-
-/** Root Query type */
-export interface QueryUserArgs {
-  id?: InputMaybe<Scalars['UserID']['input']>;
-  username?: InputMaybe<Scalars['String']['input']>;
-}
-
-
 /** Root Query type */
 export interface QueryUsersArgs {
   after?: InputMaybe<Scalars['String']['input']>;
@@ -2723,13 +1817,13 @@ export interface ReferencePath {
   /** The array index of the referenced data by the path */
   arrayIndex?: Maybe<Scalars['Int']['output']>;
   /** Time when this ReferencePath was created */
-  createdAt?: Maybe<Scalars['Time']['output']>;
+  createdAt: Scalars['Time']['output'];
   /** Global ID of this ReferencePath */
-  id?: Maybe<Scalars['ReferencePathID']['output']>;
+  id: Scalars['ReferencePathID']['output'];
   /** The path to the reference in the flow */
   path?: Maybe<Scalars['String']['output']>;
   /** Time when this ReferencePath was last updated */
-  updatedAt?: Maybe<Scalars['Time']['output']>;
+  updatedAt: Scalars['Time']['output'];
 }
 
 /** Input type for reference path */
@@ -2744,70 +1838,76 @@ export interface ReferencePathInput {
 export interface ReferenceValue {
   __typename?: 'ReferenceValue';
   /** Time when this ReferenceValue was created */
-  createdAt?: Maybe<Scalars['Time']['output']>;
+  createdAt: Scalars['Time']['output'];
   /** The identifier of the data type this reference value belongs to. */
-  dataTypeIdentifier?: Maybe<DataTypeIdentifier>;
-  /** The depth of the reference value. */
-  depth?: Maybe<Scalars['Int']['output']>;
+  dataTypeIdentifier: DataTypeIdentifier;
   /** Global ID of this ReferenceValue */
-  id?: Maybe<Scalars['ReferenceValueID']['output']>;
-  /** The node of the reference value. */
-  node?: Maybe<Scalars['Int']['output']>;
-  /** The referenced value. */
-  nodeFunctionId?: Maybe<Scalars['NodeFunctionID']['output']>;
+  id: Scalars['ReferenceValueID']['output'];
+  /** The primary level of the reference value. */
+  primaryLevel: Scalars['Int']['output'];
   /** The paths associated with this reference value. */
-  referencePath?: Maybe<Array<ReferencePath>>;
-  /** The scope of the reference value. */
-  scope?: Maybe<Array<Scalars['Int']['output']>>;
+  referencePath: Array<ReferencePath>;
+  /** The secondary level of the reference value. */
+  secondaryLevel: Scalars['Int']['output'];
+  /** The tertiary level of the reference value, if applicable. */
+  tertiaryLevel?: Maybe<Scalars['Int']['output']>;
   /** Time when this ReferenceValue was last updated */
-  updatedAt?: Maybe<Scalars['Time']['output']>;
+  updatedAt: Scalars['Time']['output'];
 }
 
 /** Input type for reference value */
 export interface ReferenceValueInput {
   /** The identifier of the data type this reference value belongs to */
   dataTypeIdentifier: DataTypeIdentifierInput;
-  /** The depth of the reference value */
-  depth: Scalars['Int']['input'];
-  /** The node of the reference */
-  node: Scalars['Int']['input'];
-  /** The referenced value */
-  nodeFunctionId: Scalars['NodeFunctionID']['input'];
+  /** The primary level of the reference value */
+  primaryLevel: Scalars['Int']['input'];
   /** The paths associated with this reference value */
   referencePath: Array<ReferencePathInput>;
-  /** The scope of the reference value */
-  scope: Array<Scalars['Int']['input']>;
+  /** The secondary level of the reference value */
+  secondaryLevel: Scalars['Int']['input'];
+  /** The tertiary level of the reference value */
+  tertiaryLevel?: InputMaybe<Scalars['Int']['input']>;
+}
+
+/** Represents a rule that can be applied to a data type. */
+export interface RegexConfig {
+  __typename?: 'RegexConfig';
+  /** The regex pattern to match against the data type value. */
+  pattern: Scalars['String']['output'];
+}
+
+/** Represents a rule that can be applied to a data type. */
+export interface ReturnTypeConfig {
+  __typename?: 'ReturnTypeConfig';
+  /** The data type identifier for the return type. */
+  dataTypeIdentifier: DataTypeIdentifier;
 }
 
 /** Represents a runtime */
 export interface Runtime {
   __typename?: 'Runtime';
   /** Time when this Runtime was created */
-  createdAt?: Maybe<Scalars['Time']['output']>;
+  createdAt: Scalars['Time']['output'];
   /** DataTypes of the runtime */
-  dataTypes?: Maybe<DataTypeConnection>;
+  dataTypes: DataTypeConnection;
   /** The description for the runtime if present */
-  description?: Maybe<Scalars['String']['output']>;
+  description: Scalars['String']['output'];
   /** FlowTypes of the runtime */
-  flowTypes?: Maybe<FlowTypeConnection>;
-  /** Function definitions of the runtime */
-  functionDefinitions?: Maybe<FunctionDefinitionConnection>;
+  flowTypes: FlowTypeConnection;
   /** Global ID of this Runtime */
-  id?: Maybe<Scalars['RuntimeID']['output']>;
+  id: Scalars['RuntimeID']['output'];
   /** The name for the runtime */
-  name?: Maybe<Scalars['String']['output']>;
+  name: Scalars['String']['output'];
   /** The parent namespace for the runtime */
   namespace?: Maybe<Namespace>;
   /** Projects associated with the runtime */
-  projects?: Maybe<NamespaceProjectConnection>;
+  projects: NamespaceProjectConnection;
   /** The status of the runtime */
-  status?: Maybe<RuntimeStatusType>;
+  status: RuntimeStatusType;
   /** Token belonging to the runtime, only present on creation */
   token?: Maybe<Scalars['String']['output']>;
   /** Time when this Runtime was last updated */
-  updatedAt?: Maybe<Scalars['Time']['output']>;
-  /** Abilities for the current user on this Runtime */
-  userAbilities?: Maybe<RuntimeUserAbilities>;
+  updatedAt: Scalars['Time']['output'];
 }
 
 
@@ -2829,15 +1929,6 @@ export interface RuntimeFlowTypesArgs {
 }
 
 
-/** Represents a runtime */
-export interface RuntimeFunctionDefinitionsArgs {
-  after?: InputMaybe<Scalars['String']['input']>;
-  before?: InputMaybe<Scalars['String']['input']>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-}
-
-
 /** Represents a runtime */
 export interface RuntimeProjectsArgs {
   after?: InputMaybe<Scalars['String']['input']>;
@@ -2850,115 +1941,54 @@ export interface RuntimeProjectsArgs {
 export interface RuntimeConnection {
   __typename?: 'RuntimeConnection';
   /** Total count of collection. */
-  count?: Maybe<Scalars['Int']['output']>;
+  count: Scalars['Int']['output'];
   /** A list of edges. */
   edges?: Maybe<Array<Maybe<RuntimeEdge>>>;
   /** A list of nodes. */
   nodes?: Maybe<Array<Maybe<Runtime>>>;
   /** Information to aid in pagination. */
-  pageInfo?: Maybe<PageInfo>;
+  pageInfo: PageInfo;
 }
 
 /** An edge in a connection. */
 export interface RuntimeEdge {
   __typename?: 'RuntimeEdge';
   /** A cursor for use in pagination. */
-  cursor?: Maybe<Scalars['String']['output']>;
+  cursor: Scalars['String']['output'];
   /** The item at the end of the edge. */
   node?: Maybe<Runtime>;
 }
 
-/** Represents a runtime function definition */
+/** Represents a Node Function definition */
 export interface RuntimeFunctionDefinition {
   __typename?: 'RuntimeFunctionDefinition';
   /** Time when this RuntimeFunctionDefinition was created */
-  createdAt?: Maybe<Scalars['Time']['output']>;
-  /** Function definitions of the runtime function definition */
-  functionDefinitions?: Maybe<FunctionDefinitionConnection>;
+  createdAt: Scalars['Time']['output'];
   /** Global ID of this RuntimeFunctionDefinition */
-  id?: Maybe<Scalars['RuntimeFunctionDefinitionID']['output']>;
-  /** Identifier of the runtime function definition */
-  identifier?: Maybe<Scalars['String']['output']>;
-  /** The runtime this runtime function definition belongs to */
-  runtime?: Maybe<Runtime>;
-  /** Parameter definitions of the runtime function definition */
-  runtimeParameterDefinitions?: Maybe<RuntimeParameterDefinitionConnection>;
+  id: Scalars['RuntimeParameterDefinitionID']['output'];
   /** Time when this RuntimeFunctionDefinition was last updated */
-  updatedAt?: Maybe<Scalars['Time']['output']>;
+  updatedAt: Scalars['Time']['output'];
 }
 
-
-/** Represents a runtime function definition */
-export interface RuntimeFunctionDefinitionFunctionDefinitionsArgs {
-  after?: InputMaybe<Scalars['String']['input']>;
-  before?: InputMaybe<Scalars['String']['input']>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-}
-
-
-/** Represents a runtime function definition */
-export interface RuntimeFunctionDefinitionRuntimeParameterDefinitionsArgs {
-  after?: InputMaybe<Scalars['String']['input']>;
-  before?: InputMaybe<Scalars['String']['input']>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-}
-
-/** Represents a runtime parameter definition */
+/** Represents a Node parameter definition */
 export interface RuntimeParameterDefinition {
   __typename?: 'RuntimeParameterDefinition';
   /** Time when this RuntimeParameterDefinition was created */
-  createdAt?: Maybe<Scalars['Time']['output']>;
+  createdAt: Scalars['Time']['output'];
   /** Global ID of this RuntimeParameterDefinition */
-  id?: Maybe<Scalars['RuntimeParameterDefinitionID']['output']>;
-  /** Identifier of the runtime parameter definition */
-  identifier?: Maybe<Scalars['String']['output']>;
+  id: Scalars['RuntimeParameterDefinitionID']['output'];
   /** Time when this RuntimeParameterDefinition was last updated */
-  updatedAt?: Maybe<Scalars['Time']['output']>;
-}
-
-/** The connection type for RuntimeParameterDefinition. */
-export interface RuntimeParameterDefinitionConnection {
-  __typename?: 'RuntimeParameterDefinitionConnection';
-  /** Total count of collection. */
-  count?: Maybe<Scalars['Int']['output']>;
-  /** A list of edges. */
-  edges?: Maybe<Array<Maybe<RuntimeParameterDefinitionEdge>>>;
-  /** A list of nodes. */
-  nodes?: Maybe<Array<Maybe<RuntimeParameterDefinition>>>;
-  /** Information to aid in pagination. */
-  pageInfo?: Maybe<PageInfo>;
-}
-
-/** An edge in a connection. */
-export interface RuntimeParameterDefinitionEdge {
-  __typename?: 'RuntimeParameterDefinitionEdge';
-  /** A cursor for use in pagination. */
-  cursor?: Maybe<Scalars['String']['output']>;
-  /** The item at the end of the edge. */
-  node?: Maybe<RuntimeParameterDefinition>;
+  updatedAt: Scalars['Time']['output'];
 }
 
 /** Represent all available types of statuses of a runtime */
-export const enum RuntimeStatusType {
+export enum RuntimeStatusType {
   /** No problem with connection, everything works as expected */
   Connected = 'CONNECTED',
   /** The runtime is disconnected, cause unknown */
   Disconnected = 'DISCONNECTED'
 }
 
-/** Abilities for the current user on this Runtime */
-export interface RuntimeUserAbilities {
-  __typename?: 'RuntimeUserAbilities';
-  /** Shows if the current user has the `delete_runtime` ability on this Runtime */
-  deleteRuntime?: Maybe<Scalars['Boolean']['output']>;
-  /** Shows if the current user has the `rotate_runtime_token` ability on this Runtime */
-  rotateRuntimeToken?: Maybe<Scalars['Boolean']['output']>;
-  /** Shows if the current user has the `update_runtime` ability on this Runtime */
-  updateRuntime?: Maybe<Scalars['Boolean']['output']>;
-}
-
 /** Autogenerated input type of RuntimesCreate */
 export interface RuntimesCreateInput {
   /** A unique identifier for the client performing the mutation. */
@@ -2977,7 +2007,7 @@ export interface RuntimesCreatePayload {
   /** A unique identifier for the client performing the mutation. */
   clientMutationId?: Maybe<Scalars['String']['output']>;
   /** Errors encountered during execution of the mutation. */
-  errors?: Maybe<Array<Error>>;
+  errors: Array<Error>;
   /** The newly created runtime. */
   runtime?: Maybe<Runtime>;
 }
@@ -2996,7 +2026,7 @@ export interface RuntimesDeletePayload {
   /** A unique identifier for the client performing the mutation. */
   clientMutationId?: Maybe<Scalars['String']['output']>;
   /** Errors encountered during execution of the mutation. */
-  errors?: Maybe<Array<Error>>;
+  errors: Array<Error>;
   /** The updated organization. */
   runtime?: Maybe<Runtime>;
 }
@@ -3015,7 +2045,7 @@ export interface RuntimesRotateTokenPayload {
   /** A unique identifier for the client performing the mutation. */
   clientMutationId?: Maybe<Scalars['String']['output']>;
   /** Errors encountered during execution of the mutation. */
-  errors?: Maybe<Array<Error>>;
+  errors: Array<Error>;
   /** The updated runtime. */
   runtime?: Maybe<Runtime>;
 }
@@ -3038,79 +2068,67 @@ export interface RuntimesUpdatePayload {
   /** A unique identifier for the client performing the mutation. */
   clientMutationId?: Maybe<Scalars['String']['output']>;
   /** Errors encountered during execution of the mutation. */
-  errors?: Maybe<Array<Error>>;
+  errors: Array<Error>;
   /** The updated runtime. */
   runtime?: Maybe<Runtime>;
 }
 
-/** Represents the configuration for a SAML identity provider. */
-export interface SamlIdentityProviderConfig {
-  __typename?: 'SamlIdentityProviderConfig';
-  /** List of attribute statements for the SAML identity provider */
-  attributeStatements?: Maybe<Scalars['JSON']['output']>;
-  /** The metadata url to fetch the metadatas (replacement for settings) */
-  metadataUrl?: Maybe<Scalars['String']['output']>;
-  /** The name of the SAML identity provider */
-  providerName?: Maybe<Scalars['String']['output']>;
-  /** The SAML response settings for the identity provider */
-  responseSettings?: Maybe<Scalars['JSON']['output']>;
-  /** The SAML settings for the identity provider */
-  settings?: Maybe<Scalars['JSON']['output']>;
-}
-
 /** Represents a translation */
 export interface Translation {
   __typename?: 'Translation';
   /** Code of the translation */
-  code?: Maybe<Scalars['String']['output']>;
+  code: Scalars['String']['output'];
   /** Content of the translation */
-  content?: Maybe<Scalars['String']['output']>;
+  content: Scalars['String']['output'];
+}
+
+/** The connection type for Translation. */
+export interface TranslationConnection {
+  __typename?: 'TranslationConnection';
+  /** Total count of collection. */
+  count: Scalars['Int']['output'];
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<TranslationEdge>>>;
+  /** A list of nodes. */
+  nodes?: Maybe<Array<Maybe<Translation>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+}
+
+/** An edge in a connection. */
+export interface TranslationEdge {
+  __typename?: 'TranslationEdge';
+  /** A cursor for use in pagination. */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge. */
+  node?: Maybe<Translation>;
 }
 
 /** Represents a user */
 export interface User {
   __typename?: 'User';
   /** Global admin status of the user */
-  admin?: Maybe<Scalars['Boolean']['output']>;
+  admin: Scalars['Boolean']['output'];
   /** The avatar if present of the user */
   avatarPath?: Maybe<Scalars['String']['output']>;
   /** Time when this User was created */
-  createdAt?: Maybe<Scalars['Time']['output']>;
+  createdAt: Scalars['Time']['output'];
   /** Email of the user */
-  email?: Maybe<Scalars['String']['output']>;
-  /** Email verification date of the user if present */
-  emailVerifiedAt?: Maybe<Scalars['Time']['output']>;
+  email: Scalars['String']['output'];
   /** Firstname of the user */
-  firstname?: Maybe<Scalars['String']['output']>;
+  firstname: Scalars['String']['output'];
   /** Global ID of this User */
-  id?: Maybe<Scalars['UserID']['output']>;
-  /** Identities of this user */
-  identities?: Maybe<UserIdentityConnection>;
+  id: Scalars['UserID']['output'];
   /** Lastname of the user */
-  lastname?: Maybe<Scalars['String']['output']>;
-  /** Multi-factor authentication status of this user */
-  mfaStatus?: Maybe<MfaStatus>;
+  lastname: Scalars['String']['output'];
   /** Namespace of this user */
   namespace?: Maybe<Namespace>;
   /** Namespace Memberships of this user */
-  namespaceMemberships?: Maybe<NamespaceMemberConnection>;
-  /** Sessions of this user */
-  sessions?: Maybe<UserSessionConnection>;
+  namespaceMemberships: NamespaceMemberConnection;
   /** Time when this User was last updated */
-  updatedAt?: Maybe<Scalars['Time']['output']>;
-  /** Abilities for the current user on this User */
-  userAbilities?: Maybe<UserUserAbilities>;
+  updatedAt: Scalars['Time']['output'];
   /** Username of the user */
-  username?: Maybe<Scalars['String']['output']>;
-}
-
-
-/** Represents a user */
-export interface UserIdentitiesArgs {
-  after?: InputMaybe<Scalars['String']['input']>;
-  before?: InputMaybe<Scalars['String']['input']>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
+  username: Scalars['String']['output'];
 }
 
 
@@ -3122,33 +2140,24 @@ export interface UserNamespaceMembershipsArgs {
   last?: InputMaybe<Scalars['Int']['input']>;
 }
 
-
-/** Represents a user */
-export interface UserSessionsArgs {
-  after?: InputMaybe<Scalars['String']['input']>;
-  before?: InputMaybe<Scalars['String']['input']>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-}
-
 /** The connection type for User. */
 export interface UserConnection {
   __typename?: 'UserConnection';
   /** Total count of collection. */
-  count?: Maybe<Scalars['Int']['output']>;
+  count: Scalars['Int']['output'];
   /** A list of edges. */
   edges?: Maybe<Array<Maybe<UserEdge>>>;
   /** A list of nodes. */
   nodes?: Maybe<Array<Maybe<User>>>;
   /** Information to aid in pagination. */
-  pageInfo?: Maybe<PageInfo>;
+  pageInfo: PageInfo;
 }
 
 /** An edge in a connection. */
 export interface UserEdge {
   __typename?: 'UserEdge';
   /** A cursor for use in pagination. */
-  cursor?: Maybe<Scalars['String']['output']>;
+  cursor: Scalars['String']['output'];
   /** The item at the end of the edge. */
   node?: Maybe<User>;
 }
@@ -3157,165 +2166,34 @@ export interface UserEdge {
 export interface UserIdentity {
   __typename?: 'UserIdentity';
   /** Time when this UserIdentity was created */
-  createdAt?: Maybe<Scalars['Time']['output']>;
+  createdAt: Scalars['Time']['output'];
   /** Global ID of this UserIdentity */
-  id?: Maybe<Scalars['UserIdentityID']['output']>;
+  id: Scalars['UserIdentityID']['output'];
   /** The description for the runtime if present */
-  identifier?: Maybe<Scalars['String']['output']>;
+  identifier: Scalars['String']['output'];
   /** The name for the runtime */
-  providerId?: Maybe<Scalars['String']['output']>;
+  providerId: Scalars['String']['output'];
   /** Time when this UserIdentity was last updated */
-  updatedAt?: Maybe<Scalars['Time']['output']>;
+  updatedAt: Scalars['Time']['output'];
   /** The correlating user of the identity */
-  user?: Maybe<User>;
-}
-
-/** The connection type for UserIdentity. */
-export interface UserIdentityConnection {
-  __typename?: 'UserIdentityConnection';
-  /** Total count of collection. */
-  count?: Maybe<Scalars['Int']['output']>;
-  /** A list of edges. */
-  edges?: Maybe<Array<Maybe<UserIdentityEdge>>>;
-  /** A list of nodes. */
-  nodes?: Maybe<Array<Maybe<UserIdentity>>>;
-  /** Information to aid in pagination. */
-  pageInfo?: Maybe<PageInfo>;
-}
-
-/** An edge in a connection. */
-export interface UserIdentityEdge {
-  __typename?: 'UserIdentityEdge';
-  /** A cursor for use in pagination. */
-  cursor?: Maybe<Scalars['String']['output']>;
-  /** The item at the end of the edge. */
-  node?: Maybe<UserIdentity>;
+  user: User;
 }
 
 /** Represents a user session */
 export interface UserSession {
   __typename?: 'UserSession';
   /** Whether or not the session is active and can be used */
-  active?: Maybe<Scalars['Boolean']['output']>;
+  active: Scalars['Boolean']['output'];
   /** Time when this UserSession was created */
-  createdAt?: Maybe<Scalars['Time']['output']>;
+  createdAt: Scalars['Time']['output'];
   /** Global ID of this UserSession */
-  id?: Maybe<Scalars['UserSessionID']['output']>;
+  id: Scalars['UserSessionID']['output'];
   /** Token belonging to the session, only present on creation */
   token?: Maybe<Scalars['String']['output']>;
   /** Time when this UserSession was last updated */
-  updatedAt?: Maybe<Scalars['Time']['output']>;
+  updatedAt: Scalars['Time']['output'];
   /** User that belongs to the session */
-  user?: Maybe<User>;
-  /** Abilities for the current user on this UserSession */
-  userAbilities?: Maybe<UserSessionUserAbilities>;
-}
-
-/** The connection type for UserSession. */
-export interface UserSessionConnection {
-  __typename?: 'UserSessionConnection';
-  /** Total count of collection. */
-  count?: Maybe<Scalars['Int']['output']>;
-  /** A list of edges. */
-  edges?: Maybe<Array<Maybe<UserSessionEdge>>>;
-  /** A list of nodes. */
-  nodes?: Maybe<Array<Maybe<UserSession>>>;
-  /** Information to aid in pagination. */
-  pageInfo?: Maybe<PageInfo>;
-}
-
-/** An edge in a connection. */
-export interface UserSessionEdge {
-  __typename?: 'UserSessionEdge';
-  /** A cursor for use in pagination. */
-  cursor?: Maybe<Scalars['String']['output']>;
-  /** The item at the end of the edge. */
-  node?: Maybe<UserSession>;
-}
-
-/** Abilities for the current user on this UserSession */
-export interface UserSessionUserAbilities {
-  __typename?: 'UserSessionUserAbilities';
-  /** Shows if the current user has the `logout_session` ability on this UserSession */
-  logoutSession?: Maybe<Scalars['Boolean']['output']>;
-}
-
-/** Abilities for the current user on this User */
-export interface UserUserAbilities {
-  __typename?: 'UserUserAbilities';
-  /** Shows if the current user has the `manage_mfa` ability on this User */
-  manageMfa?: Maybe<Scalars['Boolean']['output']>;
-  /** Shows if the current user has the `update_user` ability on this User */
-  updateUser?: Maybe<Scalars['Boolean']['output']>;
-}
-
-/** Autogenerated input type of UsersCreate */
-export interface UsersCreateInput {
-  /** Admin status for the user. */
-  admin?: InputMaybe<Scalars['Boolean']['input']>;
-  /** A unique identifier for the client performing the mutation. */
-  clientMutationId?: InputMaybe<Scalars['String']['input']>;
-  /** Email for the user. */
-  email: Scalars['String']['input'];
-  /** Firstname for the user. */
-  firstname?: InputMaybe<Scalars['String']['input']>;
-  /** Lastname for the user. */
-  lastname?: InputMaybe<Scalars['String']['input']>;
-  /** Password for the user. */
-  password: Scalars['String']['input'];
-  /** Password repeat for the user to check for typos. */
-  passwordRepeat: Scalars['String']['input'];
-  /** Username for the user. */
-  username: Scalars['String']['input'];
-}
-
-/** Autogenerated return type of UsersCreate. */
-export interface UsersCreatePayload {
-  __typename?: 'UsersCreatePayload';
-  /** A unique identifier for the client performing the mutation. */
-  clientMutationId?: Maybe<Scalars['String']['output']>;
-  /** Errors encountered during execution of the mutation. */
-  errors?: Maybe<Array<Error>>;
-  /** The created user. */
-  user?: Maybe<User>;
-}
-
-/** Autogenerated input type of UsersDelete */
-export interface UsersDeleteInput {
-  /** A unique identifier for the client performing the mutation. */
-  clientMutationId?: InputMaybe<Scalars['String']['input']>;
-  /** The user to delete. */
-  userId: Scalars['UserID']['input'];
-}
-
-/** Autogenerated return type of UsersDelete. */
-export interface UsersDeletePayload {
-  __typename?: 'UsersDeletePayload';
-  /** A unique identifier for the client performing the mutation. */
-  clientMutationId?: Maybe<Scalars['String']['output']>;
-  /** Errors encountered during execution of the mutation. */
-  errors?: Maybe<Array<Error>>;
-  /** The deleted user. */
-  user?: Maybe<User>;
-}
-
-/** Autogenerated input type of UsersEmailVerification */
-export interface UsersEmailVerificationInput {
-  /** A unique identifier for the client performing the mutation. */
-  clientMutationId?: InputMaybe<Scalars['String']['input']>;
-  /** The email verification token */
-  token: Scalars['String']['input'];
-}
-
-/** Autogenerated return type of UsersEmailVerification. */
-export interface UsersEmailVerificationPayload {
-  __typename?: 'UsersEmailVerificationPayload';
-  /** A unique identifier for the client performing the mutation. */
-  clientMutationId?: Maybe<Scalars['String']['output']>;
-  /** Errors encountered during execution of the mutation. */
-  errors?: Maybe<Array<Error>>;
-  /** The user whose email was verified */
-  user?: Maybe<User>;
+  user: User;
 }
 
 /** Autogenerated input type of UsersIdentityLink */
@@ -3334,7 +2212,7 @@ export interface UsersIdentityLinkPayload {
   /** A unique identifier for the client performing the mutation. */
   clientMutationId?: Maybe<Scalars['String']['output']>;
   /** Errors encountered during execution of the mutation. */
-  errors?: Maybe<Array<Error>>;
+  errors: Array<Error>;
   /** The created user identity */
   userIdentity?: Maybe<UserIdentity>;
 }
@@ -3355,7 +2233,7 @@ export interface UsersIdentityLoginPayload {
   /** A unique identifier for the client performing the mutation. */
   clientMutationId?: Maybe<Scalars['String']['output']>;
   /** Errors encountered during execution of the mutation. */
-  errors?: Maybe<Array<Error>>;
+  errors: Array<Error>;
   /** The created user session */
   userSession?: Maybe<UserSession>;
 }
@@ -3376,7 +2254,7 @@ export interface UsersIdentityRegisterPayload {
   /** A unique identifier for the client performing the mutation. */
   clientMutationId?: Maybe<Scalars['String']['output']>;
   /** Errors encountered during execution of the mutation. */
-  errors?: Maybe<Array<Error>>;
+  errors: Array<Error>;
   /** The created users session */
   userSession?: Maybe<UserSession>;
 }
@@ -3395,7 +2273,7 @@ export interface UsersIdentityUnlinkPayload {
   /** A unique identifier for the client performing the mutation. */
   clientMutationId?: Maybe<Scalars['String']['output']>;
   /** Errors encountered during execution of the mutation. */
-  errors?: Maybe<Array<Error>>;
+  errors: Array<Error>;
   /** The removed identity */
   userIdentity?: Maybe<UserIdentity>;
 }
@@ -3420,7 +2298,7 @@ export interface UsersLoginPayload {
   /** A unique identifier for the client performing the mutation. */
   clientMutationId?: Maybe<Scalars['String']['output']>;
   /** Errors encountered during execution of the mutation. */
-  errors?: Maybe<Array<Error>>;
+  errors: Array<Error>;
   /** The created user session */
   userSession?: Maybe<UserSession>;
 }
@@ -3439,7 +2317,7 @@ export interface UsersLogoutPayload {
   /** A unique identifier for the client performing the mutation. */
   clientMutationId?: Maybe<Scalars['String']['output']>;
   /** Errors encountered during execution of the mutation. */
-  errors?: Maybe<Array<Error>>;
+  errors: Array<Error>;
   /** The logged out user session */
   userSession?: Maybe<UserSession>;
 }
@@ -3458,7 +2336,7 @@ export interface UsersMfaBackupCodesRotatePayload {
   /** The newly rotated backup codes. */
   codes?: Maybe<Array<Scalars['String']['output']>>;
   /** Errors encountered during execution of the mutation. */
-  errors?: Maybe<Array<Error>>;
+  errors: Array<Error>;
 }
 
 /** Autogenerated input type of UsersMfaTotpGenerateSecret */
@@ -3473,7 +2351,7 @@ export interface UsersMfaTotpGenerateSecretPayload {
   /** A unique identifier for the client performing the mutation. */
   clientMutationId?: Maybe<Scalars['String']['output']>;
   /** Errors encountered during execution of the mutation. */
-  errors?: Maybe<Array<Error>>;
+  errors: Array<Error>;
   /** The created and signed secret */
   secret?: Maybe<Scalars['String']['output']>;
 }
@@ -3497,53 +2375,11 @@ export interface UsersMfaTotpValidateSecretPayload {
   /** A unique identifier for the client performing the mutation. */
   clientMutationId?: Maybe<Scalars['String']['output']>;
   /** Errors encountered during execution of the mutation. */
-  errors?: Maybe<Array<Error>>;
+  errors: Array<Error>;
   /** The modified user */
   user?: Maybe<User>;
 }
 
-/** Autogenerated input type of UsersPasswordReset */
-export interface UsersPasswordResetInput {
-  /** A unique identifier for the client performing the mutation. */
-  clientMutationId?: InputMaybe<Scalars['String']['input']>;
-  /** The new password to set for the user */
-  newPassword: Scalars['String']['input'];
-  /** The confirmation of the new password to set for the user needs to be the same as the new password */
-  newPasswordConfirmation: Scalars['String']['input'];
-  /** The password reset token sent to the user email */
-  resetToken: Scalars['String']['input'];
-}
-
-/** Autogenerated return type of UsersPasswordReset. */
-export interface UsersPasswordResetPayload {
-  __typename?: 'UsersPasswordResetPayload';
-  /** A unique identifier for the client performing the mutation. */
-  clientMutationId?: Maybe<Scalars['String']['output']>;
-  /** Errors encountered during execution of the mutation. */
-  errors?: Maybe<Array<Error>>;
-  /** A message indicating the result of the password reset request */
-  message?: Maybe<Scalars['String']['output']>;
-}
-
-/** Autogenerated input type of UsersPasswordResetRequest */
-export interface UsersPasswordResetRequestInput {
-  /** A unique identifier for the client performing the mutation. */
-  clientMutationId?: InputMaybe<Scalars['String']['input']>;
-  /** Email of the user to reset the password */
-  email: Scalars['String']['input'];
-}
-
-/** Autogenerated return type of UsersPasswordResetRequest. */
-export interface UsersPasswordResetRequestPayload {
-  __typename?: 'UsersPasswordResetRequestPayload';
-  /** A unique identifier for the client performing the mutation. */
-  clientMutationId?: Maybe<Scalars['String']['output']>;
-  /** Errors encountered during execution of the mutation. */
-  errors?: Maybe<Array<Error>>;
-  /** A message indicating the result of the password reset request */
-  message?: Maybe<Scalars['String']['output']>;
-}
-
 /** Autogenerated input type of UsersRegister */
 export interface UsersRegisterInput {
   /** A unique identifier for the client performing the mutation. */
@@ -3564,7 +2400,7 @@ export interface UsersRegisterPayload {
   /** A unique identifier for the client performing the mutation. */
   clientMutationId?: Maybe<Scalars['String']['output']>;
   /** Errors encountered during execution of the mutation. */
-  errors?: Maybe<Array<Error>>;
+  errors: Array<Error>;
   /** The created users session */
   userSession?: Maybe<UserSession>;
 }
@@ -3599,7 +2435,7 @@ export interface UsersUpdatePayload {
   /** A unique identifier for the client performing the mutation. */
   clientMutationId?: Maybe<Scalars['String']['output']>;
   /** Errors encountered during execution of the mutation. */
-  errors?: Maybe<Array<Error>>;
+  errors: Array<Error>;
   /** The updated user. */
   user?: Maybe<User>;
 }