docs: public static MetadataBuilder forProvider(Class<? extends RuleProvider> implementationType, String providerId)
      {
          Assert.notNull(implementationType, "Rule provider Implementation type must not be null.");
          Assert.notNull(providerId, "Rule provider ID must not be null.");
  
          MetadataBuilder builder = new MetadataBuilder(implementationType, providerId)
                      .setOrigin(implementationType.getName() + " loaded from " + implementationType.getClassLoader().toString());
  
          RuleMetadata metadata = Annotations.getAnnotation(implementationType, RuleMetadata.class);
          if (metadata == null)
              return builder;
  
          builder.setOverrideProvider(metadata.overrideProvider());
  
          if (StringUtils.isNotBlank(metadata.description()))
              builder.setDescription(metadata.description());
  
          Class<? extends RuleProvider>[] after = metadata.after();
          if (after.length > 0)
              builder.setExecuteAfter(Arrays.asList(after));
  
          String[] afterIDs = metadata.afterIDs();
          if (afterIDs.length > 0)
              builder.setExecuteAfterIDs(Arrays.asList(afterIDs));
  
          Class<? extends RuleProvider>[] before = metadata.before();
          if (before.length > 0)
              builder.setExecuteBefore(Arrays.asList(before));
  
          String[] beforeIDs = metadata.beforeIDs();
          if (beforeIDs.length > 0)
              builder.setExecuteBeforeIDs(Arrays.asList(beforeIDs));
  
          builder.setPhase(metadata.phase());
  
          String[] tags = metadata.tags();
          if (tags.length > 0)
              builder.setTags(Arrays.asList(tags));
  
          Technology[] sourceTechnologies = metadata.sourceTechnologies();
          if (sourceTechnologies.length > 0)
          {
              for (Technology technology : sourceTechnologies)
              {
                  builder.addSourceTechnology(new TechnologyReference(
                              technology.id(),
                              "".equals(technology.versionRange().trim())
                                      ? new EmptyVersionRange()
                                      : Versions.parseVersionRange(technology.versionRange())));
              }
          }
  
          Technology[] targetTechnologies = metadata.targetTechnologies();
          if (targetTechnologies.length > 0)
          {
              for (Technology technology : targetTechnologies)
              {
                  builder.addTargetTechnology(new TechnologyReference(
                              technology.id(),
                              "".equals(technology.versionRange().trim())
                                      ? new EmptyVersionRange()
                                      : Versions.parseVersionRange(technology.versionRange())));
              }
          }
  
          builder.haltOnException = metadata.haltOnException();
          builder.disabled = metadata.disabled();
          if (builder.disabled)
              LOG.info("Disabled provider: " + providerId);
  
          return builder;
      }