Function createTypirLangiumServices

Parameters

• langiumServices: LangiumSharedCoreServices

  Typir-Langium needs to interact with the Langium lifecycle
• reflection: AbstractAstReflection

  Typir-Langium needs to know the existing AstNode$.types in order to do some performance optimizations
• typeSystemDefinition: LangiumTypeSystemDefinition<Specifics>

  the actual definition of the type system
• Optionalcustomization1: Module<
      {
          Assignability?: TypeAssignability;
          caching?: {
              LanguageNodeInference?: LanguageNodeInferenceCaching;
              TypeRelationships?: TypeRelationshipCaching;
          };
          Conversion?: TypeConversion;
          Equality?: TypeEquality;
          factory?: {
              Bottom?: BottomFactoryService<Specifics>;
              Classes?: ClassFactoryService<Specifics>;
              Functions?: FunctionFactoryService<Specifics>;
              Operators?: OperatorFactoryService<Specifics>;
              Primitives?: PrimitiveFactoryService<Specifics>;
              Top?: TopFactoryService<Specifics>;
          };
          Inference?: TypeInferenceCollector<Specifics> & LangiumTypeInferenceCollector<
              Specifics,
          >;
          infrastructure?: {
              Graph?: TypeGraph;
              GraphAlgorithms?: GraphAlgorithms;
              Kinds?: KindRegistry<Specifics>;
              TypeResolver?: TypeResolvingService<Specifics>;
          };
          langium?: {
              LangiumServices?: {
                  AstReflection?: {
                      getAllSubTypes?: (type: ...) => ...;
                      getAllTypes?: () => ...;
                      getReferenceType?: (refInfo: ...) => ...;
                      getTypeMetaData?: (type: ...) => ...;
                      isInstance?: (node: ..., type: ...) => ...;
                      isSubtype?: (subtype: ..., supertype: ...) => ...;
                      types?: { [key: ...]: ... };
                  };
                  ServiceRegistry?: {
                      all?: readonly (...)[];
                      getServices?: (uri: ...) => ...;
                      hasServices?: (uri: ...) => ...;
                      register?: (language: ...) => ...;
                  };
                  workspace?: {
                      ConfigurationProvider?: {
                          getConfiguration?: ...;
                          initialize?: ...;
                          initialized?: ...;
                          onConfigurationSectionUpdate?: ...;
                          ready?: ...;
                          updateConfiguration?: ...;
                      };
                      DocumentBuilder?: {
                          build?: ...;
                          onBuildPhase?: ...;
                          onDocumentPhase?: ...;
                          onUpdate?: ...;
                          resetToState?: ...;
                          update?: ...;
                          updateBuildOptions?: ...;
                          waitUntil?: ...;
                      };
                      FileSystemProvider?: FileSystemProvider;
                      IndexManager?: IndexManager;
                      LangiumDocumentFactory?: LangiumDocumentFactory;
                      LangiumDocuments?: {
                          addDocument?: ...;
                          all?: ...;
                          createDocument?: ...;
                          deleteDocument?: ...;
                          deleteDocuments?: ...;
                          getDocument?: ...;
                          getOrCreateDocument?: ...;
                          hasDocument?: ...;
                          invalidateDocument?: ...;
                      };
                      TextDocuments?: TextDocumentProvider;
                      WorkspaceLock?: WorkspaceLock;
                      WorkspaceManager?: {
                          initialBuildOptions?: ...;
                          initialize?: ...;
                          initialized?: ...;
                          initializeWorkspace?: ...;
                          ready?: ...;
                          searchFolder?: ...;
                          shouldIncludeEntry?: ...;
                          workspaceFolders?: ...;
                      };
                  };
              };
              TypeCreator?: LangiumTypeCreator;
              TypeSystemDefinition?: LangiumTypeSystemDefinition<Specifics>;
          };
          Language?: LanguageService<Specifics>;
          Printer?: ProblemPrinter<Specifics>;
          Subtype?: SubType;
          validation?: {
              Collector?: ValidationCollector<Specifics> & LangiumValidationCollector<
                  Specifics,
              >;
              Constraints?: ValidationConstraints<Specifics>;
              TypeValidation?: LangiumTypirValidator<Specifics>;
          };
      },
      {
          Assignability?: TypeAssignability;
          caching?: {
              LanguageNodeInference?: LanguageNodeInferenceCaching;
              TypeRelationships?: TypeRelationshipCaching;
          };
          Conversion?: TypeConversion;
          Equality?: TypeEquality;
          factory?: {
              Bottom?: BottomFactoryService<Specifics>;
              Classes?: ClassFactoryService<Specifics>;
              Functions?: FunctionFactoryService<Specifics>;
              Operators?: OperatorFactoryService<Specifics>;
              Primitives?: PrimitiveFactoryService<Specifics>;
              Top?: TopFactoryService<Specifics>;
          };
          Inference?: TypeInferenceCollector<Specifics> & LangiumTypeInferenceCollector<
              Specifics,
          >;
          infrastructure?: {
              Graph?: TypeGraph;
              GraphAlgorithms?: GraphAlgorithms;
              Kinds?: KindRegistry<Specifics>;
              TypeResolver?: TypeResolvingService<Specifics>;
          };
          langium?: {
              LangiumServices?: {
                  AstReflection?: {
                      getAllSubTypes?: (type: ...) => ...;
                      getAllTypes?: () => ...;
                      getReferenceType?: (refInfo: ...) => ...;
                      getTypeMetaData?: (type: ...) => ...;
                      isInstance?: (node: ..., type: ...) => ...;
                      isSubtype?: (subtype: ..., supertype: ...) => ...;
                      types?: { [key: ...]: ... };
                  };
                  ServiceRegistry?: {
                      all?: readonly (...)[];
                      getServices?: (uri: ...) => ...;
                      hasServices?: (uri: ...) => ...;
                      register?: (language: ...) => ...;
                  };
                  workspace?: {
                      ConfigurationProvider?: {
                          getConfiguration?: ...;
                          initialize?: ...;
                          initialized?: ...;
                          onConfigurationSectionUpdate?: ...;
                          ready?: ...;
                          updateConfiguration?: ...;
                      };
                      DocumentBuilder?: {
                          build?: ...;
                          onBuildPhase?: ...;
                          onDocumentPhase?: ...;
                          onUpdate?: ...;
                          resetToState?: ...;
                          update?: ...;
                          updateBuildOptions?: ...;
                          waitUntil?: ...;
                      };
                      FileSystemProvider?: FileSystemProvider;
                      IndexManager?: IndexManager;
                      LangiumDocumentFactory?: LangiumDocumentFactory;
                      LangiumDocuments?: {
                          addDocument?: ...;
                          all?: ...;
                          createDocument?: ...;
                          deleteDocument?: ...;
                          deleteDocuments?: ...;
                          getDocument?: ...;
                          getOrCreateDocument?: ...;
                          hasDocument?: ...;
                          invalidateDocument?: ...;
                      };
                      TextDocuments?: TextDocumentProvider;
                      WorkspaceLock?: WorkspaceLock;
                      WorkspaceManager?: {
                          initialBuildOptions?: ...;
                          initialize?: ...;
                          initialized?: ...;
                          initializeWorkspace?: ...;
                          ready?: ...;
                          searchFolder?: ...;
                          shouldIncludeEntry?: ...;
                          workspaceFolders?: ...;
                      };
                  };
              };
              TypeCreator?: LangiumTypeCreator;
              TypeSystemDefinition?: LangiumTypeSystemDefinition<Specifics>;
          };
          Language?: LanguageService<Specifics>;
          Printer?: ProblemPrinter<Specifics>;
          Subtype?: SubType;
          validation?: {
              Collector?: ValidationCollector<Specifics> & LangiumValidationCollector<
                  Specifics,
              >;
              Constraints?: ValidationConstraints<Specifics>;
              TypeValidation?: LangiumTypirValidator<Specifics>;
          };
      },
  >

  some optional customizations of the Typir-Langium and Typir(-core) services, e.g. for production
• Optionalcustomization2: Module<
      {
          Assignability?: TypeAssignability;
          caching?: {
              LanguageNodeInference?: LanguageNodeInferenceCaching;
              TypeRelationships?: TypeRelationshipCaching;
          };
          Conversion?: TypeConversion;
          Equality?: TypeEquality;
          factory?: {
              Bottom?: BottomFactoryService<Specifics>;
              Classes?: ClassFactoryService<Specifics>;
              Functions?: FunctionFactoryService<Specifics>;
              Operators?: OperatorFactoryService<Specifics>;
              Primitives?: PrimitiveFactoryService<Specifics>;
              Top?: TopFactoryService<Specifics>;
          };
          Inference?: TypeInferenceCollector<Specifics> & LangiumTypeInferenceCollector<
              Specifics,
          >;
          infrastructure?: {
              Graph?: TypeGraph;
              GraphAlgorithms?: GraphAlgorithms;
              Kinds?: KindRegistry<Specifics>;
              TypeResolver?: TypeResolvingService<Specifics>;
          };
          langium?: {
              LangiumServices?: {
                  AstReflection?: {
                      getAllSubTypes?: (type: ...) => ...;
                      getAllTypes?: () => ...;
                      getReferenceType?: (refInfo: ...) => ...;
                      getTypeMetaData?: (type: ...) => ...;
                      isInstance?: (node: ..., type: ...) => ...;
                      isSubtype?: (subtype: ..., supertype: ...) => ...;
                      types?: { [key: ...]: ... };
                  };
                  ServiceRegistry?: {
                      all?: readonly (...)[];
                      getServices?: (uri: ...) => ...;
                      hasServices?: (uri: ...) => ...;
                      register?: (language: ...) => ...;
                  };
                  workspace?: {
                      ConfigurationProvider?: {
                          getConfiguration?: ...;
                          initialize?: ...;
                          initialized?: ...;
                          onConfigurationSectionUpdate?: ...;
                          ready?: ...;
                          updateConfiguration?: ...;
                      };
                      DocumentBuilder?: {
                          build?: ...;
                          onBuildPhase?: ...;
                          onDocumentPhase?: ...;
                          onUpdate?: ...;
                          resetToState?: ...;
                          update?: ...;
                          updateBuildOptions?: ...;
                          waitUntil?: ...;
                      };
                      FileSystemProvider?: FileSystemProvider;
                      IndexManager?: IndexManager;
                      LangiumDocumentFactory?: LangiumDocumentFactory;
                      LangiumDocuments?: {
                          addDocument?: ...;
                          all?: ...;
                          createDocument?: ...;
                          deleteDocument?: ...;
                          deleteDocuments?: ...;
                          getDocument?: ...;
                          getOrCreateDocument?: ...;
                          hasDocument?: ...;
                          invalidateDocument?: ...;
                      };
                      TextDocuments?: TextDocumentProvider;
                      WorkspaceLock?: WorkspaceLock;
                      WorkspaceManager?: {
                          initialBuildOptions?: ...;
                          initialize?: ...;
                          initialized?: ...;
                          initializeWorkspace?: ...;
                          ready?: ...;
                          searchFolder?: ...;
                          shouldIncludeEntry?: ...;
                          workspaceFolders?: ...;
                      };
                  };
              };
              TypeCreator?: LangiumTypeCreator;
              TypeSystemDefinition?: LangiumTypeSystemDefinition<Specifics>;
          };
          Language?: LanguageService<Specifics>;
          Printer?: ProblemPrinter<Specifics>;
          Subtype?: SubType;
          validation?: {
              Collector?: ValidationCollector<Specifics> & LangiumValidationCollector<
                  Specifics,
              >;
              Constraints?: ValidationConstraints<Specifics>;
              TypeValidation?: LangiumTypirValidator<Specifics>;
          };
      },
      {
          Assignability?: TypeAssignability;
          caching?: {
              LanguageNodeInference?: LanguageNodeInferenceCaching;
              TypeRelationships?: TypeRelationshipCaching;
          };
          Conversion?: TypeConversion;
          Equality?: TypeEquality;
          factory?: {
              Bottom?: BottomFactoryService<Specifics>;
              Classes?: ClassFactoryService<Specifics>;
              Functions?: FunctionFactoryService<Specifics>;
              Operators?: OperatorFactoryService<Specifics>;
              Primitives?: PrimitiveFactoryService<Specifics>;
              Top?: TopFactoryService<Specifics>;
          };
          Inference?: TypeInferenceCollector<Specifics> & LangiumTypeInferenceCollector<
              Specifics,
          >;
          infrastructure?: {
              Graph?: TypeGraph;
              GraphAlgorithms?: GraphAlgorithms;
              Kinds?: KindRegistry<Specifics>;
              TypeResolver?: TypeResolvingService<Specifics>;
          };
          langium?: {
              LangiumServices?: {
                  AstReflection?: {
                      getAllSubTypes?: (type: ...) => ...;
                      getAllTypes?: () => ...;
                      getReferenceType?: (refInfo: ...) => ...;
                      getTypeMetaData?: (type: ...) => ...;
                      isInstance?: (node: ..., type: ...) => ...;
                      isSubtype?: (subtype: ..., supertype: ...) => ...;
                      types?: { [key: ...]: ... };
                  };
                  ServiceRegistry?: {
                      all?: readonly (...)[];
                      getServices?: (uri: ...) => ...;
                      hasServices?: (uri: ...) => ...;
                      register?: (language: ...) => ...;
                  };
                  workspace?: {
                      ConfigurationProvider?: {
                          getConfiguration?: ...;
                          initialize?: ...;
                          initialized?: ...;
                          onConfigurationSectionUpdate?: ...;
                          ready?: ...;
                          updateConfiguration?: ...;
                      };
                      DocumentBuilder?: {
                          build?: ...;
                          onBuildPhase?: ...;
                          onDocumentPhase?: ...;
                          onUpdate?: ...;
                          resetToState?: ...;
                          update?: ...;
                          updateBuildOptions?: ...;
                          waitUntil?: ...;
                      };
                      FileSystemProvider?: FileSystemProvider;
                      IndexManager?: IndexManager;
                      LangiumDocumentFactory?: LangiumDocumentFactory;
                      LangiumDocuments?: {
                          addDocument?: ...;
                          all?: ...;
                          createDocument?: ...;
                          deleteDocument?: ...;
                          deleteDocuments?: ...;
                          getDocument?: ...;
                          getOrCreateDocument?: ...;
                          hasDocument?: ...;
                          invalidateDocument?: ...;
                      };
                      TextDocuments?: TextDocumentProvider;
                      WorkspaceLock?: WorkspaceLock;
                      WorkspaceManager?: {
                          initialBuildOptions?: ...;
                          initialize?: ...;
                          initialized?: ...;
                          initializeWorkspace?: ...;
                          ready?: ...;
                          searchFolder?: ...;
                          shouldIncludeEntry?: ...;
                          workspaceFolders?: ...;
                      };
                  };
              };
              TypeCreator?: LangiumTypeCreator;
              TypeSystemDefinition?: LangiumTypeSystemDefinition<Specifics>;
          };
          Language?: LanguageService<Specifics>;
          Printer?: ProblemPrinter<Specifics>;
          Subtype?: SubType;
          validation?: {
              Collector?: ValidationCollector<Specifics> & LangiumValidationCollector<
                  Specifics,
              >;
              Constraints?: ValidationConstraints<Specifics>;
              TypeValidation?: LangiumTypirValidator<Specifics>;
          };
      },
  >

  some optional customizations of the Typir-Langium and Typir(-core) services, e.g. for testing
• Optionalcustomization3: Module<
      {
          Assignability?: TypeAssignability;
          caching?: {
              LanguageNodeInference?: LanguageNodeInferenceCaching;
              TypeRelationships?: TypeRelationshipCaching;
          };
          Conversion?: TypeConversion;
          Equality?: TypeEquality;
          factory?: {
              Bottom?: BottomFactoryService<Specifics>;
              Classes?: ClassFactoryService<Specifics>;
              Functions?: FunctionFactoryService<Specifics>;
              Operators?: OperatorFactoryService<Specifics>;
              Primitives?: PrimitiveFactoryService<Specifics>;
              Top?: TopFactoryService<Specifics>;
          };
          Inference?: TypeInferenceCollector<Specifics> & LangiumTypeInferenceCollector<
              Specifics,
          >;
          infrastructure?: {
              Graph?: TypeGraph;
              GraphAlgorithms?: GraphAlgorithms;
              Kinds?: KindRegistry<Specifics>;
              TypeResolver?: TypeResolvingService<Specifics>;
          };
          langium?: {
              LangiumServices?: {
                  AstReflection?: {
                      getAllSubTypes?: (type: ...) => ...;
                      getAllTypes?: () => ...;
                      getReferenceType?: (refInfo: ...) => ...;
                      getTypeMetaData?: (type: ...) => ...;
                      isInstance?: (node: ..., type: ...) => ...;
                      isSubtype?: (subtype: ..., supertype: ...) => ...;
                      types?: { [key: ...]: ... };
                  };
                  ServiceRegistry?: {
                      all?: readonly (...)[];
                      getServices?: (uri: ...) => ...;
                      hasServices?: (uri: ...) => ...;
                      register?: (language: ...) => ...;
                  };
                  workspace?: {
                      ConfigurationProvider?: {
                          getConfiguration?: ...;
                          initialize?: ...;
                          initialized?: ...;
                          onConfigurationSectionUpdate?: ...;
                          ready?: ...;
                          updateConfiguration?: ...;
                      };
                      DocumentBuilder?: {
                          build?: ...;
                          onBuildPhase?: ...;
                          onDocumentPhase?: ...;
                          onUpdate?: ...;
                          resetToState?: ...;
                          update?: ...;
                          updateBuildOptions?: ...;
                          waitUntil?: ...;
                      };
                      FileSystemProvider?: FileSystemProvider;
                      IndexManager?: IndexManager;
                      LangiumDocumentFactory?: LangiumDocumentFactory;
                      LangiumDocuments?: {
                          addDocument?: ...;
                          all?: ...;
                          createDocument?: ...;
                          deleteDocument?: ...;
                          deleteDocuments?: ...;
                          getDocument?: ...;
                          getOrCreateDocument?: ...;
                          hasDocument?: ...;
                          invalidateDocument?: ...;
                      };
                      TextDocuments?: TextDocumentProvider;
                      WorkspaceLock?: WorkspaceLock;
                      WorkspaceManager?: {
                          initialBuildOptions?: ...;
                          initialize?: ...;
                          initialized?: ...;
                          initializeWorkspace?: ...;
                          ready?: ...;
                          searchFolder?: ...;
                          shouldIncludeEntry?: ...;
                          workspaceFolders?: ...;
                      };
                  };
              };
              TypeCreator?: LangiumTypeCreator;
              TypeSystemDefinition?: LangiumTypeSystemDefinition<Specifics>;
          };
          Language?: LanguageService<Specifics>;
          Printer?: ProblemPrinter<Specifics>;
          Subtype?: SubType;
          validation?: {
              Collector?: ValidationCollector<Specifics> & LangiumValidationCollector<
                  Specifics,
              >;
              Constraints?: ValidationConstraints<Specifics>;
              TypeValidation?: LangiumTypirValidator<Specifics>;
          };
      },
      {
          Assignability?: TypeAssignability;
          caching?: {
              LanguageNodeInference?: LanguageNodeInferenceCaching;
              TypeRelationships?: TypeRelationshipCaching;
          };
          Conversion?: TypeConversion;
          Equality?: TypeEquality;
          factory?: {
              Bottom?: BottomFactoryService<Specifics>;
              Classes?: ClassFactoryService<Specifics>;
              Functions?: FunctionFactoryService<Specifics>;
              Operators?: OperatorFactoryService<Specifics>;
              Primitives?: PrimitiveFactoryService<Specifics>;
              Top?: TopFactoryService<Specifics>;
          };
          Inference?: TypeInferenceCollector<Specifics> & LangiumTypeInferenceCollector<
              Specifics,
          >;
          infrastructure?: {
              Graph?: TypeGraph;
              GraphAlgorithms?: GraphAlgorithms;
              Kinds?: KindRegistry<Specifics>;
              TypeResolver?: TypeResolvingService<Specifics>;
          };
          langium?: {
              LangiumServices?: {
                  AstReflection?: {
                      getAllSubTypes?: (type: ...) => ...;
                      getAllTypes?: () => ...;
                      getReferenceType?: (refInfo: ...) => ...;
                      getTypeMetaData?: (type: ...) => ...;
                      isInstance?: (node: ..., type: ...) => ...;
                      isSubtype?: (subtype: ..., supertype: ...) => ...;
                      types?: { [key: ...]: ... };
                  };
                  ServiceRegistry?: {
                      all?: readonly (...)[];
                      getServices?: (uri: ...) => ...;
                      hasServices?: (uri: ...) => ...;
                      register?: (language: ...) => ...;
                  };
                  workspace?: {
                      ConfigurationProvider?: {
                          getConfiguration?: ...;
                          initialize?: ...;
                          initialized?: ...;
                          onConfigurationSectionUpdate?: ...;
                          ready?: ...;
                          updateConfiguration?: ...;
                      };
                      DocumentBuilder?: {
                          build?: ...;
                          onBuildPhase?: ...;
                          onDocumentPhase?: ...;
                          onUpdate?: ...;
                          resetToState?: ...;
                          update?: ...;
                          updateBuildOptions?: ...;
                          waitUntil?: ...;
                      };
                      FileSystemProvider?: FileSystemProvider;
                      IndexManager?: IndexManager;
                      LangiumDocumentFactory?: LangiumDocumentFactory;
                      LangiumDocuments?: {
                          addDocument?: ...;
                          all?: ...;
                          createDocument?: ...;
                          deleteDocument?: ...;
                          deleteDocuments?: ...;
                          getDocument?: ...;
                          getOrCreateDocument?: ...;
                          hasDocument?: ...;
                          invalidateDocument?: ...;
                      };
                      TextDocuments?: TextDocumentProvider;
                      WorkspaceLock?: WorkspaceLock;
                      WorkspaceManager?: {
                          initialBuildOptions?: ...;
                          initialize?: ...;
                          initialized?: ...;
                          initializeWorkspace?: ...;
                          ready?: ...;
                          searchFolder?: ...;
                          shouldIncludeEntry?: ...;
                          workspaceFolders?: ...;
                      };
                  };
              };
              TypeCreator?: LangiumTypeCreator;
              TypeSystemDefinition?: LangiumTypeSystemDefinition<Specifics>;
          };
          Language?: LanguageService<Specifics>;
          Printer?: ProblemPrinter<Specifics>;
          Subtype?: SubType;
          validation?: {
              Collector?: ValidationCollector<Specifics> & LangiumValidationCollector<
                  Specifics,
              >;
              Constraints?: ValidationConstraints<Specifics>;
              TypeValidation?: LangiumTypirValidator<Specifics>;
          };
      },
  >

  some optional customizations of the Typir-Langium and Typir(-core) services, e.g. for testing
• Optionalcustomization4: Module<
      {
          Assignability?: TypeAssignability;
          caching?: {
              LanguageNodeInference?: LanguageNodeInferenceCaching;
              TypeRelationships?: TypeRelationshipCaching;
          };
          Conversion?: TypeConversion;
          Equality?: TypeEquality;
          factory?: {
              Bottom?: BottomFactoryService<Specifics>;
              Classes?: ClassFactoryService<Specifics>;
              Functions?: FunctionFactoryService<Specifics>;
              Operators?: OperatorFactoryService<Specifics>;
              Primitives?: PrimitiveFactoryService<Specifics>;
              Top?: TopFactoryService<Specifics>;
          };
          Inference?: TypeInferenceCollector<Specifics> & LangiumTypeInferenceCollector<
              Specifics,
          >;
          infrastructure?: {
              Graph?: TypeGraph;
              GraphAlgorithms?: GraphAlgorithms;
              Kinds?: KindRegistry<Specifics>;
              TypeResolver?: TypeResolvingService<Specifics>;
          };
          langium?: {
              LangiumServices?: {
                  AstReflection?: {
                      getAllSubTypes?: (type: ...) => ...;
                      getAllTypes?: () => ...;
                      getReferenceType?: (refInfo: ...) => ...;
                      getTypeMetaData?: (type: ...) => ...;
                      isInstance?: (node: ..., type: ...) => ...;
                      isSubtype?: (subtype: ..., supertype: ...) => ...;
                      types?: { [key: ...]: ... };
                  };
                  ServiceRegistry?: {
                      all?: readonly (...)[];
                      getServices?: (uri: ...) => ...;
                      hasServices?: (uri: ...) => ...;
                      register?: (language: ...) => ...;
                  };
                  workspace?: {
                      ConfigurationProvider?: {
                          getConfiguration?: ...;
                          initialize?: ...;
                          initialized?: ...;
                          onConfigurationSectionUpdate?: ...;
                          ready?: ...;
                          updateConfiguration?: ...;
                      };
                      DocumentBuilder?: {
                          build?: ...;
                          onBuildPhase?: ...;
                          onDocumentPhase?: ...;
                          onUpdate?: ...;
                          resetToState?: ...;
                          update?: ...;
                          updateBuildOptions?: ...;
                          waitUntil?: ...;
                      };
                      FileSystemProvider?: FileSystemProvider;
                      IndexManager?: IndexManager;
                      LangiumDocumentFactory?: LangiumDocumentFactory;
                      LangiumDocuments?: {
                          addDocument?: ...;
                          all?: ...;
                          createDocument?: ...;
                          deleteDocument?: ...;
                          deleteDocuments?: ...;
                          getDocument?: ...;
                          getOrCreateDocument?: ...;
                          hasDocument?: ...;
                          invalidateDocument?: ...;
                      };
                      TextDocuments?: TextDocumentProvider;
                      WorkspaceLock?: WorkspaceLock;
                      WorkspaceManager?: {
                          initialBuildOptions?: ...;
                          initialize?: ...;
                          initialized?: ...;
                          initializeWorkspace?: ...;
                          ready?: ...;
                          searchFolder?: ...;
                          shouldIncludeEntry?: ...;
                          workspaceFolders?: ...;
                      };
                  };
              };
              TypeCreator?: LangiumTypeCreator;
              TypeSystemDefinition?: LangiumTypeSystemDefinition<Specifics>;
          };
          Language?: LanguageService<Specifics>;
          Printer?: ProblemPrinter<Specifics>;
          Subtype?: SubType;
          validation?: {
              Collector?: ValidationCollector<Specifics> & LangiumValidationCollector<
                  Specifics,
              >;
              Constraints?: ValidationConstraints<Specifics>;
              TypeValidation?: LangiumTypirValidator<Specifics>;
          };
      },
      {
          Assignability?: TypeAssignability;
          caching?: {
              LanguageNodeInference?: LanguageNodeInferenceCaching;
              TypeRelationships?: TypeRelationshipCaching;
          };
          Conversion?: TypeConversion;
          Equality?: TypeEquality;
          factory?: {
              Bottom?: BottomFactoryService<Specifics>;
              Classes?: ClassFactoryService<Specifics>;
              Functions?: FunctionFactoryService<Specifics>;
              Operators?: OperatorFactoryService<Specifics>;
              Primitives?: PrimitiveFactoryService<Specifics>;
              Top?: TopFactoryService<Specifics>;
          };
          Inference?: TypeInferenceCollector<Specifics> & LangiumTypeInferenceCollector<
              Specifics,
          >;
          infrastructure?: {
              Graph?: TypeGraph;
              GraphAlgorithms?: GraphAlgorithms;
              Kinds?: KindRegistry<Specifics>;
              TypeResolver?: TypeResolvingService<Specifics>;
          };
          langium?: {
              LangiumServices?: {
                  AstReflection?: {
                      getAllSubTypes?: (type: ...) => ...;
                      getAllTypes?: () => ...;
                      getReferenceType?: (refInfo: ...) => ...;
                      getTypeMetaData?: (type: ...) => ...;
                      isInstance?: (node: ..., type: ...) => ...;
                      isSubtype?: (subtype: ..., supertype: ...) => ...;
                      types?: { [key: ...]: ... };
                  };
                  ServiceRegistry?: {
                      all?: readonly (...)[];
                      getServices?: (uri: ...) => ...;
                      hasServices?: (uri: ...) => ...;
                      register?: (language: ...) => ...;
                  };
                  workspace?: {
                      ConfigurationProvider?: {
                          getConfiguration?: ...;
                          initialize?: ...;
                          initialized?: ...;
                          onConfigurationSectionUpdate?: ...;
                          ready?: ...;
                          updateConfiguration?: ...;
                      };
                      DocumentBuilder?: {
                          build?: ...;
                          onBuildPhase?: ...;
                          onDocumentPhase?: ...;
                          onUpdate?: ...;
                          resetToState?: ...;
                          update?: ...;
                          updateBuildOptions?: ...;
                          waitUntil?: ...;
                      };
                      FileSystemProvider?: FileSystemProvider;
                      IndexManager?: IndexManager;
                      LangiumDocumentFactory?: LangiumDocumentFactory;
                      LangiumDocuments?: {
                          addDocument?: ...;
                          all?: ...;
                          createDocument?: ...;
                          deleteDocument?: ...;
                          deleteDocuments?: ...;
                          getDocument?: ...;
                          getOrCreateDocument?: ...;
                          hasDocument?: ...;
                          invalidateDocument?: ...;
                      };
                      TextDocuments?: TextDocumentProvider;
                      WorkspaceLock?: WorkspaceLock;
                      WorkspaceManager?: {
                          initialBuildOptions?: ...;
                          initialize?: ...;
                          initialized?: ...;
                          initializeWorkspace?: ...;
                          ready?: ...;
                          searchFolder?: ...;
                          shouldIncludeEntry?: ...;
                          workspaceFolders?: ...;
                      };
                  };
              };
              TypeCreator?: LangiumTypeCreator;
              TypeSystemDefinition?: LangiumTypeSystemDefinition<Specifics>;
          };
          Language?: LanguageService<Specifics>;
          Printer?: ProblemPrinter<Specifics>;
          Subtype?: SubType;
          validation?: {
              Collector?: ValidationCollector<Specifics> & LangiumValidationCollector<
                  Specifics,
              >;
              Constraints?: ValidationConstraints<Specifics>;
              TypeValidation?: LangiumTypirValidator<Specifics>;
          };
      },
  >

  some optional customizations of the Typir-Langium and Typir(-core) services