{
  "formatVersion": "1.1",
  "component": {
    "group": "${pom.groupId}",
    "module": "${pom.artifactId}",
    "version": "${pom.version}",
    "attributes": {
      "org.gradle.status": "${module.status}"
    }
  },
  "createdBy": {
    "maven": {
      "version": "${maven.version}",
      "buildId": "${maven.build.version}"
    }
  },
  "variants": [
    {
      "name": "${variant.jvmEnvironmentVariantName}ApiElements",

            Path tempDir = Files.createTempDirectory("apply-test");
            try {
                Path pomFile = tempDir.resolve("pom.xml");
                String pomContent = PomBuilder.create()
                        .groupId("test")
                        .artifactId("test")
                        .version("1.0.0")
                        .build();
                Files.writeString(pomFile, pomContent);

- **Maven 3.6+** or **Gradle 7+** for build management
- **Optional**: SLF4J or Commons Logging for logging support

### Maven Dependency
```xml
<dependency>
    <groupId>org.codelibs</groupId>
    <artifactId>corelib</artifactId>
    <version>0.7.0</version>
</dependency>
```

### Gradle Dependency
```gradle
implementation 'org.codelibs:corelib:0.7.0'
```

## 📖 Usage Examples

        packagingRegistry = EMPTY_PACKAGING_REGISTRY;
    }

    private static Plugin newPlugin(String artifactId, String... goals) {
        return Plugin.newBuilder()
                .groupId("org.apache.maven.plugins")
                .artifactId(artifactId)
                .executions(Arrays.stream(goals)
                        .map(goal -> PluginExecution.newBuilder()

        remove(project.dependencies.gradleTestKit())
    }
}

publishing.publications.withType<MavenPublication>().configureEach {
    if (name == "pluginMaven") {
        groupId = project.group.toString()
        artifactId = gradleModule.identity.baseName.get()
    }
    pom {
        licenses {
            license {
                name = "The Apache License, Version 2.0"

 * </p>
 *
 * @since 4.0.0
 */
@Experimental
@Immutable
public interface Artifact {
    /**
     * {@return a unique identifier for this artifact}.
     * The identifier is composed of groupId, artifactId, extension, classifier, and version.
     *
     * @see ArtifactCoordinates#getId()
     */
    @Nonnull
    default String key() {
        String c = getClassifier();
        return getGroupId()

        }
        return result.getRawModel();
    }

    /**
     * Gets the identifier of the POM whose effective model could not be built. The general format of the identifier is
     * {@code <groupId>:<artifactId>:<version>} but some of these coordinates may still be unknown at the point the
     * exception is thrown so this information is merely meant to assist the user.
     *

		t.Fatalf("CreateInBatches failed: %v", err)
	}

	grouped, err := gorm.G[User](DB).Select("name").Where("name like ?", "GenericsGroupHaving%").Group("name").Having("COUNT(id) > ?", 1).Find(ctx)
	if err != nil {
		t.Fatalf("Group+Having Find failed: %v", err)
	}

	if len(grouped) != 1 {
		t.Errorf("expected 1 group with count>1, got %d", len(grouped))
	} else if grouped[0].Name != "GenericsGroupHavingMulti" {

public interface ModelBuildingResult {

    /**
     * Gets the sequence of model identifiers that denote the lineage of models from which the effective model was
     * constructed. Model identifiers have the form {@code <groupId>:<artifactId>:<version>}. The first identifier from
     * the list denotes the model on which the model builder was originally invoked. The last identifier will always be
     * an empty string that by definition denotes the super POM.

	}

	// Set policy via group and validate policy assignment.
	groupDN := "cn=projectb,ou=groups,ou=swengg,dc=min,dc=io"
	groupReq := madmin.PolicyAssociationReq{
		Policies: []string{policy},
		Group:    groupDN,
	}

	if _, err = s.adm.AttachPolicyLDAP(ctx, groupReq); err != nil {
		c.Fatalf("Unable to attach group policy: %v", err)
	}

	value, err = ldapID.Retrieve()