@code0-tech/sagittarius-graphql-types 0.0.0-6f0b32a0eb18c9c3569a090f089c6adf1b4d666c → 0.0.0-f91466f0f343596ad170e7e5c5316a70b072594d

package/index.d.ts

@@ -7,41 +7,73 @@ export type MakeEmpty<T extends { [key: string]: unknown }, K extends keyof T> =
 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: string; output: string; }
+  ID: { input: `gid://sagittarius//${number}`; output: `gid://sagittarius//${number}`; }
   String: { input: string; output: string; }
   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: any; output: any; }
+  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}`; }
+  /** 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: any; output: any; }
+  NamespaceID: { input: `gid://sagittarius/Namespace/${number}`; output: `gid://sagittarius/Namespace/${number}`; }
   /** A unique identifier for all NamespaceLicense entities of the application */
-  NamespaceLicenseID: { input: any; output: any; }
+  NamespaceLicenseID: { input: `gid://sagittarius/NamespaceLicense/${number}`; output: `gid://sagittarius/NamespaceLicense/${number}`; }
   /** A unique identifier for all NamespaceMember entities of the application */
-  NamespaceMemberID: { input: any; output: any; }
+  NamespaceMemberID: { input: `gid://sagittarius/NamespaceMember/${number}`; output: `gid://sagittarius/NamespaceMember/${number}`; }
   /** A unique identifier for all NamespaceMemberRole entities of the application */
-  NamespaceMemberRoleID: { input: any; output: any; }
+  NamespaceMemberRoleID: { input: `gid://sagittarius/NamespaceMemberRole/${number}`; output: `gid://sagittarius/NamespaceMemberRole/${number}`; }
   /** A unique identifier for all NamespaceProject entities of the application */
-  NamespaceProjectID: { input: any; output: any; }
+  NamespaceProjectID: { input: `gid://sagittarius/NamespaceProject/${number}`; output: `gid://sagittarius/NamespaceProject/${number}`; }
   /** A unique identifier for all NamespaceRole entities of the application */
-  NamespaceRoleID: { input: any; output: any; }
+  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: any; output: any; }
+  OrganizationID: { input: `gid://sagittarius/Organization/${number}`; output: `gid://sagittarius/Organization/${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: any; output: any; }
+  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: any; output: any; }
+  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: any; output: any; }
+  UserID: { input: `gid://sagittarius/User/${number}`; output: `gid://sagittarius/User/${number}`; }
   /** A unique identifier for all UserIdentity entities of the application */
-  UserIdentityID: { input: any; output: any; }
+  UserIdentityID: { input: `gid://sagittarius/UserIdentity/${number}`; output: `gid://sagittarius/UserIdentity/${number}`; }
   /** A unique identifier for all UserSession entities of the application */
-  UserSessionID: { input: any; output: any; }
+  UserSessionID: { input: `gid://sagittarius/UserSession/${number}`; output: `gid://sagittarius/UserSession/${number}`; }
 }
 
 /** Represents an active model error */
@@ -86,23 +118,68 @@ export interface ApplicationSettingsUpdatePayload {
 /** 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';
   /** Time when this DataType was created */
   createdAt: Scalars['Time']['output'];
+  /** Generic keys of the datatype */
+  genericKeys?: Maybe<Array<Scalars['String']['output']>>;
   /** Global ID of this DataType */
   id: Scalars['DataTypeID']['output'];
   /** The identifier scoped to the namespace */
   identifier: Scalars['String']['output'];
+  /** Names of the flow type setting */
+  name: TranslationConnection;
   /** The namespace where this datatype belongs to */
   namespace?: Maybe<Namespace>;
+  /** The parent datatype */
+  parent?: Maybe<DataTypeIdentifier>;
+  /** Rules of the datatype */
+  rules: DataTypeRuleConnection;
   /** Time when this DataType was last updated */
   updatedAt: Scalars['Time']['output'];
   /** The type of the datatype */
   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']>;
+}
+
+
+/** Represents a DataType */
+export interface DataTypeRulesArgs {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+}
+
 /** The connection type for DataType. */
 export interface DataTypeConnection {
   __typename?: 'DataTypeConnection';
@@ -125,12 +202,98 @@ export interface DataTypeEdge {
   node?: Maybe<DataType>;
 }
 
+/** Represents a data type identifier. */
+export interface DataTypeIdentifier {
+  __typename?: 'DataTypeIdentifier';
+  /** Time when this DataTypeIdentifier was created */
+  createdAt: Scalars['Time']['output'];
+  /** The data type of the data type identifier. */
+  dataType?: Maybe<DataType>;
+  /** The generic key of the data type identifier. */
+  genericKey?: Maybe<Scalars['String']['output']>;
+  /** The generic type of the data type identifier. */
+  genericType?: Maybe<GenericType>;
+  /** Global ID of this DataTypeIdentifier */
+  id: Scalars['DataTypeIdentifierID']['output'];
+  /** Time when this DataTypeIdentifier was last updated */
+  updatedAt: Scalars['Time']['output'];
+}
+
+/** Input type for data type identifier */
+export interface DataTypeIdentifierInput {
+  /** Data type ID */
+  dataTypeId?: InputMaybe<Scalars['DataTypeID']['input']>;
+  /** Generic key value */
+  genericKey?: InputMaybe<Scalars['String']['input']>;
+  /** Generic type information */
+  genericType?: InputMaybe<GenericTypeInput>;
+}
+
+/** Represents a rule that can be applied to a data type. */
+export interface DataTypeRule {
+  __typename?: 'DataTypeRule';
+  /** The configuration of the rule */
+  config: Config;
+  /** Time when this DataTypeRule was created */
+  createdAt: Scalars['Time']['output'];
+  /** Global ID of this DataTypeRule */
+  id: Scalars['DataTypeRuleID']['output'];
+  /** Time when this DataTypeRule was last updated */
+  updatedAt: Scalars['Time']['output'];
+  /** The type of the rule */
+  variant: DataTypeRulesDataTypeRuleVariant;
+}
+
+/** The connection type for DataTypeRule. */
+export interface DataTypeRuleConnection {
+  __typename?: 'DataTypeRuleConnection';
+  /** Total count of collection. */
+  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: PageInfo;
+}
+
+/** An edge in a connection. */
+export interface DataTypeRuleEdge {
+  __typename?: 'DataTypeRuleEdge';
+  /** A cursor for use in pagination. */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge. */
+  node?: Maybe<DataTypeRule>;
+}
+
+/** The type of rule that can be applied to a data type. */
+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. */
+  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 a string matches a specified regular expression. */
+  Regex = 'REGEX',
+  /** The rule checks if the data type matches a specific return type. */
+  ReturnType = 'RETURN_TYPE'
+}
+
 /** Represent all available types of a datatype */
 export enum DataTypeVariant {
   /** Represents an array */
   Array = 'ARRAY',
   /** Represents an data type containing a data type */
   DataType = 'DATA_TYPE',
+  /** Represents a error */
+  Error = 'ERROR',
+  /** Represents a node */
+  Node = 'NODE',
   /** Represents an object */
   Object = 'OBJECT',
   /** Represents a primitive datatype */
@@ -161,12 +324,252 @@ export interface EchoPayload {
 /** Objects that can present an error */
 export type Error = ActiveModelError | MessageError;
 
+/** Represents a flow */
+export interface Flow {
+  __typename?: 'Flow';
+  /** Time when this Flow was created */
+  createdAt: Scalars['Time']['output'];
+  /** Global ID of this Flow */
+  id: Scalars['FlowID']['output'];
+  /** The input data type of the flow */
+  inputType?: Maybe<DataType>;
+  /** The return data type of the flow */
+  returnType?: Maybe<DataType>;
+  /** The settings of the flow */
+  settings?: Maybe<Array<FlowSetting>>;
+  /** The starting node of the flow */
+  startingNode: NodeFunction;
+  /** The flow type of the flow */
+  type: FlowType;
+  /** Time when this Flow was last updated */
+  updatedAt: Scalars['Time']['output'];
+}
+
+/** Input type for creating or updating a flow */
+export interface FlowInput {
+  /** The settings of the flow */
+  settings?: InputMaybe<Array<FlowSettingInput>>;
+  /** The starting node of the flow */
+  startingNode: NodeFunctionInput;
+  /** The identifier of the flow type */
+  type: Scalars['FlowTypeID']['input'];
+}
+
+/** Represents a flow setting */
+export interface FlowSetting {
+  __typename?: 'FlowSetting';
+  /** Time when this FlowSetting was created */
+  createdAt: Scalars['Time']['output'];
+  /** The identifier of the flow setting */
+  flowSettingId: Scalars['String']['output'];
+  /** Global ID of this FlowSetting */
+  id: Scalars['FlowSettingID']['output'];
+  /** Time when this FlowSetting was last updated */
+  updatedAt: Scalars['Time']['output'];
+  /** The value of the flow setting */
+  value: Scalars['JSON']['output'];
+}
+
+/** Input type for flow settings */
+export interface FlowSettingInput {
+  /** The identifier (not database id) of the flow setting */
+  flowSettingId: Scalars['String']['input'];
+  /** The value of the flow setting */
+  object: Scalars['JSON']['input'];
+}
+
+/** Represents a flow type */
+export interface FlowType {
+  __typename?: 'FlowType';
+  /** Time when this FlowType was created */
+  createdAt: Scalars['Time']['output'];
+  /** Descriptions of the flow type */
+  descriptions?: Maybe<TranslationConnection>;
+  /** Editable status of the flow type */
+  editable: Scalars['Boolean']['output'];
+  /** Flow type settings of the flow type */
+  flowTypeSettings: Array<FlowTypeSetting>;
+  /** Global ID of this FlowType */
+  id: Scalars['TypesFlowTypeID']['output'];
+  /** Identifier of the flow type */
+  identifier: Scalars['String']['output'];
+  /** Input type of the flow type */
+  inputType?: Maybe<DataType>;
+  /** Names of the flow type */
+  names?: Maybe<TranslationConnection>;
+  /** Return type of the flow type */
+  returnType?: Maybe<DataType>;
+  /** Time when this FlowType was last updated */
+  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: 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: PageInfo;
+}
+
+/** An edge in a connection. */
+export interface FlowTypeEdge {
+  __typename?: 'FlowTypeEdge';
+  /** A cursor for use in pagination. */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge. */
+  node?: Maybe<FlowType>;
+}
+
+/** Represents a flow type setting */
+export interface FlowTypeSetting {
+  __typename?: 'FlowTypeSetting';
+  /** Time when this FlowTypeSetting was created */
+  createdAt: Scalars['Time']['output'];
+  /** Data type of the flow type setting */
+  dataType?: Maybe<DataType>;
+  /** Descriptions of the flow type setting */
+  descriptions: TranslationConnection;
+  /** Flow type of the flow type setting */
+  flowType?: Maybe<FlowType>;
+  /** Global ID of this FlowTypeSetting */
+  id: Scalars['FlowTypeSettingID']['output'];
+  /** Identifier of the flow type setting */
+  identifier: Scalars['String']['output'];
+  /** Names of the flow type setting */
+  names: TranslationConnection;
+  /** Unique status of the flow type setting */
+  unique: Scalars['Boolean']['output'];
+  /** Time when this FlowTypeSetting was last updated */
+  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']>;
+}
+
+
+/** 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: Scalars['Time']['output'];
+  /** Global ID of this GenericMapper */
+  id: Scalars['GenericMapperID']['output'];
+  /** The source data type identifier. */
+  source: DataTypeIdentifier;
+  /** The target key for the generic value. */
+  target: Scalars['String']['output'];
+  /** Time when this GenericMapper was last updated */
+  updatedAt: Scalars['Time']['output'];
+}
+
+/** Input type for generic mappers */
+export interface GenericMapperInput {
+  /** The source data type identifier for the mapper */
+  sources: Array<DataTypeIdentifierInput>;
+  /** The target data type identifier for the mapper */
+  target: Scalars['String']['input'];
+}
+
+/** Represents a generic type that can be used in various contexts. */
+export interface GenericType {
+  __typename?: 'GenericType';
+  /** Time when this GenericType was created */
+  createdAt: Scalars['Time']['output'];
+  /** The data type associated with this generic type. */
+  dataType: DataType;
+  /** The mappers associated with this generic type. */
+  genericMappers: Array<GenericMapper>;
+  /** Global ID of this GenericType */
+  id: Scalars['GenericTypeID']['output'];
+  /** Time when this GenericType was last updated */
+  updatedAt: Scalars['Time']['output'];
+}
+
+/** Input type for generic type operations. */
+export interface GenericTypeInput {
+  /** The data type associated with this generic type. */
+  dataTypeId: Scalars['DataTypeID']['input'];
+  /** The mappers associated with this generic type. */
+  genericMappers: Array<GenericMapperInput>;
+}
+
 /** Represents the input for external user identity validation */
 export interface IdentityInput {
   /** This validation code will be used for the oAuth validation process */
   code?: InputMaybe<Scalars['String']['input']>;
 }
 
+/** 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;
+}
+
+/** 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: Scalars['Time']['output'];
+  /** Time when this LiteralValue was last updated */
+  updatedAt: Scalars['Time']['output'];
+  /** The literal value itself as JSON. */
+  value: Scalars['JSON']['output'];
+}
+
 /** Represents an error message */
 export interface MessageError {
   __typename?: 'MessageError';
@@ -212,10 +615,16 @@ export interface Mutation {
   namespacesMembersDelete?: Maybe<NamespacesMembersDeletePayload>;
   /** Invite a new member to a namespace. */
   namespacesMembersInvite?: Maybe<NamespacesMembersInvitePayload>;
+  /** Assign runtimes to a project */
+  namespacesProjectsAssignRuntimes?: Maybe<NamespacesProjectsAssignRuntimesPayload>;
   /** Creates a new namespace project. */
   namespacesProjectsCreate?: Maybe<NamespacesProjectsCreatePayload>;
   /** Deletes a namespace project. */
   namespacesProjectsDelete?: Maybe<NamespacesProjectsDeletePayload>;
+  /** Creates a new flow. */
+  namespacesProjectsFlowsCreate?: Maybe<NamespacesProjectsFlowsCreatePayload>;
+  /** Deletes a namespace project. */
+  namespacesProjectsFlowsDelete?: Maybe<NamespacesProjectsFlowsDeletePayload>;
   /** Updates a namespace project. */
   namespacesProjectsUpdate?: Maybe<NamespacesProjectsUpdatePayload>;
   /** Update the abilities a role is granted. */
@@ -309,6 +718,12 @@ export interface MutationNamespacesMembersInviteArgs {
 }
 
 
+/** Root Mutation type */
+export interface MutationNamespacesProjectsAssignRuntimesArgs {
+  input: NamespacesProjectsAssignRuntimesInput;
+}
+
+
 /** Root Mutation type */
 export interface MutationNamespacesProjectsCreateArgs {
   input: NamespacesProjectsCreateInput;
@@ -321,6 +736,18 @@ export interface MutationNamespacesProjectsDeleteArgs {
 }
 
 
+/** Root Mutation type */
+export interface MutationNamespacesProjectsFlowsCreateArgs {
+  input: NamespacesProjectsFlowsCreateInput;
+}
+
+
+/** Root Mutation type */
+export interface MutationNamespacesProjectsFlowsDeleteArgs {
+  input: NamespacesProjectsFlowsDeleteInput;
+}
+
+
 /** Root Mutation type */
 export interface MutationNamespacesProjectsUpdateArgs {
   input: NamespacesProjectsUpdateInput;
@@ -635,10 +1062,23 @@ export interface NamespaceProject {
   name: Scalars['String']['output'];
   /** The namespace where this project belongs to */
   namespace: Namespace;
+  /** The primary runtime for the project */
+  primaryRuntime?: Maybe<Runtime>;
+  /** Runtimes assigned to this project */
+  runtimes: RuntimeConnection;
   /** Time when this NamespaceProject was last updated */
   updatedAt: Scalars['Time']['output'];
 }
 
+
+/** Represents a namespace project */
+export interface NamespaceProjectRuntimesArgs {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+}
+
 /** The connection type for NamespaceProject. */
 export interface NamespaceProjectConnection {
   __typename?: 'NamespaceProjectConnection';
@@ -693,10 +1133,14 @@ export interface NamespaceRoleAssignedProjectsArgs {
 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 */
+  AssignProjectRuntimes = 'ASSIGN_PROJECT_RUNTIMES',
   /** Allows to change the abilities of a namespace role */
   AssignRoleAbilities = 'ASSIGN_ROLE_ABILITIES',
   /** Allows to change the assigned projects of a namespace role */
   AssignRoleProjects = 'ASSIGN_ROLE_PROJECTS',
+  /** Allows to create flows in a namespace project */
+  CreateFlows = 'CREATE_FLOWS',
   /** Allows to create a license for the namespace */
   CreateNamespaceLicense = 'CREATE_NAMESPACE_LICENSE',
   /** Allows to create a project in the namespace */
@@ -705,6 +1149,8 @@ export enum NamespaceRoleAbility {
   CreateNamespaceRole = 'CREATE_NAMESPACE_ROLE',
   /** Allows to create a runtime globally or for the namespace */
   CreateRuntime = 'CREATE_RUNTIME',
+  /** Allows to delete flows in a namespace project */
+  DeleteFlows = 'DELETE_FLOWS',
   /** Allows to remove members of a namespace */
   DeleteMember = 'DELETE_MEMBER',
   /** Allows to delete the license of the namespace */
@@ -727,6 +1173,8 @@ export enum NamespaceRoleAbility {
   ReadNamespaceProject = 'READ_NAMESPACE_PROJECT',
   /** Allows to regenerate a runtime token */
   RotateRuntimeToken = 'ROTATE_RUNTIME_TOKEN',
+  /** Allows to update flows in the project */
+  UpdateFlows = 'UPDATE_FLOWS',
   /** Allows to update the project of the namespace */
   UpdateNamespaceProject = 'UPDATE_NAMESPACE_PROJECT',
   /** Allows to update the namespace role */
@@ -860,6 +1308,27 @@ export interface NamespacesMembersInvitePayload {
   namespaceMember?: Maybe<NamespaceMember>;
 }
 
+/** Autogenerated input type of NamespacesProjectsAssignRuntimes */
+export interface NamespacesProjectsAssignRuntimesInput {
+  /** A unique identifier for the client performing the mutation. */
+  clientMutationId?: InputMaybe<Scalars['String']['input']>;
+  /** ID of the project to assign runtimes to */
+  namespaceProjectId: Scalars['NamespaceProjectID']['input'];
+  /** The new runtimes assigned to the project */
+  runtimeIds: Array<Scalars['RuntimeID']['input']>;
+}
+
+/** Autogenerated return type of NamespacesProjectsAssignRuntimes. */
+export interface NamespacesProjectsAssignRuntimesPayload {
+  __typename?: 'NamespacesProjectsAssignRuntimesPayload';
+  /** A unique identifier for the client performing the mutation. */
+  clientMutationId?: Maybe<Scalars['String']['output']>;
+  /** Errors encountered during execution of the mutation. */
+  errors: Array<Error>;
+  /** The updated project with assigned runtimes */
+  namespaceProject?: Maybe<NamespaceProject>;
+}
+
 /** Autogenerated input type of NamespacesProjectsCreate */
 export interface NamespacesProjectsCreateInput {
   /** A unique identifier for the client performing the mutation. */
@@ -902,6 +1371,46 @@ export interface NamespacesProjectsDeletePayload {
   namespaceProject?: Maybe<NamespaceProject>;
 }
 
+/** Autogenerated input type of NamespacesProjectsFlowsCreate */
+export interface NamespacesProjectsFlowsCreateInput {
+  /** A unique identifier for the client performing the mutation. */
+  clientMutationId?: InputMaybe<Scalars['String']['input']>;
+  /** The flow to create */
+  flow: FlowInput;
+  /** The ID of the project to which the flow belongs to */
+  projectId: Scalars['NamespaceProjectID']['input'];
+}
+
+/** Autogenerated return type of NamespacesProjectsFlowsCreate. */
+export interface NamespacesProjectsFlowsCreatePayload {
+  __typename?: 'NamespacesProjectsFlowsCreatePayload';
+  /** A unique identifier for the client performing the mutation. */
+  clientMutationId?: Maybe<Scalars['String']['output']>;
+  /** Errors encountered during execution of the mutation. */
+  errors: Array<Error>;
+  /** The newly created flow. */
+  flow?: Maybe<Flow>;
+}
+
+/** Autogenerated input type of NamespacesProjectsFlowsDelete */
+export interface NamespacesProjectsFlowsDeleteInput {
+  /** A unique identifier for the client performing the mutation. */
+  clientMutationId?: InputMaybe<Scalars['String']['input']>;
+  /** The id of the flow which will be deleted */
+  flowId: Scalars['FlowID']['input'];
+}
+
+/** Autogenerated return type of NamespacesProjectsFlowsDelete. */
+export interface NamespacesProjectsFlowsDeletePayload {
+  __typename?: 'NamespacesProjectsFlowsDeletePayload';
+  /** A unique identifier for the client performing the mutation. */
+  clientMutationId?: Maybe<Scalars['String']['output']>;
+  /** Errors encountered during execution of the mutation. */
+  errors: Array<Error>;
+  /** The deleted flow. */
+  flow?: Maybe<Flow>;
+}
+
 /** Autogenerated input type of NamespacesProjectsUpdate */
 export interface NamespacesProjectsUpdateInput {
   /** A unique identifier for the client performing the mutation. */
@@ -912,6 +1421,8 @@ export interface NamespacesProjectsUpdateInput {
   name?: InputMaybe<Scalars['String']['input']>;
   /** The id of the namespace project which will be updated */
   namespaceProjectId: Scalars['NamespaceProjectID']['input'];
+  /** The primary runtime for the updated project. */
+  primaryRuntimeId?: InputMaybe<Scalars['RuntimeID']['input']>;
 }
 
 /** Autogenerated return type of NamespacesProjectsUpdate. */
@@ -1034,6 +1545,111 @@ export interface Node {
   id: Scalars['ID']['output'];
 }
 
+/** Represents a Node Function */
+export interface NodeFunction {
+  __typename?: 'NodeFunction';
+  /** Time when this NodeFunction was created */
+  createdAt: Scalars['Time']['output'];
+  /** Global ID of this NodeFunction */
+  id: Scalars['NodeFunctionID']['output'];
+  /** The next Node Function in the flow */
+  nextNode?: Maybe<NodeFunction>;
+  /** The parameters of the Node Function */
+  parameters: NodeParameterConnection;
+  /** The definition of the Node Function */
+  runtimeFunction: RuntimeFunctionDefinition;
+  /** Time when this NodeFunction was last updated */
+  updatedAt: Scalars['Time']['output'];
+}
+
+
+/** Represents a Node Function */
+export interface NodeFunctionParametersArgs {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+}
+
+/** Input type for a Node Function */
+export interface NodeFunctionInput {
+  /** The next Node Function in the flow */
+  nextNode?: InputMaybe<NodeFunctionInput>;
+  /** The parameters of the Node Function */
+  parameters: Array<NodeParameterInput>;
+  /** The identifier of the Runtime Function Definition */
+  runtimeFunctionId: Scalars['RuntimeFunctionDefinitionID']['input'];
+}
+
+/** Represents a Node parameter */
+export interface NodeParameter {
+  __typename?: 'NodeParameter';
+  /** Time when this NodeParameter was created */
+  createdAt: Scalars['Time']['output'];
+  /** Global ID of this NodeParameter */
+  id: Scalars['NodeParameterID']['output'];
+  /** The definition of the parameter */
+  runtimeParameter: RuntimeParameterDefinition;
+  /** Time when this NodeParameter was last updated */
+  updatedAt: Scalars['Time']['output'];
+  /** The value of the parameter */
+  value?: Maybe<NodeParameterValue>;
+}
+
+/** The connection type for NodeParameter. */
+export interface NodeParameterConnection {
+  __typename?: 'NodeParameterConnection';
+  /** Total count of collection. */
+  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: PageInfo;
+}
+
+/** An edge in a connection. */
+export interface NodeParameterEdge {
+  __typename?: 'NodeParameterEdge';
+  /** A cursor for use in pagination. */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge. */
+  node?: Maybe<NodeParameter>;
+}
+
+/** Input type for Node parameter */
+export interface NodeParameterInput {
+  /** The identifier of the Runtime Parameter Definition */
+  runtimeParameterDefinitionId: Scalars['RuntimeParameterDefinitionID']['input'];
+  /** The value of the parameter */
+  value?: InputMaybe<NodeParameterValueInput>;
+}
+
+/** Represents a parameter value for a node. */
+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 reference value of the parameter */
+  referenceValue?: InputMaybe<ReferenceValueInput>;
+}
+
+/** 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';
@@ -1142,6 +1758,8 @@ export interface Query {
   nodes?: Maybe<Array<Maybe<Node>>>;
   /** Find a organization */
   organization?: Maybe<Organization>;
+  /** Find users */
+  users: UserConnection;
 }
 
 
@@ -1184,6 +1802,87 @@ export interface QueryOrganizationArgs {
   name?: InputMaybe<Scalars['String']['input']>;
 }
 
+
+/** Root Query type */
+export interface QueryUsersArgs {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+}
+
+/** Represents a reference path in a flow */
+export interface ReferencePath {
+  __typename?: 'ReferencePath';
+  /** The array index of the referenced data by the path */
+  arrayIndex?: Maybe<Scalars['Int']['output']>;
+  /** Time when this ReferencePath was created */
+  createdAt: Scalars['Time']['output'];
+  /** Global ID of this ReferencePath */
+  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: Scalars['Time']['output'];
+}
+
+/** Input type for reference path */
+export interface ReferencePathInput {
+  /** Array index if applicable */
+  arrayIndex?: InputMaybe<Scalars['Int']['input']>;
+  /** The path to the reference in the flow */
+  path?: InputMaybe<Scalars['String']['input']>;
+}
+
+/** Represents a reference value in the system. */
+export interface ReferenceValue {
+  __typename?: 'ReferenceValue';
+  /** Time when this ReferenceValue was created */
+  createdAt: Scalars['Time']['output'];
+  /** The identifier of the data type this reference value belongs to. */
+  dataTypeIdentifier: DataTypeIdentifier;
+  /** Global ID of this ReferenceValue */
+  id: Scalars['ReferenceValueID']['output'];
+  /** The primary level of the reference value. */
+  primaryLevel: Scalars['Int']['output'];
+  /** The paths associated with this reference value. */
+  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: 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 primary level of the reference value */
+  primaryLevel: Scalars['Int']['input'];
+  /** The paths associated with this reference value */
+  referencePath: Array<ReferencePathInput>;
+  /** 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';
@@ -1193,12 +1892,18 @@ export interface Runtime {
   dataTypes: DataTypeConnection;
   /** The description for the runtime if present */
   description: Scalars['String']['output'];
+  /** FlowTypes of the runtime */
+  flowTypes: FlowTypeConnection;
   /** Global ID of this Runtime */
   id: Scalars['RuntimeID']['output'];
   /** The name for the runtime */
   name: Scalars['String']['output'];
   /** The parent namespace for the runtime */
   namespace?: Maybe<Namespace>;
+  /** Projects associated with the runtime */
+  projects: NamespaceProjectConnection;
+  /** The status of the runtime */
+  status: RuntimeStatusType;
   /** Token belonging to the runtime, only present on creation */
   token?: Maybe<Scalars['String']['output']>;
   /** Time when this Runtime was last updated */
@@ -1214,6 +1919,24 @@ export interface RuntimeDataTypesArgs {
   last?: InputMaybe<Scalars['Int']['input']>;
 }
 
+
+/** Represents a runtime */
+export interface RuntimeFlowTypesArgs {
+  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']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+}
+
 /** The connection type for Runtime. */
 export interface RuntimeConnection {
   __typename?: 'RuntimeConnection';
@@ -1236,6 +1959,36 @@ export interface RuntimeEdge {
   node?: Maybe<Runtime>;
 }
 
+/** Represents a Node Function definition */
+export interface RuntimeFunctionDefinition {
+  __typename?: 'RuntimeFunctionDefinition';
+  /** Time when this RuntimeFunctionDefinition was created */
+  createdAt: Scalars['Time']['output'];
+  /** Global ID of this RuntimeFunctionDefinition */
+  id: Scalars['RuntimeParameterDefinitionID']['output'];
+  /** Time when this RuntimeFunctionDefinition was last updated */
+  updatedAt: Scalars['Time']['output'];
+}
+
+/** Represents a Node parameter definition */
+export interface RuntimeParameterDefinition {
+  __typename?: 'RuntimeParameterDefinition';
+  /** Time when this RuntimeParameterDefinition was created */
+  createdAt: Scalars['Time']['output'];
+  /** Global ID of this RuntimeParameterDefinition */
+  id: Scalars['RuntimeParameterDefinitionID']['output'];
+  /** Time when this RuntimeParameterDefinition was last updated */
+  updatedAt: Scalars['Time']['output'];
+}
+
+/** Represent all available types of statuses of a runtime */
+export enum RuntimeStatusType {
+  /** No problem with connection, everything works as expected */
+  Connected = 'CONNECTED',
+  /** The runtime is disconnected, cause unknown */
+  Disconnected = 'DISCONNECTED'
+}
+
 /** Autogenerated input type of RuntimesCreate */
 export interface RuntimesCreateInput {
   /** A unique identifier for the client performing the mutation. */
@@ -1320,6 +2073,37 @@ export interface RuntimesUpdatePayload {
   runtime?: Maybe<Runtime>;
 }
 
+/** Represents a translation */
+export interface Translation {
+  __typename?: 'Translation';
+  /** Code of the translation */
+  code: Scalars['String']['output'];
+  /** Content of the translation */
+  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';
@@ -1356,6 +2140,28 @@ export interface UserNamespaceMembershipsArgs {
   last?: InputMaybe<Scalars['Int']['input']>;
 }
 
+/** The connection type for User. */
+export interface UserConnection {
+  __typename?: 'UserConnection';
+  /** Total count of collection. */
+  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: PageInfo;
+}
+
+/** An edge in a connection. */
+export interface UserEdge {
+  __typename?: 'UserEdge';
+  /** A cursor for use in pagination. */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge. */
+  node?: Maybe<User>;
+}
+
 /** Represents an external user identity */
 export interface UserIdentity {
   __typename?: 'UserIdentity';
@@ -1582,6 +2388,8 @@ export interface UsersRegisterInput {
   email: Scalars['String']['input'];
   /** Password of the user */
   password: Scalars['String']['input'];
+  /** The repeated password of the user to check for typos */
+  passwordRepeat: Scalars['String']['input'];
   /** Username of the user */
   username: Scalars['String']['input'];
 }
@@ -1609,6 +2417,12 @@ export interface UsersUpdateInput {
   firstname?: InputMaybe<Scalars['String']['input']>;
   /** New lastname for the user. */
   lastname?: InputMaybe<Scalars['String']['input']>;
+  /** The data of the mfa validation */
+  mfa?: InputMaybe<MfaInput>;
+  /** New password for the user. */
+  password?: InputMaybe<Scalars['String']['input']>;
+  /** New password repeat for the user to check for typos, required if password is set. */
+  passwordRepeat?: InputMaybe<Scalars['String']['input']>;
   /** ID of the user to update. */
   userId: Scalars['UserID']['input'];
   /** New username for the user. */

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@code0-tech/sagittarius-graphql-types",
-  "version": "0.0.0-6f0b32a0eb18c9c3569a090f089c6adf1b4d666c",
+  "version": "0.0.0-f91466f0f343596ad170e7e5c5316a70b072594d",
   "description": "",
   "main": "index.js",
   "types": "index.d.ts",
   "scripts": {
-    "generate": "graphql-codegen --config codegen.yml"
+    "generate": "graphql-codegen --config codegen.ts"
   },
   "repository": {
     "type": "git",