@code0-tech/sagittarius-graphql-types 0.0.0-967667e8c736081887d32d99a5e2ab0445718798 → 0.0.0-beb91167a8ea12eb6d4a6e3933483bacf845f2f6

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}`; }
@@ -101,12 +101,10 @@ export interface DataType {
   identifier?: Maybe<Scalars['String']['output']>;
   /** Names of the flow type setting */
   name?: Maybe<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>;
   /** Time when this DataType was last updated */
   updatedAt?: Maybe<Scalars['Time']['output']>;
   /** The type of the datatype */
@@ -241,8 +239,8 @@ export interface DataTypeRulesInputTypeConfig {
   __typename?: 'DataTypeRulesInputTypeConfig';
   /** The identifier of the data type this input type belongs to */
   dataTypeIdentifier?: Maybe<DataTypeIdentifier>;
-  /** The input data type that this configuration applies to */
-  inputType?: Maybe<DataType>;
+  /** The input identifier that this configuration applies to */
+  inputIdentifier?: Maybe<Scalars['String']['output']>;
 }
 
 /** Represents a rule that can be applied to a data type. */
@@ -292,7 +290,7 @@ export interface DataTypeRulesReturnTypeConfig {
 }
 
 /** The type of rule that can be applied to a data type. */
-export enum DataTypeRulesVariant {
+export const enum DataTypeRulesVariant {
   /** 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. */
@@ -312,7 +310,7 @@ export enum DataTypeRulesVariant {
 }
 
 /** Represent all available types of a datatype */
-export enum DataTypeVariant {
+export const enum DataTypeVariant {
   /** Represents an array */
   Array = 'ARRAY',
   /** Represents an data type containing a data type */
@@ -349,7 +347,74 @@ export interface EchoPayload {
 }
 
 /** Objects that can present an error */
-export type Error = ActiveModelError | MessageError;
+export type Error = ActiveModelError | ErrorCode | MessageError;
+
+/** Represents an error code */
+export interface ErrorCode {
+  __typename?: 'ErrorCode';
+  /** The error code */
+  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',
+  /** 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',
+  /** 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',
+  /** The new backup codes could not be saved */
+  FailedToSaveValidBackupCode = 'FAILED_TO_SAVE_VALID_BACKUP_CODE',
+  /** The given key was not found in the data type */
+  GenericKeyNotFound = 'GENERIC_KEY_NOT_FOUND',
+  /** Failed to validate the external identity */
+  IdentityValidationFailed = 'IDENTITY_VALIDATION_FAILED',
+  /** Resources are from different namespaces */
+  InconsistentNamespace = 'INCONSISTENT_NAMESPACE',
+  /** This external identity is invalid */
+  InvalidExternalIdentity = 'INVALID_EXTERNAL_IDENTITY',
+  /** Invalid login data provided */
+  InvalidLoginData = 'INVALID_LOGIN_DATA',
+  /** Invalid setting provided */
+  InvalidSetting = 'INVALID_SETTING',
+  /** Invalid verification code provided */
+  InvalidVerificationCode = 'INVALID_VERIFICATION_CODE',
+  /** Invalid MFA data provided */
+  MfaFailed = 'MFA_FAILED',
+  /** MFA is required */
+  MfaRequired = 'MFA_REQUIRED',
+  /** 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',
+  /** There are no free license seats to complete this operation */
+  NoFreeLicenseSeats = 'NO_FREE_LICENSE_SEATS',
+  /** The project does not have a primary runtime */
+  NoPrimaryRuntime = 'NO_PRIMARY_RUNTIME',
+  /** @deprecated Outdated concept */
+  PrimaryLevelNotFound = 'PRIMARY_LEVEL_NOT_FOUND',
+  /** Self-registration is disabled */
+  RegistrationDisabled = 'REGISTRATION_DISABLED',
+  /** Resources are from different runtimes */
+  RuntimeMismatch = 'RUNTIME_MISMATCH',
+  /** @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',
+  /** Invalid TOTP code provided */
+  WrongTotp = 'WRONG_TOTP'
+}
 
 /** Represents a flow */
 export interface Flow {
@@ -360,18 +425,22 @@ export interface Flow {
   id?: Maybe<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 return data type of the flow */
   returnType?: Maybe<DataType>;
   /** The settings of the flow */
-  settings?: Maybe<Array<FlowSetting>>;
+  settings?: Maybe<FlowSettingConnection>;
   /** The ID of the starting node of the flow */
   startingNodeId?: Maybe<Scalars['NodeFunctionID']['output']>;
   /** The flow type of the flow */
   type?: Maybe<FlowType>;
   /** Time when this Flow was last updated */
   updatedAt?: Maybe<Scalars['Time']['output']>;
+  /** Abilities for the current user on this Flow */
+  userAbilities?: Maybe<FlowUserAbilities>;
 }
 
 
@@ -383,6 +452,15 @@ export interface FlowNodesArgs {
   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';
@@ -407,6 +485,8 @@ export interface FlowEdge {
 
 /** Input type for creating or updating a flow */
 export interface FlowInput {
+  /** The name of the flow */
+  name: Scalars['String']['input'];
   /** The settings of the flow */
   settings?: InputMaybe<Array<FlowSettingInput>>;
   /** The starting node of the flow */
@@ -421,7 +501,7 @@ export interface FlowSetting {
   /** Time when this FlowSetting was created */
   createdAt?: Maybe<Scalars['Time']['output']>;
   /** The identifier of the flow setting */
-  flowSettingId?: Maybe<Scalars['String']['output']>;
+  flowSettingIdentifier?: Maybe<Scalars['String']['output']>;
   /** Global ID of this FlowSetting */
   id?: Maybe<Scalars['FlowSettingID']['output']>;
   /** Time when this FlowSetting was last updated */
@@ -430,6 +510,28 @@ export interface FlowSetting {
   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>;
+}
+
 /** Input type for flow settings */
 export interface FlowSettingInput {
   /** The identifier (not database id) of the flow setting */
@@ -544,6 +646,13 @@ export interface FlowTypeSettingNamesArgs {
   last?: InputMaybe<Scalars['Int']['input']>;
 }
 
+/** 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 function definition */
 export interface FunctionDefinition {
   __typename?: 'FunctionDefinition';
@@ -559,6 +668,8 @@ export interface FunctionDefinition {
   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<TranslationConnection>;
   /** Parameters of the function */
@@ -656,7 +767,7 @@ export interface GenericCombinationStrategy {
 }
 
 /** The available combination strategy types. */
-export enum GenericCombinationStrategyType {
+export const enum GenericCombinationStrategyType {
   /** Represents a logical AND combination. */
   And = 'AND',
   /** Represents a logical OR combination. */
@@ -673,7 +784,7 @@ export interface GenericMapper {
   /** Global ID of this GenericMapper */
   id?: Maybe<Scalars['GenericMapperID']['output']>;
   /** The source data type identifier. */
-  sources?: Maybe<Array<DataTypeIdentifier>>;
+  sourceDataTypeIdentifiers?: Maybe<Array<DataTypeIdentifier>>;
   /** The target key for the generic value. */
   target?: Maybe<Scalars['String']['output']>;
   /** Time when this GenericMapper was last updated */
@@ -717,6 +828,23 @@ export interface IdentityInput {
   code?: InputMaybe<Scalars['String']['input']>;
 }
 
+/** Abilities for the current user on this Instance */
+export interface InstanceUserAbilities {
+  __typename?: 'InstanceUserAbilities';
+  /** Shows if the current user has the `create_organization` ability on this Instance */
+  createOrganization?: Maybe<Scalars['Boolean']['output']>;
+  /** Shows if the current user has the `create_runtime` ability on this Instance */
+  createRuntime?: Maybe<Scalars['Boolean']['output']>;
+  /** Shows if the current user has the `delete_runtime` ability on this Instance */
+  deleteRuntime?: Maybe<Scalars['Boolean']['output']>;
+  /** Shows if the current user has the `rotate_runtime_token` ability on this Instance */
+  rotateRuntimeToken?: Maybe<Scalars['Boolean']['output']>;
+  /** Shows if the current user has the `update_application_setting` ability on this Instance */
+  updateApplicationSetting?: Maybe<Scalars['Boolean']['output']>;
+  /** Shows if the current user has the `update_runtime` ability on this Instance */
+  updateRuntime?: Maybe<Scalars['Boolean']['output']>;
+}
+
 /** Represents a literal value, such as a string or number. */
 export interface LiteralValue {
   __typename?: 'LiteralValue';
@@ -744,7 +872,7 @@ export interface MfaInput {
 }
 
 /** Represent all available types to authenticate with mfa */
-export enum MfaType {
+export const enum MfaType {
   /** Single use backup code */
   BackupCode = 'BACKUP_CODE',
   /** Time based onetime password */
@@ -764,9 +892,9 @@ export interface Mutation {
    *
    */
   echo?: Maybe<EchoPayload>;
-  /** Create a new namespace license. */
+  /** (EE only) Create a new namespace license. */
   namespacesLicensesCreate?: Maybe<NamespacesLicensesCreatePayload>;
-  /** Deletes an namespace license. */
+  /** (EE only) Deletes an namespace license. */
   namespacesLicensesDelete?: Maybe<NamespacesLicensesDeletePayload>;
   /** Update the roles a member is assigned to. */
   namespacesMembersAssignRoles?: Maybe<NamespacesMembersAssignRolesPayload>;
@@ -830,6 +958,10 @@ 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. */
@@ -1047,6 +1179,18 @@ 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;
@@ -1063,11 +1207,13 @@ 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>;
   /** Global ID of this Namespace */
   id?: Maybe<Scalars['NamespaceID']['output']>;
   /** Members of the namespace */
   members?: Maybe<NamespaceMemberConnection>;
-  /** Licenses of the namespace */
+  /** (EE only) Licenses of the namespace */
   namespaceLicenses?: Maybe<NamespaceLicenseConnection>;
   /** Parent of this namespace */
   parent?: Maybe<NamespaceParent>;
@@ -1079,6 +1225,8 @@ export interface Namespace {
   runtimes?: Maybe<RuntimeConnection>;
   /** Time when this Namespace was last updated */
   updatedAt?: Maybe<Scalars['Time']['output']>;
+  /** Abilities for the current user on this Namespace */
+  userAbilities?: Maybe<NamespaceUserAbilities>;
 }
 
 
@@ -1126,17 +1274,25 @@ export interface NamespaceRuntimesArgs {
   last?: InputMaybe<Scalars['Int']['input']>;
 }
 
-/** Represents a Namespace License */
+/** (EE only) 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']>;
   /** Global ID of this NamespaceLicense */
   id?: Maybe<Scalars['NamespaceLicenseID']['output']>;
+  /** The licensee information */
+  licensee?: Maybe<Scalars['JSON']['output']>;
   /** The namespace the license belongs to */
   namespace?: Maybe<Namespace>;
+  /** The start date of the license */
+  startDate?: Maybe<Scalars['Time']['output']>;
   /** Time when this NamespaceLicense was last updated */
   updatedAt?: Maybe<Scalars['Time']['output']>;
+  /** Abilities for the current user on this NamespaceLicense */
+  userAbilities?: Maybe<NamespaceLicenseUserAbilities>;
 }
 
 /** The connection type for NamespaceLicense. */
@@ -1161,6 +1317,13 @@ export interface NamespaceLicenseEdge {
   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';
@@ -1168,12 +1331,36 @@ export interface NamespaceMember {
   createdAt?: Maybe<Scalars['Time']['output']>;
   /** Global ID of this NamespaceMember */
   id?: Maybe<Scalars['NamespaceMemberID']['output']>;
+  /** Memberroles of the member */
+  memberRoles?: Maybe<NamespaceMemberRoleConnection>;
   /** Namespace this member belongs to */
   namespace?: Maybe<Namespace>;
+  /** Roles of the member */
+  roles?: Maybe<NamespaceRoleConnection>;
   /** Time when this NamespaceMember was last updated */
   updatedAt?: Maybe<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']>;
 }
 
 /** The connection type for NamespaceMember. */
@@ -1213,8 +1400,39 @@ export interface NamespaceMemberRole {
   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']>;
+}
+
 /** Objects that can present a namespace */
-export type NamespaceParent = Organization;
+export type NamespaceParent = Organization | User;
 
 /** Represents a namespace project */
 export interface NamespaceProject {
@@ -1239,6 +1457,8 @@ export interface NamespaceProject {
   runtimes?: Maybe<RuntimeConnection>;
   /** Time when this NamespaceProject was last updated */
   updatedAt?: Maybe<Scalars['Time']['output']>;
+  /** Abilities for the current user on this NamespaceProject */
+  userAbilities?: Maybe<NamespaceProjectUserAbilities>;
 }
 
 
@@ -1287,6 +1507,19 @@ export interface NamespaceProjectEdge {
   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';
@@ -1304,6 +1537,8 @@ export interface NamespaceRole {
   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>;
 }
 
 
@@ -1316,7 +1551,7 @@ export interface NamespaceRoleAssignedProjectsArgs {
 }
 
 /** Represents abilities that can be granted to roles in namespaces. */
-export enum NamespaceRoleAbility {
+export const 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 */
@@ -1326,7 +1561,7 @@ export enum NamespaceRoleAbility {
   /** 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',
+  CreateFlow = 'CREATE_FLOW',
   /** Allows to create a license for the namespace */
   CreateNamespaceLicense = 'CREATE_NAMESPACE_LICENSE',
   /** Allows to create a project in the namespace */
@@ -1336,7 +1571,7 @@ export enum NamespaceRoleAbility {
   /** Allows to create a runtime globally or for the namespace */
   CreateRuntime = 'CREATE_RUNTIME',
   /** Allows to delete flows in a namespace project */
-  DeleteFlows = 'DELETE_FLOWS',
+  DeleteFlow = 'DELETE_FLOW',
   /** Allows to remove members of a namespace */
   DeleteMember = 'DELETE_MEMBER',
   /** Allows to delete the license of the namespace */
@@ -1360,7 +1595,7 @@ export enum NamespaceRoleAbility {
   /** Allows to regenerate a runtime token */
   RotateRuntimeToken = 'ROTATE_RUNTIME_TOKEN',
   /** Allows to update flows in the project */
-  UpdateFlows = 'UPDATE_FLOWS',
+  UpdateFlow = 'UPDATE_FLOW',
   /** Allows to update the project of the namespace */
   UpdateNamespaceProject = 'UPDATE_NAMESPACE_PROJECT',
   /** Allows to update the namespace role */
@@ -1393,6 +1628,34 @@ export interface NamespaceRoleEdge {
   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. */
@@ -1736,14 +1999,14 @@ 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>;
   /** 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']>;
   /** The parameters of the Node Function */
   parameters?: Maybe<NodeParameterConnection>;
-  /** The definition of the Node Function */
-  runtimeFunction?: Maybe<RuntimeFunctionDefinition>;
   /** Time when this NodeFunction was last updated */
   updatedAt?: Maybe<Scalars['Time']['output']>;
 }
@@ -1860,6 +2123,39 @@ export interface Organization {
   namespace?: Maybe<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']>;
 }
 
 /** Autogenerated input type of OrganizationsCreate */
@@ -1940,13 +2236,15 @@ export interface ParameterDefinition {
   /** Time when this ParameterDefinition was created */
   createdAt?: Maybe<Scalars['Time']['output']>;
   /** Data type of the parameter */
-  dataType?: Maybe<DataTypeIdentifier>;
+  dataTypeIdentifier?: Maybe<DataTypeIdentifier>;
   /** Description of the parameter */
   descriptions?: Maybe<TranslationConnection>;
   /** Documentation of the parameter */
   documentations?: Maybe<TranslationConnection>;
   /** 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<TranslationConnection>;
   /** Time when this ParameterDefinition was last updated */
@@ -2023,6 +2321,10 @@ export interface Query {
   nodes?: Maybe<Array<Maybe<Node>>>;
   /** Find a organization */
   organization?: Maybe<Organization>;
+  /** Find organizations */
+  organizations?: Maybe<OrganizationConnection>;
+  /** Abilities for the current user on this Instance */
+  userAbilities?: Maybe<InstanceUserAbilities>;
   /** Find users */
   users?: Maybe<UserConnection>;
 }
@@ -2068,6 +2370,15 @@ 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 QueryUsersArgs {
   after?: InputMaybe<Scalars['String']['input']>;
@@ -2112,6 +2423,8 @@ export interface 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']>;
   /** The paths associated with this reference value. */
   referencePath?: Maybe<Array<ReferencePath>>;
   /** The scope of the reference value. */
@@ -2124,14 +2437,16 @@ export interface ReferenceValue {
 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 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 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']>;
+  /** The scope of the reference value */
+  scope: Array<Scalars['Int']['input']>;
 }
 
 /** Represents a runtime */
@@ -2159,6 +2474,8 @@ export interface Runtime {
   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>;
 }
 
 
@@ -2210,25 +2527,27 @@ export interface RuntimeEdge {
   node?: Maybe<Runtime>;
 }
 
-/** Represents a Node Function definition */
+/** Represents a runtime function definition */
 export interface RuntimeFunctionDefinition {
   __typename?: 'RuntimeFunctionDefinition';
   /** Time when this RuntimeFunctionDefinition was created */
   createdAt?: Maybe<Scalars['Time']['output']>;
-  /** Function definitions of the Node Function */
+  /** Function definitions of the runtime function definition */
   functionDefinitions?: Maybe<FunctionDefinitionConnection>;
   /** Global ID of this RuntimeFunctionDefinition */
-  id?: Maybe<Scalars['RuntimeParameterDefinitionID']['output']>;
-  /** Identifier of the Node Function */
+  id?: Maybe<Scalars['RuntimeFunctionDefinitionID']['output']>;
+  /** Identifier of the runtime function definition */
   identifier?: Maybe<Scalars['String']['output']>;
-  /** The runtime this Node Function belongs to */
+  /** The runtime this runtime function definition belongs to */
   runtime?: Maybe<Runtime>;
+  /** Parameter definitions of the runtime function definition */
+  runtimeParameterDefinitions?: Maybe<RuntimeParameterDefinitionConnection>;
   /** Time when this RuntimeFunctionDefinition was last updated */
   updatedAt?: Maybe<Scalars['Time']['output']>;
 }
 
 
-/** Represents a Node Function definition */
+/** Represents a runtime function definition */
 export interface RuntimeFunctionDefinitionFunctionDefinitionsArgs {
   after?: InputMaybe<Scalars['String']['input']>;
   before?: InputMaybe<Scalars['String']['input']>;
@@ -2236,7 +2555,16 @@ export interface RuntimeFunctionDefinitionFunctionDefinitionsArgs {
   last?: InputMaybe<Scalars['Int']['input']>;
 }
 
-/** Represents a Node parameter definition */
+
+/** 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 */
 export interface RuntimeParameterDefinition {
   __typename?: 'RuntimeParameterDefinition';
   /** Time when this RuntimeParameterDefinition was created */
@@ -2247,14 +2575,47 @@ export interface RuntimeParameterDefinition {
   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>;
+}
+
 /** Represent all available types of statuses of a runtime */
-export enum RuntimeStatusType {
+export const 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. */
@@ -2381,23 +2742,40 @@ export interface User {
   createdAt?: Maybe<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']>;
   /** Firstname of the user */
   firstname?: Maybe<Scalars['String']['output']>;
   /** Global ID of this User */
   id?: Maybe<Scalars['UserID']['output']>;
+  /** Identities of this user */
+  identities?: Maybe<UserIdentityConnection>;
   /** Lastname of the user */
   lastname?: Maybe<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>;
   /** Time when this User was last updated */
   updatedAt?: Maybe<Scalars['Time']['output']>;
+  /** Abilities for the current user on this User */
+  userAbilities?: Maybe<UserUserAbilities>;
   /** 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']>;
+}
+
+
 /** Represents a user */
 export interface UserNamespaceMembershipsArgs {
   after?: InputMaybe<Scalars['String']['input']>;
@@ -2406,6 +2784,15 @@ 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';
@@ -2445,6 +2832,28 @@ export interface UserIdentity {
   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>;
+}
+
 /** Represents a user session */
 export interface UserSession {
   __typename?: 'UserSession';
@@ -2460,6 +2869,46 @@ export interface UserSession {
   updatedAt?: Maybe<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 UsersEmailVerification */
@@ -2665,6 +3114,48 @@ export interface UsersMfaTotpValidateSecretPayload {
   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. */

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@code0-tech/sagittarius-graphql-types",
-  "version": "0.0.0-967667e8c736081887d32d99a5e2ab0445718798",
+  "version": "0.0.0-beb91167a8ea12eb6d4a6e3933483bacf845f2f6",
   "description": "",
-  "main": "index.js",
+  "main": "index.d.ts",
   "types": "index.d.ts",
   "scripts": {
     "generate": "graphql-codegen --config codegen.ts"
@@ -23,7 +23,6 @@
   },
   "files": [
     "index.d.ts",
-    "index.js",
     "package.json"
   ],
   "publishConfig": {