Gradle Maven Publish Plugin

https://vanniktech.github.io/gradle-maven-publish-plugin
Admin
A Gradle plugin that automates publishing Java, Kotlin, and Android libraries to Maven repositories...
Tokens:19,152
Snippets:182
Trust Score:8.3
Update:3 months ago
Show doc for...
Tokens:
Raw
### Equivalent Gradle configuration for AndroidSingleVariantLibrary

Source: https://vanniktech.github.io/gradle-maven-publish-plugin/api/plugin/com.vanniktech.maven.publish/-android-single-variant-library/index.html

Shows the manual Gradle setup equivalent to using the AndroidSingleVariantLibrary configuration.

```gradle
android {
  publishing {
   singleVariant("variant") {
     withSourcesJar()
     withJavadocJar()
   }
  }
}

afterEvaluate {
  publishing {
    publications {
      create<MavenPublication>("variant") {
        from(components["variant"])
      }
    }
  }
}
```

--------------------------------

### KotlinMultiplatform Gradle Setup

Source: https://vanniktech.github.io/gradle-maven-publish-plugin/api/plugin/com.vanniktech.maven.publish/-kotlin-multiplatform/index.html

Indicates that no manual configuration is required for the Kotlin Multiplatform plugin setup.

```gradle
// Nothing to configure setup is automatic.
```

--------------------------------

### Equivalent Gradle setup for JavaLibrary

Source: https://vanniktech.github.io/gradle-maven-publish-plugin/api/plugin/com.vanniktech.maven.publish/-java-library/index.html

Configures a Maven publication for the java component and enables sources and Javadoc jar generation.

```kotlin
publishing {
  publications {
    create<MavenPublication>("maven") {
      from(components["java"])
    }
  }
}

java {
  withSourcesJar()
  withJavadocJar()
}
```

--------------------------------

### configure

Source: https://vanniktech.github.io/gradle-maven-publish-plugin/api/plugin/com.vanniktech.maven.publish/-maven-publish-base-extension/index.html

Configures a Platform which will automatically set up the artifacts that should get published.

```APIDOC
## fun configure(platform: Platform)

### Description
Configures a Platform which will automatically set up the artifacts that should get published, including javadoc and sources jars depending on the option.
```

--------------------------------

### Equivalent Gradle setup for GradlePlugin

Source: https://vanniktech.github.io/gradle-maven-publish-plugin/api/plugin/com.vanniktech.maven.publish/-gradle-plugin/index.html

Configures the java plugin to include sources and javadoc jars in the publication.

```groovy
java {
  withSourcesJar()
  withJavadocJar()
}
```

--------------------------------

### Equivalent Gradle Setup for AndroidMultiVariantLibrary

Source: https://vanniktech.github.io/gradle-maven-publish-plugin/api/plugin/com.vanniktech.maven.publish/-android-multi-variant-library/index.html

Shows the equivalent Gradle configuration for AGP 7.1.1 to achieve multi-variant publishing.

```gradle
android {
  publishing {
   multipleVariants {
     allVariants() // or calls to includeBuildTypeValues and includeFlavorDimensionAndValues
     withSourcesJar()
     withJavadocJar()
   }
  }
}

afterEvaluate {
  publishing {
    publications {
      create<MavenPublication>("default") {
        from(components["default"])
      }
    }
  }
}
```

--------------------------------

### fun configure(platform: Platform)

Source: https://vanniktech.github.io/gradle-maven-publish-plugin/api/plugin/com.vanniktech.maven.publish/-maven-publish-base-extension/configure.html

Configures a Platform which will automatically set up the artifacts that should get published, including javadoc and sources jars depending on the option.

```APIDOC
## fun configure(platform: Platform)

### Description
Configures a Platform which will automatically set up the artifacts that should get published, including javadoc and sources jars depending on the option.

### Parameters
- **platform** (Platform) - Required - The platform configuration to apply.
```

--------------------------------

### Configure KotlinJvm publication in Gradle

Source: https://vanniktech.github.io/gradle-maven-publish-plugin/api/plugin/com.vanniktech.maven.publish/-kotlin-jvm/index.html

Shows the equivalent Gradle setup for a KotlinJvm publication, including the java component and sources jar.

```kotlin
publications {
  create<MavenPublication>("maven") {
    from(components["java"])
    artifact(project.tasks.named("javaSourcesJar"))
  }
}
```

--------------------------------

### Example PGP private key block

Source: https://vanniktech.github.io/gradle-maven-publish-plugin/central

The expected format of the exported ASCII armored PGP key.

```text
-----BEGIN PGP PRIVATE KEY BLOCK-----

lQdGBF4jUfwBEACblZV4uBViHcYLOb2280tEp
r64iB9b6YRkWil3EODiiLd9JS3V9pip+B1QLw
...
EdLCEJA+3IIiw4qM5hnMw=
=s83f
-----END PGP PRIVATE KEY BLOCK-----
```

--------------------------------

### Configure credentials via environment variables

Source: https://vanniktech.github.io/gradle-maven-publish-plugin/central

Use environment variables for CI server authentication, prefixing properties with ORG_GRADLE_PROJECT_.

```bash
ORG_GRADLE_PROJECT_mavenCentralUsername=username
ORG_GRADLE_PROJECT_mavenCentralPassword=the_password

# see below for how to obtain this
ORG_GRADLE_PROJECT_signingInMemoryKey=exported_ascii_armored_key
# Optional
ORG_GRADLE_PROJECT_signingInMemoryKeyId=12345678
# If key was created with a password.
ORG_GRADLE_PROJECT_signingInMemoryKeyPassword=some_password
```

--------------------------------

### Configure Sonatype publishing via environment variables

Source: https://vanniktech.github.io/gradle-maven-publish-plugin/changelog

Set these environment variables to enable automatic staging repository management and release.

```properties
SONATYPE_HOST=DEFAULT # or S01
SONATYPE_AUTOMATIC_RELEASE=true
```

--------------------------------

### JavaLibrary(JavadocJar, SourcesJar)

Source: https://vanniktech.github.io/gradle-maven-publish-plugin/api/plugin/com.vanniktech.maven.publish/-java-library/-java-library.html

Initializes a new JavaLibrary instance with specified Javadoc and Sources JAR configurations.

```APIDOC
## JavaLibrary(JavadocJar, SourcesJar)

### Description
Constructs a JavaLibrary instance to configure publishing settings for Java libraries.

### Signature
`@JvmOverloads constructor(javadocJar: JavadocJar = JavadocJar.Empty(), sourcesJar: SourcesJar = SourcesJar.Sources())`

### Parameters
- **javadocJar** (JavadocJar) - Optional - Configuration for the Javadoc JAR, defaults to JavadocJar.Empty().
- **sourcesJar** (SourcesJar) - Optional - Configuration for the Sources JAR, defaults to SourcesJar.Sources().
```

--------------------------------

### Apply the base plugin

Source: https://vanniktech.github.io/gradle-maven-publish-plugin/base

Add the base plugin to your Gradle project to enable manual publishing configuration.

```gradle
plugins {
  id "com.vanniktech.maven.publish.base" version "0.37.0"
}
```

```kotlin
plugins {
  id("com.vanniktech.maven.publish.base") version "0.37.0"
}
```

--------------------------------

### fun signAllPublications()

Source: https://vanniktech.github.io/gradle-maven-publish-plugin/api/plugin/com.vanniktech.maven.publish/-maven-publish-base-extension/sign-all-publications.html

Configures all publications to be signed using the Gradle signing plugin. This method requires appropriate signing credentials to be provided via Gradle properties or environment variables.

```APIDOC
## signAllPublications()

### Description
Automatically applies Gradle's `signing` plugin and configures all publications to be signed. If signing credentials are not configured, the build will fail unless the current version is a `SNAPSHOT`.

### Usage
Call this method within your `mavenPublish` configuration block to enable automatic signing for all publications.

### Configuration
Signing can be configured via Gradle properties:

#### Local secring.gpg
- `signing.keyId`
- `signing.password`
- `signing.secretKeyRingFile`

#### In-memory GPG Key
- `signingInMemoryKey`
- `signingInMemoryKeyId` (optional)
- `signingInMemoryKeyPassword` (optional)

Properties can also be provided as environment variables by prefixing them with `ORG_GRADLE_PROJECT_`.
```

--------------------------------

### Configure Maven Central and GPG Signing in Build Files

Source: https://vanniktech.github.io/gradle-maven-publish-plugin/changelog

Use the mavenPublishing block to enable publishing and signing in build scripts.

```groovy
mavenPublishing {
  publishToMavenCentral()
  // publishToMavenCentral("S01") for publishing through s01.oss.sonatype.org
  signAllPublications()
}
```

```kotlin
mavenPublishing {
  publishToMavenCentral()
  // publishToMavenCentral(SonatypeHost.S01) for publishing through s01.oss.sonatype.org
  signAllPublications()
}
```

--------------------------------

### KotlinJvm constructor

Source: https://vanniktech.github.io/gradle-maven-publish-plugin/api/plugin/com.vanniktech.maven.publish/-kotlin-jvm/index.html

Initializes a new KotlinJvm configuration instance for a Maven publication.

```APIDOC
## KotlinJvm(javadocJar: JavadocJar, sourcesJar: SourcesJar)

### Description
Creates a configuration for `org.jetbrains.kotlin.jvm` projects to define how Javadoc and sources jars are included in the Maven publication.

### Parameters
- **javadocJar** (JavadocJar) - Optional - Configuration for the Javadoc jar, defaults to JavadocJar.Empty().
- **sourcesJar** (SourcesJar) - Optional - Configuration for the sources jar, defaults to SourcesJar.Sources().
```

--------------------------------

### Publishing to a repository

Source: https://vanniktech.github.io/gradle-maven-publish-plugin/other

Execute this command to publish all publications to a specific repository defined in the configuration.

```bash
./gradlew publishAllPublicationsTo<RepoName>Repository
```

--------------------------------

### AndroidSingleVariantLibrary(javadocJar, sourcesJar, variant)

Source: https://vanniktech.github.io/gradle-maven-publish-plugin/api/plugin/com.vanniktech.maven.publish/-android-single-variant-library/-android-single-variant-library.html

Initializes a new AndroidSingleVariantLibrary instance with specific Javadoc and source configurations.

```APIDOC
## constructor(javadocJar: JavadocJar, sourcesJar: SourcesJar, variant: String)

### Description
Creates an instance of AndroidSingleVariantLibrary with explicit JavadocJar and SourcesJar configurations.

### Parameters
- **javadocJar** (JavadocJar) - Optional - The Javadoc configuration, defaults to JavadocJar.Empty().
- **sourcesJar** (SourcesJar) - Optional - The sources configuration, defaults to SourcesJar.Sources().
- **variant** (String) - Optional - The Android variant name, defaults to "release".
```

--------------------------------

### Configure Maven Central and GPG Signing in gradle.properties

Source: https://vanniktech.github.io/gradle-maven-publish-plugin/changelog

Add these properties to enable Maven Central publishing and GPG signing globally.

```properties
SONATYPE_HOST=DEFAULT
# SONATYPE_HOST=S01 for publishing through s01.oss.sonatype.org
RELEASE_SIGNING_ENABLED=true
```

--------------------------------

### GradlePlugin(javadocJar: JavadocJar, sourcesJar: SourcesJar)

Source: https://vanniktech.github.io/gradle-maven-publish-plugin/api/plugin/com.vanniktech.maven.publish/-gradle-plugin/-gradle-plugin.html

Initializes a new GradlePlugin instance with specified Javadoc and Sources configurations.

```APIDOC
## GradlePlugin(javadocJar: JavadocJar, sourcesJar: SourcesJar)

### Description
Initializes the GradlePlugin with the provided Javadoc and Sources jar configurations.

### Parameters
- **javadocJar** (JavadocJar) - Optional - Defaults to JavadocJar.Empty().
- **sourcesJar** (SourcesJar) - Optional - Defaults to SourcesJar.Sources().
```

--------------------------------

### Configure Version Catalog Plugin

Source: https://vanniktech.github.io/gradle-maven-publish-plugin/what

Use this configuration for projects that apply the version-catalog plugin.

```groovy
import com.vanniktech.maven.publish.VersionCatalog

mavenPublishing {
  configure(new VersionCatalog())
}
```

```kotlin
import com.vanniktech.maven.publish.VersionCatalog

mavenPublishing {
  configure(VersionCatalog())
}
```

--------------------------------

### Publish snapshots to Maven Central

Source: https://vanniktech.github.io/gradle-maven-publish-plugin/central

Execute this task after setting the version to a -SNAPSHOT suffix.

```bash
./gradlew publishToMavenCentral
```

--------------------------------

### Configure publishing based on applied plugins

Source: https://vanniktech.github.io/gradle-maven-publish-plugin/what

Use configureBasedOnAppliedPlugins to define Javadoc and Sources jar behavior when using the base plugin or customizing artifact generation.

```gradle
import com.vanniktech.maven.publish.JavadocJar
import com.vanniktech.maven.publish.SourcesJar

mavenPublishing {
  configureBasedOnAppliedPlugins(
    // the first parameter configures the -javadoc artifact, possible values:
    // - `JavadocJar.None()` don't publish this artifact
    // - `JavadocJar.Empty()` publish an empty jar
    // - `JavadocJar.Javadoc()` to publish standard javadocs
    // - `JavadocJar.Dokka("dokkaHtml")` when using Kotlin with Dokka, where `dokkaHtml` is the name of the Dokka task that should be used as input
    new JavadocJar.Empty(),
    // configures the -sources artifact, possible values:
    // - `SourcesJar.None()` don't publish this artifact
    // - `SourcesJar.Empty()` publish an empty jar
    // - `SourcesJar.Sources()` publish the sources
    new SourcesJar.Sources()
  )
}
```

```gradle.kts
import com.vanniktech.maven.publish.JavadocJar
import com.vanniktech.maven.publish.SourcesJar

mavenPublishing {
  configureBasedOnAppliedPlugins(
    // configures the -javadoc artifact, possible values:
    // - `JavadocJar.None()` don't publish this artifact
    // - `JavadocJar.Empty()` publish an empty jar
    // - `JavadocJar.Javadoc()` to publish standard javadocs
    // - `JavadocJar.Dokka("dokkaHtml")` when using Kotlin with Dokka, where `dokkaHtml` is the name of the Dokka task that should be used as input
    javadocJar = JavadocJar.Empty(),
    // configures the -sources artifact, possible values:
    // - `SourcesJar.None()` don't publish this artifact
    // - `SourcesJar.Empty()` publish an empty jar
    // - `SourcesJar.Sources()` publish the sources
    sourcesJar = SourcesJar.Sources(),
  )
}
```

--------------------------------

### Configure Sonatype publishing via Gradle DSL

Source: https://vanniktech.github.io/gradle-maven-publish-plugin/changelog

Use the mavenPublishing block to configure the host and automatic release behavior directly in the build script.

```groovy
mavenPublishing {
  publishToMavenCentral("DEFAULT", true)
  // or publishToMavenCentral("S01", true)
}
```

--------------------------------

### Publish and release automatically

Source: https://vanniktech.github.io/gradle-maven-publish-plugin/central

Configure automatic publishing using CLI tasks, DSL parameters, or properties files.

```bash
./gradlew publishAndReleaseToMavenCentral
```

```groovy
mavenPublishing {
  publishToMavenCentral(true)

  // rest of publishing config
}
```

```bash
./gradlew publishToMavenCentral
```

```kotlin
mavenPublishing {
  publishToMavenCentral(automaticRelease = true)

  // rest of publishing config
}
```

```bash
./gradlew publishToMavenCentral
```

```properties
mavenCentralAutomaticPublishing=true
```

```bash
./gradlew publishToMavenCentral
```

--------------------------------

### signAllPublications

Source: https://vanniktech.github.io/gradle-maven-publish-plugin/api/plugin/com.vanniktech.maven.publish/-maven-publish-base-extension/index.html

Automatically apply Gradle's signing plugin and configure all publications to be signed.

```APIDOC
## fun signAllPublications()

### Description
Automatically apply Gradle's signing plugin and configure all publications to be signed.
```

--------------------------------

### Sources()

Source: https://vanniktech.github.io/gradle-maven-publish-plugin/api/plugin/com.vanniktech.maven.publish/-sources-jar/-sources/index.html

Constructor for the Sources class, which initializes the configuration for creating a sources jar.

```APIDOC
## constructor()

### Description
Creates a new instance of the Sources class to configure the generation of a project sources jar.
```

--------------------------------

### Configure Maven Central Publishing

Source: https://vanniktech.github.io/gradle-maven-publish-plugin/central

Enable publishing to Maven Central and GPG signing via DSL or properties.

```gradle
mavenPublishing {
  publishToMavenCentral()

  signAllPublications()
}
```

```kotlin
mavenPublishing {
  publishToMavenCentral()

  signAllPublications()
}
```

```properties
mavenCentralPublishing=true

signAllPublications=true
```

--------------------------------

### Configure GitHub Packages repository

Source: https://vanniktech.github.io/gradle-maven-publish-plugin/other

Set up publishing to GitHub Packages using credentials provided via Gradle properties or environment variables.

```gradle
publishing {
    repositories {
        maven {
            name = "githubPackages"
            url = "https://maven.pkg.github.com/your-org/your-project"
            // username and password (a personal Github access token) should be specified as
            // `githubPackagesUsername` and `githubPackagesPassword` Gradle properties or alternatively
            // as `ORG_GRADLE_PROJECT_githubPackagesUsername` and `ORG_GRADLE_PROJECT_githubPackagesPassword`
            // environment variables
            credentials(PasswordCredentials)
        }
    }
}
```

```kotlin
publishing {
    repositories {
        maven {
            name = "githubPackages"
            url = uri("https://maven.pkg.github.com/your-org/your-project")
            // username and password (a personal Github access token) should be specified as
            // `githubPackagesUsername` and `githubPackagesPassword` Gradle properties or alternatively
            // as `ORG_GRADLE_PROJECT_githubPackagesUsername` and `ORG_GRADLE_PROJECT_githubPackagesPassword`
            // environment variables
            credentials(PasswordCredentials::class)
        }
    }
}
```

--------------------------------

### apply(project: Project)

Source: https://vanniktech.github.io/gradle-maven-publish-plugin/api/plugin/com.vanniktech.maven.publish/-maven-publish-plugin/index.html

Applies the plugin to the given Gradle project.

```APIDOC
## apply(project: Project)

### Description
Applies the MavenPublishPlugin to the specified Gradle project, enabling the publishing configuration.

### Signature
`open override fun apply(project: Project)`

### Parameters
- **project** (Project) - The Gradle project to which the plugin is applied.
```

--------------------------------

### Empty()

Source: https://vanniktech.github.io/gradle-maven-publish-plugin/api/plugin/com.vanniktech.maven.publish/-sources-jar/-empty/index.html

Constructor for the Empty class, which initializes an empty sources jar configuration.

```APIDOC
## constructor()

### Description
Creates an instance of an empty sources jar to satisfy maven central requirements.
```

--------------------------------

### AndroidSingleVariantLibrary Constructor

Source: https://vanniktech.github.io/gradle-maven-publish-plugin/api/plugin/com.vanniktech.maven.publish/-android-single-variant-library/index.html

Initializes a new instance of AndroidSingleVariantLibrary to configure a single variant publication for an Android library.

```APIDOC
## Constructor

### Signature
`AndroidSingleVariantLibrary(javadocJar: JavadocJar = JavadocJar.Empty(), sourcesJar: SourcesJar = SourcesJar.Sources(), variant: String = "release")`

### Description
Creates a configuration for an Android library publication. This setup creates a publication for the specified variant and optionally includes Javadoc and source jars.

### Parameters
- **javadocJar** (JavadocJar) - Optional - Configuration for the Javadoc jar. Defaults to JavadocJar.Empty().
- **sourcesJar** (SourcesJar) - Optional - Configuration for the sources jar. Defaults to SourcesJar.Sources().
- **variant** (String) - Optional - The name of the Android build variant to publish. Defaults to "release".
```

--------------------------------

### Configure publishing options

Source: https://vanniktech.github.io/gradle-maven-publish-plugin/base

Define publishing behavior using the configure method or automatically based on applied plugins.

```gradle
mavenPublishing {
  configure(...)
  // or
  configureBasedOnAppliedPlugins()
}
```

```kotlin
mavenPublishing {
  configure(...)
  // or
  configureBasedOnAppliedPlugins()
}
```

--------------------------------

### Apply the Maven Publish plugin

Source: https://vanniktech.github.io/gradle-maven-publish-plugin/other

Add the plugin to your Gradle project to enable publishing capabilities.

```gradle
plugins {
  id "com.vanniktech.maven.publish" version "0.37.0"
}
```

```kotlin
plugins {
  id("com.vanniktech.maven.publish") version "0.37.0"
}
```

--------------------------------

### Configure credentials in gradle.properties

Source: https://vanniktech.github.io/gradle-maven-publish-plugin/central

Store Sonatype credentials and GPG signing details in the user's home gradle.properties file to avoid committing them to version control.

```properties
mavenCentralUsername=username
mavenCentralPassword=the_password

signing.keyId=12345678
signing.password=some_password
signing.secretKeyRingFile=/Users/yourusername/.gnupg/secring.gpg
```

--------------------------------

### KotlinMultiplatform Constructor

Source: https://vanniktech.github.io/gradle-maven-publish-plugin/api/plugin/com.vanniktech.maven.publish/-kotlin-multiplatform/index.html

Initializes a new instance of the KotlinMultiplatform configuration for use with the org.jetbrains.kotlin.multiplatform plugin.

```APIDOC
## KotlinMultiplatform Constructor

### Signature
KotlinMultiplatform(javadocJar: JavadocJar = JavadocJar.Empty(), sourcesJar: SourcesJar = SourcesJar.Sources(), androidVariantsToPublish: List<String> = listOf("release"))

### Parameters
- **javadocJar** (JavadocJar) - Optional - Configuration for the Javadoc jar, defaults to JavadocJar.Empty().
- **sourcesJar** (SourcesJar) - Optional - Configuration for the sources jar, defaults to SourcesJar.Sources().
- **androidVariantsToPublish** (List<String>) - Optional - List of Android build variants to publish, defaults to ["release"].
```

--------------------------------

### GradlePlugin Constructor

Source: https://vanniktech.github.io/gradle-maven-publish-plugin/api/plugin/com.vanniktech.maven.publish/-gradle-plugin/index.html

Initializes a new GradlePlugin instance to configure publication settings for java-gradle-plugin projects.

```APIDOC
## GradlePlugin(javadocJar: JavadocJar, sourcesJar: SourcesJar)

### Description
Creates a configuration for java-gradle-plugin projects. It allows specifying whether javadoc and sources jars should be included in the publication.

### Parameters
- **javadocJar** (JavadocJar) - Optional - Configuration for the javadoc jar, defaults to JavadocJar.Empty().
- **sourcesJar** (SourcesJar) - Optional - Configuration for the sources jar, defaults to JavadocJar.Sources().
```

--------------------------------

### Configure Java Platform Plugin

Source: https://vanniktech.github.io/gradle-maven-publish-plugin/what

Use this configuration for projects that apply the java-platform plugin.

```groovy
import com.vanniktech.maven.publish.JavaPlatform

mavenPublishing {
  configure(new JavaPlatform())
}
```

```kotlin
import com.vanniktech.maven.publish.JavaPlatform

mavenPublishing {
  configure(JavaPlatform())
}
```

--------------------------------

### Configure in-memory GPG signing properties

Source: https://vanniktech.github.io/gradle-maven-publish-plugin/api/plugin/com.vanniktech.maven.publish/-maven-publish-base-extension/sign-all-publications.html

Use these properties to provide an ASCII-armored GPG key directly in memory, suitable for CI environments.

```properties
signingInMemoryKey=exported_ascii_armored_key
# optional
signingInMemoryKeyId=24875D73
# if key was created with a password
signingInMemoryKeyPassword=secret
```

--------------------------------

### Empty()

Source: https://vanniktech.github.io/gradle-maven-publish-plugin/api/plugin/com.vanniktech.maven.publish/-javadoc-jar/-empty/index.html

Constructor for creating an instance of the Empty JavadocJar configuration.

```APIDOC
## Constructor

### Empty()

Creates an empty javadoc jar to satisfy maven central requirements.
```

--------------------------------

### Migrate sonatypeHost Configuration

Source: https://vanniktech.github.io/gradle-maven-publish-plugin/changelog

Update the deprecated mavenPublish extension usage to the new mavenPublishing block.

```groovy
mavenPublishing {
  publishToMavenCentral("S01")
}
```

--------------------------------

### AndroidMultiVariantLibrary Constructor

Source: https://vanniktech.github.io/gradle-maven-publish-plugin/api/plugin/com.vanniktech.maven.publish/-android-multi-variant-library/index.html

Initializes a new instance of AndroidMultiVariantLibrary to configure publication settings for Android library components.

```APIDOC
## AndroidMultiVariantLibrary(javadocJar, sourcesJar, includedBuildTypeValues, includedFlavorDimensionsAndValues)

### Description
Creates a configuration for publishing multiple variants of an Android library. This allows for the inclusion of Javadoc and source jars, and provides filtering capabilities for specific build types and flavor dimensions.

### Parameters
- **javadocJar** (JavadocJar) - Optional - Configuration for the Javadoc jar (default: JavadocJar.Empty()).
- **sourcesJar** (SourcesJar) - Optional - Configuration for the sources jar (default: SourcesJar.Sources()).
- **includedBuildTypeValues** (Set<String>) - Optional - A set of build type names to include in the publication (default: emptySet()).
- **includedFlavorDimensionsAndValues** (Map<String, Set<String>>) - Optional - A map of flavor dimensions to sets of flavor values to include (default: emptyMap()).
```

--------------------------------

### configureBasedOnAppliedPlugins(JavadocJar, SourcesJar)

Source: https://vanniktech.github.io/gradle-maven-publish-plugin/api/plugin/com.vanniktech.maven.publish/-maven-publish-base-extension/configure-based-on-applied-plugins.html

Configures the plugin based on applied Gradle plugins using JavadocJar and SourcesJar options.

```APIDOC
## fun configureBasedOnAppliedPlugins(javadocJar: JavadocJar, sourcesJar: SourcesJar)

### Description
Calls configure with a Platform chosen based on other applied Gradle plugins.

### Parameters
- **javadocJar** (JavadocJar) - Optional - Defaults to defaultJavaDocOption(true).
- **sourcesJar** (SourcesJar) - Optional - Defaults to SourcesJar.Sources().
```

--------------------------------

### KotlinMultiplatform(JavadocJar, SourcesJar, List<String>)

Source: https://vanniktech.github.io/gradle-maven-publish-plugin/api/plugin/com.vanniktech.maven.publish/-kotlin-multiplatform/-kotlin-multiplatform.html

Primary constructor for configuring Kotlin Multiplatform publishing settings.

```APIDOC
## KotlinMultiplatform(JavadocJar, SourcesJar, List<String>)

### Description
Initializes the KotlinMultiplatform configuration with specific Javadoc, source jar, and Android variant settings.

### Parameters
- **javadocJar** (JavadocJar) - Optional - Configuration for the Javadoc jar, defaults to JavadocJar.Empty().
- **sourcesJar** (SourcesJar) - Optional - Configuration for the sources jar, defaults to SourcesJar.Sources().
- **androidVariantsToPublish** (List<String>) - Optional - List of Android variants to publish, defaults to listOf("release").
```

--------------------------------

### Configure local GPG signing properties

Source: https://vanniktech.github.io/gradle-maven-publish-plugin/api/plugin/com.vanniktech.maven.publish/-maven-publish-base-extension/sign-all-publications.html

Set these properties in your gradle.properties file to use a local secring.gpg file for signing.

```properties
signing.keyId=24875D73
signing.password=secret
signing.secretKeyRingFile=/Users/me/.gnupg/secring.gpg
```

--------------------------------

### Configure Gradle Plugin for Publishing

Source: https://vanniktech.github.io/gradle-maven-publish-plugin/what

Configures the maven publishing settings for Gradle plugins using either Groovy or Kotlin DSL.

```gradle
import com.vanniktech.maven.publish.GradlePlugin
import com.vanniktech.maven.publish.JavadocJar
import com.vanniktech.maven.publish.SourcesJar

mavenPublishing {
  configure(new GradlePlugin(
    // the first parameter configures the -javadoc artifact, possible values:
    // - `JavadocJar.None()` don't publish this artifact
    // - `JavadocJar.Empty()` publish an empty jar
    // - `JavadocJar.Javadoc()` to publish standard javadocs
    // - `JavadocJar.Dokka("dokkaHtml")` when using Kotlin with Dokka, where `dokkaHtml` is the name of the Dokka task that should be used as input
    new JavadocJar.Empty(),
    // configures the -sources artifact, possible values:
    // - `SourcesJar.None()` don't publish this artifact
    // - `SourcesJar.Empty()` publish an empty jar
    // - `SourcesJar.Sources()` publish the sources
    new SourcesJar.Sources()
  ))
}
```

```kotlin
import com.vanniktech.maven.publish.GradlePlugin
import com.vanniktech.maven.publish.JavadocJar
import com.vanniktech.maven.publish.SourcesJar

mavenPublishing {
  configure(GradlePlugin(
    // configures the -javadoc artifact, possible values:
    // - `JavadocJar.None()` don't publish this artifact
    // - `JavadocJar.Empty()` publish an empty jar
    // - `JavadocJar.Javadoc()` to publish standard javadocs
    // - `JavadocJar.Dokka("dokkaHtml")` when using Kotlin with Dokka, where `dokkaHtml` is the name of the Dokka task that should be used as input
    javadocJar = JavadocJar.Empty(),
    // configures the -sources artifact, possible values:
    // - `SourcesJar.None()` don't publish this artifact
    // - `SourcesJar.Empty()` publish an empty jar
    // - `SourcesJar.Sources()` publish the sources
    sourcesJar = SourcesJar.Sources(),
  ))
}
```

--------------------------------

### pomFromGradleProperties()

Source: https://vanniktech.github.io/gradle-maven-publish-plugin/api/plugin/com.vanniktech.maven.publish/-maven-publish-base-extension/pom-from-gradle-properties.html

Configures the POM through Gradle properties. This method is marked as @Incubating.

```APIDOC
## pomFromGradleProperties()

### Description
Configures the POM through Gradle properties. This method is marked as @Incubating.

### Signature
fun pomFromGradleProperties()
```

--------------------------------

### AndroidMultiVariantLibrary(JavadocJar, SourcesJar, Set<String>, Map<String, Set<String>>)

Source: https://vanniktech.github.io/gradle-maven-publish-plugin/api/plugin/com.vanniktech.maven.publish/-android-multi-variant-library/-android-multi-variant-library.html

Constructs an AndroidMultiVariantLibrary instance with specific configurations for Javadoc and source JARs, build types, and flavor dimensions.

```APIDOC
## AndroidMultiVariantLibrary(JavadocJar, SourcesJar, Set<String>, Map<String, Set<String>>)

### Description
Initializes a new instance of AndroidMultiVariantLibrary to configure how Android library variants are published.

### Parameters
- **javadocJar** (JavadocJar) - Optional - Configuration for the Javadoc JAR, defaults to JavadocJar.Empty().
- **sourcesJar** (SourcesJar) - Optional - Configuration for the sources JAR, defaults to JavadocJar.Sources().
- **includedBuildTypeValues** (Set<String>) - Optional - Set of build type names to include, defaults to emptySet().
- **includedFlavorDimensionsAndValues** (Map<String, Set<String>>) - Optional - Map of flavor dimensions to sets of flavor values to include, defaults to emptyMap().
```

--------------------------------

### Dokka Constructors

Source: https://vanniktech.github.io/gradle-maven-publish-plugin/api/plugin/com.vanniktech.maven.publish/-javadoc-jar/-dokka/-dokka.html

Initializes a new instance of the Dokka class using one of the available task configuration methods.

```APIDOC
## Dokka Constructors

### Description
Initializes the Dokka configuration for the maven-publish-plugin. Users can specify the task name directly, via a Provider, or by passing a TaskProvider.

### Signatures
- constructor(taskName: String)
- constructor(taskName: Provider<String>)
- constructor(task: TaskProvider<*>)
```

--------------------------------

### Configure Kotlin Multiplatform Publishing

Source: https://vanniktech.github.io/gradle-maven-publish-plugin/what

Configures the maven-publish-plugin for Kotlin Multiplatform projects using either Groovy or Kotlin DSL.

```gradle
import com.vanniktech.maven.publish.KotlinMultiplatform
import com.vanniktech.maven.publish.JavadocJar
import com.vanniktech.maven.publish.SourcesJar

mavenPublishing {
  configure(new KotlinMultiplatform(
    // the first parameter configures the -javadoc artifact, possible values:
    // - `JavadocJar.None()` don't publish this artifact
    // - `JavadocJar.Empty()` publish an empty jar
    // - `JavadocJar.Dokka("dokkaHtml")` when using Kotlin with Dokka, where `dokkaHtml` is the name of the Dokka task that should be used as input
    new JavadocJar.Empty(),
    // configures the -sources artifact, possible values:
    // - `SourcesJar.None()` don't publish this artifact
    // - `SourcesJar.Empty()` publish an empty jar
    // - `SourcesJar.Sources()` publish the sources
    new SourcesJar.Sources(),
    // configure which Android library variants to publish if this project has an Android target
    // defaults to "release" when using the main plugin and nothing for the base plugin
    ["debug", "release"]
  ))
}
```

```kotlin
import com.vanniktech.maven.publish.KotlinMultiplatform
import com.vanniktech.maven.publish.JavadocJar
import com.vanniktech.maven.publish.SourcesJar

mavenPublishing {
  // sources publishing is always enabled by the Kotlin Multiplatform plugin
  configure(KotlinMultiplatform(
    // configures the -javadoc artifact, possible values:
    // - `JavadocJar.None()` don't publish this artifact
    // - `JavadocJar.Empty()` publish an empty jar
    // - `JavadocJar.Dokka("dokkaHtml")` when using Kotlin with Dokka, where `dokkaHtml` is the name of the Dokka task that should be used as input
    javadocJar = JavadocJar.Empty(),
    // configures the -sources artifact, possible values:
    // - `SourcesJar.None()` don't publish this artifact
    // - `SourcesJar.Empty()` publish an empty jar
    // - `SourcesJar.Sources()` publish the sources
    sourcesJar = SourcesJar.Sources(),
    // configure which Android library variants to publish if this project has an Android target
    // defaults to "release" when using the main plugin and nothing for the base plugin
    androidVariantsToPublish = listOf("debug", "release"),
  ))
}
```

--------------------------------

### GradlePlugin(javadocJar: JavadocJar, sourcesJar: Boolean)

Source: https://vanniktech.github.io/gradle-maven-publish-plugin/api/plugin/com.vanniktech.maven.publish/-gradle-plugin/-gradle-plugin.html

Deprecated constructor for initializing the GradlePlugin.

```APIDOC
## GradlePlugin(javadocJar: JavadocJar, sourcesJar: Boolean)

### Description
Deprecated constructor. Use the constructor with SourcesJar instead of Boolean.

### Parameters
- **javadocJar** (JavadocJar) - Optional - Defaults to JavadocJar.Empty().
- **sourcesJar** (Boolean) - Required
```

--------------------------------

### Configure Android Single Variant Library

Source: https://vanniktech.github.io/gradle-maven-publish-plugin/what

Configures the maven publishing extension for a single Android library variant using either Groovy or Kotlin DSL.

```groovy
import com.vanniktech.maven.publish.AndroidSingleVariantLibrary
import com.vanniktech.maven.publish.JavadocJar
import com.vanniktech.maven.publish.SourcesJar

mavenPublishing {
  configure(new AndroidSingleVariantLibrary(
    // the first parameter configures the -javadoc artifact, possible values:
    // - `JavadocJar.None()` don't publish this artifact
    // - `JavadocJar.Empty()` publish an empty jar
    // - `JavadocJar.Javadoc()` to publish standard javadocs
    // - `JavadocJar.Dokka("dokkaHtml")` when using Kotlin with Dokka, where `dokkaHtml` is the name of the Dokka task that should be used as input
    new JavadocJar.Empty(),
    // configures the -sources artifact, possible values:
    // - `SourcesJar.None()` don't publish this artifact
    // - `SourcesJar.Empty()` publish an empty jar
    // - `SourcesJar.Sources()` publish the sources
    new SourcesJar.Sources(),
    // which variant is published
    "release"
  ))
}
```

```kotlin
import com.vanniktech.maven.publish.AndroidSingleVariantLibrary
import com.vanniktech.maven.publish.JavadocJar
import com.vanniktech.maven.publish.SourcesJar

mavenPublishing {
  configure(AndroidSingleVariantLibrary(
    // configures the -javadoc artifact, possible values:
    // - `JavadocJar.None()` don't publish this artifact
    // - `JavadocJar.Empty()` publish an empty jar
    // - `JavadocJar.Javadoc()` to publish standard javadocs
    // - `JavadocJar.Dokka("dokkaHtml")` when using Kotlin with Dokka, where `dokkaHtml` is the name of the Dokka task that should be used as input
    javadocJar = JavadocJar.Empty(),
    // configures the -sources artifact, possible values:
    // - `SourcesJar.None()` don't publish this artifact
    // - `SourcesJar.Empty()` publish an empty jar
    // - `SourcesJar.Sources()` publish the sources
    sourcesJar = SourcesJar.Sources(),
    // the published variant
    variant = "release",
  ))
}
```

--------------------------------

### Configure POM metadata via properties

Source: https://vanniktech.github.io/gradle-maven-publish-plugin/other

Define project coordinates and POM metadata using a gradle.properties file.

```properties
GROUP=com.test.mylibrary
POM_ARTIFACT_ID=mylibrary-runtime
VERSION_NAME=3.0.5

# the following is optional

POM_NAME=My Library
POM_DESCRIPTION=A description of what my library does.
POM_INCEPTION_YEAR=2020
POM_URL=https://github.com/username/mylibrary/

POM_LICENSE_NAME=Apache-2.0
POM_LICENSE_URL=https://www.apache.org/licenses/LICENSE-2.0.txt
POM_LICENSE_DIST=repo

POM_SCM_URL=https://github.com/username/mylibrary/
POM_SCM_CONNECTION=scm:git:git://github.com/username/mylibrary.git
POM_SCM_DEV_CONNECTION=scm:git:ssh://git@github.com/username/mylibrary.git

POM_DEVELOPER_ID=username
POM_DEVELOPER_NAME=User Name
POM_DEVELOPER_URL=https://github.com/username/
```

--------------------------------

### Dokka Constructors

Source: https://vanniktech.github.io/gradle-maven-publish-plugin/api/plugin/com.vanniktech.maven.publish/-javadoc-jar/-dokka/index.html

Constructors for initializing the Dokka configuration with a specific task name, provider, or task provider.

```APIDOC
## Constructors

### Dokka(taskName: String)
Creates a javadoc jar using Dokka's output, specifying the task name as a String.

### Dokka(taskName: Provider<String>)
Creates a javadoc jar using Dokka's output, specifying the task name via a Provider.

### Dokka(task: TaskProvider<*>)
Creates a javadoc jar using Dokka's output, specifying the task via a TaskProvider.
```

--------------------------------

### Configure Maven Central and GPG Signing

Source: https://vanniktech.github.io/gradle-maven-publish-plugin/changelog

Use this configuration in build files to maintain Maven Central publishing and GPG signing after the upcoming behavior change.

```groovy
mavenPublishing {
  publishToMavenCentral() // use publishToMavenCentral("S01") for publishing through s01.oss.sonatype.org
  signAllPublications()
}
```

--------------------------------

### Configure custom Maven repositories

Source: https://vanniktech.github.io/gradle-maven-publish-plugin/other

Define additional repositories within the publishing block to specify target locations for artifacts.

```gradle
publishing {
    repositories {
        maven {
            name = "myRepo"
            url = layout.buildDirectory.dir('repo')
            // or
            url = "http://my.org/repo"
            // or when a separate snapshot repository is required
            url = version.toString().endsWith("SNAPSHOT") ? "http://my.org/repos/snapshots" : "http://my.org/repos/releases"
        }

        // more repositories can go here
    }
}
```

```kotlin
publishing {
    repositories {
        maven {
            name = "myRepo"
            url = uri(layout.buildDirectory.dir("repo"))
            // or
            url = uri("http://my.org/repo")
            // or when a separate snapshot repository is required
            url = uri(if (version.toString().endsWith("SNAPSHOT")) "http://my.org/repos/snapshots" else "http://my.org/repos/releases")
        }

        // more repositories can go here
    }
}
```

--------------------------------

### Configure Android Multi-Variant Library

Source: https://vanniktech.github.io/gradle-maven-publish-plugin/what

Configures the maven-publish-plugin for Android libraries, allowing customization of javadoc and source artifacts, and optional filtering of build types and flavors.

```kotlin
import com.vanniktech.maven.publish.AndroidMultiVariantLibrary
import com.vanniktech.maven.publish.JavadocJar
import com.vanniktech.maven.publish.SourcesJar

mavenPublishing {
  configure(AndroidMultiVariantLibrary(
    // configures the -javadoc artifact, possible values:
    // - `JavadocJar.None()` don't publish this artifact
    // - `JavadocJar.Empty()` publish an empty jar
    // - `JavadocJar.Javadoc()` to publish standard javadocs
    // - `JavadocJar.Dokka("dokkaHtml")` when using Kotlin with Dokka, where `dokkaHtml` is the name of the Dokka task that should be used as input
    javadocJar = JavadocJar.Empty(),
    // configures the -sources artifact, possible values:
    // - `SourcesJar.None()` don't publish this artifact
    // - `SourcesJar.Empty()` publish an empty jar
    // - `SourcesJar.Sources()` publish the sources
    sourcesJar = SourcesJar.Sources(),
  ))
  // or
  configure(AndroidMultiVariantLibrary(
    // configures the -javadoc artifact, possible values:
    // - `JavadocJar.None()` don't publish this artifact
    // - `JavadocJar.Empty()` publish an empty jar
    // - `JavadocJar.Javadoc()` to publish standard javadocs
    // - `JavadocJar.Dokka("dokkaHtml")` when using Kotlin with Dokka, where `dokkaHtml` is the name of the Dokka task that should be used as input
    javadocJar = JavadocJar.Empty(),
    // configures the -sources artifact, possible values:
    // - `SourcesJar.None()` don't publish this artifact
    // - `SourcesJar.Empty()` publish an empty jar
    // - `SourcesJar.Sources()` publish the sources
    sourcesJar = SourcesJar.Sources(),
    // limit which build types to include
    includedBuildTypeValues = setOf("beta", "release"),
  ))
  // or
  configure(AndroidMultiVariantLibrary(
    // configures the -javadoc artifact, possible values:
    // - `JavadocJar.None()` don't publish this artifact
    // - `JavadocJar.Empty()` publish an empty jar
    // - `JavadocJar.Javadoc()` to publish standard javadocs
    // - `JavadocJar.Dokka("dokkaHtml")` when using Kotlin with Dokka, where `dokkaHtml` is the name of the Dokka task that should be used as input
    javadocJar = JavadocJar.Empty(),
    // configures the -sources artifact, possible values:
    // - `SourcesJar.None()` don't publish this artifact
    // - `SourcesJar.Empty()` publish an empty jar
    // - `SourcesJar.Sources()` publish the sources
    sourcesJar = SourcesJar.Sources(),
    // limit which build types to include
    includedBuildTypeValues = setOf("beta", "release"),
    // limit which flavors to include, the map key is a flavor dimension, the set contains the flavors
    includedFlavorDimensionsAndValues = mapOf("store" to setOf("google", "samsung")),
  ))
}
```

--------------------------------

### Configure Gradle Publish Plugin

Source: https://vanniktech.github.io/gradle-maven-publish-plugin/what

Use this configuration for projects utilizing the com.gradle.plugin-publish plugin. It automatically includes sources and javadoc jars.

```groovy
import com.vanniktech.maven.publish.GradlePublishPlugin

mavenPublishing {
  configure(new GradlePublishPlugin())
}
```

```kotlin
import com.vanniktech.maven.publish.GradlePublishPlugin

mavenPublishing {
  configure(GradlePublishPlugin())
}
```

--------------------------------

### Configure POM metadata in Gradle

Source: https://vanniktech.github.io/gradle-maven-publish-plugin/other

Use the mavenPublishing block to define project coordinates and POM details. Choose between Groovy or Kotlin DSL based on your build script language.

```groovy
mavenPublishing {
  coordinates("com.example.mylibrary", "library-name", "1.0.3-SNAPSHOT")

  // the following is optional

  pom {
    name = "My Library"
    description = "A description of what my library does."
    inceptionYear = "2020"
    url = "https://github.com/username/mylibrary/"
    licenses {
      license {
        name = "The Apache License, Version 2.0"
        url = "http://www.apache.org/licenses/LICENSE-2.0.txt"
        distribution = "http://www.apache.org/licenses/LICENSE-2.0.txt"
      }
    }
    developers {
      developer {
        id = "username"
        name = "User Name"
        url = "https://github.com/username/"
      }
    }
    scm {
      url = "https://github.com/username/mylibrary/"
      connection = "scm:git:git://github.com/username/mylibrary.git"
      developerConnection = "scm:git:ssh://git@github.com/username/mylibrary.git"
    }
  }
}
```

```kotlin
mavenPublishing {
  coordinates("com.example.mylibrary", "library-name", "1.0.3-SNAPSHOT")

  // the following is optional

  pom {
    name.set("My Library")
    description.set("A description of what my library does.")
    inceptionYear.set("2020")
    url.set("https://github.com/username/mylibrary/")
    licenses {
      license {
        name.set("The Apache License, Version 2.0")
        url.set("http://www.apache.org/licenses/LICENSE-2.0.txt")
        distribution.set("http://www.apache.org/licenses/LICENSE-2.0.txt")
      }
    }
    developers {
      developer {
        id.set("username")
        name.set("User Name")
        url.set("https://github.com/username/")
      }
    }
    scm {
      url.set("https://github.com/username/mylibrary/")
      connection.set("scm:git:git://github.com/username/mylibrary.git")
      developerConnection.set("scm:git:ssh://git@github.com/username/mylibrary.git")
    }
  }
}
```

--------------------------------

### Configure Android Multi-Variant Library Publishing

Source: https://vanniktech.github.io/gradle-maven-publish-plugin/what

Use the AndroidMultiVariantLibrary class to define Javadoc and Sources artifacts, with optional filtering for build types and flavors.

```groovy
import com.vanniktech.maven.publish.AndroidMultiVariantLibrary
import com.vanniktech.maven.publish.JavadocJar
import com.vanniktech.maven.publish.SourcesJar

mavenPublishing {
  configure(new AndroidMultiVariantLibrary(
    // the first parameter configures the -javadoc artifact, possible values:
    // - `JavadocJar.None()` don't publish this artifact
    // - `JavadocJar.Empty()` publish an empty jar
    // - `JavadocJar.Javadoc()` to publish standard javadocs
    // - `JavadocJar.Dokka("dokkaHtml")` when using Kotlin with Dokka, where `dokkaHtml` is the name of the Dokka task that should be used as input
    new JavadocJar.Empty(),
    // configures the -sources artifact, possible values:
    // - `SourcesJar.None()` don't publish this artifact
    // - `SourcesJar.Empty()` publish an empty jar
    // - `SourcesJar.Sources()` publish the sources
    new SourcesJar.Sources()
  ))

  // or

  configure(new AndroidMultiVariantLibrary(
    // the first parameter configures the -javadoc artifact, possible values:
    // - `JavadocJar.None()` don't publish this artifact
    // - `JavadocJar.Empty()` publish an empty jar
    // - `JavadocJar.Javadoc()` to publish standard javadocs
    // - `JavadocJar.Dokka("dokkaHtml")` when using Kotlin with Dokka, where `dokkaHtml` is the name of the Dokka task that should be used as input
    new JavadocJar.Empty(),
    // configures the -sources artifact, possible values:
    // - `SourcesJar.None()` don't publish this artifact
    // - `SourcesJar.Empty()` publish an empty jar
    // - `SourcesJar.Sources()` publish the sources
    new SourcesJar.Sources(),
    // limit which build types to include
    ["beta", "release"] as Set
  ))

  // or

  configure(new AndroidMultiVariantLibrary(
    // the first parameter configures the -javadoc artifact, possible values:
    // - `JavadocJar.None()` don't publish this artifact
    // - `JavadocJar.Empty()` publish an empty jar
    // - `JavadocJar.Javadoc()` to publish standard javadocs
    // - `JavadocJar.Dokka("dokkaHtml")` when using Kotlin with Dokka, where `dokkaHtml` is the name of the Dokka task that should be used as input
    new JavadocJar.Empty(),
    // configures the -sources artifact, possible values:
    // - `SourcesJar.None()` don't publish this artifact
    // - `SourcesJar.Empty()` publish an empty jar
    // - `SourcesJar.Sources()` publish the sources
    new SourcesJar.Sources(),
    // limit which build types to include
    ["beta", "release"] as Set,
    // limit which flavors to include
    // the map key is a flavor dimension, the set contains the flavors
    ["store": ["google", "samsung"] as Set]
  ))
}
```

--------------------------------

### AndroidSingleVariantLibrary(variant, sourcesJar, publishJavadocJar)

Source: https://vanniktech.github.io/gradle-maven-publish-plugin/api/plugin/com.vanniktech.maven.publish/-android-single-variant-library/-android-single-variant-library.html

Deprecated constructor for initializing an AndroidSingleVariantLibrary.

```APIDOC
## constructor(variant: String, sourcesJar: Boolean, publishJavadocJar: Boolean)

### Description
Deprecated constructor for initializing an AndroidSingleVariantLibrary. Use the constructor with JavadocJar and SourcesJar instead.

### Parameters
- **variant** (String) - Optional - The Android variant name, defaults to "release".
- **sourcesJar** (Boolean) - Optional - Whether to include sources, defaults to true.
- **publishJavadocJar** (Boolean) - Required - Whether to publish the Javadoc jar.
```

--------------------------------

### KotlinJvm(JavadocJar, SourcesJar)

Source: https://vanniktech.github.io/gradle-maven-publish-plugin/api/plugin/com.vanniktech.maven.publish/-kotlin-jvm/-kotlin-jvm.html

Primary constructor for configuring Kotlin JVM publishing with specific Javadoc and Sources JAR settings.

```APIDOC
## KotlinJvm(JavadocJar, SourcesJar)

### Description
Initializes a new KotlinJvm configuration instance with specified Javadoc and Sources JAR strategies.

### Signature
`constructor(javadocJar: JavadocJar = JavadocJar.Empty(), sourcesJar: SourcesJar = SourcesJar.Sources())`

### Parameters
- **javadocJar** (JavadocJar) - Optional - The strategy for generating Javadoc JARs. Defaults to JavadocJar.Empty().
- **sourcesJar** (SourcesJar) - Optional - The strategy for generating Sources JARs. Defaults to SourcesJar.Sources().
```
Tokens:
Raw