diff --git a/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/KotlinCompilerPluginClasspathConfigurationAccessors.kt b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/KotlinCompilerPluginClasspathConfigurationAccessors.kt new file mode 100644 index 00000000..c4ad55dd --- /dev/null +++ b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/KotlinCompilerPluginClasspathConfigurationAccessors.kt @@ -0,0 +1,213 @@ + +/* + * Copyright 2018 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +@file:Suppress( + "unused", + "nothing_to_inline", + "useless_cast", + "unchecked_cast", + "extension_shadowed_by_member", + "redundant_projection", + "RemoveRedundantBackticks", + "ObjectPropertyName", + "deprecation" +) +@file:org.gradle.api.Generated + +/* ktlint-disable */ + +package org.gradle.kotlin.dsl + + +import org.gradle.api.Action +import org.gradle.api.Incubating +import org.gradle.api.NamedDomainObjectProvider +import org.gradle.api.Project +import org.gradle.api.Task +import org.gradle.api.artifacts.Configuration +import org.gradle.api.artifacts.ConfigurablePublishArtifact +import org.gradle.api.artifacts.ConfigurationContainer +import org.gradle.api.artifacts.Dependency +import org.gradle.api.artifacts.DependencyConstraint +import org.gradle.api.artifacts.ExternalModuleDependency +import org.gradle.api.artifacts.ModuleDependency +import org.gradle.api.artifacts.PublishArtifact +import org.gradle.api.artifacts.dsl.ArtifactHandler +import org.gradle.api.artifacts.dsl.DependencyConstraintHandler +import org.gradle.api.artifacts.dsl.DependencyHandler +import org.gradle.api.provider.Provider +import org.gradle.api.provider.ProviderConvertible +import org.gradle.api.tasks.TaskContainer +import org.gradle.api.tasks.TaskProvider + +import org.gradle.kotlin.dsl.* +import org.gradle.kotlin.dsl.accessors.runtime.* + + +/** + * Adds a dependency to the 'kotlinCompilerPluginClasspath' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`kotlinCompilerPluginClasspath`(dependencyNotation: Any): Dependency? = + add("kotlinCompilerPluginClasspath", dependencyNotation) + +/** + * Adds a dependency to the 'kotlinCompilerPluginClasspath' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`kotlinCompilerPluginClasspath`( + dependencyNotation: String, + dependencyConfiguration: Action +): ExternalModuleDependency = addDependencyTo( + this, "kotlinCompilerPluginClasspath", dependencyNotation, dependencyConfiguration +) as ExternalModuleDependency + +/** + * Adds a dependency to the 'kotlinCompilerPluginClasspath' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`kotlinCompilerPluginClasspath`( + dependencyNotation: Provider<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "kotlinCompilerPluginClasspath", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'kotlinCompilerPluginClasspath' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`kotlinCompilerPluginClasspath`( + dependencyNotation: ProviderConvertible<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "kotlinCompilerPluginClasspath", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'kotlinCompilerPluginClasspath' configuration. + * + * @param group the group of the module to be added as a dependency. + * @param name the name of the module to be added as a dependency. + * @param version the optional version of the module to be added as a dependency. + * @param configuration the optional configuration of the module to be added as a dependency. + * @param classifier the optional classifier of the module artifact to be added as a dependency. + * @param ext the optional extension of the module artifact to be added as a dependency. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.create] + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`kotlinCompilerPluginClasspath`( + group: String, + name: String, + version: String? = null, + configuration: String? = null, + classifier: String? = null, + ext: String? = null, + dependencyConfiguration: Action? = null +): ExternalModuleDependency = addExternalModuleDependencyTo( + this, "kotlinCompilerPluginClasspath", group, name, version, configuration, classifier, ext, dependencyConfiguration +) + +/** + * Adds a dependency to the 'kotlinCompilerPluginClasspath' configuration. + * + * @param dependency dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`kotlinCompilerPluginClasspath`( + dependency: T, + dependencyConfiguration: T.() -> Unit +): T = add("kotlinCompilerPluginClasspath", dependency, dependencyConfiguration) + +/** + * Adds a dependency constraint to the 'kotlinCompilerPluginClasspath' configuration. + * + * @param constraintNotation the dependency constraint notation + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`kotlinCompilerPluginClasspath`(constraintNotation: Any): DependencyConstraint = + add("kotlinCompilerPluginClasspath", constraintNotation) + +/** + * Adds a dependency constraint to the 'kotlinCompilerPluginClasspath' configuration. + * + * @param constraintNotation the dependency constraint notation + * @param block the block to use to configure the dependency constraint + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`kotlinCompilerPluginClasspath`(constraintNotation: Any, block: DependencyConstraint.() -> Unit): DependencyConstraint = + add("kotlinCompilerPluginClasspath", constraintNotation, block) + +/** + * Adds an artifact to the 'kotlinCompilerPluginClasspath' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`kotlinCompilerPluginClasspath`(artifactNotation: Any): PublishArtifact = + add("kotlinCompilerPluginClasspath", artifactNotation) + +/** + * Adds an artifact to the 'kotlinCompilerPluginClasspath' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @param configureAction The action to execute to configure the artifact. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`kotlinCompilerPluginClasspath`( + artifactNotation: Any, + configureAction: ConfigurablePublishArtifact.() -> Unit +): PublishArtifact = + add("kotlinCompilerPluginClasspath", artifactNotation, configureAction) + + + diff --git a/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/KotlinKlibCommonizerClasspathConfigurationAccessors.kt b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/KotlinKlibCommonizerClasspathConfigurationAccessors.kt new file mode 100644 index 00000000..ff884778 --- /dev/null +++ b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/KotlinKlibCommonizerClasspathConfigurationAccessors.kt @@ -0,0 +1,213 @@ + +/* + * Copyright 2018 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +@file:Suppress( + "unused", + "nothing_to_inline", + "useless_cast", + "unchecked_cast", + "extension_shadowed_by_member", + "redundant_projection", + "RemoveRedundantBackticks", + "ObjectPropertyName", + "deprecation" +) +@file:org.gradle.api.Generated + +/* ktlint-disable */ + +package org.gradle.kotlin.dsl + + +import org.gradle.api.Action +import org.gradle.api.Incubating +import org.gradle.api.NamedDomainObjectProvider +import org.gradle.api.Project +import org.gradle.api.Task +import org.gradle.api.artifacts.Configuration +import org.gradle.api.artifacts.ConfigurablePublishArtifact +import org.gradle.api.artifacts.ConfigurationContainer +import org.gradle.api.artifacts.Dependency +import org.gradle.api.artifacts.DependencyConstraint +import org.gradle.api.artifacts.ExternalModuleDependency +import org.gradle.api.artifacts.ModuleDependency +import org.gradle.api.artifacts.PublishArtifact +import org.gradle.api.artifacts.dsl.ArtifactHandler +import org.gradle.api.artifacts.dsl.DependencyConstraintHandler +import org.gradle.api.artifacts.dsl.DependencyHandler +import org.gradle.api.provider.Provider +import org.gradle.api.provider.ProviderConvertible +import org.gradle.api.tasks.TaskContainer +import org.gradle.api.tasks.TaskProvider + +import org.gradle.kotlin.dsl.* +import org.gradle.kotlin.dsl.accessors.runtime.* + + +/** + * Adds a dependency to the 'kotlinKlibCommonizerClasspath' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`kotlinKlibCommonizerClasspath`(dependencyNotation: Any): Dependency? = + add("kotlinKlibCommonizerClasspath", dependencyNotation) + +/** + * Adds a dependency to the 'kotlinKlibCommonizerClasspath' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`kotlinKlibCommonizerClasspath`( + dependencyNotation: String, + dependencyConfiguration: Action +): ExternalModuleDependency = addDependencyTo( + this, "kotlinKlibCommonizerClasspath", dependencyNotation, dependencyConfiguration +) as ExternalModuleDependency + +/** + * Adds a dependency to the 'kotlinKlibCommonizerClasspath' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`kotlinKlibCommonizerClasspath`( + dependencyNotation: Provider<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "kotlinKlibCommonizerClasspath", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'kotlinKlibCommonizerClasspath' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`kotlinKlibCommonizerClasspath`( + dependencyNotation: ProviderConvertible<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "kotlinKlibCommonizerClasspath", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'kotlinKlibCommonizerClasspath' configuration. + * + * @param group the group of the module to be added as a dependency. + * @param name the name of the module to be added as a dependency. + * @param version the optional version of the module to be added as a dependency. + * @param configuration the optional configuration of the module to be added as a dependency. + * @param classifier the optional classifier of the module artifact to be added as a dependency. + * @param ext the optional extension of the module artifact to be added as a dependency. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.create] + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`kotlinKlibCommonizerClasspath`( + group: String, + name: String, + version: String? = null, + configuration: String? = null, + classifier: String? = null, + ext: String? = null, + dependencyConfiguration: Action? = null +): ExternalModuleDependency = addExternalModuleDependencyTo( + this, "kotlinKlibCommonizerClasspath", group, name, version, configuration, classifier, ext, dependencyConfiguration +) + +/** + * Adds a dependency to the 'kotlinKlibCommonizerClasspath' configuration. + * + * @param dependency dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`kotlinKlibCommonizerClasspath`( + dependency: T, + dependencyConfiguration: T.() -> Unit +): T = add("kotlinKlibCommonizerClasspath", dependency, dependencyConfiguration) + +/** + * Adds a dependency constraint to the 'kotlinKlibCommonizerClasspath' configuration. + * + * @param constraintNotation the dependency constraint notation + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`kotlinKlibCommonizerClasspath`(constraintNotation: Any): DependencyConstraint = + add("kotlinKlibCommonizerClasspath", constraintNotation) + +/** + * Adds a dependency constraint to the 'kotlinKlibCommonizerClasspath' configuration. + * + * @param constraintNotation the dependency constraint notation + * @param block the block to use to configure the dependency constraint + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`kotlinKlibCommonizerClasspath`(constraintNotation: Any, block: DependencyConstraint.() -> Unit): DependencyConstraint = + add("kotlinKlibCommonizerClasspath", constraintNotation, block) + +/** + * Adds an artifact to the 'kotlinKlibCommonizerClasspath' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`kotlinKlibCommonizerClasspath`(artifactNotation: Any): PublishArtifact = + add("kotlinKlibCommonizerClasspath", artifactNotation) + +/** + * Adds an artifact to the 'kotlinKlibCommonizerClasspath' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @param configureAction The action to execute to configure the artifact. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`kotlinKlibCommonizerClasspath`( + artifactNotation: Any, + configureAction: ConfigurablePublishArtifact.() -> Unit +): PublishArtifact = + add("kotlinKlibCommonizerClasspath", artifactNotation, configureAction) + + + diff --git a/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/KotlinNativeCompilerPluginClasspathConfigurationAccessors.kt b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/KotlinNativeCompilerPluginClasspathConfigurationAccessors.kt new file mode 100644 index 00000000..54f55be4 --- /dev/null +++ b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/KotlinNativeCompilerPluginClasspathConfigurationAccessors.kt @@ -0,0 +1,213 @@ + +/* + * Copyright 2018 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +@file:Suppress( + "unused", + "nothing_to_inline", + "useless_cast", + "unchecked_cast", + "extension_shadowed_by_member", + "redundant_projection", + "RemoveRedundantBackticks", + "ObjectPropertyName", + "deprecation" +) +@file:org.gradle.api.Generated + +/* ktlint-disable */ + +package org.gradle.kotlin.dsl + + +import org.gradle.api.Action +import org.gradle.api.Incubating +import org.gradle.api.NamedDomainObjectProvider +import org.gradle.api.Project +import org.gradle.api.Task +import org.gradle.api.artifacts.Configuration +import org.gradle.api.artifacts.ConfigurablePublishArtifact +import org.gradle.api.artifacts.ConfigurationContainer +import org.gradle.api.artifacts.Dependency +import org.gradle.api.artifacts.DependencyConstraint +import org.gradle.api.artifacts.ExternalModuleDependency +import org.gradle.api.artifacts.ModuleDependency +import org.gradle.api.artifacts.PublishArtifact +import org.gradle.api.artifacts.dsl.ArtifactHandler +import org.gradle.api.artifacts.dsl.DependencyConstraintHandler +import org.gradle.api.artifacts.dsl.DependencyHandler +import org.gradle.api.provider.Provider +import org.gradle.api.provider.ProviderConvertible +import org.gradle.api.tasks.TaskContainer +import org.gradle.api.tasks.TaskProvider + +import org.gradle.kotlin.dsl.* +import org.gradle.kotlin.dsl.accessors.runtime.* + + +/** + * Adds a dependency to the 'kotlinNativeCompilerPluginClasspath' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`kotlinNativeCompilerPluginClasspath`(dependencyNotation: Any): Dependency? = + add("kotlinNativeCompilerPluginClasspath", dependencyNotation) + +/** + * Adds a dependency to the 'kotlinNativeCompilerPluginClasspath' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`kotlinNativeCompilerPluginClasspath`( + dependencyNotation: String, + dependencyConfiguration: Action +): ExternalModuleDependency = addDependencyTo( + this, "kotlinNativeCompilerPluginClasspath", dependencyNotation, dependencyConfiguration +) as ExternalModuleDependency + +/** + * Adds a dependency to the 'kotlinNativeCompilerPluginClasspath' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`kotlinNativeCompilerPluginClasspath`( + dependencyNotation: Provider<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "kotlinNativeCompilerPluginClasspath", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'kotlinNativeCompilerPluginClasspath' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`kotlinNativeCompilerPluginClasspath`( + dependencyNotation: ProviderConvertible<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "kotlinNativeCompilerPluginClasspath", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'kotlinNativeCompilerPluginClasspath' configuration. + * + * @param group the group of the module to be added as a dependency. + * @param name the name of the module to be added as a dependency. + * @param version the optional version of the module to be added as a dependency. + * @param configuration the optional configuration of the module to be added as a dependency. + * @param classifier the optional classifier of the module artifact to be added as a dependency. + * @param ext the optional extension of the module artifact to be added as a dependency. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.create] + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`kotlinNativeCompilerPluginClasspath`( + group: String, + name: String, + version: String? = null, + configuration: String? = null, + classifier: String? = null, + ext: String? = null, + dependencyConfiguration: Action? = null +): ExternalModuleDependency = addExternalModuleDependencyTo( + this, "kotlinNativeCompilerPluginClasspath", group, name, version, configuration, classifier, ext, dependencyConfiguration +) + +/** + * Adds a dependency to the 'kotlinNativeCompilerPluginClasspath' configuration. + * + * @param dependency dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`kotlinNativeCompilerPluginClasspath`( + dependency: T, + dependencyConfiguration: T.() -> Unit +): T = add("kotlinNativeCompilerPluginClasspath", dependency, dependencyConfiguration) + +/** + * Adds a dependency constraint to the 'kotlinNativeCompilerPluginClasspath' configuration. + * + * @param constraintNotation the dependency constraint notation + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`kotlinNativeCompilerPluginClasspath`(constraintNotation: Any): DependencyConstraint = + add("kotlinNativeCompilerPluginClasspath", constraintNotation) + +/** + * Adds a dependency constraint to the 'kotlinNativeCompilerPluginClasspath' configuration. + * + * @param constraintNotation the dependency constraint notation + * @param block the block to use to configure the dependency constraint + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`kotlinNativeCompilerPluginClasspath`(constraintNotation: Any, block: DependencyConstraint.() -> Unit): DependencyConstraint = + add("kotlinNativeCompilerPluginClasspath", constraintNotation, block) + +/** + * Adds an artifact to the 'kotlinNativeCompilerPluginClasspath' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`kotlinNativeCompilerPluginClasspath`(artifactNotation: Any): PublishArtifact = + add("kotlinNativeCompilerPluginClasspath", artifactNotation) + +/** + * Adds an artifact to the 'kotlinNativeCompilerPluginClasspath' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @param configureAction The action to execute to configure the artifact. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`kotlinNativeCompilerPluginClasspath`( + artifactNotation: Any, + configureAction: ConfigurablePublishArtifact.() -> Unit +): PublishArtifact = + add("kotlinNativeCompilerPluginClasspath", artifactNotation, configureAction) + + + diff --git a/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/LintChecksConfigurationAccessors.kt b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/LintChecksConfigurationAccessors.kt new file mode 100644 index 00000000..cce3328c --- /dev/null +++ b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/LintChecksConfigurationAccessors.kt @@ -0,0 +1,213 @@ + +/* + * Copyright 2018 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +@file:Suppress( + "unused", + "nothing_to_inline", + "useless_cast", + "unchecked_cast", + "extension_shadowed_by_member", + "redundant_projection", + "RemoveRedundantBackticks", + "ObjectPropertyName", + "deprecation" +) +@file:org.gradle.api.Generated + +/* ktlint-disable */ + +package org.gradle.kotlin.dsl + + +import org.gradle.api.Action +import org.gradle.api.Incubating +import org.gradle.api.NamedDomainObjectProvider +import org.gradle.api.Project +import org.gradle.api.Task +import org.gradle.api.artifacts.Configuration +import org.gradle.api.artifacts.ConfigurablePublishArtifact +import org.gradle.api.artifacts.ConfigurationContainer +import org.gradle.api.artifacts.Dependency +import org.gradle.api.artifacts.DependencyConstraint +import org.gradle.api.artifacts.ExternalModuleDependency +import org.gradle.api.artifacts.ModuleDependency +import org.gradle.api.artifacts.PublishArtifact +import org.gradle.api.artifacts.dsl.ArtifactHandler +import org.gradle.api.artifacts.dsl.DependencyConstraintHandler +import org.gradle.api.artifacts.dsl.DependencyHandler +import org.gradle.api.provider.Provider +import org.gradle.api.provider.ProviderConvertible +import org.gradle.api.tasks.TaskContainer +import org.gradle.api.tasks.TaskProvider + +import org.gradle.kotlin.dsl.* +import org.gradle.kotlin.dsl.accessors.runtime.* + + +/** + * Adds a dependency to the 'lintChecks' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`lintChecks`(dependencyNotation: Any): Dependency? = + add("lintChecks", dependencyNotation) + +/** + * Adds a dependency to the 'lintChecks' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`lintChecks`( + dependencyNotation: String, + dependencyConfiguration: Action +): ExternalModuleDependency = addDependencyTo( + this, "lintChecks", dependencyNotation, dependencyConfiguration +) as ExternalModuleDependency + +/** + * Adds a dependency to the 'lintChecks' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`lintChecks`( + dependencyNotation: Provider<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "lintChecks", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'lintChecks' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`lintChecks`( + dependencyNotation: ProviderConvertible<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "lintChecks", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'lintChecks' configuration. + * + * @param group the group of the module to be added as a dependency. + * @param name the name of the module to be added as a dependency. + * @param version the optional version of the module to be added as a dependency. + * @param configuration the optional configuration of the module to be added as a dependency. + * @param classifier the optional classifier of the module artifact to be added as a dependency. + * @param ext the optional extension of the module artifact to be added as a dependency. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.create] + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`lintChecks`( + group: String, + name: String, + version: String? = null, + configuration: String? = null, + classifier: String? = null, + ext: String? = null, + dependencyConfiguration: Action? = null +): ExternalModuleDependency = addExternalModuleDependencyTo( + this, "lintChecks", group, name, version, configuration, classifier, ext, dependencyConfiguration +) + +/** + * Adds a dependency to the 'lintChecks' configuration. + * + * @param dependency dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`lintChecks`( + dependency: T, + dependencyConfiguration: T.() -> Unit +): T = add("lintChecks", dependency, dependencyConfiguration) + +/** + * Adds a dependency constraint to the 'lintChecks' configuration. + * + * @param constraintNotation the dependency constraint notation + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`lintChecks`(constraintNotation: Any): DependencyConstraint = + add("lintChecks", constraintNotation) + +/** + * Adds a dependency constraint to the 'lintChecks' configuration. + * + * @param constraintNotation the dependency constraint notation + * @param block the block to use to configure the dependency constraint + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`lintChecks`(constraintNotation: Any, block: DependencyConstraint.() -> Unit): DependencyConstraint = + add("lintChecks", constraintNotation, block) + +/** + * Adds an artifact to the 'lintChecks' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`lintChecks`(artifactNotation: Any): PublishArtifact = + add("lintChecks", artifactNotation) + +/** + * Adds an artifact to the 'lintChecks' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @param configureAction The action to execute to configure the artifact. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`lintChecks`( + artifactNotation: Any, + configureAction: ConfigurablePublishArtifact.() -> Unit +): PublishArtifact = + add("lintChecks", artifactNotation, configureAction) + + + diff --git a/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/LintPublishConfigurationAccessors.kt b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/LintPublishConfigurationAccessors.kt new file mode 100644 index 00000000..8a9b23a1 --- /dev/null +++ b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/LintPublishConfigurationAccessors.kt @@ -0,0 +1,213 @@ + +/* + * Copyright 2018 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +@file:Suppress( + "unused", + "nothing_to_inline", + "useless_cast", + "unchecked_cast", + "extension_shadowed_by_member", + "redundant_projection", + "RemoveRedundantBackticks", + "ObjectPropertyName", + "deprecation" +) +@file:org.gradle.api.Generated + +/* ktlint-disable */ + +package org.gradle.kotlin.dsl + + +import org.gradle.api.Action +import org.gradle.api.Incubating +import org.gradle.api.NamedDomainObjectProvider +import org.gradle.api.Project +import org.gradle.api.Task +import org.gradle.api.artifacts.Configuration +import org.gradle.api.artifacts.ConfigurablePublishArtifact +import org.gradle.api.artifacts.ConfigurationContainer +import org.gradle.api.artifacts.Dependency +import org.gradle.api.artifacts.DependencyConstraint +import org.gradle.api.artifacts.ExternalModuleDependency +import org.gradle.api.artifacts.ModuleDependency +import org.gradle.api.artifacts.PublishArtifact +import org.gradle.api.artifacts.dsl.ArtifactHandler +import org.gradle.api.artifacts.dsl.DependencyConstraintHandler +import org.gradle.api.artifacts.dsl.DependencyHandler +import org.gradle.api.provider.Provider +import org.gradle.api.provider.ProviderConvertible +import org.gradle.api.tasks.TaskContainer +import org.gradle.api.tasks.TaskProvider + +import org.gradle.kotlin.dsl.* +import org.gradle.kotlin.dsl.accessors.runtime.* + + +/** + * Adds a dependency to the 'lintPublish' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`lintPublish`(dependencyNotation: Any): Dependency? = + add("lintPublish", dependencyNotation) + +/** + * Adds a dependency to the 'lintPublish' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`lintPublish`( + dependencyNotation: String, + dependencyConfiguration: Action +): ExternalModuleDependency = addDependencyTo( + this, "lintPublish", dependencyNotation, dependencyConfiguration +) as ExternalModuleDependency + +/** + * Adds a dependency to the 'lintPublish' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`lintPublish`( + dependencyNotation: Provider<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "lintPublish", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'lintPublish' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`lintPublish`( + dependencyNotation: ProviderConvertible<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "lintPublish", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'lintPublish' configuration. + * + * @param group the group of the module to be added as a dependency. + * @param name the name of the module to be added as a dependency. + * @param version the optional version of the module to be added as a dependency. + * @param configuration the optional configuration of the module to be added as a dependency. + * @param classifier the optional classifier of the module artifact to be added as a dependency. + * @param ext the optional extension of the module artifact to be added as a dependency. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.create] + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`lintPublish`( + group: String, + name: String, + version: String? = null, + configuration: String? = null, + classifier: String? = null, + ext: String? = null, + dependencyConfiguration: Action? = null +): ExternalModuleDependency = addExternalModuleDependencyTo( + this, "lintPublish", group, name, version, configuration, classifier, ext, dependencyConfiguration +) + +/** + * Adds a dependency to the 'lintPublish' configuration. + * + * @param dependency dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`lintPublish`( + dependency: T, + dependencyConfiguration: T.() -> Unit +): T = add("lintPublish", dependency, dependencyConfiguration) + +/** + * Adds a dependency constraint to the 'lintPublish' configuration. + * + * @param constraintNotation the dependency constraint notation + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`lintPublish`(constraintNotation: Any): DependencyConstraint = + add("lintPublish", constraintNotation) + +/** + * Adds a dependency constraint to the 'lintPublish' configuration. + * + * @param constraintNotation the dependency constraint notation + * @param block the block to use to configure the dependency constraint + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`lintPublish`(constraintNotation: Any, block: DependencyConstraint.() -> Unit): DependencyConstraint = + add("lintPublish", constraintNotation, block) + +/** + * Adds an artifact to the 'lintPublish' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`lintPublish`(artifactNotation: Any): PublishArtifact = + add("lintPublish", artifactNotation) + +/** + * Adds an artifact to the 'lintPublish' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @param configureAction The action to execute to configure the artifact. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`lintPublish`( + artifactNotation: Any, + configureAction: ConfigurablePublishArtifact.() -> Unit +): PublishArtifact = + add("lintPublish", artifactNotation, configureAction) + + + diff --git a/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/ReleaseAnnotationProcessorConfigurationAccessors.kt b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/ReleaseAnnotationProcessorConfigurationAccessors.kt new file mode 100644 index 00000000..48315e49 --- /dev/null +++ b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/ReleaseAnnotationProcessorConfigurationAccessors.kt @@ -0,0 +1,213 @@ + +/* + * Copyright 2018 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +@file:Suppress( + "unused", + "nothing_to_inline", + "useless_cast", + "unchecked_cast", + "extension_shadowed_by_member", + "redundant_projection", + "RemoveRedundantBackticks", + "ObjectPropertyName", + "deprecation" +) +@file:org.gradle.api.Generated + +/* ktlint-disable */ + +package org.gradle.kotlin.dsl + + +import org.gradle.api.Action +import org.gradle.api.Incubating +import org.gradle.api.NamedDomainObjectProvider +import org.gradle.api.Project +import org.gradle.api.Task +import org.gradle.api.artifacts.Configuration +import org.gradle.api.artifacts.ConfigurablePublishArtifact +import org.gradle.api.artifacts.ConfigurationContainer +import org.gradle.api.artifacts.Dependency +import org.gradle.api.artifacts.DependencyConstraint +import org.gradle.api.artifacts.ExternalModuleDependency +import org.gradle.api.artifacts.ModuleDependency +import org.gradle.api.artifacts.PublishArtifact +import org.gradle.api.artifacts.dsl.ArtifactHandler +import org.gradle.api.artifacts.dsl.DependencyConstraintHandler +import org.gradle.api.artifacts.dsl.DependencyHandler +import org.gradle.api.provider.Provider +import org.gradle.api.provider.ProviderConvertible +import org.gradle.api.tasks.TaskContainer +import org.gradle.api.tasks.TaskProvider + +import org.gradle.kotlin.dsl.* +import org.gradle.kotlin.dsl.accessors.runtime.* + + +/** + * Adds a dependency to the 'releaseAnnotationProcessor' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`releaseAnnotationProcessor`(dependencyNotation: Any): Dependency? = + add("releaseAnnotationProcessor", dependencyNotation) + +/** + * Adds a dependency to the 'releaseAnnotationProcessor' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`releaseAnnotationProcessor`( + dependencyNotation: String, + dependencyConfiguration: Action +): ExternalModuleDependency = addDependencyTo( + this, "releaseAnnotationProcessor", dependencyNotation, dependencyConfiguration +) as ExternalModuleDependency + +/** + * Adds a dependency to the 'releaseAnnotationProcessor' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`releaseAnnotationProcessor`( + dependencyNotation: Provider<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "releaseAnnotationProcessor", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'releaseAnnotationProcessor' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`releaseAnnotationProcessor`( + dependencyNotation: ProviderConvertible<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "releaseAnnotationProcessor", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'releaseAnnotationProcessor' configuration. + * + * @param group the group of the module to be added as a dependency. + * @param name the name of the module to be added as a dependency. + * @param version the optional version of the module to be added as a dependency. + * @param configuration the optional configuration of the module to be added as a dependency. + * @param classifier the optional classifier of the module artifact to be added as a dependency. + * @param ext the optional extension of the module artifact to be added as a dependency. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.create] + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`releaseAnnotationProcessor`( + group: String, + name: String, + version: String? = null, + configuration: String? = null, + classifier: String? = null, + ext: String? = null, + dependencyConfiguration: Action? = null +): ExternalModuleDependency = addExternalModuleDependencyTo( + this, "releaseAnnotationProcessor", group, name, version, configuration, classifier, ext, dependencyConfiguration +) + +/** + * Adds a dependency to the 'releaseAnnotationProcessor' configuration. + * + * @param dependency dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`releaseAnnotationProcessor`( + dependency: T, + dependencyConfiguration: T.() -> Unit +): T = add("releaseAnnotationProcessor", dependency, dependencyConfiguration) + +/** + * Adds a dependency constraint to the 'releaseAnnotationProcessor' configuration. + * + * @param constraintNotation the dependency constraint notation + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`releaseAnnotationProcessor`(constraintNotation: Any): DependencyConstraint = + add("releaseAnnotationProcessor", constraintNotation) + +/** + * Adds a dependency constraint to the 'releaseAnnotationProcessor' configuration. + * + * @param constraintNotation the dependency constraint notation + * @param block the block to use to configure the dependency constraint + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`releaseAnnotationProcessor`(constraintNotation: Any, block: DependencyConstraint.() -> Unit): DependencyConstraint = + add("releaseAnnotationProcessor", constraintNotation, block) + +/** + * Adds an artifact to the 'releaseAnnotationProcessor' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`releaseAnnotationProcessor`(artifactNotation: Any): PublishArtifact = + add("releaseAnnotationProcessor", artifactNotation) + +/** + * Adds an artifact to the 'releaseAnnotationProcessor' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @param configureAction The action to execute to configure the artifact. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`releaseAnnotationProcessor`( + artifactNotation: Any, + configureAction: ConfigurablePublishArtifact.() -> Unit +): PublishArtifact = + add("releaseAnnotationProcessor", artifactNotation, configureAction) + + + diff --git a/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/ReleaseApiConfigurationAccessors.kt b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/ReleaseApiConfigurationAccessors.kt new file mode 100644 index 00000000..2363a0ae --- /dev/null +++ b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/ReleaseApiConfigurationAccessors.kt @@ -0,0 +1,213 @@ + +/* + * Copyright 2018 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +@file:Suppress( + "unused", + "nothing_to_inline", + "useless_cast", + "unchecked_cast", + "extension_shadowed_by_member", + "redundant_projection", + "RemoveRedundantBackticks", + "ObjectPropertyName", + "deprecation" +) +@file:org.gradle.api.Generated + +/* ktlint-disable */ + +package org.gradle.kotlin.dsl + + +import org.gradle.api.Action +import org.gradle.api.Incubating +import org.gradle.api.NamedDomainObjectProvider +import org.gradle.api.Project +import org.gradle.api.Task +import org.gradle.api.artifacts.Configuration +import org.gradle.api.artifacts.ConfigurablePublishArtifact +import org.gradle.api.artifacts.ConfigurationContainer +import org.gradle.api.artifacts.Dependency +import org.gradle.api.artifacts.DependencyConstraint +import org.gradle.api.artifacts.ExternalModuleDependency +import org.gradle.api.artifacts.ModuleDependency +import org.gradle.api.artifacts.PublishArtifact +import org.gradle.api.artifacts.dsl.ArtifactHandler +import org.gradle.api.artifacts.dsl.DependencyConstraintHandler +import org.gradle.api.artifacts.dsl.DependencyHandler +import org.gradle.api.provider.Provider +import org.gradle.api.provider.ProviderConvertible +import org.gradle.api.tasks.TaskContainer +import org.gradle.api.tasks.TaskProvider + +import org.gradle.kotlin.dsl.* +import org.gradle.kotlin.dsl.accessors.runtime.* + + +/** + * Adds a dependency to the 'releaseApi' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`releaseApi`(dependencyNotation: Any): Dependency? = + add("releaseApi", dependencyNotation) + +/** + * Adds a dependency to the 'releaseApi' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`releaseApi`( + dependencyNotation: String, + dependencyConfiguration: Action +): ExternalModuleDependency = addDependencyTo( + this, "releaseApi", dependencyNotation, dependencyConfiguration +) as ExternalModuleDependency + +/** + * Adds a dependency to the 'releaseApi' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`releaseApi`( + dependencyNotation: Provider<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "releaseApi", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'releaseApi' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`releaseApi`( + dependencyNotation: ProviderConvertible<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "releaseApi", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'releaseApi' configuration. + * + * @param group the group of the module to be added as a dependency. + * @param name the name of the module to be added as a dependency. + * @param version the optional version of the module to be added as a dependency. + * @param configuration the optional configuration of the module to be added as a dependency. + * @param classifier the optional classifier of the module artifact to be added as a dependency. + * @param ext the optional extension of the module artifact to be added as a dependency. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.create] + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`releaseApi`( + group: String, + name: String, + version: String? = null, + configuration: String? = null, + classifier: String? = null, + ext: String? = null, + dependencyConfiguration: Action? = null +): ExternalModuleDependency = addExternalModuleDependencyTo( + this, "releaseApi", group, name, version, configuration, classifier, ext, dependencyConfiguration +) + +/** + * Adds a dependency to the 'releaseApi' configuration. + * + * @param dependency dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`releaseApi`( + dependency: T, + dependencyConfiguration: T.() -> Unit +): T = add("releaseApi", dependency, dependencyConfiguration) + +/** + * Adds a dependency constraint to the 'releaseApi' configuration. + * + * @param constraintNotation the dependency constraint notation + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`releaseApi`(constraintNotation: Any): DependencyConstraint = + add("releaseApi", constraintNotation) + +/** + * Adds a dependency constraint to the 'releaseApi' configuration. + * + * @param constraintNotation the dependency constraint notation + * @param block the block to use to configure the dependency constraint + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`releaseApi`(constraintNotation: Any, block: DependencyConstraint.() -> Unit): DependencyConstraint = + add("releaseApi", constraintNotation, block) + +/** + * Adds an artifact to the 'releaseApi' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`releaseApi`(artifactNotation: Any): PublishArtifact = + add("releaseApi", artifactNotation) + +/** + * Adds an artifact to the 'releaseApi' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @param configureAction The action to execute to configure the artifact. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`releaseApi`( + artifactNotation: Any, + configureAction: ConfigurablePublishArtifact.() -> Unit +): PublishArtifact = + add("releaseApi", artifactNotation, configureAction) + + + diff --git a/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/ReleaseApiDependenciesMetadataConfigurationAccessors.kt b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/ReleaseApiDependenciesMetadataConfigurationAccessors.kt new file mode 100644 index 00000000..27929429 --- /dev/null +++ b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/ReleaseApiDependenciesMetadataConfigurationAccessors.kt @@ -0,0 +1,213 @@ + +/* + * Copyright 2018 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +@file:Suppress( + "unused", + "nothing_to_inline", + "useless_cast", + "unchecked_cast", + "extension_shadowed_by_member", + "redundant_projection", + "RemoveRedundantBackticks", + "ObjectPropertyName", + "deprecation" +) +@file:org.gradle.api.Generated + +/* ktlint-disable */ + +package org.gradle.kotlin.dsl + + +import org.gradle.api.Action +import org.gradle.api.Incubating +import org.gradle.api.NamedDomainObjectProvider +import org.gradle.api.Project +import org.gradle.api.Task +import org.gradle.api.artifacts.Configuration +import org.gradle.api.artifacts.ConfigurablePublishArtifact +import org.gradle.api.artifacts.ConfigurationContainer +import org.gradle.api.artifacts.Dependency +import org.gradle.api.artifacts.DependencyConstraint +import org.gradle.api.artifacts.ExternalModuleDependency +import org.gradle.api.artifacts.ModuleDependency +import org.gradle.api.artifacts.PublishArtifact +import org.gradle.api.artifacts.dsl.ArtifactHandler +import org.gradle.api.artifacts.dsl.DependencyConstraintHandler +import org.gradle.api.artifacts.dsl.DependencyHandler +import org.gradle.api.provider.Provider +import org.gradle.api.provider.ProviderConvertible +import org.gradle.api.tasks.TaskContainer +import org.gradle.api.tasks.TaskProvider + +import org.gradle.kotlin.dsl.* +import org.gradle.kotlin.dsl.accessors.runtime.* + + +/** + * Adds a dependency to the 'releaseApiDependenciesMetadata' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`releaseApiDependenciesMetadata`(dependencyNotation: Any): Dependency? = + add("releaseApiDependenciesMetadata", dependencyNotation) + +/** + * Adds a dependency to the 'releaseApiDependenciesMetadata' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`releaseApiDependenciesMetadata`( + dependencyNotation: String, + dependencyConfiguration: Action +): ExternalModuleDependency = addDependencyTo( + this, "releaseApiDependenciesMetadata", dependencyNotation, dependencyConfiguration +) as ExternalModuleDependency + +/** + * Adds a dependency to the 'releaseApiDependenciesMetadata' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`releaseApiDependenciesMetadata`( + dependencyNotation: Provider<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "releaseApiDependenciesMetadata", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'releaseApiDependenciesMetadata' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`releaseApiDependenciesMetadata`( + dependencyNotation: ProviderConvertible<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "releaseApiDependenciesMetadata", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'releaseApiDependenciesMetadata' configuration. + * + * @param group the group of the module to be added as a dependency. + * @param name the name of the module to be added as a dependency. + * @param version the optional version of the module to be added as a dependency. + * @param configuration the optional configuration of the module to be added as a dependency. + * @param classifier the optional classifier of the module artifact to be added as a dependency. + * @param ext the optional extension of the module artifact to be added as a dependency. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.create] + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`releaseApiDependenciesMetadata`( + group: String, + name: String, + version: String? = null, + configuration: String? = null, + classifier: String? = null, + ext: String? = null, + dependencyConfiguration: Action? = null +): ExternalModuleDependency = addExternalModuleDependencyTo( + this, "releaseApiDependenciesMetadata", group, name, version, configuration, classifier, ext, dependencyConfiguration +) + +/** + * Adds a dependency to the 'releaseApiDependenciesMetadata' configuration. + * + * @param dependency dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`releaseApiDependenciesMetadata`( + dependency: T, + dependencyConfiguration: T.() -> Unit +): T = add("releaseApiDependenciesMetadata", dependency, dependencyConfiguration) + +/** + * Adds a dependency constraint to the 'releaseApiDependenciesMetadata' configuration. + * + * @param constraintNotation the dependency constraint notation + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`releaseApiDependenciesMetadata`(constraintNotation: Any): DependencyConstraint = + add("releaseApiDependenciesMetadata", constraintNotation) + +/** + * Adds a dependency constraint to the 'releaseApiDependenciesMetadata' configuration. + * + * @param constraintNotation the dependency constraint notation + * @param block the block to use to configure the dependency constraint + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`releaseApiDependenciesMetadata`(constraintNotation: Any, block: DependencyConstraint.() -> Unit): DependencyConstraint = + add("releaseApiDependenciesMetadata", constraintNotation, block) + +/** + * Adds an artifact to the 'releaseApiDependenciesMetadata' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`releaseApiDependenciesMetadata`(artifactNotation: Any): PublishArtifact = + add("releaseApiDependenciesMetadata", artifactNotation) + +/** + * Adds an artifact to the 'releaseApiDependenciesMetadata' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @param configureAction The action to execute to configure the artifact. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`releaseApiDependenciesMetadata`( + artifactNotation: Any, + configureAction: ConfigurablePublishArtifact.() -> Unit +): PublishArtifact = + add("releaseApiDependenciesMetadata", artifactNotation, configureAction) + + + diff --git a/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/ReleaseCompileOnlyApiConfigurationAccessors.kt b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/ReleaseCompileOnlyApiConfigurationAccessors.kt new file mode 100644 index 00000000..56e1a3fd --- /dev/null +++ b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/ReleaseCompileOnlyApiConfigurationAccessors.kt @@ -0,0 +1,213 @@ + +/* + * Copyright 2018 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +@file:Suppress( + "unused", + "nothing_to_inline", + "useless_cast", + "unchecked_cast", + "extension_shadowed_by_member", + "redundant_projection", + "RemoveRedundantBackticks", + "ObjectPropertyName", + "deprecation" +) +@file:org.gradle.api.Generated + +/* ktlint-disable */ + +package org.gradle.kotlin.dsl + + +import org.gradle.api.Action +import org.gradle.api.Incubating +import org.gradle.api.NamedDomainObjectProvider +import org.gradle.api.Project +import org.gradle.api.Task +import org.gradle.api.artifacts.Configuration +import org.gradle.api.artifacts.ConfigurablePublishArtifact +import org.gradle.api.artifacts.ConfigurationContainer +import org.gradle.api.artifacts.Dependency +import org.gradle.api.artifacts.DependencyConstraint +import org.gradle.api.artifacts.ExternalModuleDependency +import org.gradle.api.artifacts.ModuleDependency +import org.gradle.api.artifacts.PublishArtifact +import org.gradle.api.artifacts.dsl.ArtifactHandler +import org.gradle.api.artifacts.dsl.DependencyConstraintHandler +import org.gradle.api.artifacts.dsl.DependencyHandler +import org.gradle.api.provider.Provider +import org.gradle.api.provider.ProviderConvertible +import org.gradle.api.tasks.TaskContainer +import org.gradle.api.tasks.TaskProvider + +import org.gradle.kotlin.dsl.* +import org.gradle.kotlin.dsl.accessors.runtime.* + + +/** + * Adds a dependency to the 'releaseCompileOnlyApi' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`releaseCompileOnlyApi`(dependencyNotation: Any): Dependency? = + add("releaseCompileOnlyApi", dependencyNotation) + +/** + * Adds a dependency to the 'releaseCompileOnlyApi' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`releaseCompileOnlyApi`( + dependencyNotation: String, + dependencyConfiguration: Action +): ExternalModuleDependency = addDependencyTo( + this, "releaseCompileOnlyApi", dependencyNotation, dependencyConfiguration +) as ExternalModuleDependency + +/** + * Adds a dependency to the 'releaseCompileOnlyApi' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`releaseCompileOnlyApi`( + dependencyNotation: Provider<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "releaseCompileOnlyApi", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'releaseCompileOnlyApi' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`releaseCompileOnlyApi`( + dependencyNotation: ProviderConvertible<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "releaseCompileOnlyApi", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'releaseCompileOnlyApi' configuration. + * + * @param group the group of the module to be added as a dependency. + * @param name the name of the module to be added as a dependency. + * @param version the optional version of the module to be added as a dependency. + * @param configuration the optional configuration of the module to be added as a dependency. + * @param classifier the optional classifier of the module artifact to be added as a dependency. + * @param ext the optional extension of the module artifact to be added as a dependency. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.create] + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`releaseCompileOnlyApi`( + group: String, + name: String, + version: String? = null, + configuration: String? = null, + classifier: String? = null, + ext: String? = null, + dependencyConfiguration: Action? = null +): ExternalModuleDependency = addExternalModuleDependencyTo( + this, "releaseCompileOnlyApi", group, name, version, configuration, classifier, ext, dependencyConfiguration +) + +/** + * Adds a dependency to the 'releaseCompileOnlyApi' configuration. + * + * @param dependency dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`releaseCompileOnlyApi`( + dependency: T, + dependencyConfiguration: T.() -> Unit +): T = add("releaseCompileOnlyApi", dependency, dependencyConfiguration) + +/** + * Adds a dependency constraint to the 'releaseCompileOnlyApi' configuration. + * + * @param constraintNotation the dependency constraint notation + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`releaseCompileOnlyApi`(constraintNotation: Any): DependencyConstraint = + add("releaseCompileOnlyApi", constraintNotation) + +/** + * Adds a dependency constraint to the 'releaseCompileOnlyApi' configuration. + * + * @param constraintNotation the dependency constraint notation + * @param block the block to use to configure the dependency constraint + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`releaseCompileOnlyApi`(constraintNotation: Any, block: DependencyConstraint.() -> Unit): DependencyConstraint = + add("releaseCompileOnlyApi", constraintNotation, block) + +/** + * Adds an artifact to the 'releaseCompileOnlyApi' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`releaseCompileOnlyApi`(artifactNotation: Any): PublishArtifact = + add("releaseCompileOnlyApi", artifactNotation) + +/** + * Adds an artifact to the 'releaseCompileOnlyApi' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @param configureAction The action to execute to configure the artifact. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`releaseCompileOnlyApi`( + artifactNotation: Any, + configureAction: ConfigurablePublishArtifact.() -> Unit +): PublishArtifact = + add("releaseCompileOnlyApi", artifactNotation, configureAction) + + + diff --git a/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/ReleaseCompileOnlyConfigurationAccessors.kt b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/ReleaseCompileOnlyConfigurationAccessors.kt new file mode 100644 index 00000000..3b35aeae --- /dev/null +++ b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/ReleaseCompileOnlyConfigurationAccessors.kt @@ -0,0 +1,213 @@ + +/* + * Copyright 2018 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +@file:Suppress( + "unused", + "nothing_to_inline", + "useless_cast", + "unchecked_cast", + "extension_shadowed_by_member", + "redundant_projection", + "RemoveRedundantBackticks", + "ObjectPropertyName", + "deprecation" +) +@file:org.gradle.api.Generated + +/* ktlint-disable */ + +package org.gradle.kotlin.dsl + + +import org.gradle.api.Action +import org.gradle.api.Incubating +import org.gradle.api.NamedDomainObjectProvider +import org.gradle.api.Project +import org.gradle.api.Task +import org.gradle.api.artifacts.Configuration +import org.gradle.api.artifacts.ConfigurablePublishArtifact +import org.gradle.api.artifacts.ConfigurationContainer +import org.gradle.api.artifacts.Dependency +import org.gradle.api.artifacts.DependencyConstraint +import org.gradle.api.artifacts.ExternalModuleDependency +import org.gradle.api.artifacts.ModuleDependency +import org.gradle.api.artifacts.PublishArtifact +import org.gradle.api.artifacts.dsl.ArtifactHandler +import org.gradle.api.artifacts.dsl.DependencyConstraintHandler +import org.gradle.api.artifacts.dsl.DependencyHandler +import org.gradle.api.provider.Provider +import org.gradle.api.provider.ProviderConvertible +import org.gradle.api.tasks.TaskContainer +import org.gradle.api.tasks.TaskProvider + +import org.gradle.kotlin.dsl.* +import org.gradle.kotlin.dsl.accessors.runtime.* + + +/** + * Adds a dependency to the 'releaseCompileOnly' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`releaseCompileOnly`(dependencyNotation: Any): Dependency? = + add("releaseCompileOnly", dependencyNotation) + +/** + * Adds a dependency to the 'releaseCompileOnly' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`releaseCompileOnly`( + dependencyNotation: String, + dependencyConfiguration: Action +): ExternalModuleDependency = addDependencyTo( + this, "releaseCompileOnly", dependencyNotation, dependencyConfiguration +) as ExternalModuleDependency + +/** + * Adds a dependency to the 'releaseCompileOnly' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`releaseCompileOnly`( + dependencyNotation: Provider<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "releaseCompileOnly", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'releaseCompileOnly' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`releaseCompileOnly`( + dependencyNotation: ProviderConvertible<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "releaseCompileOnly", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'releaseCompileOnly' configuration. + * + * @param group the group of the module to be added as a dependency. + * @param name the name of the module to be added as a dependency. + * @param version the optional version of the module to be added as a dependency. + * @param configuration the optional configuration of the module to be added as a dependency. + * @param classifier the optional classifier of the module artifact to be added as a dependency. + * @param ext the optional extension of the module artifact to be added as a dependency. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.create] + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`releaseCompileOnly`( + group: String, + name: String, + version: String? = null, + configuration: String? = null, + classifier: String? = null, + ext: String? = null, + dependencyConfiguration: Action? = null +): ExternalModuleDependency = addExternalModuleDependencyTo( + this, "releaseCompileOnly", group, name, version, configuration, classifier, ext, dependencyConfiguration +) + +/** + * Adds a dependency to the 'releaseCompileOnly' configuration. + * + * @param dependency dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`releaseCompileOnly`( + dependency: T, + dependencyConfiguration: T.() -> Unit +): T = add("releaseCompileOnly", dependency, dependencyConfiguration) + +/** + * Adds a dependency constraint to the 'releaseCompileOnly' configuration. + * + * @param constraintNotation the dependency constraint notation + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`releaseCompileOnly`(constraintNotation: Any): DependencyConstraint = + add("releaseCompileOnly", constraintNotation) + +/** + * Adds a dependency constraint to the 'releaseCompileOnly' configuration. + * + * @param constraintNotation the dependency constraint notation + * @param block the block to use to configure the dependency constraint + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`releaseCompileOnly`(constraintNotation: Any, block: DependencyConstraint.() -> Unit): DependencyConstraint = + add("releaseCompileOnly", constraintNotation, block) + +/** + * Adds an artifact to the 'releaseCompileOnly' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`releaseCompileOnly`(artifactNotation: Any): PublishArtifact = + add("releaseCompileOnly", artifactNotation) + +/** + * Adds an artifact to the 'releaseCompileOnly' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @param configureAction The action to execute to configure the artifact. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`releaseCompileOnly`( + artifactNotation: Any, + configureAction: ConfigurablePublishArtifact.() -> Unit +): PublishArtifact = + add("releaseCompileOnly", artifactNotation, configureAction) + + + diff --git a/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/ReleaseCompileOnlyDependenciesMetadataConfigurationAccessors.kt b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/ReleaseCompileOnlyDependenciesMetadataConfigurationAccessors.kt new file mode 100644 index 00000000..e429b9a6 --- /dev/null +++ b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/ReleaseCompileOnlyDependenciesMetadataConfigurationAccessors.kt @@ -0,0 +1,213 @@ + +/* + * Copyright 2018 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +@file:Suppress( + "unused", + "nothing_to_inline", + "useless_cast", + "unchecked_cast", + "extension_shadowed_by_member", + "redundant_projection", + "RemoveRedundantBackticks", + "ObjectPropertyName", + "deprecation" +) +@file:org.gradle.api.Generated + +/* ktlint-disable */ + +package org.gradle.kotlin.dsl + + +import org.gradle.api.Action +import org.gradle.api.Incubating +import org.gradle.api.NamedDomainObjectProvider +import org.gradle.api.Project +import org.gradle.api.Task +import org.gradle.api.artifacts.Configuration +import org.gradle.api.artifacts.ConfigurablePublishArtifact +import org.gradle.api.artifacts.ConfigurationContainer +import org.gradle.api.artifacts.Dependency +import org.gradle.api.artifacts.DependencyConstraint +import org.gradle.api.artifacts.ExternalModuleDependency +import org.gradle.api.artifacts.ModuleDependency +import org.gradle.api.artifacts.PublishArtifact +import org.gradle.api.artifacts.dsl.ArtifactHandler +import org.gradle.api.artifacts.dsl.DependencyConstraintHandler +import org.gradle.api.artifacts.dsl.DependencyHandler +import org.gradle.api.provider.Provider +import org.gradle.api.provider.ProviderConvertible +import org.gradle.api.tasks.TaskContainer +import org.gradle.api.tasks.TaskProvider + +import org.gradle.kotlin.dsl.* +import org.gradle.kotlin.dsl.accessors.runtime.* + + +/** + * Adds a dependency to the 'releaseCompileOnlyDependenciesMetadata' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`releaseCompileOnlyDependenciesMetadata`(dependencyNotation: Any): Dependency? = + add("releaseCompileOnlyDependenciesMetadata", dependencyNotation) + +/** + * Adds a dependency to the 'releaseCompileOnlyDependenciesMetadata' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`releaseCompileOnlyDependenciesMetadata`( + dependencyNotation: String, + dependencyConfiguration: Action +): ExternalModuleDependency = addDependencyTo( + this, "releaseCompileOnlyDependenciesMetadata", dependencyNotation, dependencyConfiguration +) as ExternalModuleDependency + +/** + * Adds a dependency to the 'releaseCompileOnlyDependenciesMetadata' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`releaseCompileOnlyDependenciesMetadata`( + dependencyNotation: Provider<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "releaseCompileOnlyDependenciesMetadata", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'releaseCompileOnlyDependenciesMetadata' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`releaseCompileOnlyDependenciesMetadata`( + dependencyNotation: ProviderConvertible<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "releaseCompileOnlyDependenciesMetadata", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'releaseCompileOnlyDependenciesMetadata' configuration. + * + * @param group the group of the module to be added as a dependency. + * @param name the name of the module to be added as a dependency. + * @param version the optional version of the module to be added as a dependency. + * @param configuration the optional configuration of the module to be added as a dependency. + * @param classifier the optional classifier of the module artifact to be added as a dependency. + * @param ext the optional extension of the module artifact to be added as a dependency. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.create] + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`releaseCompileOnlyDependenciesMetadata`( + group: String, + name: String, + version: String? = null, + configuration: String? = null, + classifier: String? = null, + ext: String? = null, + dependencyConfiguration: Action? = null +): ExternalModuleDependency = addExternalModuleDependencyTo( + this, "releaseCompileOnlyDependenciesMetadata", group, name, version, configuration, classifier, ext, dependencyConfiguration +) + +/** + * Adds a dependency to the 'releaseCompileOnlyDependenciesMetadata' configuration. + * + * @param dependency dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`releaseCompileOnlyDependenciesMetadata`( + dependency: T, + dependencyConfiguration: T.() -> Unit +): T = add("releaseCompileOnlyDependenciesMetadata", dependency, dependencyConfiguration) + +/** + * Adds a dependency constraint to the 'releaseCompileOnlyDependenciesMetadata' configuration. + * + * @param constraintNotation the dependency constraint notation + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`releaseCompileOnlyDependenciesMetadata`(constraintNotation: Any): DependencyConstraint = + add("releaseCompileOnlyDependenciesMetadata", constraintNotation) + +/** + * Adds a dependency constraint to the 'releaseCompileOnlyDependenciesMetadata' configuration. + * + * @param constraintNotation the dependency constraint notation + * @param block the block to use to configure the dependency constraint + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`releaseCompileOnlyDependenciesMetadata`(constraintNotation: Any, block: DependencyConstraint.() -> Unit): DependencyConstraint = + add("releaseCompileOnlyDependenciesMetadata", constraintNotation, block) + +/** + * Adds an artifact to the 'releaseCompileOnlyDependenciesMetadata' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`releaseCompileOnlyDependenciesMetadata`(artifactNotation: Any): PublishArtifact = + add("releaseCompileOnlyDependenciesMetadata", artifactNotation) + +/** + * Adds an artifact to the 'releaseCompileOnlyDependenciesMetadata' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @param configureAction The action to execute to configure the artifact. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`releaseCompileOnlyDependenciesMetadata`( + artifactNotation: Any, + configureAction: ConfigurablePublishArtifact.() -> Unit +): PublishArtifact = + add("releaseCompileOnlyDependenciesMetadata", artifactNotation, configureAction) + + + diff --git a/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/ReleaseImplementationConfigurationAccessors.kt b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/ReleaseImplementationConfigurationAccessors.kt new file mode 100644 index 00000000..81594494 --- /dev/null +++ b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/ReleaseImplementationConfigurationAccessors.kt @@ -0,0 +1,213 @@ + +/* + * Copyright 2018 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +@file:Suppress( + "unused", + "nothing_to_inline", + "useless_cast", + "unchecked_cast", + "extension_shadowed_by_member", + "redundant_projection", + "RemoveRedundantBackticks", + "ObjectPropertyName", + "deprecation" +) +@file:org.gradle.api.Generated + +/* ktlint-disable */ + +package org.gradle.kotlin.dsl + + +import org.gradle.api.Action +import org.gradle.api.Incubating +import org.gradle.api.NamedDomainObjectProvider +import org.gradle.api.Project +import org.gradle.api.Task +import org.gradle.api.artifacts.Configuration +import org.gradle.api.artifacts.ConfigurablePublishArtifact +import org.gradle.api.artifacts.ConfigurationContainer +import org.gradle.api.artifacts.Dependency +import org.gradle.api.artifacts.DependencyConstraint +import org.gradle.api.artifacts.ExternalModuleDependency +import org.gradle.api.artifacts.ModuleDependency +import org.gradle.api.artifacts.PublishArtifact +import org.gradle.api.artifacts.dsl.ArtifactHandler +import org.gradle.api.artifacts.dsl.DependencyConstraintHandler +import org.gradle.api.artifacts.dsl.DependencyHandler +import org.gradle.api.provider.Provider +import org.gradle.api.provider.ProviderConvertible +import org.gradle.api.tasks.TaskContainer +import org.gradle.api.tasks.TaskProvider + +import org.gradle.kotlin.dsl.* +import org.gradle.kotlin.dsl.accessors.runtime.* + + +/** + * Adds a dependency to the 'releaseImplementation' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`releaseImplementation`(dependencyNotation: Any): Dependency? = + add("releaseImplementation", dependencyNotation) + +/** + * Adds a dependency to the 'releaseImplementation' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`releaseImplementation`( + dependencyNotation: String, + dependencyConfiguration: Action +): ExternalModuleDependency = addDependencyTo( + this, "releaseImplementation", dependencyNotation, dependencyConfiguration +) as ExternalModuleDependency + +/** + * Adds a dependency to the 'releaseImplementation' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`releaseImplementation`( + dependencyNotation: Provider<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "releaseImplementation", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'releaseImplementation' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`releaseImplementation`( + dependencyNotation: ProviderConvertible<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "releaseImplementation", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'releaseImplementation' configuration. + * + * @param group the group of the module to be added as a dependency. + * @param name the name of the module to be added as a dependency. + * @param version the optional version of the module to be added as a dependency. + * @param configuration the optional configuration of the module to be added as a dependency. + * @param classifier the optional classifier of the module artifact to be added as a dependency. + * @param ext the optional extension of the module artifact to be added as a dependency. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.create] + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`releaseImplementation`( + group: String, + name: String, + version: String? = null, + configuration: String? = null, + classifier: String? = null, + ext: String? = null, + dependencyConfiguration: Action? = null +): ExternalModuleDependency = addExternalModuleDependencyTo( + this, "releaseImplementation", group, name, version, configuration, classifier, ext, dependencyConfiguration +) + +/** + * Adds a dependency to the 'releaseImplementation' configuration. + * + * @param dependency dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`releaseImplementation`( + dependency: T, + dependencyConfiguration: T.() -> Unit +): T = add("releaseImplementation", dependency, dependencyConfiguration) + +/** + * Adds a dependency constraint to the 'releaseImplementation' configuration. + * + * @param constraintNotation the dependency constraint notation + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`releaseImplementation`(constraintNotation: Any): DependencyConstraint = + add("releaseImplementation", constraintNotation) + +/** + * Adds a dependency constraint to the 'releaseImplementation' configuration. + * + * @param constraintNotation the dependency constraint notation + * @param block the block to use to configure the dependency constraint + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`releaseImplementation`(constraintNotation: Any, block: DependencyConstraint.() -> Unit): DependencyConstraint = + add("releaseImplementation", constraintNotation, block) + +/** + * Adds an artifact to the 'releaseImplementation' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`releaseImplementation`(artifactNotation: Any): PublishArtifact = + add("releaseImplementation", artifactNotation) + +/** + * Adds an artifact to the 'releaseImplementation' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @param configureAction The action to execute to configure the artifact. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`releaseImplementation`( + artifactNotation: Any, + configureAction: ConfigurablePublishArtifact.() -> Unit +): PublishArtifact = + add("releaseImplementation", artifactNotation, configureAction) + + + diff --git a/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/ReleaseImplementationDependenciesMetadataConfigurationAccessors.kt b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/ReleaseImplementationDependenciesMetadataConfigurationAccessors.kt new file mode 100644 index 00000000..c5571d81 --- /dev/null +++ b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/ReleaseImplementationDependenciesMetadataConfigurationAccessors.kt @@ -0,0 +1,213 @@ + +/* + * Copyright 2018 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +@file:Suppress( + "unused", + "nothing_to_inline", + "useless_cast", + "unchecked_cast", + "extension_shadowed_by_member", + "redundant_projection", + "RemoveRedundantBackticks", + "ObjectPropertyName", + "deprecation" +) +@file:org.gradle.api.Generated + +/* ktlint-disable */ + +package org.gradle.kotlin.dsl + + +import org.gradle.api.Action +import org.gradle.api.Incubating +import org.gradle.api.NamedDomainObjectProvider +import org.gradle.api.Project +import org.gradle.api.Task +import org.gradle.api.artifacts.Configuration +import org.gradle.api.artifacts.ConfigurablePublishArtifact +import org.gradle.api.artifacts.ConfigurationContainer +import org.gradle.api.artifacts.Dependency +import org.gradle.api.artifacts.DependencyConstraint +import org.gradle.api.artifacts.ExternalModuleDependency +import org.gradle.api.artifacts.ModuleDependency +import org.gradle.api.artifacts.PublishArtifact +import org.gradle.api.artifacts.dsl.ArtifactHandler +import org.gradle.api.artifacts.dsl.DependencyConstraintHandler +import org.gradle.api.artifacts.dsl.DependencyHandler +import org.gradle.api.provider.Provider +import org.gradle.api.provider.ProviderConvertible +import org.gradle.api.tasks.TaskContainer +import org.gradle.api.tasks.TaskProvider + +import org.gradle.kotlin.dsl.* +import org.gradle.kotlin.dsl.accessors.runtime.* + + +/** + * Adds a dependency to the 'releaseImplementationDependenciesMetadata' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`releaseImplementationDependenciesMetadata`(dependencyNotation: Any): Dependency? = + add("releaseImplementationDependenciesMetadata", dependencyNotation) + +/** + * Adds a dependency to the 'releaseImplementationDependenciesMetadata' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`releaseImplementationDependenciesMetadata`( + dependencyNotation: String, + dependencyConfiguration: Action +): ExternalModuleDependency = addDependencyTo( + this, "releaseImplementationDependenciesMetadata", dependencyNotation, dependencyConfiguration +) as ExternalModuleDependency + +/** + * Adds a dependency to the 'releaseImplementationDependenciesMetadata' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`releaseImplementationDependenciesMetadata`( + dependencyNotation: Provider<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "releaseImplementationDependenciesMetadata", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'releaseImplementationDependenciesMetadata' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`releaseImplementationDependenciesMetadata`( + dependencyNotation: ProviderConvertible<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "releaseImplementationDependenciesMetadata", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'releaseImplementationDependenciesMetadata' configuration. + * + * @param group the group of the module to be added as a dependency. + * @param name the name of the module to be added as a dependency. + * @param version the optional version of the module to be added as a dependency. + * @param configuration the optional configuration of the module to be added as a dependency. + * @param classifier the optional classifier of the module artifact to be added as a dependency. + * @param ext the optional extension of the module artifact to be added as a dependency. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.create] + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`releaseImplementationDependenciesMetadata`( + group: String, + name: String, + version: String? = null, + configuration: String? = null, + classifier: String? = null, + ext: String? = null, + dependencyConfiguration: Action? = null +): ExternalModuleDependency = addExternalModuleDependencyTo( + this, "releaseImplementationDependenciesMetadata", group, name, version, configuration, classifier, ext, dependencyConfiguration +) + +/** + * Adds a dependency to the 'releaseImplementationDependenciesMetadata' configuration. + * + * @param dependency dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`releaseImplementationDependenciesMetadata`( + dependency: T, + dependencyConfiguration: T.() -> Unit +): T = add("releaseImplementationDependenciesMetadata", dependency, dependencyConfiguration) + +/** + * Adds a dependency constraint to the 'releaseImplementationDependenciesMetadata' configuration. + * + * @param constraintNotation the dependency constraint notation + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`releaseImplementationDependenciesMetadata`(constraintNotation: Any): DependencyConstraint = + add("releaseImplementationDependenciesMetadata", constraintNotation) + +/** + * Adds a dependency constraint to the 'releaseImplementationDependenciesMetadata' configuration. + * + * @param constraintNotation the dependency constraint notation + * @param block the block to use to configure the dependency constraint + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`releaseImplementationDependenciesMetadata`(constraintNotation: Any, block: DependencyConstraint.() -> Unit): DependencyConstraint = + add("releaseImplementationDependenciesMetadata", constraintNotation, block) + +/** + * Adds an artifact to the 'releaseImplementationDependenciesMetadata' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`releaseImplementationDependenciesMetadata`(artifactNotation: Any): PublishArtifact = + add("releaseImplementationDependenciesMetadata", artifactNotation) + +/** + * Adds an artifact to the 'releaseImplementationDependenciesMetadata' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @param configureAction The action to execute to configure the artifact. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`releaseImplementationDependenciesMetadata`( + artifactNotation: Any, + configureAction: ConfigurablePublishArtifact.() -> Unit +): PublishArtifact = + add("releaseImplementationDependenciesMetadata", artifactNotation, configureAction) + + + diff --git a/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/ReleaseIntransitiveDependenciesMetadataConfigurationAccessors.kt b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/ReleaseIntransitiveDependenciesMetadataConfigurationAccessors.kt new file mode 100644 index 00000000..19edfcc3 --- /dev/null +++ b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/ReleaseIntransitiveDependenciesMetadataConfigurationAccessors.kt @@ -0,0 +1,213 @@ + +/* + * Copyright 2018 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +@file:Suppress( + "unused", + "nothing_to_inline", + "useless_cast", + "unchecked_cast", + "extension_shadowed_by_member", + "redundant_projection", + "RemoveRedundantBackticks", + "ObjectPropertyName", + "deprecation" +) +@file:org.gradle.api.Generated + +/* ktlint-disable */ + +package org.gradle.kotlin.dsl + + +import org.gradle.api.Action +import org.gradle.api.Incubating +import org.gradle.api.NamedDomainObjectProvider +import org.gradle.api.Project +import org.gradle.api.Task +import org.gradle.api.artifacts.Configuration +import org.gradle.api.artifacts.ConfigurablePublishArtifact +import org.gradle.api.artifacts.ConfigurationContainer +import org.gradle.api.artifacts.Dependency +import org.gradle.api.artifacts.DependencyConstraint +import org.gradle.api.artifacts.ExternalModuleDependency +import org.gradle.api.artifacts.ModuleDependency +import org.gradle.api.artifacts.PublishArtifact +import org.gradle.api.artifacts.dsl.ArtifactHandler +import org.gradle.api.artifacts.dsl.DependencyConstraintHandler +import org.gradle.api.artifacts.dsl.DependencyHandler +import org.gradle.api.provider.Provider +import org.gradle.api.provider.ProviderConvertible +import org.gradle.api.tasks.TaskContainer +import org.gradle.api.tasks.TaskProvider + +import org.gradle.kotlin.dsl.* +import org.gradle.kotlin.dsl.accessors.runtime.* + + +/** + * Adds a dependency to the 'releaseIntransitiveDependenciesMetadata' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`releaseIntransitiveDependenciesMetadata`(dependencyNotation: Any): Dependency? = + add("releaseIntransitiveDependenciesMetadata", dependencyNotation) + +/** + * Adds a dependency to the 'releaseIntransitiveDependenciesMetadata' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`releaseIntransitiveDependenciesMetadata`( + dependencyNotation: String, + dependencyConfiguration: Action +): ExternalModuleDependency = addDependencyTo( + this, "releaseIntransitiveDependenciesMetadata", dependencyNotation, dependencyConfiguration +) as ExternalModuleDependency + +/** + * Adds a dependency to the 'releaseIntransitiveDependenciesMetadata' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`releaseIntransitiveDependenciesMetadata`( + dependencyNotation: Provider<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "releaseIntransitiveDependenciesMetadata", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'releaseIntransitiveDependenciesMetadata' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`releaseIntransitiveDependenciesMetadata`( + dependencyNotation: ProviderConvertible<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "releaseIntransitiveDependenciesMetadata", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'releaseIntransitiveDependenciesMetadata' configuration. + * + * @param group the group of the module to be added as a dependency. + * @param name the name of the module to be added as a dependency. + * @param version the optional version of the module to be added as a dependency. + * @param configuration the optional configuration of the module to be added as a dependency. + * @param classifier the optional classifier of the module artifact to be added as a dependency. + * @param ext the optional extension of the module artifact to be added as a dependency. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.create] + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`releaseIntransitiveDependenciesMetadata`( + group: String, + name: String, + version: String? = null, + configuration: String? = null, + classifier: String? = null, + ext: String? = null, + dependencyConfiguration: Action? = null +): ExternalModuleDependency = addExternalModuleDependencyTo( + this, "releaseIntransitiveDependenciesMetadata", group, name, version, configuration, classifier, ext, dependencyConfiguration +) + +/** + * Adds a dependency to the 'releaseIntransitiveDependenciesMetadata' configuration. + * + * @param dependency dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`releaseIntransitiveDependenciesMetadata`( + dependency: T, + dependencyConfiguration: T.() -> Unit +): T = add("releaseIntransitiveDependenciesMetadata", dependency, dependencyConfiguration) + +/** + * Adds a dependency constraint to the 'releaseIntransitiveDependenciesMetadata' configuration. + * + * @param constraintNotation the dependency constraint notation + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`releaseIntransitiveDependenciesMetadata`(constraintNotation: Any): DependencyConstraint = + add("releaseIntransitiveDependenciesMetadata", constraintNotation) + +/** + * Adds a dependency constraint to the 'releaseIntransitiveDependenciesMetadata' configuration. + * + * @param constraintNotation the dependency constraint notation + * @param block the block to use to configure the dependency constraint + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`releaseIntransitiveDependenciesMetadata`(constraintNotation: Any, block: DependencyConstraint.() -> Unit): DependencyConstraint = + add("releaseIntransitiveDependenciesMetadata", constraintNotation, block) + +/** + * Adds an artifact to the 'releaseIntransitiveDependenciesMetadata' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`releaseIntransitiveDependenciesMetadata`(artifactNotation: Any): PublishArtifact = + add("releaseIntransitiveDependenciesMetadata", artifactNotation) + +/** + * Adds an artifact to the 'releaseIntransitiveDependenciesMetadata' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @param configureAction The action to execute to configure the artifact. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`releaseIntransitiveDependenciesMetadata`( + artifactNotation: Any, + configureAction: ConfigurablePublishArtifact.() -> Unit +): PublishArtifact = + add("releaseIntransitiveDependenciesMetadata", artifactNotation, configureAction) + + + diff --git a/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/ReleaseRuntimeOnlyConfigurationAccessors.kt b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/ReleaseRuntimeOnlyConfigurationAccessors.kt new file mode 100644 index 00000000..d4beb990 --- /dev/null +++ b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/ReleaseRuntimeOnlyConfigurationAccessors.kt @@ -0,0 +1,213 @@ + +/* + * Copyright 2018 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +@file:Suppress( + "unused", + "nothing_to_inline", + "useless_cast", + "unchecked_cast", + "extension_shadowed_by_member", + "redundant_projection", + "RemoveRedundantBackticks", + "ObjectPropertyName", + "deprecation" +) +@file:org.gradle.api.Generated + +/* ktlint-disable */ + +package org.gradle.kotlin.dsl + + +import org.gradle.api.Action +import org.gradle.api.Incubating +import org.gradle.api.NamedDomainObjectProvider +import org.gradle.api.Project +import org.gradle.api.Task +import org.gradle.api.artifacts.Configuration +import org.gradle.api.artifacts.ConfigurablePublishArtifact +import org.gradle.api.artifacts.ConfigurationContainer +import org.gradle.api.artifacts.Dependency +import org.gradle.api.artifacts.DependencyConstraint +import org.gradle.api.artifacts.ExternalModuleDependency +import org.gradle.api.artifacts.ModuleDependency +import org.gradle.api.artifacts.PublishArtifact +import org.gradle.api.artifacts.dsl.ArtifactHandler +import org.gradle.api.artifacts.dsl.DependencyConstraintHandler +import org.gradle.api.artifacts.dsl.DependencyHandler +import org.gradle.api.provider.Provider +import org.gradle.api.provider.ProviderConvertible +import org.gradle.api.tasks.TaskContainer +import org.gradle.api.tasks.TaskProvider + +import org.gradle.kotlin.dsl.* +import org.gradle.kotlin.dsl.accessors.runtime.* + + +/** + * Adds a dependency to the 'releaseRuntimeOnly' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`releaseRuntimeOnly`(dependencyNotation: Any): Dependency? = + add("releaseRuntimeOnly", dependencyNotation) + +/** + * Adds a dependency to the 'releaseRuntimeOnly' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`releaseRuntimeOnly`( + dependencyNotation: String, + dependencyConfiguration: Action +): ExternalModuleDependency = addDependencyTo( + this, "releaseRuntimeOnly", dependencyNotation, dependencyConfiguration +) as ExternalModuleDependency + +/** + * Adds a dependency to the 'releaseRuntimeOnly' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`releaseRuntimeOnly`( + dependencyNotation: Provider<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "releaseRuntimeOnly", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'releaseRuntimeOnly' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`releaseRuntimeOnly`( + dependencyNotation: ProviderConvertible<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "releaseRuntimeOnly", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'releaseRuntimeOnly' configuration. + * + * @param group the group of the module to be added as a dependency. + * @param name the name of the module to be added as a dependency. + * @param version the optional version of the module to be added as a dependency. + * @param configuration the optional configuration of the module to be added as a dependency. + * @param classifier the optional classifier of the module artifact to be added as a dependency. + * @param ext the optional extension of the module artifact to be added as a dependency. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.create] + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`releaseRuntimeOnly`( + group: String, + name: String, + version: String? = null, + configuration: String? = null, + classifier: String? = null, + ext: String? = null, + dependencyConfiguration: Action? = null +): ExternalModuleDependency = addExternalModuleDependencyTo( + this, "releaseRuntimeOnly", group, name, version, configuration, classifier, ext, dependencyConfiguration +) + +/** + * Adds a dependency to the 'releaseRuntimeOnly' configuration. + * + * @param dependency dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`releaseRuntimeOnly`( + dependency: T, + dependencyConfiguration: T.() -> Unit +): T = add("releaseRuntimeOnly", dependency, dependencyConfiguration) + +/** + * Adds a dependency constraint to the 'releaseRuntimeOnly' configuration. + * + * @param constraintNotation the dependency constraint notation + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`releaseRuntimeOnly`(constraintNotation: Any): DependencyConstraint = + add("releaseRuntimeOnly", constraintNotation) + +/** + * Adds a dependency constraint to the 'releaseRuntimeOnly' configuration. + * + * @param constraintNotation the dependency constraint notation + * @param block the block to use to configure the dependency constraint + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`releaseRuntimeOnly`(constraintNotation: Any, block: DependencyConstraint.() -> Unit): DependencyConstraint = + add("releaseRuntimeOnly", constraintNotation, block) + +/** + * Adds an artifact to the 'releaseRuntimeOnly' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`releaseRuntimeOnly`(artifactNotation: Any): PublishArtifact = + add("releaseRuntimeOnly", artifactNotation) + +/** + * Adds an artifact to the 'releaseRuntimeOnly' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @param configureAction The action to execute to configure the artifact. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`releaseRuntimeOnly`( + artifactNotation: Any, + configureAction: ConfigurablePublishArtifact.() -> Unit +): PublishArtifact = + add("releaseRuntimeOnly", artifactNotation, configureAction) + + + diff --git a/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/ReleaseWearAppConfigurationAccessors.kt b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/ReleaseWearAppConfigurationAccessors.kt new file mode 100644 index 00000000..b2b04156 --- /dev/null +++ b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/ReleaseWearAppConfigurationAccessors.kt @@ -0,0 +1,213 @@ + +/* + * Copyright 2018 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +@file:Suppress( + "unused", + "nothing_to_inline", + "useless_cast", + "unchecked_cast", + "extension_shadowed_by_member", + "redundant_projection", + "RemoveRedundantBackticks", + "ObjectPropertyName", + "deprecation" +) +@file:org.gradle.api.Generated + +/* ktlint-disable */ + +package org.gradle.kotlin.dsl + + +import org.gradle.api.Action +import org.gradle.api.Incubating +import org.gradle.api.NamedDomainObjectProvider +import org.gradle.api.Project +import org.gradle.api.Task +import org.gradle.api.artifacts.Configuration +import org.gradle.api.artifacts.ConfigurablePublishArtifact +import org.gradle.api.artifacts.ConfigurationContainer +import org.gradle.api.artifacts.Dependency +import org.gradle.api.artifacts.DependencyConstraint +import org.gradle.api.artifacts.ExternalModuleDependency +import org.gradle.api.artifacts.ModuleDependency +import org.gradle.api.artifacts.PublishArtifact +import org.gradle.api.artifacts.dsl.ArtifactHandler +import org.gradle.api.artifacts.dsl.DependencyConstraintHandler +import org.gradle.api.artifacts.dsl.DependencyHandler +import org.gradle.api.provider.Provider +import org.gradle.api.provider.ProviderConvertible +import org.gradle.api.tasks.TaskContainer +import org.gradle.api.tasks.TaskProvider + +import org.gradle.kotlin.dsl.* +import org.gradle.kotlin.dsl.accessors.runtime.* + + +/** + * Adds a dependency to the 'releaseWearApp' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`releaseWearApp`(dependencyNotation: Any): Dependency? = + add("releaseWearApp", dependencyNotation) + +/** + * Adds a dependency to the 'releaseWearApp' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`releaseWearApp`( + dependencyNotation: String, + dependencyConfiguration: Action +): ExternalModuleDependency = addDependencyTo( + this, "releaseWearApp", dependencyNotation, dependencyConfiguration +) as ExternalModuleDependency + +/** + * Adds a dependency to the 'releaseWearApp' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`releaseWearApp`( + dependencyNotation: Provider<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "releaseWearApp", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'releaseWearApp' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`releaseWearApp`( + dependencyNotation: ProviderConvertible<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "releaseWearApp", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'releaseWearApp' configuration. + * + * @param group the group of the module to be added as a dependency. + * @param name the name of the module to be added as a dependency. + * @param version the optional version of the module to be added as a dependency. + * @param configuration the optional configuration of the module to be added as a dependency. + * @param classifier the optional classifier of the module artifact to be added as a dependency. + * @param ext the optional extension of the module artifact to be added as a dependency. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.create] + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`releaseWearApp`( + group: String, + name: String, + version: String? = null, + configuration: String? = null, + classifier: String? = null, + ext: String? = null, + dependencyConfiguration: Action? = null +): ExternalModuleDependency = addExternalModuleDependencyTo( + this, "releaseWearApp", group, name, version, configuration, classifier, ext, dependencyConfiguration +) + +/** + * Adds a dependency to the 'releaseWearApp' configuration. + * + * @param dependency dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`releaseWearApp`( + dependency: T, + dependencyConfiguration: T.() -> Unit +): T = add("releaseWearApp", dependency, dependencyConfiguration) + +/** + * Adds a dependency constraint to the 'releaseWearApp' configuration. + * + * @param constraintNotation the dependency constraint notation + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`releaseWearApp`(constraintNotation: Any): DependencyConstraint = + add("releaseWearApp", constraintNotation) + +/** + * Adds a dependency constraint to the 'releaseWearApp' configuration. + * + * @param constraintNotation the dependency constraint notation + * @param block the block to use to configure the dependency constraint + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`releaseWearApp`(constraintNotation: Any, block: DependencyConstraint.() -> Unit): DependencyConstraint = + add("releaseWearApp", constraintNotation, block) + +/** + * Adds an artifact to the 'releaseWearApp' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`releaseWearApp`(artifactNotation: Any): PublishArtifact = + add("releaseWearApp", artifactNotation) + +/** + * Adds an artifact to the 'releaseWearApp' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @param configureAction The action to execute to configure the artifact. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`releaseWearApp`( + artifactNotation: Any, + configureAction: ConfigurablePublishArtifact.() -> Unit +): PublishArtifact = + add("releaseWearApp", artifactNotation, configureAction) + + + diff --git a/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/RuntimeOnlyConfigurationAccessors.kt b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/RuntimeOnlyConfigurationAccessors.kt new file mode 100644 index 00000000..fa84148e --- /dev/null +++ b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/RuntimeOnlyConfigurationAccessors.kt @@ -0,0 +1,213 @@ + +/* + * Copyright 2018 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +@file:Suppress( + "unused", + "nothing_to_inline", + "useless_cast", + "unchecked_cast", + "extension_shadowed_by_member", + "redundant_projection", + "RemoveRedundantBackticks", + "ObjectPropertyName", + "deprecation" +) +@file:org.gradle.api.Generated + +/* ktlint-disable */ + +package org.gradle.kotlin.dsl + + +import org.gradle.api.Action +import org.gradle.api.Incubating +import org.gradle.api.NamedDomainObjectProvider +import org.gradle.api.Project +import org.gradle.api.Task +import org.gradle.api.artifacts.Configuration +import org.gradle.api.artifacts.ConfigurablePublishArtifact +import org.gradle.api.artifacts.ConfigurationContainer +import org.gradle.api.artifacts.Dependency +import org.gradle.api.artifacts.DependencyConstraint +import org.gradle.api.artifacts.ExternalModuleDependency +import org.gradle.api.artifacts.ModuleDependency +import org.gradle.api.artifacts.PublishArtifact +import org.gradle.api.artifacts.dsl.ArtifactHandler +import org.gradle.api.artifacts.dsl.DependencyConstraintHandler +import org.gradle.api.artifacts.dsl.DependencyHandler +import org.gradle.api.provider.Provider +import org.gradle.api.provider.ProviderConvertible +import org.gradle.api.tasks.TaskContainer +import org.gradle.api.tasks.TaskProvider + +import org.gradle.kotlin.dsl.* +import org.gradle.kotlin.dsl.accessors.runtime.* + + +/** + * Adds a dependency to the 'runtimeOnly' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`runtimeOnly`(dependencyNotation: Any): Dependency? = + add("runtimeOnly", dependencyNotation) + +/** + * Adds a dependency to the 'runtimeOnly' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`runtimeOnly`( + dependencyNotation: String, + dependencyConfiguration: Action +): ExternalModuleDependency = addDependencyTo( + this, "runtimeOnly", dependencyNotation, dependencyConfiguration +) as ExternalModuleDependency + +/** + * Adds a dependency to the 'runtimeOnly' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`runtimeOnly`( + dependencyNotation: Provider<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "runtimeOnly", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'runtimeOnly' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`runtimeOnly`( + dependencyNotation: ProviderConvertible<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "runtimeOnly", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'runtimeOnly' configuration. + * + * @param group the group of the module to be added as a dependency. + * @param name the name of the module to be added as a dependency. + * @param version the optional version of the module to be added as a dependency. + * @param configuration the optional configuration of the module to be added as a dependency. + * @param classifier the optional classifier of the module artifact to be added as a dependency. + * @param ext the optional extension of the module artifact to be added as a dependency. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.create] + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`runtimeOnly`( + group: String, + name: String, + version: String? = null, + configuration: String? = null, + classifier: String? = null, + ext: String? = null, + dependencyConfiguration: Action? = null +): ExternalModuleDependency = addExternalModuleDependencyTo( + this, "runtimeOnly", group, name, version, configuration, classifier, ext, dependencyConfiguration +) + +/** + * Adds a dependency to the 'runtimeOnly' configuration. + * + * @param dependency dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`runtimeOnly`( + dependency: T, + dependencyConfiguration: T.() -> Unit +): T = add("runtimeOnly", dependency, dependencyConfiguration) + +/** + * Adds a dependency constraint to the 'runtimeOnly' configuration. + * + * @param constraintNotation the dependency constraint notation + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`runtimeOnly`(constraintNotation: Any): DependencyConstraint = + add("runtimeOnly", constraintNotation) + +/** + * Adds a dependency constraint to the 'runtimeOnly' configuration. + * + * @param constraintNotation the dependency constraint notation + * @param block the block to use to configure the dependency constraint + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`runtimeOnly`(constraintNotation: Any, block: DependencyConstraint.() -> Unit): DependencyConstraint = + add("runtimeOnly", constraintNotation, block) + +/** + * Adds an artifact to the 'runtimeOnly' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`runtimeOnly`(artifactNotation: Any): PublishArtifact = + add("runtimeOnly", artifactNotation) + +/** + * Adds an artifact to the 'runtimeOnly' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @param configureAction The action to execute to configure the artifact. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`runtimeOnly`( + artifactNotation: Any, + configureAction: ConfigurablePublishArtifact.() -> Unit +): PublishArtifact = + add("runtimeOnly", artifactNotation, configureAction) + + + diff --git a/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestAnnotationProcessorConfigurationAccessors.kt b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestAnnotationProcessorConfigurationAccessors.kt new file mode 100644 index 00000000..1e4a6c2f --- /dev/null +++ b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestAnnotationProcessorConfigurationAccessors.kt @@ -0,0 +1,213 @@ + +/* + * Copyright 2018 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +@file:Suppress( + "unused", + "nothing_to_inline", + "useless_cast", + "unchecked_cast", + "extension_shadowed_by_member", + "redundant_projection", + "RemoveRedundantBackticks", + "ObjectPropertyName", + "deprecation" +) +@file:org.gradle.api.Generated + +/* ktlint-disable */ + +package org.gradle.kotlin.dsl + + +import org.gradle.api.Action +import org.gradle.api.Incubating +import org.gradle.api.NamedDomainObjectProvider +import org.gradle.api.Project +import org.gradle.api.Task +import org.gradle.api.artifacts.Configuration +import org.gradle.api.artifacts.ConfigurablePublishArtifact +import org.gradle.api.artifacts.ConfigurationContainer +import org.gradle.api.artifacts.Dependency +import org.gradle.api.artifacts.DependencyConstraint +import org.gradle.api.artifacts.ExternalModuleDependency +import org.gradle.api.artifacts.ModuleDependency +import org.gradle.api.artifacts.PublishArtifact +import org.gradle.api.artifacts.dsl.ArtifactHandler +import org.gradle.api.artifacts.dsl.DependencyConstraintHandler +import org.gradle.api.artifacts.dsl.DependencyHandler +import org.gradle.api.provider.Provider +import org.gradle.api.provider.ProviderConvertible +import org.gradle.api.tasks.TaskContainer +import org.gradle.api.tasks.TaskProvider + +import org.gradle.kotlin.dsl.* +import org.gradle.kotlin.dsl.accessors.runtime.* + + +/** + * Adds a dependency to the 'testAnnotationProcessor' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testAnnotationProcessor`(dependencyNotation: Any): Dependency? = + add("testAnnotationProcessor", dependencyNotation) + +/** + * Adds a dependency to the 'testAnnotationProcessor' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testAnnotationProcessor`( + dependencyNotation: String, + dependencyConfiguration: Action +): ExternalModuleDependency = addDependencyTo( + this, "testAnnotationProcessor", dependencyNotation, dependencyConfiguration +) as ExternalModuleDependency + +/** + * Adds a dependency to the 'testAnnotationProcessor' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testAnnotationProcessor`( + dependencyNotation: Provider<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "testAnnotationProcessor", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testAnnotationProcessor' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testAnnotationProcessor`( + dependencyNotation: ProviderConvertible<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "testAnnotationProcessor", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testAnnotationProcessor' configuration. + * + * @param group the group of the module to be added as a dependency. + * @param name the name of the module to be added as a dependency. + * @param version the optional version of the module to be added as a dependency. + * @param configuration the optional configuration of the module to be added as a dependency. + * @param classifier the optional classifier of the module artifact to be added as a dependency. + * @param ext the optional extension of the module artifact to be added as a dependency. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.create] + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testAnnotationProcessor`( + group: String, + name: String, + version: String? = null, + configuration: String? = null, + classifier: String? = null, + ext: String? = null, + dependencyConfiguration: Action? = null +): ExternalModuleDependency = addExternalModuleDependencyTo( + this, "testAnnotationProcessor", group, name, version, configuration, classifier, ext, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testAnnotationProcessor' configuration. + * + * @param dependency dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testAnnotationProcessor`( + dependency: T, + dependencyConfiguration: T.() -> Unit +): T = add("testAnnotationProcessor", dependency, dependencyConfiguration) + +/** + * Adds a dependency constraint to the 'testAnnotationProcessor' configuration. + * + * @param constraintNotation the dependency constraint notation + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`testAnnotationProcessor`(constraintNotation: Any): DependencyConstraint = + add("testAnnotationProcessor", constraintNotation) + +/** + * Adds a dependency constraint to the 'testAnnotationProcessor' configuration. + * + * @param constraintNotation the dependency constraint notation + * @param block the block to use to configure the dependency constraint + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`testAnnotationProcessor`(constraintNotation: Any, block: DependencyConstraint.() -> Unit): DependencyConstraint = + add("testAnnotationProcessor", constraintNotation, block) + +/** + * Adds an artifact to the 'testAnnotationProcessor' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`testAnnotationProcessor`(artifactNotation: Any): PublishArtifact = + add("testAnnotationProcessor", artifactNotation) + +/** + * Adds an artifact to the 'testAnnotationProcessor' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @param configureAction The action to execute to configure the artifact. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`testAnnotationProcessor`( + artifactNotation: Any, + configureAction: ConfigurablePublishArtifact.() -> Unit +): PublishArtifact = + add("testAnnotationProcessor", artifactNotation, configureAction) + + + diff --git a/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestApiConfigurationAccessors.kt b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestApiConfigurationAccessors.kt new file mode 100644 index 00000000..9bc52bff --- /dev/null +++ b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestApiConfigurationAccessors.kt @@ -0,0 +1,213 @@ + +/* + * Copyright 2018 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +@file:Suppress( + "unused", + "nothing_to_inline", + "useless_cast", + "unchecked_cast", + "extension_shadowed_by_member", + "redundant_projection", + "RemoveRedundantBackticks", + "ObjectPropertyName", + "deprecation" +) +@file:org.gradle.api.Generated + +/* ktlint-disable */ + +package org.gradle.kotlin.dsl + + +import org.gradle.api.Action +import org.gradle.api.Incubating +import org.gradle.api.NamedDomainObjectProvider +import org.gradle.api.Project +import org.gradle.api.Task +import org.gradle.api.artifacts.Configuration +import org.gradle.api.artifacts.ConfigurablePublishArtifact +import org.gradle.api.artifacts.ConfigurationContainer +import org.gradle.api.artifacts.Dependency +import org.gradle.api.artifacts.DependencyConstraint +import org.gradle.api.artifacts.ExternalModuleDependency +import org.gradle.api.artifacts.ModuleDependency +import org.gradle.api.artifacts.PublishArtifact +import org.gradle.api.artifacts.dsl.ArtifactHandler +import org.gradle.api.artifacts.dsl.DependencyConstraintHandler +import org.gradle.api.artifacts.dsl.DependencyHandler +import org.gradle.api.provider.Provider +import org.gradle.api.provider.ProviderConvertible +import org.gradle.api.tasks.TaskContainer +import org.gradle.api.tasks.TaskProvider + +import org.gradle.kotlin.dsl.* +import org.gradle.kotlin.dsl.accessors.runtime.* + + +/** + * Adds a dependency to the 'testApi' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testApi`(dependencyNotation: Any): Dependency? = + add("testApi", dependencyNotation) + +/** + * Adds a dependency to the 'testApi' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testApi`( + dependencyNotation: String, + dependencyConfiguration: Action +): ExternalModuleDependency = addDependencyTo( + this, "testApi", dependencyNotation, dependencyConfiguration +) as ExternalModuleDependency + +/** + * Adds a dependency to the 'testApi' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testApi`( + dependencyNotation: Provider<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "testApi", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testApi' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testApi`( + dependencyNotation: ProviderConvertible<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "testApi", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testApi' configuration. + * + * @param group the group of the module to be added as a dependency. + * @param name the name of the module to be added as a dependency. + * @param version the optional version of the module to be added as a dependency. + * @param configuration the optional configuration of the module to be added as a dependency. + * @param classifier the optional classifier of the module artifact to be added as a dependency. + * @param ext the optional extension of the module artifact to be added as a dependency. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.create] + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testApi`( + group: String, + name: String, + version: String? = null, + configuration: String? = null, + classifier: String? = null, + ext: String? = null, + dependencyConfiguration: Action? = null +): ExternalModuleDependency = addExternalModuleDependencyTo( + this, "testApi", group, name, version, configuration, classifier, ext, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testApi' configuration. + * + * @param dependency dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testApi`( + dependency: T, + dependencyConfiguration: T.() -> Unit +): T = add("testApi", dependency, dependencyConfiguration) + +/** + * Adds a dependency constraint to the 'testApi' configuration. + * + * @param constraintNotation the dependency constraint notation + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`testApi`(constraintNotation: Any): DependencyConstraint = + add("testApi", constraintNotation) + +/** + * Adds a dependency constraint to the 'testApi' configuration. + * + * @param constraintNotation the dependency constraint notation + * @param block the block to use to configure the dependency constraint + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`testApi`(constraintNotation: Any, block: DependencyConstraint.() -> Unit): DependencyConstraint = + add("testApi", constraintNotation, block) + +/** + * Adds an artifact to the 'testApi' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`testApi`(artifactNotation: Any): PublishArtifact = + add("testApi", artifactNotation) + +/** + * Adds an artifact to the 'testApi' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @param configureAction The action to execute to configure the artifact. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`testApi`( + artifactNotation: Any, + configureAction: ConfigurablePublishArtifact.() -> Unit +): PublishArtifact = + add("testApi", artifactNotation, configureAction) + + + diff --git a/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestApiDependenciesMetadataConfigurationAccessors.kt b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestApiDependenciesMetadataConfigurationAccessors.kt new file mode 100644 index 00000000..7f214136 --- /dev/null +++ b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestApiDependenciesMetadataConfigurationAccessors.kt @@ -0,0 +1,213 @@ + +/* + * Copyright 2018 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +@file:Suppress( + "unused", + "nothing_to_inline", + "useless_cast", + "unchecked_cast", + "extension_shadowed_by_member", + "redundant_projection", + "RemoveRedundantBackticks", + "ObjectPropertyName", + "deprecation" +) +@file:org.gradle.api.Generated + +/* ktlint-disable */ + +package org.gradle.kotlin.dsl + + +import org.gradle.api.Action +import org.gradle.api.Incubating +import org.gradle.api.NamedDomainObjectProvider +import org.gradle.api.Project +import org.gradle.api.Task +import org.gradle.api.artifacts.Configuration +import org.gradle.api.artifacts.ConfigurablePublishArtifact +import org.gradle.api.artifacts.ConfigurationContainer +import org.gradle.api.artifacts.Dependency +import org.gradle.api.artifacts.DependencyConstraint +import org.gradle.api.artifacts.ExternalModuleDependency +import org.gradle.api.artifacts.ModuleDependency +import org.gradle.api.artifacts.PublishArtifact +import org.gradle.api.artifacts.dsl.ArtifactHandler +import org.gradle.api.artifacts.dsl.DependencyConstraintHandler +import org.gradle.api.artifacts.dsl.DependencyHandler +import org.gradle.api.provider.Provider +import org.gradle.api.provider.ProviderConvertible +import org.gradle.api.tasks.TaskContainer +import org.gradle.api.tasks.TaskProvider + +import org.gradle.kotlin.dsl.* +import org.gradle.kotlin.dsl.accessors.runtime.* + + +/** + * Adds a dependency to the 'testApiDependenciesMetadata' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testApiDependenciesMetadata`(dependencyNotation: Any): Dependency? = + add("testApiDependenciesMetadata", dependencyNotation) + +/** + * Adds a dependency to the 'testApiDependenciesMetadata' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testApiDependenciesMetadata`( + dependencyNotation: String, + dependencyConfiguration: Action +): ExternalModuleDependency = addDependencyTo( + this, "testApiDependenciesMetadata", dependencyNotation, dependencyConfiguration +) as ExternalModuleDependency + +/** + * Adds a dependency to the 'testApiDependenciesMetadata' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testApiDependenciesMetadata`( + dependencyNotation: Provider<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "testApiDependenciesMetadata", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testApiDependenciesMetadata' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testApiDependenciesMetadata`( + dependencyNotation: ProviderConvertible<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "testApiDependenciesMetadata", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testApiDependenciesMetadata' configuration. + * + * @param group the group of the module to be added as a dependency. + * @param name the name of the module to be added as a dependency. + * @param version the optional version of the module to be added as a dependency. + * @param configuration the optional configuration of the module to be added as a dependency. + * @param classifier the optional classifier of the module artifact to be added as a dependency. + * @param ext the optional extension of the module artifact to be added as a dependency. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.create] + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testApiDependenciesMetadata`( + group: String, + name: String, + version: String? = null, + configuration: String? = null, + classifier: String? = null, + ext: String? = null, + dependencyConfiguration: Action? = null +): ExternalModuleDependency = addExternalModuleDependencyTo( + this, "testApiDependenciesMetadata", group, name, version, configuration, classifier, ext, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testApiDependenciesMetadata' configuration. + * + * @param dependency dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testApiDependenciesMetadata`( + dependency: T, + dependencyConfiguration: T.() -> Unit +): T = add("testApiDependenciesMetadata", dependency, dependencyConfiguration) + +/** + * Adds a dependency constraint to the 'testApiDependenciesMetadata' configuration. + * + * @param constraintNotation the dependency constraint notation + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`testApiDependenciesMetadata`(constraintNotation: Any): DependencyConstraint = + add("testApiDependenciesMetadata", constraintNotation) + +/** + * Adds a dependency constraint to the 'testApiDependenciesMetadata' configuration. + * + * @param constraintNotation the dependency constraint notation + * @param block the block to use to configure the dependency constraint + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`testApiDependenciesMetadata`(constraintNotation: Any, block: DependencyConstraint.() -> Unit): DependencyConstraint = + add("testApiDependenciesMetadata", constraintNotation, block) + +/** + * Adds an artifact to the 'testApiDependenciesMetadata' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`testApiDependenciesMetadata`(artifactNotation: Any): PublishArtifact = + add("testApiDependenciesMetadata", artifactNotation) + +/** + * Adds an artifact to the 'testApiDependenciesMetadata' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @param configureAction The action to execute to configure the artifact. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`testApiDependenciesMetadata`( + artifactNotation: Any, + configureAction: ConfigurablePublishArtifact.() -> Unit +): PublishArtifact = + add("testApiDependenciesMetadata", artifactNotation, configureAction) + + + diff --git a/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestCompileOnlyConfigurationAccessors.kt b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestCompileOnlyConfigurationAccessors.kt new file mode 100644 index 00000000..3529ba96 --- /dev/null +++ b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestCompileOnlyConfigurationAccessors.kt @@ -0,0 +1,213 @@ + +/* + * Copyright 2018 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +@file:Suppress( + "unused", + "nothing_to_inline", + "useless_cast", + "unchecked_cast", + "extension_shadowed_by_member", + "redundant_projection", + "RemoveRedundantBackticks", + "ObjectPropertyName", + "deprecation" +) +@file:org.gradle.api.Generated + +/* ktlint-disable */ + +package org.gradle.kotlin.dsl + + +import org.gradle.api.Action +import org.gradle.api.Incubating +import org.gradle.api.NamedDomainObjectProvider +import org.gradle.api.Project +import org.gradle.api.Task +import org.gradle.api.artifacts.Configuration +import org.gradle.api.artifacts.ConfigurablePublishArtifact +import org.gradle.api.artifacts.ConfigurationContainer +import org.gradle.api.artifacts.Dependency +import org.gradle.api.artifacts.DependencyConstraint +import org.gradle.api.artifacts.ExternalModuleDependency +import org.gradle.api.artifacts.ModuleDependency +import org.gradle.api.artifacts.PublishArtifact +import org.gradle.api.artifacts.dsl.ArtifactHandler +import org.gradle.api.artifacts.dsl.DependencyConstraintHandler +import org.gradle.api.artifacts.dsl.DependencyHandler +import org.gradle.api.provider.Provider +import org.gradle.api.provider.ProviderConvertible +import org.gradle.api.tasks.TaskContainer +import org.gradle.api.tasks.TaskProvider + +import org.gradle.kotlin.dsl.* +import org.gradle.kotlin.dsl.accessors.runtime.* + + +/** + * Adds a dependency to the 'testCompileOnly' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testCompileOnly`(dependencyNotation: Any): Dependency? = + add("testCompileOnly", dependencyNotation) + +/** + * Adds a dependency to the 'testCompileOnly' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testCompileOnly`( + dependencyNotation: String, + dependencyConfiguration: Action +): ExternalModuleDependency = addDependencyTo( + this, "testCompileOnly", dependencyNotation, dependencyConfiguration +) as ExternalModuleDependency + +/** + * Adds a dependency to the 'testCompileOnly' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testCompileOnly`( + dependencyNotation: Provider<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "testCompileOnly", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testCompileOnly' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testCompileOnly`( + dependencyNotation: ProviderConvertible<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "testCompileOnly", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testCompileOnly' configuration. + * + * @param group the group of the module to be added as a dependency. + * @param name the name of the module to be added as a dependency. + * @param version the optional version of the module to be added as a dependency. + * @param configuration the optional configuration of the module to be added as a dependency. + * @param classifier the optional classifier of the module artifact to be added as a dependency. + * @param ext the optional extension of the module artifact to be added as a dependency. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.create] + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testCompileOnly`( + group: String, + name: String, + version: String? = null, + configuration: String? = null, + classifier: String? = null, + ext: String? = null, + dependencyConfiguration: Action? = null +): ExternalModuleDependency = addExternalModuleDependencyTo( + this, "testCompileOnly", group, name, version, configuration, classifier, ext, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testCompileOnly' configuration. + * + * @param dependency dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testCompileOnly`( + dependency: T, + dependencyConfiguration: T.() -> Unit +): T = add("testCompileOnly", dependency, dependencyConfiguration) + +/** + * Adds a dependency constraint to the 'testCompileOnly' configuration. + * + * @param constraintNotation the dependency constraint notation + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`testCompileOnly`(constraintNotation: Any): DependencyConstraint = + add("testCompileOnly", constraintNotation) + +/** + * Adds a dependency constraint to the 'testCompileOnly' configuration. + * + * @param constraintNotation the dependency constraint notation + * @param block the block to use to configure the dependency constraint + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`testCompileOnly`(constraintNotation: Any, block: DependencyConstraint.() -> Unit): DependencyConstraint = + add("testCompileOnly", constraintNotation, block) + +/** + * Adds an artifact to the 'testCompileOnly' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`testCompileOnly`(artifactNotation: Any): PublishArtifact = + add("testCompileOnly", artifactNotation) + +/** + * Adds an artifact to the 'testCompileOnly' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @param configureAction The action to execute to configure the artifact. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`testCompileOnly`( + artifactNotation: Any, + configureAction: ConfigurablePublishArtifact.() -> Unit +): PublishArtifact = + add("testCompileOnly", artifactNotation, configureAction) + + + diff --git a/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestCompileOnlyDependenciesMetadataConfigurationAccessors.kt b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestCompileOnlyDependenciesMetadataConfigurationAccessors.kt new file mode 100644 index 00000000..ef03c704 --- /dev/null +++ b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestCompileOnlyDependenciesMetadataConfigurationAccessors.kt @@ -0,0 +1,213 @@ + +/* + * Copyright 2018 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +@file:Suppress( + "unused", + "nothing_to_inline", + "useless_cast", + "unchecked_cast", + "extension_shadowed_by_member", + "redundant_projection", + "RemoveRedundantBackticks", + "ObjectPropertyName", + "deprecation" +) +@file:org.gradle.api.Generated + +/* ktlint-disable */ + +package org.gradle.kotlin.dsl + + +import org.gradle.api.Action +import org.gradle.api.Incubating +import org.gradle.api.NamedDomainObjectProvider +import org.gradle.api.Project +import org.gradle.api.Task +import org.gradle.api.artifacts.Configuration +import org.gradle.api.artifacts.ConfigurablePublishArtifact +import org.gradle.api.artifacts.ConfigurationContainer +import org.gradle.api.artifacts.Dependency +import org.gradle.api.artifacts.DependencyConstraint +import org.gradle.api.artifacts.ExternalModuleDependency +import org.gradle.api.artifacts.ModuleDependency +import org.gradle.api.artifacts.PublishArtifact +import org.gradle.api.artifacts.dsl.ArtifactHandler +import org.gradle.api.artifacts.dsl.DependencyConstraintHandler +import org.gradle.api.artifacts.dsl.DependencyHandler +import org.gradle.api.provider.Provider +import org.gradle.api.provider.ProviderConvertible +import org.gradle.api.tasks.TaskContainer +import org.gradle.api.tasks.TaskProvider + +import org.gradle.kotlin.dsl.* +import org.gradle.kotlin.dsl.accessors.runtime.* + + +/** + * Adds a dependency to the 'testCompileOnlyDependenciesMetadata' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testCompileOnlyDependenciesMetadata`(dependencyNotation: Any): Dependency? = + add("testCompileOnlyDependenciesMetadata", dependencyNotation) + +/** + * Adds a dependency to the 'testCompileOnlyDependenciesMetadata' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testCompileOnlyDependenciesMetadata`( + dependencyNotation: String, + dependencyConfiguration: Action +): ExternalModuleDependency = addDependencyTo( + this, "testCompileOnlyDependenciesMetadata", dependencyNotation, dependencyConfiguration +) as ExternalModuleDependency + +/** + * Adds a dependency to the 'testCompileOnlyDependenciesMetadata' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testCompileOnlyDependenciesMetadata`( + dependencyNotation: Provider<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "testCompileOnlyDependenciesMetadata", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testCompileOnlyDependenciesMetadata' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testCompileOnlyDependenciesMetadata`( + dependencyNotation: ProviderConvertible<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "testCompileOnlyDependenciesMetadata", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testCompileOnlyDependenciesMetadata' configuration. + * + * @param group the group of the module to be added as a dependency. + * @param name the name of the module to be added as a dependency. + * @param version the optional version of the module to be added as a dependency. + * @param configuration the optional configuration of the module to be added as a dependency. + * @param classifier the optional classifier of the module artifact to be added as a dependency. + * @param ext the optional extension of the module artifact to be added as a dependency. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.create] + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testCompileOnlyDependenciesMetadata`( + group: String, + name: String, + version: String? = null, + configuration: String? = null, + classifier: String? = null, + ext: String? = null, + dependencyConfiguration: Action? = null +): ExternalModuleDependency = addExternalModuleDependencyTo( + this, "testCompileOnlyDependenciesMetadata", group, name, version, configuration, classifier, ext, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testCompileOnlyDependenciesMetadata' configuration. + * + * @param dependency dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testCompileOnlyDependenciesMetadata`( + dependency: T, + dependencyConfiguration: T.() -> Unit +): T = add("testCompileOnlyDependenciesMetadata", dependency, dependencyConfiguration) + +/** + * Adds a dependency constraint to the 'testCompileOnlyDependenciesMetadata' configuration. + * + * @param constraintNotation the dependency constraint notation + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`testCompileOnlyDependenciesMetadata`(constraintNotation: Any): DependencyConstraint = + add("testCompileOnlyDependenciesMetadata", constraintNotation) + +/** + * Adds a dependency constraint to the 'testCompileOnlyDependenciesMetadata' configuration. + * + * @param constraintNotation the dependency constraint notation + * @param block the block to use to configure the dependency constraint + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`testCompileOnlyDependenciesMetadata`(constraintNotation: Any, block: DependencyConstraint.() -> Unit): DependencyConstraint = + add("testCompileOnlyDependenciesMetadata", constraintNotation, block) + +/** + * Adds an artifact to the 'testCompileOnlyDependenciesMetadata' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`testCompileOnlyDependenciesMetadata`(artifactNotation: Any): PublishArtifact = + add("testCompileOnlyDependenciesMetadata", artifactNotation) + +/** + * Adds an artifact to the 'testCompileOnlyDependenciesMetadata' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @param configureAction The action to execute to configure the artifact. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`testCompileOnlyDependenciesMetadata`( + artifactNotation: Any, + configureAction: ConfigurablePublishArtifact.() -> Unit +): PublishArtifact = + add("testCompileOnlyDependenciesMetadata", artifactNotation, configureAction) + + + diff --git a/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestDebugAnnotationProcessorConfigurationAccessors.kt b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestDebugAnnotationProcessorConfigurationAccessors.kt new file mode 100644 index 00000000..ee382284 --- /dev/null +++ b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestDebugAnnotationProcessorConfigurationAccessors.kt @@ -0,0 +1,213 @@ + +/* + * Copyright 2018 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +@file:Suppress( + "unused", + "nothing_to_inline", + "useless_cast", + "unchecked_cast", + "extension_shadowed_by_member", + "redundant_projection", + "RemoveRedundantBackticks", + "ObjectPropertyName", + "deprecation" +) +@file:org.gradle.api.Generated + +/* ktlint-disable */ + +package org.gradle.kotlin.dsl + + +import org.gradle.api.Action +import org.gradle.api.Incubating +import org.gradle.api.NamedDomainObjectProvider +import org.gradle.api.Project +import org.gradle.api.Task +import org.gradle.api.artifacts.Configuration +import org.gradle.api.artifacts.ConfigurablePublishArtifact +import org.gradle.api.artifacts.ConfigurationContainer +import org.gradle.api.artifacts.Dependency +import org.gradle.api.artifacts.DependencyConstraint +import org.gradle.api.artifacts.ExternalModuleDependency +import org.gradle.api.artifacts.ModuleDependency +import org.gradle.api.artifacts.PublishArtifact +import org.gradle.api.artifacts.dsl.ArtifactHandler +import org.gradle.api.artifacts.dsl.DependencyConstraintHandler +import org.gradle.api.artifacts.dsl.DependencyHandler +import org.gradle.api.provider.Provider +import org.gradle.api.provider.ProviderConvertible +import org.gradle.api.tasks.TaskContainer +import org.gradle.api.tasks.TaskProvider + +import org.gradle.kotlin.dsl.* +import org.gradle.kotlin.dsl.accessors.runtime.* + + +/** + * Adds a dependency to the 'testDebugAnnotationProcessor' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testDebugAnnotationProcessor`(dependencyNotation: Any): Dependency? = + add("testDebugAnnotationProcessor", dependencyNotation) + +/** + * Adds a dependency to the 'testDebugAnnotationProcessor' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testDebugAnnotationProcessor`( + dependencyNotation: String, + dependencyConfiguration: Action +): ExternalModuleDependency = addDependencyTo( + this, "testDebugAnnotationProcessor", dependencyNotation, dependencyConfiguration +) as ExternalModuleDependency + +/** + * Adds a dependency to the 'testDebugAnnotationProcessor' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testDebugAnnotationProcessor`( + dependencyNotation: Provider<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "testDebugAnnotationProcessor", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testDebugAnnotationProcessor' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testDebugAnnotationProcessor`( + dependencyNotation: ProviderConvertible<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "testDebugAnnotationProcessor", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testDebugAnnotationProcessor' configuration. + * + * @param group the group of the module to be added as a dependency. + * @param name the name of the module to be added as a dependency. + * @param version the optional version of the module to be added as a dependency. + * @param configuration the optional configuration of the module to be added as a dependency. + * @param classifier the optional classifier of the module artifact to be added as a dependency. + * @param ext the optional extension of the module artifact to be added as a dependency. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.create] + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testDebugAnnotationProcessor`( + group: String, + name: String, + version: String? = null, + configuration: String? = null, + classifier: String? = null, + ext: String? = null, + dependencyConfiguration: Action? = null +): ExternalModuleDependency = addExternalModuleDependencyTo( + this, "testDebugAnnotationProcessor", group, name, version, configuration, classifier, ext, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testDebugAnnotationProcessor' configuration. + * + * @param dependency dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testDebugAnnotationProcessor`( + dependency: T, + dependencyConfiguration: T.() -> Unit +): T = add("testDebugAnnotationProcessor", dependency, dependencyConfiguration) + +/** + * Adds a dependency constraint to the 'testDebugAnnotationProcessor' configuration. + * + * @param constraintNotation the dependency constraint notation + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`testDebugAnnotationProcessor`(constraintNotation: Any): DependencyConstraint = + add("testDebugAnnotationProcessor", constraintNotation) + +/** + * Adds a dependency constraint to the 'testDebugAnnotationProcessor' configuration. + * + * @param constraintNotation the dependency constraint notation + * @param block the block to use to configure the dependency constraint + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`testDebugAnnotationProcessor`(constraintNotation: Any, block: DependencyConstraint.() -> Unit): DependencyConstraint = + add("testDebugAnnotationProcessor", constraintNotation, block) + +/** + * Adds an artifact to the 'testDebugAnnotationProcessor' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`testDebugAnnotationProcessor`(artifactNotation: Any): PublishArtifact = + add("testDebugAnnotationProcessor", artifactNotation) + +/** + * Adds an artifact to the 'testDebugAnnotationProcessor' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @param configureAction The action to execute to configure the artifact. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`testDebugAnnotationProcessor`( + artifactNotation: Any, + configureAction: ConfigurablePublishArtifact.() -> Unit +): PublishArtifact = + add("testDebugAnnotationProcessor", artifactNotation, configureAction) + + + diff --git a/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestDebugApiConfigurationAccessors.kt b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestDebugApiConfigurationAccessors.kt new file mode 100644 index 00000000..67f154bc --- /dev/null +++ b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestDebugApiConfigurationAccessors.kt @@ -0,0 +1,213 @@ + +/* + * Copyright 2018 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +@file:Suppress( + "unused", + "nothing_to_inline", + "useless_cast", + "unchecked_cast", + "extension_shadowed_by_member", + "redundant_projection", + "RemoveRedundantBackticks", + "ObjectPropertyName", + "deprecation" +) +@file:org.gradle.api.Generated + +/* ktlint-disable */ + +package org.gradle.kotlin.dsl + + +import org.gradle.api.Action +import org.gradle.api.Incubating +import org.gradle.api.NamedDomainObjectProvider +import org.gradle.api.Project +import org.gradle.api.Task +import org.gradle.api.artifacts.Configuration +import org.gradle.api.artifacts.ConfigurablePublishArtifact +import org.gradle.api.artifacts.ConfigurationContainer +import org.gradle.api.artifacts.Dependency +import org.gradle.api.artifacts.DependencyConstraint +import org.gradle.api.artifacts.ExternalModuleDependency +import org.gradle.api.artifacts.ModuleDependency +import org.gradle.api.artifacts.PublishArtifact +import org.gradle.api.artifacts.dsl.ArtifactHandler +import org.gradle.api.artifacts.dsl.DependencyConstraintHandler +import org.gradle.api.artifacts.dsl.DependencyHandler +import org.gradle.api.provider.Provider +import org.gradle.api.provider.ProviderConvertible +import org.gradle.api.tasks.TaskContainer +import org.gradle.api.tasks.TaskProvider + +import org.gradle.kotlin.dsl.* +import org.gradle.kotlin.dsl.accessors.runtime.* + + +/** + * Adds a dependency to the 'testDebugApi' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testDebugApi`(dependencyNotation: Any): Dependency? = + add("testDebugApi", dependencyNotation) + +/** + * Adds a dependency to the 'testDebugApi' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testDebugApi`( + dependencyNotation: String, + dependencyConfiguration: Action +): ExternalModuleDependency = addDependencyTo( + this, "testDebugApi", dependencyNotation, dependencyConfiguration +) as ExternalModuleDependency + +/** + * Adds a dependency to the 'testDebugApi' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testDebugApi`( + dependencyNotation: Provider<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "testDebugApi", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testDebugApi' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testDebugApi`( + dependencyNotation: ProviderConvertible<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "testDebugApi", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testDebugApi' configuration. + * + * @param group the group of the module to be added as a dependency. + * @param name the name of the module to be added as a dependency. + * @param version the optional version of the module to be added as a dependency. + * @param configuration the optional configuration of the module to be added as a dependency. + * @param classifier the optional classifier of the module artifact to be added as a dependency. + * @param ext the optional extension of the module artifact to be added as a dependency. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.create] + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testDebugApi`( + group: String, + name: String, + version: String? = null, + configuration: String? = null, + classifier: String? = null, + ext: String? = null, + dependencyConfiguration: Action? = null +): ExternalModuleDependency = addExternalModuleDependencyTo( + this, "testDebugApi", group, name, version, configuration, classifier, ext, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testDebugApi' configuration. + * + * @param dependency dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testDebugApi`( + dependency: T, + dependencyConfiguration: T.() -> Unit +): T = add("testDebugApi", dependency, dependencyConfiguration) + +/** + * Adds a dependency constraint to the 'testDebugApi' configuration. + * + * @param constraintNotation the dependency constraint notation + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`testDebugApi`(constraintNotation: Any): DependencyConstraint = + add("testDebugApi", constraintNotation) + +/** + * Adds a dependency constraint to the 'testDebugApi' configuration. + * + * @param constraintNotation the dependency constraint notation + * @param block the block to use to configure the dependency constraint + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`testDebugApi`(constraintNotation: Any, block: DependencyConstraint.() -> Unit): DependencyConstraint = + add("testDebugApi", constraintNotation, block) + +/** + * Adds an artifact to the 'testDebugApi' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`testDebugApi`(artifactNotation: Any): PublishArtifact = + add("testDebugApi", artifactNotation) + +/** + * Adds an artifact to the 'testDebugApi' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @param configureAction The action to execute to configure the artifact. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`testDebugApi`( + artifactNotation: Any, + configureAction: ConfigurablePublishArtifact.() -> Unit +): PublishArtifact = + add("testDebugApi", artifactNotation, configureAction) + + + diff --git a/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestDebugApiDependenciesMetadataConfigurationAccessors.kt b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestDebugApiDependenciesMetadataConfigurationAccessors.kt new file mode 100644 index 00000000..14442db1 --- /dev/null +++ b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestDebugApiDependenciesMetadataConfigurationAccessors.kt @@ -0,0 +1,213 @@ + +/* + * Copyright 2018 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +@file:Suppress( + "unused", + "nothing_to_inline", + "useless_cast", + "unchecked_cast", + "extension_shadowed_by_member", + "redundant_projection", + "RemoveRedundantBackticks", + "ObjectPropertyName", + "deprecation" +) +@file:org.gradle.api.Generated + +/* ktlint-disable */ + +package org.gradle.kotlin.dsl + + +import org.gradle.api.Action +import org.gradle.api.Incubating +import org.gradle.api.NamedDomainObjectProvider +import org.gradle.api.Project +import org.gradle.api.Task +import org.gradle.api.artifacts.Configuration +import org.gradle.api.artifacts.ConfigurablePublishArtifact +import org.gradle.api.artifacts.ConfigurationContainer +import org.gradle.api.artifacts.Dependency +import org.gradle.api.artifacts.DependencyConstraint +import org.gradle.api.artifacts.ExternalModuleDependency +import org.gradle.api.artifacts.ModuleDependency +import org.gradle.api.artifacts.PublishArtifact +import org.gradle.api.artifacts.dsl.ArtifactHandler +import org.gradle.api.artifacts.dsl.DependencyConstraintHandler +import org.gradle.api.artifacts.dsl.DependencyHandler +import org.gradle.api.provider.Provider +import org.gradle.api.provider.ProviderConvertible +import org.gradle.api.tasks.TaskContainer +import org.gradle.api.tasks.TaskProvider + +import org.gradle.kotlin.dsl.* +import org.gradle.kotlin.dsl.accessors.runtime.* + + +/** + * Adds a dependency to the 'testDebugApiDependenciesMetadata' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testDebugApiDependenciesMetadata`(dependencyNotation: Any): Dependency? = + add("testDebugApiDependenciesMetadata", dependencyNotation) + +/** + * Adds a dependency to the 'testDebugApiDependenciesMetadata' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testDebugApiDependenciesMetadata`( + dependencyNotation: String, + dependencyConfiguration: Action +): ExternalModuleDependency = addDependencyTo( + this, "testDebugApiDependenciesMetadata", dependencyNotation, dependencyConfiguration +) as ExternalModuleDependency + +/** + * Adds a dependency to the 'testDebugApiDependenciesMetadata' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testDebugApiDependenciesMetadata`( + dependencyNotation: Provider<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "testDebugApiDependenciesMetadata", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testDebugApiDependenciesMetadata' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testDebugApiDependenciesMetadata`( + dependencyNotation: ProviderConvertible<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "testDebugApiDependenciesMetadata", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testDebugApiDependenciesMetadata' configuration. + * + * @param group the group of the module to be added as a dependency. + * @param name the name of the module to be added as a dependency. + * @param version the optional version of the module to be added as a dependency. + * @param configuration the optional configuration of the module to be added as a dependency. + * @param classifier the optional classifier of the module artifact to be added as a dependency. + * @param ext the optional extension of the module artifact to be added as a dependency. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.create] + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testDebugApiDependenciesMetadata`( + group: String, + name: String, + version: String? = null, + configuration: String? = null, + classifier: String? = null, + ext: String? = null, + dependencyConfiguration: Action? = null +): ExternalModuleDependency = addExternalModuleDependencyTo( + this, "testDebugApiDependenciesMetadata", group, name, version, configuration, classifier, ext, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testDebugApiDependenciesMetadata' configuration. + * + * @param dependency dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testDebugApiDependenciesMetadata`( + dependency: T, + dependencyConfiguration: T.() -> Unit +): T = add("testDebugApiDependenciesMetadata", dependency, dependencyConfiguration) + +/** + * Adds a dependency constraint to the 'testDebugApiDependenciesMetadata' configuration. + * + * @param constraintNotation the dependency constraint notation + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`testDebugApiDependenciesMetadata`(constraintNotation: Any): DependencyConstraint = + add("testDebugApiDependenciesMetadata", constraintNotation) + +/** + * Adds a dependency constraint to the 'testDebugApiDependenciesMetadata' configuration. + * + * @param constraintNotation the dependency constraint notation + * @param block the block to use to configure the dependency constraint + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`testDebugApiDependenciesMetadata`(constraintNotation: Any, block: DependencyConstraint.() -> Unit): DependencyConstraint = + add("testDebugApiDependenciesMetadata", constraintNotation, block) + +/** + * Adds an artifact to the 'testDebugApiDependenciesMetadata' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`testDebugApiDependenciesMetadata`(artifactNotation: Any): PublishArtifact = + add("testDebugApiDependenciesMetadata", artifactNotation) + +/** + * Adds an artifact to the 'testDebugApiDependenciesMetadata' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @param configureAction The action to execute to configure the artifact. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`testDebugApiDependenciesMetadata`( + artifactNotation: Any, + configureAction: ConfigurablePublishArtifact.() -> Unit +): PublishArtifact = + add("testDebugApiDependenciesMetadata", artifactNotation, configureAction) + + + diff --git a/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestDebugCompileOnlyConfigurationAccessors.kt b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestDebugCompileOnlyConfigurationAccessors.kt new file mode 100644 index 00000000..17195201 --- /dev/null +++ b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestDebugCompileOnlyConfigurationAccessors.kt @@ -0,0 +1,213 @@ + +/* + * Copyright 2018 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +@file:Suppress( + "unused", + "nothing_to_inline", + "useless_cast", + "unchecked_cast", + "extension_shadowed_by_member", + "redundant_projection", + "RemoveRedundantBackticks", + "ObjectPropertyName", + "deprecation" +) +@file:org.gradle.api.Generated + +/* ktlint-disable */ + +package org.gradle.kotlin.dsl + + +import org.gradle.api.Action +import org.gradle.api.Incubating +import org.gradle.api.NamedDomainObjectProvider +import org.gradle.api.Project +import org.gradle.api.Task +import org.gradle.api.artifacts.Configuration +import org.gradle.api.artifacts.ConfigurablePublishArtifact +import org.gradle.api.artifacts.ConfigurationContainer +import org.gradle.api.artifacts.Dependency +import org.gradle.api.artifacts.DependencyConstraint +import org.gradle.api.artifacts.ExternalModuleDependency +import org.gradle.api.artifacts.ModuleDependency +import org.gradle.api.artifacts.PublishArtifact +import org.gradle.api.artifacts.dsl.ArtifactHandler +import org.gradle.api.artifacts.dsl.DependencyConstraintHandler +import org.gradle.api.artifacts.dsl.DependencyHandler +import org.gradle.api.provider.Provider +import org.gradle.api.provider.ProviderConvertible +import org.gradle.api.tasks.TaskContainer +import org.gradle.api.tasks.TaskProvider + +import org.gradle.kotlin.dsl.* +import org.gradle.kotlin.dsl.accessors.runtime.* + + +/** + * Adds a dependency to the 'testDebugCompileOnly' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testDebugCompileOnly`(dependencyNotation: Any): Dependency? = + add("testDebugCompileOnly", dependencyNotation) + +/** + * Adds a dependency to the 'testDebugCompileOnly' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testDebugCompileOnly`( + dependencyNotation: String, + dependencyConfiguration: Action +): ExternalModuleDependency = addDependencyTo( + this, "testDebugCompileOnly", dependencyNotation, dependencyConfiguration +) as ExternalModuleDependency + +/** + * Adds a dependency to the 'testDebugCompileOnly' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testDebugCompileOnly`( + dependencyNotation: Provider<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "testDebugCompileOnly", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testDebugCompileOnly' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testDebugCompileOnly`( + dependencyNotation: ProviderConvertible<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "testDebugCompileOnly", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testDebugCompileOnly' configuration. + * + * @param group the group of the module to be added as a dependency. + * @param name the name of the module to be added as a dependency. + * @param version the optional version of the module to be added as a dependency. + * @param configuration the optional configuration of the module to be added as a dependency. + * @param classifier the optional classifier of the module artifact to be added as a dependency. + * @param ext the optional extension of the module artifact to be added as a dependency. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.create] + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testDebugCompileOnly`( + group: String, + name: String, + version: String? = null, + configuration: String? = null, + classifier: String? = null, + ext: String? = null, + dependencyConfiguration: Action? = null +): ExternalModuleDependency = addExternalModuleDependencyTo( + this, "testDebugCompileOnly", group, name, version, configuration, classifier, ext, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testDebugCompileOnly' configuration. + * + * @param dependency dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testDebugCompileOnly`( + dependency: T, + dependencyConfiguration: T.() -> Unit +): T = add("testDebugCompileOnly", dependency, dependencyConfiguration) + +/** + * Adds a dependency constraint to the 'testDebugCompileOnly' configuration. + * + * @param constraintNotation the dependency constraint notation + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`testDebugCompileOnly`(constraintNotation: Any): DependencyConstraint = + add("testDebugCompileOnly", constraintNotation) + +/** + * Adds a dependency constraint to the 'testDebugCompileOnly' configuration. + * + * @param constraintNotation the dependency constraint notation + * @param block the block to use to configure the dependency constraint + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`testDebugCompileOnly`(constraintNotation: Any, block: DependencyConstraint.() -> Unit): DependencyConstraint = + add("testDebugCompileOnly", constraintNotation, block) + +/** + * Adds an artifact to the 'testDebugCompileOnly' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`testDebugCompileOnly`(artifactNotation: Any): PublishArtifact = + add("testDebugCompileOnly", artifactNotation) + +/** + * Adds an artifact to the 'testDebugCompileOnly' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @param configureAction The action to execute to configure the artifact. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`testDebugCompileOnly`( + artifactNotation: Any, + configureAction: ConfigurablePublishArtifact.() -> Unit +): PublishArtifact = + add("testDebugCompileOnly", artifactNotation, configureAction) + + + diff --git a/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestDebugCompileOnlyDependenciesMetadataConfigurationAccessors.kt b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestDebugCompileOnlyDependenciesMetadataConfigurationAccessors.kt new file mode 100644 index 00000000..410cb869 --- /dev/null +++ b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestDebugCompileOnlyDependenciesMetadataConfigurationAccessors.kt @@ -0,0 +1,213 @@ + +/* + * Copyright 2018 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +@file:Suppress( + "unused", + "nothing_to_inline", + "useless_cast", + "unchecked_cast", + "extension_shadowed_by_member", + "redundant_projection", + "RemoveRedundantBackticks", + "ObjectPropertyName", + "deprecation" +) +@file:org.gradle.api.Generated + +/* ktlint-disable */ + +package org.gradle.kotlin.dsl + + +import org.gradle.api.Action +import org.gradle.api.Incubating +import org.gradle.api.NamedDomainObjectProvider +import org.gradle.api.Project +import org.gradle.api.Task +import org.gradle.api.artifacts.Configuration +import org.gradle.api.artifacts.ConfigurablePublishArtifact +import org.gradle.api.artifacts.ConfigurationContainer +import org.gradle.api.artifacts.Dependency +import org.gradle.api.artifacts.DependencyConstraint +import org.gradle.api.artifacts.ExternalModuleDependency +import org.gradle.api.artifacts.ModuleDependency +import org.gradle.api.artifacts.PublishArtifact +import org.gradle.api.artifacts.dsl.ArtifactHandler +import org.gradle.api.artifacts.dsl.DependencyConstraintHandler +import org.gradle.api.artifacts.dsl.DependencyHandler +import org.gradle.api.provider.Provider +import org.gradle.api.provider.ProviderConvertible +import org.gradle.api.tasks.TaskContainer +import org.gradle.api.tasks.TaskProvider + +import org.gradle.kotlin.dsl.* +import org.gradle.kotlin.dsl.accessors.runtime.* + + +/** + * Adds a dependency to the 'testDebugCompileOnlyDependenciesMetadata' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testDebugCompileOnlyDependenciesMetadata`(dependencyNotation: Any): Dependency? = + add("testDebugCompileOnlyDependenciesMetadata", dependencyNotation) + +/** + * Adds a dependency to the 'testDebugCompileOnlyDependenciesMetadata' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testDebugCompileOnlyDependenciesMetadata`( + dependencyNotation: String, + dependencyConfiguration: Action +): ExternalModuleDependency = addDependencyTo( + this, "testDebugCompileOnlyDependenciesMetadata", dependencyNotation, dependencyConfiguration +) as ExternalModuleDependency + +/** + * Adds a dependency to the 'testDebugCompileOnlyDependenciesMetadata' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testDebugCompileOnlyDependenciesMetadata`( + dependencyNotation: Provider<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "testDebugCompileOnlyDependenciesMetadata", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testDebugCompileOnlyDependenciesMetadata' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testDebugCompileOnlyDependenciesMetadata`( + dependencyNotation: ProviderConvertible<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "testDebugCompileOnlyDependenciesMetadata", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testDebugCompileOnlyDependenciesMetadata' configuration. + * + * @param group the group of the module to be added as a dependency. + * @param name the name of the module to be added as a dependency. + * @param version the optional version of the module to be added as a dependency. + * @param configuration the optional configuration of the module to be added as a dependency. + * @param classifier the optional classifier of the module artifact to be added as a dependency. + * @param ext the optional extension of the module artifact to be added as a dependency. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.create] + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testDebugCompileOnlyDependenciesMetadata`( + group: String, + name: String, + version: String? = null, + configuration: String? = null, + classifier: String? = null, + ext: String? = null, + dependencyConfiguration: Action? = null +): ExternalModuleDependency = addExternalModuleDependencyTo( + this, "testDebugCompileOnlyDependenciesMetadata", group, name, version, configuration, classifier, ext, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testDebugCompileOnlyDependenciesMetadata' configuration. + * + * @param dependency dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testDebugCompileOnlyDependenciesMetadata`( + dependency: T, + dependencyConfiguration: T.() -> Unit +): T = add("testDebugCompileOnlyDependenciesMetadata", dependency, dependencyConfiguration) + +/** + * Adds a dependency constraint to the 'testDebugCompileOnlyDependenciesMetadata' configuration. + * + * @param constraintNotation the dependency constraint notation + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`testDebugCompileOnlyDependenciesMetadata`(constraintNotation: Any): DependencyConstraint = + add("testDebugCompileOnlyDependenciesMetadata", constraintNotation) + +/** + * Adds a dependency constraint to the 'testDebugCompileOnlyDependenciesMetadata' configuration. + * + * @param constraintNotation the dependency constraint notation + * @param block the block to use to configure the dependency constraint + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`testDebugCompileOnlyDependenciesMetadata`(constraintNotation: Any, block: DependencyConstraint.() -> Unit): DependencyConstraint = + add("testDebugCompileOnlyDependenciesMetadata", constraintNotation, block) + +/** + * Adds an artifact to the 'testDebugCompileOnlyDependenciesMetadata' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`testDebugCompileOnlyDependenciesMetadata`(artifactNotation: Any): PublishArtifact = + add("testDebugCompileOnlyDependenciesMetadata", artifactNotation) + +/** + * Adds an artifact to the 'testDebugCompileOnlyDependenciesMetadata' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @param configureAction The action to execute to configure the artifact. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`testDebugCompileOnlyDependenciesMetadata`( + artifactNotation: Any, + configureAction: ConfigurablePublishArtifact.() -> Unit +): PublishArtifact = + add("testDebugCompileOnlyDependenciesMetadata", artifactNotation, configureAction) + + + diff --git a/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestDebugImplementationConfigurationAccessors.kt b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestDebugImplementationConfigurationAccessors.kt new file mode 100644 index 00000000..da68b404 --- /dev/null +++ b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestDebugImplementationConfigurationAccessors.kt @@ -0,0 +1,213 @@ + +/* + * Copyright 2018 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +@file:Suppress( + "unused", + "nothing_to_inline", + "useless_cast", + "unchecked_cast", + "extension_shadowed_by_member", + "redundant_projection", + "RemoveRedundantBackticks", + "ObjectPropertyName", + "deprecation" +) +@file:org.gradle.api.Generated + +/* ktlint-disable */ + +package org.gradle.kotlin.dsl + + +import org.gradle.api.Action +import org.gradle.api.Incubating +import org.gradle.api.NamedDomainObjectProvider +import org.gradle.api.Project +import org.gradle.api.Task +import org.gradle.api.artifacts.Configuration +import org.gradle.api.artifacts.ConfigurablePublishArtifact +import org.gradle.api.artifacts.ConfigurationContainer +import org.gradle.api.artifacts.Dependency +import org.gradle.api.artifacts.DependencyConstraint +import org.gradle.api.artifacts.ExternalModuleDependency +import org.gradle.api.artifacts.ModuleDependency +import org.gradle.api.artifacts.PublishArtifact +import org.gradle.api.artifacts.dsl.ArtifactHandler +import org.gradle.api.artifacts.dsl.DependencyConstraintHandler +import org.gradle.api.artifacts.dsl.DependencyHandler +import org.gradle.api.provider.Provider +import org.gradle.api.provider.ProviderConvertible +import org.gradle.api.tasks.TaskContainer +import org.gradle.api.tasks.TaskProvider + +import org.gradle.kotlin.dsl.* +import org.gradle.kotlin.dsl.accessors.runtime.* + + +/** + * Adds a dependency to the 'testDebugImplementation' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testDebugImplementation`(dependencyNotation: Any): Dependency? = + add("testDebugImplementation", dependencyNotation) + +/** + * Adds a dependency to the 'testDebugImplementation' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testDebugImplementation`( + dependencyNotation: String, + dependencyConfiguration: Action +): ExternalModuleDependency = addDependencyTo( + this, "testDebugImplementation", dependencyNotation, dependencyConfiguration +) as ExternalModuleDependency + +/** + * Adds a dependency to the 'testDebugImplementation' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testDebugImplementation`( + dependencyNotation: Provider<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "testDebugImplementation", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testDebugImplementation' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testDebugImplementation`( + dependencyNotation: ProviderConvertible<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "testDebugImplementation", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testDebugImplementation' configuration. + * + * @param group the group of the module to be added as a dependency. + * @param name the name of the module to be added as a dependency. + * @param version the optional version of the module to be added as a dependency. + * @param configuration the optional configuration of the module to be added as a dependency. + * @param classifier the optional classifier of the module artifact to be added as a dependency. + * @param ext the optional extension of the module artifact to be added as a dependency. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.create] + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testDebugImplementation`( + group: String, + name: String, + version: String? = null, + configuration: String? = null, + classifier: String? = null, + ext: String? = null, + dependencyConfiguration: Action? = null +): ExternalModuleDependency = addExternalModuleDependencyTo( + this, "testDebugImplementation", group, name, version, configuration, classifier, ext, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testDebugImplementation' configuration. + * + * @param dependency dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testDebugImplementation`( + dependency: T, + dependencyConfiguration: T.() -> Unit +): T = add("testDebugImplementation", dependency, dependencyConfiguration) + +/** + * Adds a dependency constraint to the 'testDebugImplementation' configuration. + * + * @param constraintNotation the dependency constraint notation + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`testDebugImplementation`(constraintNotation: Any): DependencyConstraint = + add("testDebugImplementation", constraintNotation) + +/** + * Adds a dependency constraint to the 'testDebugImplementation' configuration. + * + * @param constraintNotation the dependency constraint notation + * @param block the block to use to configure the dependency constraint + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`testDebugImplementation`(constraintNotation: Any, block: DependencyConstraint.() -> Unit): DependencyConstraint = + add("testDebugImplementation", constraintNotation, block) + +/** + * Adds an artifact to the 'testDebugImplementation' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`testDebugImplementation`(artifactNotation: Any): PublishArtifact = + add("testDebugImplementation", artifactNotation) + +/** + * Adds an artifact to the 'testDebugImplementation' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @param configureAction The action to execute to configure the artifact. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`testDebugImplementation`( + artifactNotation: Any, + configureAction: ConfigurablePublishArtifact.() -> Unit +): PublishArtifact = + add("testDebugImplementation", artifactNotation, configureAction) + + + diff --git a/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestDebugImplementationDependenciesMetadataConfigurationAccessors.kt b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestDebugImplementationDependenciesMetadataConfigurationAccessors.kt new file mode 100644 index 00000000..53683f6e --- /dev/null +++ b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestDebugImplementationDependenciesMetadataConfigurationAccessors.kt @@ -0,0 +1,213 @@ + +/* + * Copyright 2018 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +@file:Suppress( + "unused", + "nothing_to_inline", + "useless_cast", + "unchecked_cast", + "extension_shadowed_by_member", + "redundant_projection", + "RemoveRedundantBackticks", + "ObjectPropertyName", + "deprecation" +) +@file:org.gradle.api.Generated + +/* ktlint-disable */ + +package org.gradle.kotlin.dsl + + +import org.gradle.api.Action +import org.gradle.api.Incubating +import org.gradle.api.NamedDomainObjectProvider +import org.gradle.api.Project +import org.gradle.api.Task +import org.gradle.api.artifacts.Configuration +import org.gradle.api.artifacts.ConfigurablePublishArtifact +import org.gradle.api.artifacts.ConfigurationContainer +import org.gradle.api.artifacts.Dependency +import org.gradle.api.artifacts.DependencyConstraint +import org.gradle.api.artifacts.ExternalModuleDependency +import org.gradle.api.artifacts.ModuleDependency +import org.gradle.api.artifacts.PublishArtifact +import org.gradle.api.artifacts.dsl.ArtifactHandler +import org.gradle.api.artifacts.dsl.DependencyConstraintHandler +import org.gradle.api.artifacts.dsl.DependencyHandler +import org.gradle.api.provider.Provider +import org.gradle.api.provider.ProviderConvertible +import org.gradle.api.tasks.TaskContainer +import org.gradle.api.tasks.TaskProvider + +import org.gradle.kotlin.dsl.* +import org.gradle.kotlin.dsl.accessors.runtime.* + + +/** + * Adds a dependency to the 'testDebugImplementationDependenciesMetadata' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testDebugImplementationDependenciesMetadata`(dependencyNotation: Any): Dependency? = + add("testDebugImplementationDependenciesMetadata", dependencyNotation) + +/** + * Adds a dependency to the 'testDebugImplementationDependenciesMetadata' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testDebugImplementationDependenciesMetadata`( + dependencyNotation: String, + dependencyConfiguration: Action +): ExternalModuleDependency = addDependencyTo( + this, "testDebugImplementationDependenciesMetadata", dependencyNotation, dependencyConfiguration +) as ExternalModuleDependency + +/** + * Adds a dependency to the 'testDebugImplementationDependenciesMetadata' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testDebugImplementationDependenciesMetadata`( + dependencyNotation: Provider<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "testDebugImplementationDependenciesMetadata", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testDebugImplementationDependenciesMetadata' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testDebugImplementationDependenciesMetadata`( + dependencyNotation: ProviderConvertible<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "testDebugImplementationDependenciesMetadata", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testDebugImplementationDependenciesMetadata' configuration. + * + * @param group the group of the module to be added as a dependency. + * @param name the name of the module to be added as a dependency. + * @param version the optional version of the module to be added as a dependency. + * @param configuration the optional configuration of the module to be added as a dependency. + * @param classifier the optional classifier of the module artifact to be added as a dependency. + * @param ext the optional extension of the module artifact to be added as a dependency. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.create] + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testDebugImplementationDependenciesMetadata`( + group: String, + name: String, + version: String? = null, + configuration: String? = null, + classifier: String? = null, + ext: String? = null, + dependencyConfiguration: Action? = null +): ExternalModuleDependency = addExternalModuleDependencyTo( + this, "testDebugImplementationDependenciesMetadata", group, name, version, configuration, classifier, ext, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testDebugImplementationDependenciesMetadata' configuration. + * + * @param dependency dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testDebugImplementationDependenciesMetadata`( + dependency: T, + dependencyConfiguration: T.() -> Unit +): T = add("testDebugImplementationDependenciesMetadata", dependency, dependencyConfiguration) + +/** + * Adds a dependency constraint to the 'testDebugImplementationDependenciesMetadata' configuration. + * + * @param constraintNotation the dependency constraint notation + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`testDebugImplementationDependenciesMetadata`(constraintNotation: Any): DependencyConstraint = + add("testDebugImplementationDependenciesMetadata", constraintNotation) + +/** + * Adds a dependency constraint to the 'testDebugImplementationDependenciesMetadata' configuration. + * + * @param constraintNotation the dependency constraint notation + * @param block the block to use to configure the dependency constraint + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`testDebugImplementationDependenciesMetadata`(constraintNotation: Any, block: DependencyConstraint.() -> Unit): DependencyConstraint = + add("testDebugImplementationDependenciesMetadata", constraintNotation, block) + +/** + * Adds an artifact to the 'testDebugImplementationDependenciesMetadata' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`testDebugImplementationDependenciesMetadata`(artifactNotation: Any): PublishArtifact = + add("testDebugImplementationDependenciesMetadata", artifactNotation) + +/** + * Adds an artifact to the 'testDebugImplementationDependenciesMetadata' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @param configureAction The action to execute to configure the artifact. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`testDebugImplementationDependenciesMetadata`( + artifactNotation: Any, + configureAction: ConfigurablePublishArtifact.() -> Unit +): PublishArtifact = + add("testDebugImplementationDependenciesMetadata", artifactNotation, configureAction) + + + diff --git a/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestDebugIntransitiveDependenciesMetadataConfigurationAccessors.kt b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestDebugIntransitiveDependenciesMetadataConfigurationAccessors.kt new file mode 100644 index 00000000..614f8a93 --- /dev/null +++ b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestDebugIntransitiveDependenciesMetadataConfigurationAccessors.kt @@ -0,0 +1,213 @@ + +/* + * Copyright 2018 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +@file:Suppress( + "unused", + "nothing_to_inline", + "useless_cast", + "unchecked_cast", + "extension_shadowed_by_member", + "redundant_projection", + "RemoveRedundantBackticks", + "ObjectPropertyName", + "deprecation" +) +@file:org.gradle.api.Generated + +/* ktlint-disable */ + +package org.gradle.kotlin.dsl + + +import org.gradle.api.Action +import org.gradle.api.Incubating +import org.gradle.api.NamedDomainObjectProvider +import org.gradle.api.Project +import org.gradle.api.Task +import org.gradle.api.artifacts.Configuration +import org.gradle.api.artifacts.ConfigurablePublishArtifact +import org.gradle.api.artifacts.ConfigurationContainer +import org.gradle.api.artifacts.Dependency +import org.gradle.api.artifacts.DependencyConstraint +import org.gradle.api.artifacts.ExternalModuleDependency +import org.gradle.api.artifacts.ModuleDependency +import org.gradle.api.artifacts.PublishArtifact +import org.gradle.api.artifacts.dsl.ArtifactHandler +import org.gradle.api.artifacts.dsl.DependencyConstraintHandler +import org.gradle.api.artifacts.dsl.DependencyHandler +import org.gradle.api.provider.Provider +import org.gradle.api.provider.ProviderConvertible +import org.gradle.api.tasks.TaskContainer +import org.gradle.api.tasks.TaskProvider + +import org.gradle.kotlin.dsl.* +import org.gradle.kotlin.dsl.accessors.runtime.* + + +/** + * Adds a dependency to the 'testDebugIntransitiveDependenciesMetadata' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testDebugIntransitiveDependenciesMetadata`(dependencyNotation: Any): Dependency? = + add("testDebugIntransitiveDependenciesMetadata", dependencyNotation) + +/** + * Adds a dependency to the 'testDebugIntransitiveDependenciesMetadata' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testDebugIntransitiveDependenciesMetadata`( + dependencyNotation: String, + dependencyConfiguration: Action +): ExternalModuleDependency = addDependencyTo( + this, "testDebugIntransitiveDependenciesMetadata", dependencyNotation, dependencyConfiguration +) as ExternalModuleDependency + +/** + * Adds a dependency to the 'testDebugIntransitiveDependenciesMetadata' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testDebugIntransitiveDependenciesMetadata`( + dependencyNotation: Provider<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "testDebugIntransitiveDependenciesMetadata", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testDebugIntransitiveDependenciesMetadata' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testDebugIntransitiveDependenciesMetadata`( + dependencyNotation: ProviderConvertible<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "testDebugIntransitiveDependenciesMetadata", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testDebugIntransitiveDependenciesMetadata' configuration. + * + * @param group the group of the module to be added as a dependency. + * @param name the name of the module to be added as a dependency. + * @param version the optional version of the module to be added as a dependency. + * @param configuration the optional configuration of the module to be added as a dependency. + * @param classifier the optional classifier of the module artifact to be added as a dependency. + * @param ext the optional extension of the module artifact to be added as a dependency. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.create] + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testDebugIntransitiveDependenciesMetadata`( + group: String, + name: String, + version: String? = null, + configuration: String? = null, + classifier: String? = null, + ext: String? = null, + dependencyConfiguration: Action? = null +): ExternalModuleDependency = addExternalModuleDependencyTo( + this, "testDebugIntransitiveDependenciesMetadata", group, name, version, configuration, classifier, ext, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testDebugIntransitiveDependenciesMetadata' configuration. + * + * @param dependency dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testDebugIntransitiveDependenciesMetadata`( + dependency: T, + dependencyConfiguration: T.() -> Unit +): T = add("testDebugIntransitiveDependenciesMetadata", dependency, dependencyConfiguration) + +/** + * Adds a dependency constraint to the 'testDebugIntransitiveDependenciesMetadata' configuration. + * + * @param constraintNotation the dependency constraint notation + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`testDebugIntransitiveDependenciesMetadata`(constraintNotation: Any): DependencyConstraint = + add("testDebugIntransitiveDependenciesMetadata", constraintNotation) + +/** + * Adds a dependency constraint to the 'testDebugIntransitiveDependenciesMetadata' configuration. + * + * @param constraintNotation the dependency constraint notation + * @param block the block to use to configure the dependency constraint + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`testDebugIntransitiveDependenciesMetadata`(constraintNotation: Any, block: DependencyConstraint.() -> Unit): DependencyConstraint = + add("testDebugIntransitiveDependenciesMetadata", constraintNotation, block) + +/** + * Adds an artifact to the 'testDebugIntransitiveDependenciesMetadata' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`testDebugIntransitiveDependenciesMetadata`(artifactNotation: Any): PublishArtifact = + add("testDebugIntransitiveDependenciesMetadata", artifactNotation) + +/** + * Adds an artifact to the 'testDebugIntransitiveDependenciesMetadata' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @param configureAction The action to execute to configure the artifact. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`testDebugIntransitiveDependenciesMetadata`( + artifactNotation: Any, + configureAction: ConfigurablePublishArtifact.() -> Unit +): PublishArtifact = + add("testDebugIntransitiveDependenciesMetadata", artifactNotation, configureAction) + + + diff --git a/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestDebugRuntimeOnlyConfigurationAccessors.kt b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestDebugRuntimeOnlyConfigurationAccessors.kt new file mode 100644 index 00000000..107dccfd --- /dev/null +++ b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestDebugRuntimeOnlyConfigurationAccessors.kt @@ -0,0 +1,213 @@ + +/* + * Copyright 2018 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +@file:Suppress( + "unused", + "nothing_to_inline", + "useless_cast", + "unchecked_cast", + "extension_shadowed_by_member", + "redundant_projection", + "RemoveRedundantBackticks", + "ObjectPropertyName", + "deprecation" +) +@file:org.gradle.api.Generated + +/* ktlint-disable */ + +package org.gradle.kotlin.dsl + + +import org.gradle.api.Action +import org.gradle.api.Incubating +import org.gradle.api.NamedDomainObjectProvider +import org.gradle.api.Project +import org.gradle.api.Task +import org.gradle.api.artifacts.Configuration +import org.gradle.api.artifacts.ConfigurablePublishArtifact +import org.gradle.api.artifacts.ConfigurationContainer +import org.gradle.api.artifacts.Dependency +import org.gradle.api.artifacts.DependencyConstraint +import org.gradle.api.artifacts.ExternalModuleDependency +import org.gradle.api.artifacts.ModuleDependency +import org.gradle.api.artifacts.PublishArtifact +import org.gradle.api.artifacts.dsl.ArtifactHandler +import org.gradle.api.artifacts.dsl.DependencyConstraintHandler +import org.gradle.api.artifacts.dsl.DependencyHandler +import org.gradle.api.provider.Provider +import org.gradle.api.provider.ProviderConvertible +import org.gradle.api.tasks.TaskContainer +import org.gradle.api.tasks.TaskProvider + +import org.gradle.kotlin.dsl.* +import org.gradle.kotlin.dsl.accessors.runtime.* + + +/** + * Adds a dependency to the 'testDebugRuntimeOnly' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testDebugRuntimeOnly`(dependencyNotation: Any): Dependency? = + add("testDebugRuntimeOnly", dependencyNotation) + +/** + * Adds a dependency to the 'testDebugRuntimeOnly' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testDebugRuntimeOnly`( + dependencyNotation: String, + dependencyConfiguration: Action +): ExternalModuleDependency = addDependencyTo( + this, "testDebugRuntimeOnly", dependencyNotation, dependencyConfiguration +) as ExternalModuleDependency + +/** + * Adds a dependency to the 'testDebugRuntimeOnly' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testDebugRuntimeOnly`( + dependencyNotation: Provider<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "testDebugRuntimeOnly", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testDebugRuntimeOnly' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testDebugRuntimeOnly`( + dependencyNotation: ProviderConvertible<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "testDebugRuntimeOnly", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testDebugRuntimeOnly' configuration. + * + * @param group the group of the module to be added as a dependency. + * @param name the name of the module to be added as a dependency. + * @param version the optional version of the module to be added as a dependency. + * @param configuration the optional configuration of the module to be added as a dependency. + * @param classifier the optional classifier of the module artifact to be added as a dependency. + * @param ext the optional extension of the module artifact to be added as a dependency. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.create] + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testDebugRuntimeOnly`( + group: String, + name: String, + version: String? = null, + configuration: String? = null, + classifier: String? = null, + ext: String? = null, + dependencyConfiguration: Action? = null +): ExternalModuleDependency = addExternalModuleDependencyTo( + this, "testDebugRuntimeOnly", group, name, version, configuration, classifier, ext, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testDebugRuntimeOnly' configuration. + * + * @param dependency dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testDebugRuntimeOnly`( + dependency: T, + dependencyConfiguration: T.() -> Unit +): T = add("testDebugRuntimeOnly", dependency, dependencyConfiguration) + +/** + * Adds a dependency constraint to the 'testDebugRuntimeOnly' configuration. + * + * @param constraintNotation the dependency constraint notation + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`testDebugRuntimeOnly`(constraintNotation: Any): DependencyConstraint = + add("testDebugRuntimeOnly", constraintNotation) + +/** + * Adds a dependency constraint to the 'testDebugRuntimeOnly' configuration. + * + * @param constraintNotation the dependency constraint notation + * @param block the block to use to configure the dependency constraint + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`testDebugRuntimeOnly`(constraintNotation: Any, block: DependencyConstraint.() -> Unit): DependencyConstraint = + add("testDebugRuntimeOnly", constraintNotation, block) + +/** + * Adds an artifact to the 'testDebugRuntimeOnly' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`testDebugRuntimeOnly`(artifactNotation: Any): PublishArtifact = + add("testDebugRuntimeOnly", artifactNotation) + +/** + * Adds an artifact to the 'testDebugRuntimeOnly' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @param configureAction The action to execute to configure the artifact. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`testDebugRuntimeOnly`( + artifactNotation: Any, + configureAction: ConfigurablePublishArtifact.() -> Unit +): PublishArtifact = + add("testDebugRuntimeOnly", artifactNotation, configureAction) + + + diff --git a/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestDebugWearAppConfigurationAccessors.kt b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestDebugWearAppConfigurationAccessors.kt new file mode 100644 index 00000000..37f5eb73 --- /dev/null +++ b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestDebugWearAppConfigurationAccessors.kt @@ -0,0 +1,213 @@ + +/* + * Copyright 2018 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +@file:Suppress( + "unused", + "nothing_to_inline", + "useless_cast", + "unchecked_cast", + "extension_shadowed_by_member", + "redundant_projection", + "RemoveRedundantBackticks", + "ObjectPropertyName", + "deprecation" +) +@file:org.gradle.api.Generated + +/* ktlint-disable */ + +package org.gradle.kotlin.dsl + + +import org.gradle.api.Action +import org.gradle.api.Incubating +import org.gradle.api.NamedDomainObjectProvider +import org.gradle.api.Project +import org.gradle.api.Task +import org.gradle.api.artifacts.Configuration +import org.gradle.api.artifacts.ConfigurablePublishArtifact +import org.gradle.api.artifacts.ConfigurationContainer +import org.gradle.api.artifacts.Dependency +import org.gradle.api.artifacts.DependencyConstraint +import org.gradle.api.artifacts.ExternalModuleDependency +import org.gradle.api.artifacts.ModuleDependency +import org.gradle.api.artifacts.PublishArtifact +import org.gradle.api.artifacts.dsl.ArtifactHandler +import org.gradle.api.artifacts.dsl.DependencyConstraintHandler +import org.gradle.api.artifacts.dsl.DependencyHandler +import org.gradle.api.provider.Provider +import org.gradle.api.provider.ProviderConvertible +import org.gradle.api.tasks.TaskContainer +import org.gradle.api.tasks.TaskProvider + +import org.gradle.kotlin.dsl.* +import org.gradle.kotlin.dsl.accessors.runtime.* + + +/** + * Adds a dependency to the 'testDebugWearApp' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testDebugWearApp`(dependencyNotation: Any): Dependency? = + add("testDebugWearApp", dependencyNotation) + +/** + * Adds a dependency to the 'testDebugWearApp' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testDebugWearApp`( + dependencyNotation: String, + dependencyConfiguration: Action +): ExternalModuleDependency = addDependencyTo( + this, "testDebugWearApp", dependencyNotation, dependencyConfiguration +) as ExternalModuleDependency + +/** + * Adds a dependency to the 'testDebugWearApp' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testDebugWearApp`( + dependencyNotation: Provider<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "testDebugWearApp", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testDebugWearApp' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testDebugWearApp`( + dependencyNotation: ProviderConvertible<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "testDebugWearApp", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testDebugWearApp' configuration. + * + * @param group the group of the module to be added as a dependency. + * @param name the name of the module to be added as a dependency. + * @param version the optional version of the module to be added as a dependency. + * @param configuration the optional configuration of the module to be added as a dependency. + * @param classifier the optional classifier of the module artifact to be added as a dependency. + * @param ext the optional extension of the module artifact to be added as a dependency. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.create] + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testDebugWearApp`( + group: String, + name: String, + version: String? = null, + configuration: String? = null, + classifier: String? = null, + ext: String? = null, + dependencyConfiguration: Action? = null +): ExternalModuleDependency = addExternalModuleDependencyTo( + this, "testDebugWearApp", group, name, version, configuration, classifier, ext, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testDebugWearApp' configuration. + * + * @param dependency dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testDebugWearApp`( + dependency: T, + dependencyConfiguration: T.() -> Unit +): T = add("testDebugWearApp", dependency, dependencyConfiguration) + +/** + * Adds a dependency constraint to the 'testDebugWearApp' configuration. + * + * @param constraintNotation the dependency constraint notation + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`testDebugWearApp`(constraintNotation: Any): DependencyConstraint = + add("testDebugWearApp", constraintNotation) + +/** + * Adds a dependency constraint to the 'testDebugWearApp' configuration. + * + * @param constraintNotation the dependency constraint notation + * @param block the block to use to configure the dependency constraint + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`testDebugWearApp`(constraintNotation: Any, block: DependencyConstraint.() -> Unit): DependencyConstraint = + add("testDebugWearApp", constraintNotation, block) + +/** + * Adds an artifact to the 'testDebugWearApp' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`testDebugWearApp`(artifactNotation: Any): PublishArtifact = + add("testDebugWearApp", artifactNotation) + +/** + * Adds an artifact to the 'testDebugWearApp' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @param configureAction The action to execute to configure the artifact. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`testDebugWearApp`( + artifactNotation: Any, + configureAction: ConfigurablePublishArtifact.() -> Unit +): PublishArtifact = + add("testDebugWearApp", artifactNotation, configureAction) + + + diff --git a/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestFixturesAnnotationProcessorConfigurationAccessors.kt b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestFixturesAnnotationProcessorConfigurationAccessors.kt new file mode 100644 index 00000000..5e6777d9 --- /dev/null +++ b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestFixturesAnnotationProcessorConfigurationAccessors.kt @@ -0,0 +1,213 @@ + +/* + * Copyright 2018 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +@file:Suppress( + "unused", + "nothing_to_inline", + "useless_cast", + "unchecked_cast", + "extension_shadowed_by_member", + "redundant_projection", + "RemoveRedundantBackticks", + "ObjectPropertyName", + "deprecation" +) +@file:org.gradle.api.Generated + +/* ktlint-disable */ + +package org.gradle.kotlin.dsl + + +import org.gradle.api.Action +import org.gradle.api.Incubating +import org.gradle.api.NamedDomainObjectProvider +import org.gradle.api.Project +import org.gradle.api.Task +import org.gradle.api.artifacts.Configuration +import org.gradle.api.artifacts.ConfigurablePublishArtifact +import org.gradle.api.artifacts.ConfigurationContainer +import org.gradle.api.artifacts.Dependency +import org.gradle.api.artifacts.DependencyConstraint +import org.gradle.api.artifacts.ExternalModuleDependency +import org.gradle.api.artifacts.ModuleDependency +import org.gradle.api.artifacts.PublishArtifact +import org.gradle.api.artifacts.dsl.ArtifactHandler +import org.gradle.api.artifacts.dsl.DependencyConstraintHandler +import org.gradle.api.artifacts.dsl.DependencyHandler +import org.gradle.api.provider.Provider +import org.gradle.api.provider.ProviderConvertible +import org.gradle.api.tasks.TaskContainer +import org.gradle.api.tasks.TaskProvider + +import org.gradle.kotlin.dsl.* +import org.gradle.kotlin.dsl.accessors.runtime.* + + +/** + * Adds a dependency to the 'testFixturesAnnotationProcessor' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesAnnotationProcessor`(dependencyNotation: Any): Dependency? = + add("testFixturesAnnotationProcessor", dependencyNotation) + +/** + * Adds a dependency to the 'testFixturesAnnotationProcessor' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesAnnotationProcessor`( + dependencyNotation: String, + dependencyConfiguration: Action +): ExternalModuleDependency = addDependencyTo( + this, "testFixturesAnnotationProcessor", dependencyNotation, dependencyConfiguration +) as ExternalModuleDependency + +/** + * Adds a dependency to the 'testFixturesAnnotationProcessor' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesAnnotationProcessor`( + dependencyNotation: Provider<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "testFixturesAnnotationProcessor", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testFixturesAnnotationProcessor' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesAnnotationProcessor`( + dependencyNotation: ProviderConvertible<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "testFixturesAnnotationProcessor", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testFixturesAnnotationProcessor' configuration. + * + * @param group the group of the module to be added as a dependency. + * @param name the name of the module to be added as a dependency. + * @param version the optional version of the module to be added as a dependency. + * @param configuration the optional configuration of the module to be added as a dependency. + * @param classifier the optional classifier of the module artifact to be added as a dependency. + * @param ext the optional extension of the module artifact to be added as a dependency. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.create] + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesAnnotationProcessor`( + group: String, + name: String, + version: String? = null, + configuration: String? = null, + classifier: String? = null, + ext: String? = null, + dependencyConfiguration: Action? = null +): ExternalModuleDependency = addExternalModuleDependencyTo( + this, "testFixturesAnnotationProcessor", group, name, version, configuration, classifier, ext, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testFixturesAnnotationProcessor' configuration. + * + * @param dependency dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesAnnotationProcessor`( + dependency: T, + dependencyConfiguration: T.() -> Unit +): T = add("testFixturesAnnotationProcessor", dependency, dependencyConfiguration) + +/** + * Adds a dependency constraint to the 'testFixturesAnnotationProcessor' configuration. + * + * @param constraintNotation the dependency constraint notation + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`testFixturesAnnotationProcessor`(constraintNotation: Any): DependencyConstraint = + add("testFixturesAnnotationProcessor", constraintNotation) + +/** + * Adds a dependency constraint to the 'testFixturesAnnotationProcessor' configuration. + * + * @param constraintNotation the dependency constraint notation + * @param block the block to use to configure the dependency constraint + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`testFixturesAnnotationProcessor`(constraintNotation: Any, block: DependencyConstraint.() -> Unit): DependencyConstraint = + add("testFixturesAnnotationProcessor", constraintNotation, block) + +/** + * Adds an artifact to the 'testFixturesAnnotationProcessor' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`testFixturesAnnotationProcessor`(artifactNotation: Any): PublishArtifact = + add("testFixturesAnnotationProcessor", artifactNotation) + +/** + * Adds an artifact to the 'testFixturesAnnotationProcessor' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @param configureAction The action to execute to configure the artifact. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`testFixturesAnnotationProcessor`( + artifactNotation: Any, + configureAction: ConfigurablePublishArtifact.() -> Unit +): PublishArtifact = + add("testFixturesAnnotationProcessor", artifactNotation, configureAction) + + + diff --git a/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestFixturesApiConfigurationAccessors.kt b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestFixturesApiConfigurationAccessors.kt new file mode 100644 index 00000000..511aecb3 --- /dev/null +++ b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestFixturesApiConfigurationAccessors.kt @@ -0,0 +1,213 @@ + +/* + * Copyright 2018 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +@file:Suppress( + "unused", + "nothing_to_inline", + "useless_cast", + "unchecked_cast", + "extension_shadowed_by_member", + "redundant_projection", + "RemoveRedundantBackticks", + "ObjectPropertyName", + "deprecation" +) +@file:org.gradle.api.Generated + +/* ktlint-disable */ + +package org.gradle.kotlin.dsl + + +import org.gradle.api.Action +import org.gradle.api.Incubating +import org.gradle.api.NamedDomainObjectProvider +import org.gradle.api.Project +import org.gradle.api.Task +import org.gradle.api.artifacts.Configuration +import org.gradle.api.artifacts.ConfigurablePublishArtifact +import org.gradle.api.artifacts.ConfigurationContainer +import org.gradle.api.artifacts.Dependency +import org.gradle.api.artifacts.DependencyConstraint +import org.gradle.api.artifacts.ExternalModuleDependency +import org.gradle.api.artifacts.ModuleDependency +import org.gradle.api.artifacts.PublishArtifact +import org.gradle.api.artifacts.dsl.ArtifactHandler +import org.gradle.api.artifacts.dsl.DependencyConstraintHandler +import org.gradle.api.artifacts.dsl.DependencyHandler +import org.gradle.api.provider.Provider +import org.gradle.api.provider.ProviderConvertible +import org.gradle.api.tasks.TaskContainer +import org.gradle.api.tasks.TaskProvider + +import org.gradle.kotlin.dsl.* +import org.gradle.kotlin.dsl.accessors.runtime.* + + +/** + * Adds a dependency to the 'testFixturesApi' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesApi`(dependencyNotation: Any): Dependency? = + add("testFixturesApi", dependencyNotation) + +/** + * Adds a dependency to the 'testFixturesApi' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesApi`( + dependencyNotation: String, + dependencyConfiguration: Action +): ExternalModuleDependency = addDependencyTo( + this, "testFixturesApi", dependencyNotation, dependencyConfiguration +) as ExternalModuleDependency + +/** + * Adds a dependency to the 'testFixturesApi' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesApi`( + dependencyNotation: Provider<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "testFixturesApi", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testFixturesApi' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesApi`( + dependencyNotation: ProviderConvertible<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "testFixturesApi", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testFixturesApi' configuration. + * + * @param group the group of the module to be added as a dependency. + * @param name the name of the module to be added as a dependency. + * @param version the optional version of the module to be added as a dependency. + * @param configuration the optional configuration of the module to be added as a dependency. + * @param classifier the optional classifier of the module artifact to be added as a dependency. + * @param ext the optional extension of the module artifact to be added as a dependency. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.create] + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesApi`( + group: String, + name: String, + version: String? = null, + configuration: String? = null, + classifier: String? = null, + ext: String? = null, + dependencyConfiguration: Action? = null +): ExternalModuleDependency = addExternalModuleDependencyTo( + this, "testFixturesApi", group, name, version, configuration, classifier, ext, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testFixturesApi' configuration. + * + * @param dependency dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesApi`( + dependency: T, + dependencyConfiguration: T.() -> Unit +): T = add("testFixturesApi", dependency, dependencyConfiguration) + +/** + * Adds a dependency constraint to the 'testFixturesApi' configuration. + * + * @param constraintNotation the dependency constraint notation + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`testFixturesApi`(constraintNotation: Any): DependencyConstraint = + add("testFixturesApi", constraintNotation) + +/** + * Adds a dependency constraint to the 'testFixturesApi' configuration. + * + * @param constraintNotation the dependency constraint notation + * @param block the block to use to configure the dependency constraint + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`testFixturesApi`(constraintNotation: Any, block: DependencyConstraint.() -> Unit): DependencyConstraint = + add("testFixturesApi", constraintNotation, block) + +/** + * Adds an artifact to the 'testFixturesApi' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`testFixturesApi`(artifactNotation: Any): PublishArtifact = + add("testFixturesApi", artifactNotation) + +/** + * Adds an artifact to the 'testFixturesApi' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @param configureAction The action to execute to configure the artifact. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`testFixturesApi`( + artifactNotation: Any, + configureAction: ConfigurablePublishArtifact.() -> Unit +): PublishArtifact = + add("testFixturesApi", artifactNotation, configureAction) + + + diff --git a/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestFixturesApiDependenciesMetadataConfigurationAccessors.kt b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestFixturesApiDependenciesMetadataConfigurationAccessors.kt new file mode 100644 index 00000000..6795a671 --- /dev/null +++ b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestFixturesApiDependenciesMetadataConfigurationAccessors.kt @@ -0,0 +1,213 @@ + +/* + * Copyright 2018 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +@file:Suppress( + "unused", + "nothing_to_inline", + "useless_cast", + "unchecked_cast", + "extension_shadowed_by_member", + "redundant_projection", + "RemoveRedundantBackticks", + "ObjectPropertyName", + "deprecation" +) +@file:org.gradle.api.Generated + +/* ktlint-disable */ + +package org.gradle.kotlin.dsl + + +import org.gradle.api.Action +import org.gradle.api.Incubating +import org.gradle.api.NamedDomainObjectProvider +import org.gradle.api.Project +import org.gradle.api.Task +import org.gradle.api.artifacts.Configuration +import org.gradle.api.artifacts.ConfigurablePublishArtifact +import org.gradle.api.artifacts.ConfigurationContainer +import org.gradle.api.artifacts.Dependency +import org.gradle.api.artifacts.DependencyConstraint +import org.gradle.api.artifacts.ExternalModuleDependency +import org.gradle.api.artifacts.ModuleDependency +import org.gradle.api.artifacts.PublishArtifact +import org.gradle.api.artifacts.dsl.ArtifactHandler +import org.gradle.api.artifacts.dsl.DependencyConstraintHandler +import org.gradle.api.artifacts.dsl.DependencyHandler +import org.gradle.api.provider.Provider +import org.gradle.api.provider.ProviderConvertible +import org.gradle.api.tasks.TaskContainer +import org.gradle.api.tasks.TaskProvider + +import org.gradle.kotlin.dsl.* +import org.gradle.kotlin.dsl.accessors.runtime.* + + +/** + * Adds a dependency to the 'testFixturesApiDependenciesMetadata' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesApiDependenciesMetadata`(dependencyNotation: Any): Dependency? = + add("testFixturesApiDependenciesMetadata", dependencyNotation) + +/** + * Adds a dependency to the 'testFixturesApiDependenciesMetadata' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesApiDependenciesMetadata`( + dependencyNotation: String, + dependencyConfiguration: Action +): ExternalModuleDependency = addDependencyTo( + this, "testFixturesApiDependenciesMetadata", dependencyNotation, dependencyConfiguration +) as ExternalModuleDependency + +/** + * Adds a dependency to the 'testFixturesApiDependenciesMetadata' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesApiDependenciesMetadata`( + dependencyNotation: Provider<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "testFixturesApiDependenciesMetadata", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testFixturesApiDependenciesMetadata' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesApiDependenciesMetadata`( + dependencyNotation: ProviderConvertible<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "testFixturesApiDependenciesMetadata", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testFixturesApiDependenciesMetadata' configuration. + * + * @param group the group of the module to be added as a dependency. + * @param name the name of the module to be added as a dependency. + * @param version the optional version of the module to be added as a dependency. + * @param configuration the optional configuration of the module to be added as a dependency. + * @param classifier the optional classifier of the module artifact to be added as a dependency. + * @param ext the optional extension of the module artifact to be added as a dependency. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.create] + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesApiDependenciesMetadata`( + group: String, + name: String, + version: String? = null, + configuration: String? = null, + classifier: String? = null, + ext: String? = null, + dependencyConfiguration: Action? = null +): ExternalModuleDependency = addExternalModuleDependencyTo( + this, "testFixturesApiDependenciesMetadata", group, name, version, configuration, classifier, ext, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testFixturesApiDependenciesMetadata' configuration. + * + * @param dependency dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesApiDependenciesMetadata`( + dependency: T, + dependencyConfiguration: T.() -> Unit +): T = add("testFixturesApiDependenciesMetadata", dependency, dependencyConfiguration) + +/** + * Adds a dependency constraint to the 'testFixturesApiDependenciesMetadata' configuration. + * + * @param constraintNotation the dependency constraint notation + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`testFixturesApiDependenciesMetadata`(constraintNotation: Any): DependencyConstraint = + add("testFixturesApiDependenciesMetadata", constraintNotation) + +/** + * Adds a dependency constraint to the 'testFixturesApiDependenciesMetadata' configuration. + * + * @param constraintNotation the dependency constraint notation + * @param block the block to use to configure the dependency constraint + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`testFixturesApiDependenciesMetadata`(constraintNotation: Any, block: DependencyConstraint.() -> Unit): DependencyConstraint = + add("testFixturesApiDependenciesMetadata", constraintNotation, block) + +/** + * Adds an artifact to the 'testFixturesApiDependenciesMetadata' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`testFixturesApiDependenciesMetadata`(artifactNotation: Any): PublishArtifact = + add("testFixturesApiDependenciesMetadata", artifactNotation) + +/** + * Adds an artifact to the 'testFixturesApiDependenciesMetadata' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @param configureAction The action to execute to configure the artifact. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`testFixturesApiDependenciesMetadata`( + artifactNotation: Any, + configureAction: ConfigurablePublishArtifact.() -> Unit +): PublishArtifact = + add("testFixturesApiDependenciesMetadata", artifactNotation, configureAction) + + + diff --git a/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestFixturesCompileOnlyApiConfigurationAccessors.kt b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestFixturesCompileOnlyApiConfigurationAccessors.kt new file mode 100644 index 00000000..ba26e4ea --- /dev/null +++ b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestFixturesCompileOnlyApiConfigurationAccessors.kt @@ -0,0 +1,213 @@ + +/* + * Copyright 2018 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +@file:Suppress( + "unused", + "nothing_to_inline", + "useless_cast", + "unchecked_cast", + "extension_shadowed_by_member", + "redundant_projection", + "RemoveRedundantBackticks", + "ObjectPropertyName", + "deprecation" +) +@file:org.gradle.api.Generated + +/* ktlint-disable */ + +package org.gradle.kotlin.dsl + + +import org.gradle.api.Action +import org.gradle.api.Incubating +import org.gradle.api.NamedDomainObjectProvider +import org.gradle.api.Project +import org.gradle.api.Task +import org.gradle.api.artifacts.Configuration +import org.gradle.api.artifacts.ConfigurablePublishArtifact +import org.gradle.api.artifacts.ConfigurationContainer +import org.gradle.api.artifacts.Dependency +import org.gradle.api.artifacts.DependencyConstraint +import org.gradle.api.artifacts.ExternalModuleDependency +import org.gradle.api.artifacts.ModuleDependency +import org.gradle.api.artifacts.PublishArtifact +import org.gradle.api.artifacts.dsl.ArtifactHandler +import org.gradle.api.artifacts.dsl.DependencyConstraintHandler +import org.gradle.api.artifacts.dsl.DependencyHandler +import org.gradle.api.provider.Provider +import org.gradle.api.provider.ProviderConvertible +import org.gradle.api.tasks.TaskContainer +import org.gradle.api.tasks.TaskProvider + +import org.gradle.kotlin.dsl.* +import org.gradle.kotlin.dsl.accessors.runtime.* + + +/** + * Adds a dependency to the 'testFixturesCompileOnlyApi' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesCompileOnlyApi`(dependencyNotation: Any): Dependency? = + add("testFixturesCompileOnlyApi", dependencyNotation) + +/** + * Adds a dependency to the 'testFixturesCompileOnlyApi' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesCompileOnlyApi`( + dependencyNotation: String, + dependencyConfiguration: Action +): ExternalModuleDependency = addDependencyTo( + this, "testFixturesCompileOnlyApi", dependencyNotation, dependencyConfiguration +) as ExternalModuleDependency + +/** + * Adds a dependency to the 'testFixturesCompileOnlyApi' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesCompileOnlyApi`( + dependencyNotation: Provider<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "testFixturesCompileOnlyApi", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testFixturesCompileOnlyApi' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesCompileOnlyApi`( + dependencyNotation: ProviderConvertible<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "testFixturesCompileOnlyApi", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testFixturesCompileOnlyApi' configuration. + * + * @param group the group of the module to be added as a dependency. + * @param name the name of the module to be added as a dependency. + * @param version the optional version of the module to be added as a dependency. + * @param configuration the optional configuration of the module to be added as a dependency. + * @param classifier the optional classifier of the module artifact to be added as a dependency. + * @param ext the optional extension of the module artifact to be added as a dependency. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.create] + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesCompileOnlyApi`( + group: String, + name: String, + version: String? = null, + configuration: String? = null, + classifier: String? = null, + ext: String? = null, + dependencyConfiguration: Action? = null +): ExternalModuleDependency = addExternalModuleDependencyTo( + this, "testFixturesCompileOnlyApi", group, name, version, configuration, classifier, ext, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testFixturesCompileOnlyApi' configuration. + * + * @param dependency dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesCompileOnlyApi`( + dependency: T, + dependencyConfiguration: T.() -> Unit +): T = add("testFixturesCompileOnlyApi", dependency, dependencyConfiguration) + +/** + * Adds a dependency constraint to the 'testFixturesCompileOnlyApi' configuration. + * + * @param constraintNotation the dependency constraint notation + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`testFixturesCompileOnlyApi`(constraintNotation: Any): DependencyConstraint = + add("testFixturesCompileOnlyApi", constraintNotation) + +/** + * Adds a dependency constraint to the 'testFixturesCompileOnlyApi' configuration. + * + * @param constraintNotation the dependency constraint notation + * @param block the block to use to configure the dependency constraint + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`testFixturesCompileOnlyApi`(constraintNotation: Any, block: DependencyConstraint.() -> Unit): DependencyConstraint = + add("testFixturesCompileOnlyApi", constraintNotation, block) + +/** + * Adds an artifact to the 'testFixturesCompileOnlyApi' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`testFixturesCompileOnlyApi`(artifactNotation: Any): PublishArtifact = + add("testFixturesCompileOnlyApi", artifactNotation) + +/** + * Adds an artifact to the 'testFixturesCompileOnlyApi' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @param configureAction The action to execute to configure the artifact. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`testFixturesCompileOnlyApi`( + artifactNotation: Any, + configureAction: ConfigurablePublishArtifact.() -> Unit +): PublishArtifact = + add("testFixturesCompileOnlyApi", artifactNotation, configureAction) + + + diff --git a/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestFixturesCompileOnlyConfigurationAccessors.kt b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestFixturesCompileOnlyConfigurationAccessors.kt new file mode 100644 index 00000000..13d4338a --- /dev/null +++ b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestFixturesCompileOnlyConfigurationAccessors.kt @@ -0,0 +1,213 @@ + +/* + * Copyright 2018 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +@file:Suppress( + "unused", + "nothing_to_inline", + "useless_cast", + "unchecked_cast", + "extension_shadowed_by_member", + "redundant_projection", + "RemoveRedundantBackticks", + "ObjectPropertyName", + "deprecation" +) +@file:org.gradle.api.Generated + +/* ktlint-disable */ + +package org.gradle.kotlin.dsl + + +import org.gradle.api.Action +import org.gradle.api.Incubating +import org.gradle.api.NamedDomainObjectProvider +import org.gradle.api.Project +import org.gradle.api.Task +import org.gradle.api.artifacts.Configuration +import org.gradle.api.artifacts.ConfigurablePublishArtifact +import org.gradle.api.artifacts.ConfigurationContainer +import org.gradle.api.artifacts.Dependency +import org.gradle.api.artifacts.DependencyConstraint +import org.gradle.api.artifacts.ExternalModuleDependency +import org.gradle.api.artifacts.ModuleDependency +import org.gradle.api.artifacts.PublishArtifact +import org.gradle.api.artifacts.dsl.ArtifactHandler +import org.gradle.api.artifacts.dsl.DependencyConstraintHandler +import org.gradle.api.artifacts.dsl.DependencyHandler +import org.gradle.api.provider.Provider +import org.gradle.api.provider.ProviderConvertible +import org.gradle.api.tasks.TaskContainer +import org.gradle.api.tasks.TaskProvider + +import org.gradle.kotlin.dsl.* +import org.gradle.kotlin.dsl.accessors.runtime.* + + +/** + * Adds a dependency to the 'testFixturesCompileOnly' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesCompileOnly`(dependencyNotation: Any): Dependency? = + add("testFixturesCompileOnly", dependencyNotation) + +/** + * Adds a dependency to the 'testFixturesCompileOnly' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesCompileOnly`( + dependencyNotation: String, + dependencyConfiguration: Action +): ExternalModuleDependency = addDependencyTo( + this, "testFixturesCompileOnly", dependencyNotation, dependencyConfiguration +) as ExternalModuleDependency + +/** + * Adds a dependency to the 'testFixturesCompileOnly' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesCompileOnly`( + dependencyNotation: Provider<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "testFixturesCompileOnly", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testFixturesCompileOnly' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesCompileOnly`( + dependencyNotation: ProviderConvertible<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "testFixturesCompileOnly", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testFixturesCompileOnly' configuration. + * + * @param group the group of the module to be added as a dependency. + * @param name the name of the module to be added as a dependency. + * @param version the optional version of the module to be added as a dependency. + * @param configuration the optional configuration of the module to be added as a dependency. + * @param classifier the optional classifier of the module artifact to be added as a dependency. + * @param ext the optional extension of the module artifact to be added as a dependency. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.create] + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesCompileOnly`( + group: String, + name: String, + version: String? = null, + configuration: String? = null, + classifier: String? = null, + ext: String? = null, + dependencyConfiguration: Action? = null +): ExternalModuleDependency = addExternalModuleDependencyTo( + this, "testFixturesCompileOnly", group, name, version, configuration, classifier, ext, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testFixturesCompileOnly' configuration. + * + * @param dependency dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesCompileOnly`( + dependency: T, + dependencyConfiguration: T.() -> Unit +): T = add("testFixturesCompileOnly", dependency, dependencyConfiguration) + +/** + * Adds a dependency constraint to the 'testFixturesCompileOnly' configuration. + * + * @param constraintNotation the dependency constraint notation + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`testFixturesCompileOnly`(constraintNotation: Any): DependencyConstraint = + add("testFixturesCompileOnly", constraintNotation) + +/** + * Adds a dependency constraint to the 'testFixturesCompileOnly' configuration. + * + * @param constraintNotation the dependency constraint notation + * @param block the block to use to configure the dependency constraint + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`testFixturesCompileOnly`(constraintNotation: Any, block: DependencyConstraint.() -> Unit): DependencyConstraint = + add("testFixturesCompileOnly", constraintNotation, block) + +/** + * Adds an artifact to the 'testFixturesCompileOnly' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`testFixturesCompileOnly`(artifactNotation: Any): PublishArtifact = + add("testFixturesCompileOnly", artifactNotation) + +/** + * Adds an artifact to the 'testFixturesCompileOnly' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @param configureAction The action to execute to configure the artifact. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`testFixturesCompileOnly`( + artifactNotation: Any, + configureAction: ConfigurablePublishArtifact.() -> Unit +): PublishArtifact = + add("testFixturesCompileOnly", artifactNotation, configureAction) + + + diff --git a/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestFixturesCompileOnlyDependenciesMetadataConfigurationAccessors.kt b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestFixturesCompileOnlyDependenciesMetadataConfigurationAccessors.kt new file mode 100644 index 00000000..c2368359 --- /dev/null +++ b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestFixturesCompileOnlyDependenciesMetadataConfigurationAccessors.kt @@ -0,0 +1,213 @@ + +/* + * Copyright 2018 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +@file:Suppress( + "unused", + "nothing_to_inline", + "useless_cast", + "unchecked_cast", + "extension_shadowed_by_member", + "redundant_projection", + "RemoveRedundantBackticks", + "ObjectPropertyName", + "deprecation" +) +@file:org.gradle.api.Generated + +/* ktlint-disable */ + +package org.gradle.kotlin.dsl + + +import org.gradle.api.Action +import org.gradle.api.Incubating +import org.gradle.api.NamedDomainObjectProvider +import org.gradle.api.Project +import org.gradle.api.Task +import org.gradle.api.artifacts.Configuration +import org.gradle.api.artifacts.ConfigurablePublishArtifact +import org.gradle.api.artifacts.ConfigurationContainer +import org.gradle.api.artifacts.Dependency +import org.gradle.api.artifacts.DependencyConstraint +import org.gradle.api.artifacts.ExternalModuleDependency +import org.gradle.api.artifacts.ModuleDependency +import org.gradle.api.artifacts.PublishArtifact +import org.gradle.api.artifacts.dsl.ArtifactHandler +import org.gradle.api.artifacts.dsl.DependencyConstraintHandler +import org.gradle.api.artifacts.dsl.DependencyHandler +import org.gradle.api.provider.Provider +import org.gradle.api.provider.ProviderConvertible +import org.gradle.api.tasks.TaskContainer +import org.gradle.api.tasks.TaskProvider + +import org.gradle.kotlin.dsl.* +import org.gradle.kotlin.dsl.accessors.runtime.* + + +/** + * Adds a dependency to the 'testFixturesCompileOnlyDependenciesMetadata' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesCompileOnlyDependenciesMetadata`(dependencyNotation: Any): Dependency? = + add("testFixturesCompileOnlyDependenciesMetadata", dependencyNotation) + +/** + * Adds a dependency to the 'testFixturesCompileOnlyDependenciesMetadata' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesCompileOnlyDependenciesMetadata`( + dependencyNotation: String, + dependencyConfiguration: Action +): ExternalModuleDependency = addDependencyTo( + this, "testFixturesCompileOnlyDependenciesMetadata", dependencyNotation, dependencyConfiguration +) as ExternalModuleDependency + +/** + * Adds a dependency to the 'testFixturesCompileOnlyDependenciesMetadata' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesCompileOnlyDependenciesMetadata`( + dependencyNotation: Provider<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "testFixturesCompileOnlyDependenciesMetadata", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testFixturesCompileOnlyDependenciesMetadata' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesCompileOnlyDependenciesMetadata`( + dependencyNotation: ProviderConvertible<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "testFixturesCompileOnlyDependenciesMetadata", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testFixturesCompileOnlyDependenciesMetadata' configuration. + * + * @param group the group of the module to be added as a dependency. + * @param name the name of the module to be added as a dependency. + * @param version the optional version of the module to be added as a dependency. + * @param configuration the optional configuration of the module to be added as a dependency. + * @param classifier the optional classifier of the module artifact to be added as a dependency. + * @param ext the optional extension of the module artifact to be added as a dependency. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.create] + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesCompileOnlyDependenciesMetadata`( + group: String, + name: String, + version: String? = null, + configuration: String? = null, + classifier: String? = null, + ext: String? = null, + dependencyConfiguration: Action? = null +): ExternalModuleDependency = addExternalModuleDependencyTo( + this, "testFixturesCompileOnlyDependenciesMetadata", group, name, version, configuration, classifier, ext, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testFixturesCompileOnlyDependenciesMetadata' configuration. + * + * @param dependency dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesCompileOnlyDependenciesMetadata`( + dependency: T, + dependencyConfiguration: T.() -> Unit +): T = add("testFixturesCompileOnlyDependenciesMetadata", dependency, dependencyConfiguration) + +/** + * Adds a dependency constraint to the 'testFixturesCompileOnlyDependenciesMetadata' configuration. + * + * @param constraintNotation the dependency constraint notation + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`testFixturesCompileOnlyDependenciesMetadata`(constraintNotation: Any): DependencyConstraint = + add("testFixturesCompileOnlyDependenciesMetadata", constraintNotation) + +/** + * Adds a dependency constraint to the 'testFixturesCompileOnlyDependenciesMetadata' configuration. + * + * @param constraintNotation the dependency constraint notation + * @param block the block to use to configure the dependency constraint + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`testFixturesCompileOnlyDependenciesMetadata`(constraintNotation: Any, block: DependencyConstraint.() -> Unit): DependencyConstraint = + add("testFixturesCompileOnlyDependenciesMetadata", constraintNotation, block) + +/** + * Adds an artifact to the 'testFixturesCompileOnlyDependenciesMetadata' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`testFixturesCompileOnlyDependenciesMetadata`(artifactNotation: Any): PublishArtifact = + add("testFixturesCompileOnlyDependenciesMetadata", artifactNotation) + +/** + * Adds an artifact to the 'testFixturesCompileOnlyDependenciesMetadata' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @param configureAction The action to execute to configure the artifact. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`testFixturesCompileOnlyDependenciesMetadata`( + artifactNotation: Any, + configureAction: ConfigurablePublishArtifact.() -> Unit +): PublishArtifact = + add("testFixturesCompileOnlyDependenciesMetadata", artifactNotation, configureAction) + + + diff --git a/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestFixturesDebugAnnotationProcessorConfigurationAccessors.kt b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestFixturesDebugAnnotationProcessorConfigurationAccessors.kt new file mode 100644 index 00000000..8c2a15fb --- /dev/null +++ b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestFixturesDebugAnnotationProcessorConfigurationAccessors.kt @@ -0,0 +1,213 @@ + +/* + * Copyright 2018 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +@file:Suppress( + "unused", + "nothing_to_inline", + "useless_cast", + "unchecked_cast", + "extension_shadowed_by_member", + "redundant_projection", + "RemoveRedundantBackticks", + "ObjectPropertyName", + "deprecation" +) +@file:org.gradle.api.Generated + +/* ktlint-disable */ + +package org.gradle.kotlin.dsl + + +import org.gradle.api.Action +import org.gradle.api.Incubating +import org.gradle.api.NamedDomainObjectProvider +import org.gradle.api.Project +import org.gradle.api.Task +import org.gradle.api.artifacts.Configuration +import org.gradle.api.artifacts.ConfigurablePublishArtifact +import org.gradle.api.artifacts.ConfigurationContainer +import org.gradle.api.artifacts.Dependency +import org.gradle.api.artifacts.DependencyConstraint +import org.gradle.api.artifacts.ExternalModuleDependency +import org.gradle.api.artifacts.ModuleDependency +import org.gradle.api.artifacts.PublishArtifact +import org.gradle.api.artifacts.dsl.ArtifactHandler +import org.gradle.api.artifacts.dsl.DependencyConstraintHandler +import org.gradle.api.artifacts.dsl.DependencyHandler +import org.gradle.api.provider.Provider +import org.gradle.api.provider.ProviderConvertible +import org.gradle.api.tasks.TaskContainer +import org.gradle.api.tasks.TaskProvider + +import org.gradle.kotlin.dsl.* +import org.gradle.kotlin.dsl.accessors.runtime.* + + +/** + * Adds a dependency to the 'testFixturesDebugAnnotationProcessor' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesDebugAnnotationProcessor`(dependencyNotation: Any): Dependency? = + add("testFixturesDebugAnnotationProcessor", dependencyNotation) + +/** + * Adds a dependency to the 'testFixturesDebugAnnotationProcessor' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesDebugAnnotationProcessor`( + dependencyNotation: String, + dependencyConfiguration: Action +): ExternalModuleDependency = addDependencyTo( + this, "testFixturesDebugAnnotationProcessor", dependencyNotation, dependencyConfiguration +) as ExternalModuleDependency + +/** + * Adds a dependency to the 'testFixturesDebugAnnotationProcessor' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesDebugAnnotationProcessor`( + dependencyNotation: Provider<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "testFixturesDebugAnnotationProcessor", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testFixturesDebugAnnotationProcessor' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesDebugAnnotationProcessor`( + dependencyNotation: ProviderConvertible<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "testFixturesDebugAnnotationProcessor", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testFixturesDebugAnnotationProcessor' configuration. + * + * @param group the group of the module to be added as a dependency. + * @param name the name of the module to be added as a dependency. + * @param version the optional version of the module to be added as a dependency. + * @param configuration the optional configuration of the module to be added as a dependency. + * @param classifier the optional classifier of the module artifact to be added as a dependency. + * @param ext the optional extension of the module artifact to be added as a dependency. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.create] + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesDebugAnnotationProcessor`( + group: String, + name: String, + version: String? = null, + configuration: String? = null, + classifier: String? = null, + ext: String? = null, + dependencyConfiguration: Action? = null +): ExternalModuleDependency = addExternalModuleDependencyTo( + this, "testFixturesDebugAnnotationProcessor", group, name, version, configuration, classifier, ext, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testFixturesDebugAnnotationProcessor' configuration. + * + * @param dependency dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesDebugAnnotationProcessor`( + dependency: T, + dependencyConfiguration: T.() -> Unit +): T = add("testFixturesDebugAnnotationProcessor", dependency, dependencyConfiguration) + +/** + * Adds a dependency constraint to the 'testFixturesDebugAnnotationProcessor' configuration. + * + * @param constraintNotation the dependency constraint notation + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`testFixturesDebugAnnotationProcessor`(constraintNotation: Any): DependencyConstraint = + add("testFixturesDebugAnnotationProcessor", constraintNotation) + +/** + * Adds a dependency constraint to the 'testFixturesDebugAnnotationProcessor' configuration. + * + * @param constraintNotation the dependency constraint notation + * @param block the block to use to configure the dependency constraint + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`testFixturesDebugAnnotationProcessor`(constraintNotation: Any, block: DependencyConstraint.() -> Unit): DependencyConstraint = + add("testFixturesDebugAnnotationProcessor", constraintNotation, block) + +/** + * Adds an artifact to the 'testFixturesDebugAnnotationProcessor' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`testFixturesDebugAnnotationProcessor`(artifactNotation: Any): PublishArtifact = + add("testFixturesDebugAnnotationProcessor", artifactNotation) + +/** + * Adds an artifact to the 'testFixturesDebugAnnotationProcessor' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @param configureAction The action to execute to configure the artifact. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`testFixturesDebugAnnotationProcessor`( + artifactNotation: Any, + configureAction: ConfigurablePublishArtifact.() -> Unit +): PublishArtifact = + add("testFixturesDebugAnnotationProcessor", artifactNotation, configureAction) + + + diff --git a/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestFixturesDebugApiConfigurationAccessors.kt b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestFixturesDebugApiConfigurationAccessors.kt new file mode 100644 index 00000000..998da2af --- /dev/null +++ b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestFixturesDebugApiConfigurationAccessors.kt @@ -0,0 +1,213 @@ + +/* + * Copyright 2018 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +@file:Suppress( + "unused", + "nothing_to_inline", + "useless_cast", + "unchecked_cast", + "extension_shadowed_by_member", + "redundant_projection", + "RemoveRedundantBackticks", + "ObjectPropertyName", + "deprecation" +) +@file:org.gradle.api.Generated + +/* ktlint-disable */ + +package org.gradle.kotlin.dsl + + +import org.gradle.api.Action +import org.gradle.api.Incubating +import org.gradle.api.NamedDomainObjectProvider +import org.gradle.api.Project +import org.gradle.api.Task +import org.gradle.api.artifacts.Configuration +import org.gradle.api.artifacts.ConfigurablePublishArtifact +import org.gradle.api.artifacts.ConfigurationContainer +import org.gradle.api.artifacts.Dependency +import org.gradle.api.artifacts.DependencyConstraint +import org.gradle.api.artifacts.ExternalModuleDependency +import org.gradle.api.artifacts.ModuleDependency +import org.gradle.api.artifacts.PublishArtifact +import org.gradle.api.artifacts.dsl.ArtifactHandler +import org.gradle.api.artifacts.dsl.DependencyConstraintHandler +import org.gradle.api.artifacts.dsl.DependencyHandler +import org.gradle.api.provider.Provider +import org.gradle.api.provider.ProviderConvertible +import org.gradle.api.tasks.TaskContainer +import org.gradle.api.tasks.TaskProvider + +import org.gradle.kotlin.dsl.* +import org.gradle.kotlin.dsl.accessors.runtime.* + + +/** + * Adds a dependency to the 'testFixturesDebugApi' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesDebugApi`(dependencyNotation: Any): Dependency? = + add("testFixturesDebugApi", dependencyNotation) + +/** + * Adds a dependency to the 'testFixturesDebugApi' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesDebugApi`( + dependencyNotation: String, + dependencyConfiguration: Action +): ExternalModuleDependency = addDependencyTo( + this, "testFixturesDebugApi", dependencyNotation, dependencyConfiguration +) as ExternalModuleDependency + +/** + * Adds a dependency to the 'testFixturesDebugApi' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesDebugApi`( + dependencyNotation: Provider<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "testFixturesDebugApi", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testFixturesDebugApi' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesDebugApi`( + dependencyNotation: ProviderConvertible<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "testFixturesDebugApi", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testFixturesDebugApi' configuration. + * + * @param group the group of the module to be added as a dependency. + * @param name the name of the module to be added as a dependency. + * @param version the optional version of the module to be added as a dependency. + * @param configuration the optional configuration of the module to be added as a dependency. + * @param classifier the optional classifier of the module artifact to be added as a dependency. + * @param ext the optional extension of the module artifact to be added as a dependency. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.create] + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesDebugApi`( + group: String, + name: String, + version: String? = null, + configuration: String? = null, + classifier: String? = null, + ext: String? = null, + dependencyConfiguration: Action? = null +): ExternalModuleDependency = addExternalModuleDependencyTo( + this, "testFixturesDebugApi", group, name, version, configuration, classifier, ext, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testFixturesDebugApi' configuration. + * + * @param dependency dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesDebugApi`( + dependency: T, + dependencyConfiguration: T.() -> Unit +): T = add("testFixturesDebugApi", dependency, dependencyConfiguration) + +/** + * Adds a dependency constraint to the 'testFixturesDebugApi' configuration. + * + * @param constraintNotation the dependency constraint notation + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`testFixturesDebugApi`(constraintNotation: Any): DependencyConstraint = + add("testFixturesDebugApi", constraintNotation) + +/** + * Adds a dependency constraint to the 'testFixturesDebugApi' configuration. + * + * @param constraintNotation the dependency constraint notation + * @param block the block to use to configure the dependency constraint + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`testFixturesDebugApi`(constraintNotation: Any, block: DependencyConstraint.() -> Unit): DependencyConstraint = + add("testFixturesDebugApi", constraintNotation, block) + +/** + * Adds an artifact to the 'testFixturesDebugApi' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`testFixturesDebugApi`(artifactNotation: Any): PublishArtifact = + add("testFixturesDebugApi", artifactNotation) + +/** + * Adds an artifact to the 'testFixturesDebugApi' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @param configureAction The action to execute to configure the artifact. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`testFixturesDebugApi`( + artifactNotation: Any, + configureAction: ConfigurablePublishArtifact.() -> Unit +): PublishArtifact = + add("testFixturesDebugApi", artifactNotation, configureAction) + + + diff --git a/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestFixturesDebugApiDependenciesMetadataConfigurationAccessors.kt b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestFixturesDebugApiDependenciesMetadataConfigurationAccessors.kt new file mode 100644 index 00000000..2929efc8 --- /dev/null +++ b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestFixturesDebugApiDependenciesMetadataConfigurationAccessors.kt @@ -0,0 +1,213 @@ + +/* + * Copyright 2018 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +@file:Suppress( + "unused", + "nothing_to_inline", + "useless_cast", + "unchecked_cast", + "extension_shadowed_by_member", + "redundant_projection", + "RemoveRedundantBackticks", + "ObjectPropertyName", + "deprecation" +) +@file:org.gradle.api.Generated + +/* ktlint-disable */ + +package org.gradle.kotlin.dsl + + +import org.gradle.api.Action +import org.gradle.api.Incubating +import org.gradle.api.NamedDomainObjectProvider +import org.gradle.api.Project +import org.gradle.api.Task +import org.gradle.api.artifacts.Configuration +import org.gradle.api.artifacts.ConfigurablePublishArtifact +import org.gradle.api.artifacts.ConfigurationContainer +import org.gradle.api.artifacts.Dependency +import org.gradle.api.artifacts.DependencyConstraint +import org.gradle.api.artifacts.ExternalModuleDependency +import org.gradle.api.artifacts.ModuleDependency +import org.gradle.api.artifacts.PublishArtifact +import org.gradle.api.artifacts.dsl.ArtifactHandler +import org.gradle.api.artifacts.dsl.DependencyConstraintHandler +import org.gradle.api.artifacts.dsl.DependencyHandler +import org.gradle.api.provider.Provider +import org.gradle.api.provider.ProviderConvertible +import org.gradle.api.tasks.TaskContainer +import org.gradle.api.tasks.TaskProvider + +import org.gradle.kotlin.dsl.* +import org.gradle.kotlin.dsl.accessors.runtime.* + + +/** + * Adds a dependency to the 'testFixturesDebugApiDependenciesMetadata' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesDebugApiDependenciesMetadata`(dependencyNotation: Any): Dependency? = + add("testFixturesDebugApiDependenciesMetadata", dependencyNotation) + +/** + * Adds a dependency to the 'testFixturesDebugApiDependenciesMetadata' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesDebugApiDependenciesMetadata`( + dependencyNotation: String, + dependencyConfiguration: Action +): ExternalModuleDependency = addDependencyTo( + this, "testFixturesDebugApiDependenciesMetadata", dependencyNotation, dependencyConfiguration +) as ExternalModuleDependency + +/** + * Adds a dependency to the 'testFixturesDebugApiDependenciesMetadata' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesDebugApiDependenciesMetadata`( + dependencyNotation: Provider<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "testFixturesDebugApiDependenciesMetadata", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testFixturesDebugApiDependenciesMetadata' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesDebugApiDependenciesMetadata`( + dependencyNotation: ProviderConvertible<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "testFixturesDebugApiDependenciesMetadata", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testFixturesDebugApiDependenciesMetadata' configuration. + * + * @param group the group of the module to be added as a dependency. + * @param name the name of the module to be added as a dependency. + * @param version the optional version of the module to be added as a dependency. + * @param configuration the optional configuration of the module to be added as a dependency. + * @param classifier the optional classifier of the module artifact to be added as a dependency. + * @param ext the optional extension of the module artifact to be added as a dependency. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.create] + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesDebugApiDependenciesMetadata`( + group: String, + name: String, + version: String? = null, + configuration: String? = null, + classifier: String? = null, + ext: String? = null, + dependencyConfiguration: Action? = null +): ExternalModuleDependency = addExternalModuleDependencyTo( + this, "testFixturesDebugApiDependenciesMetadata", group, name, version, configuration, classifier, ext, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testFixturesDebugApiDependenciesMetadata' configuration. + * + * @param dependency dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesDebugApiDependenciesMetadata`( + dependency: T, + dependencyConfiguration: T.() -> Unit +): T = add("testFixturesDebugApiDependenciesMetadata", dependency, dependencyConfiguration) + +/** + * Adds a dependency constraint to the 'testFixturesDebugApiDependenciesMetadata' configuration. + * + * @param constraintNotation the dependency constraint notation + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`testFixturesDebugApiDependenciesMetadata`(constraintNotation: Any): DependencyConstraint = + add("testFixturesDebugApiDependenciesMetadata", constraintNotation) + +/** + * Adds a dependency constraint to the 'testFixturesDebugApiDependenciesMetadata' configuration. + * + * @param constraintNotation the dependency constraint notation + * @param block the block to use to configure the dependency constraint + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`testFixturesDebugApiDependenciesMetadata`(constraintNotation: Any, block: DependencyConstraint.() -> Unit): DependencyConstraint = + add("testFixturesDebugApiDependenciesMetadata", constraintNotation, block) + +/** + * Adds an artifact to the 'testFixturesDebugApiDependenciesMetadata' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`testFixturesDebugApiDependenciesMetadata`(artifactNotation: Any): PublishArtifact = + add("testFixturesDebugApiDependenciesMetadata", artifactNotation) + +/** + * Adds an artifact to the 'testFixturesDebugApiDependenciesMetadata' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @param configureAction The action to execute to configure the artifact. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`testFixturesDebugApiDependenciesMetadata`( + artifactNotation: Any, + configureAction: ConfigurablePublishArtifact.() -> Unit +): PublishArtifact = + add("testFixturesDebugApiDependenciesMetadata", artifactNotation, configureAction) + + + diff --git a/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestFixturesDebugCompileOnlyApiConfigurationAccessors.kt b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestFixturesDebugCompileOnlyApiConfigurationAccessors.kt new file mode 100644 index 00000000..3409be01 --- /dev/null +++ b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestFixturesDebugCompileOnlyApiConfigurationAccessors.kt @@ -0,0 +1,213 @@ + +/* + * Copyright 2018 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +@file:Suppress( + "unused", + "nothing_to_inline", + "useless_cast", + "unchecked_cast", + "extension_shadowed_by_member", + "redundant_projection", + "RemoveRedundantBackticks", + "ObjectPropertyName", + "deprecation" +) +@file:org.gradle.api.Generated + +/* ktlint-disable */ + +package org.gradle.kotlin.dsl + + +import org.gradle.api.Action +import org.gradle.api.Incubating +import org.gradle.api.NamedDomainObjectProvider +import org.gradle.api.Project +import org.gradle.api.Task +import org.gradle.api.artifacts.Configuration +import org.gradle.api.artifacts.ConfigurablePublishArtifact +import org.gradle.api.artifacts.ConfigurationContainer +import org.gradle.api.artifacts.Dependency +import org.gradle.api.artifacts.DependencyConstraint +import org.gradle.api.artifacts.ExternalModuleDependency +import org.gradle.api.artifacts.ModuleDependency +import org.gradle.api.artifacts.PublishArtifact +import org.gradle.api.artifacts.dsl.ArtifactHandler +import org.gradle.api.artifacts.dsl.DependencyConstraintHandler +import org.gradle.api.artifacts.dsl.DependencyHandler +import org.gradle.api.provider.Provider +import org.gradle.api.provider.ProviderConvertible +import org.gradle.api.tasks.TaskContainer +import org.gradle.api.tasks.TaskProvider + +import org.gradle.kotlin.dsl.* +import org.gradle.kotlin.dsl.accessors.runtime.* + + +/** + * Adds a dependency to the 'testFixturesDebugCompileOnlyApi' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesDebugCompileOnlyApi`(dependencyNotation: Any): Dependency? = + add("testFixturesDebugCompileOnlyApi", dependencyNotation) + +/** + * Adds a dependency to the 'testFixturesDebugCompileOnlyApi' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesDebugCompileOnlyApi`( + dependencyNotation: String, + dependencyConfiguration: Action +): ExternalModuleDependency = addDependencyTo( + this, "testFixturesDebugCompileOnlyApi", dependencyNotation, dependencyConfiguration +) as ExternalModuleDependency + +/** + * Adds a dependency to the 'testFixturesDebugCompileOnlyApi' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesDebugCompileOnlyApi`( + dependencyNotation: Provider<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "testFixturesDebugCompileOnlyApi", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testFixturesDebugCompileOnlyApi' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesDebugCompileOnlyApi`( + dependencyNotation: ProviderConvertible<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "testFixturesDebugCompileOnlyApi", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testFixturesDebugCompileOnlyApi' configuration. + * + * @param group the group of the module to be added as a dependency. + * @param name the name of the module to be added as a dependency. + * @param version the optional version of the module to be added as a dependency. + * @param configuration the optional configuration of the module to be added as a dependency. + * @param classifier the optional classifier of the module artifact to be added as a dependency. + * @param ext the optional extension of the module artifact to be added as a dependency. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.create] + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesDebugCompileOnlyApi`( + group: String, + name: String, + version: String? = null, + configuration: String? = null, + classifier: String? = null, + ext: String? = null, + dependencyConfiguration: Action? = null +): ExternalModuleDependency = addExternalModuleDependencyTo( + this, "testFixturesDebugCompileOnlyApi", group, name, version, configuration, classifier, ext, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testFixturesDebugCompileOnlyApi' configuration. + * + * @param dependency dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesDebugCompileOnlyApi`( + dependency: T, + dependencyConfiguration: T.() -> Unit +): T = add("testFixturesDebugCompileOnlyApi", dependency, dependencyConfiguration) + +/** + * Adds a dependency constraint to the 'testFixturesDebugCompileOnlyApi' configuration. + * + * @param constraintNotation the dependency constraint notation + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`testFixturesDebugCompileOnlyApi`(constraintNotation: Any): DependencyConstraint = + add("testFixturesDebugCompileOnlyApi", constraintNotation) + +/** + * Adds a dependency constraint to the 'testFixturesDebugCompileOnlyApi' configuration. + * + * @param constraintNotation the dependency constraint notation + * @param block the block to use to configure the dependency constraint + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`testFixturesDebugCompileOnlyApi`(constraintNotation: Any, block: DependencyConstraint.() -> Unit): DependencyConstraint = + add("testFixturesDebugCompileOnlyApi", constraintNotation, block) + +/** + * Adds an artifact to the 'testFixturesDebugCompileOnlyApi' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`testFixturesDebugCompileOnlyApi`(artifactNotation: Any): PublishArtifact = + add("testFixturesDebugCompileOnlyApi", artifactNotation) + +/** + * Adds an artifact to the 'testFixturesDebugCompileOnlyApi' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @param configureAction The action to execute to configure the artifact. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`testFixturesDebugCompileOnlyApi`( + artifactNotation: Any, + configureAction: ConfigurablePublishArtifact.() -> Unit +): PublishArtifact = + add("testFixturesDebugCompileOnlyApi", artifactNotation, configureAction) + + + diff --git a/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestFixturesDebugCompileOnlyConfigurationAccessors.kt b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestFixturesDebugCompileOnlyConfigurationAccessors.kt new file mode 100644 index 00000000..d9369012 --- /dev/null +++ b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestFixturesDebugCompileOnlyConfigurationAccessors.kt @@ -0,0 +1,213 @@ + +/* + * Copyright 2018 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +@file:Suppress( + "unused", + "nothing_to_inline", + "useless_cast", + "unchecked_cast", + "extension_shadowed_by_member", + "redundant_projection", + "RemoveRedundantBackticks", + "ObjectPropertyName", + "deprecation" +) +@file:org.gradle.api.Generated + +/* ktlint-disable */ + +package org.gradle.kotlin.dsl + + +import org.gradle.api.Action +import org.gradle.api.Incubating +import org.gradle.api.NamedDomainObjectProvider +import org.gradle.api.Project +import org.gradle.api.Task +import org.gradle.api.artifacts.Configuration +import org.gradle.api.artifacts.ConfigurablePublishArtifact +import org.gradle.api.artifacts.ConfigurationContainer +import org.gradle.api.artifacts.Dependency +import org.gradle.api.artifacts.DependencyConstraint +import org.gradle.api.artifacts.ExternalModuleDependency +import org.gradle.api.artifacts.ModuleDependency +import org.gradle.api.artifacts.PublishArtifact +import org.gradle.api.artifacts.dsl.ArtifactHandler +import org.gradle.api.artifacts.dsl.DependencyConstraintHandler +import org.gradle.api.artifacts.dsl.DependencyHandler +import org.gradle.api.provider.Provider +import org.gradle.api.provider.ProviderConvertible +import org.gradle.api.tasks.TaskContainer +import org.gradle.api.tasks.TaskProvider + +import org.gradle.kotlin.dsl.* +import org.gradle.kotlin.dsl.accessors.runtime.* + + +/** + * Adds a dependency to the 'testFixturesDebugCompileOnly' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesDebugCompileOnly`(dependencyNotation: Any): Dependency? = + add("testFixturesDebugCompileOnly", dependencyNotation) + +/** + * Adds a dependency to the 'testFixturesDebugCompileOnly' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesDebugCompileOnly`( + dependencyNotation: String, + dependencyConfiguration: Action +): ExternalModuleDependency = addDependencyTo( + this, "testFixturesDebugCompileOnly", dependencyNotation, dependencyConfiguration +) as ExternalModuleDependency + +/** + * Adds a dependency to the 'testFixturesDebugCompileOnly' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesDebugCompileOnly`( + dependencyNotation: Provider<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "testFixturesDebugCompileOnly", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testFixturesDebugCompileOnly' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesDebugCompileOnly`( + dependencyNotation: ProviderConvertible<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "testFixturesDebugCompileOnly", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testFixturesDebugCompileOnly' configuration. + * + * @param group the group of the module to be added as a dependency. + * @param name the name of the module to be added as a dependency. + * @param version the optional version of the module to be added as a dependency. + * @param configuration the optional configuration of the module to be added as a dependency. + * @param classifier the optional classifier of the module artifact to be added as a dependency. + * @param ext the optional extension of the module artifact to be added as a dependency. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.create] + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesDebugCompileOnly`( + group: String, + name: String, + version: String? = null, + configuration: String? = null, + classifier: String? = null, + ext: String? = null, + dependencyConfiguration: Action? = null +): ExternalModuleDependency = addExternalModuleDependencyTo( + this, "testFixturesDebugCompileOnly", group, name, version, configuration, classifier, ext, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testFixturesDebugCompileOnly' configuration. + * + * @param dependency dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesDebugCompileOnly`( + dependency: T, + dependencyConfiguration: T.() -> Unit +): T = add("testFixturesDebugCompileOnly", dependency, dependencyConfiguration) + +/** + * Adds a dependency constraint to the 'testFixturesDebugCompileOnly' configuration. + * + * @param constraintNotation the dependency constraint notation + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`testFixturesDebugCompileOnly`(constraintNotation: Any): DependencyConstraint = + add("testFixturesDebugCompileOnly", constraintNotation) + +/** + * Adds a dependency constraint to the 'testFixturesDebugCompileOnly' configuration. + * + * @param constraintNotation the dependency constraint notation + * @param block the block to use to configure the dependency constraint + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`testFixturesDebugCompileOnly`(constraintNotation: Any, block: DependencyConstraint.() -> Unit): DependencyConstraint = + add("testFixturesDebugCompileOnly", constraintNotation, block) + +/** + * Adds an artifact to the 'testFixturesDebugCompileOnly' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`testFixturesDebugCompileOnly`(artifactNotation: Any): PublishArtifact = + add("testFixturesDebugCompileOnly", artifactNotation) + +/** + * Adds an artifact to the 'testFixturesDebugCompileOnly' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @param configureAction The action to execute to configure the artifact. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`testFixturesDebugCompileOnly`( + artifactNotation: Any, + configureAction: ConfigurablePublishArtifact.() -> Unit +): PublishArtifact = + add("testFixturesDebugCompileOnly", artifactNotation, configureAction) + + + diff --git a/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestFixturesDebugCompileOnlyDependenciesMetadataConfigurationAccessors.kt b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestFixturesDebugCompileOnlyDependenciesMetadataConfigurationAccessors.kt new file mode 100644 index 00000000..04dff5b0 --- /dev/null +++ b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestFixturesDebugCompileOnlyDependenciesMetadataConfigurationAccessors.kt @@ -0,0 +1,213 @@ + +/* + * Copyright 2018 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +@file:Suppress( + "unused", + "nothing_to_inline", + "useless_cast", + "unchecked_cast", + "extension_shadowed_by_member", + "redundant_projection", + "RemoveRedundantBackticks", + "ObjectPropertyName", + "deprecation" +) +@file:org.gradle.api.Generated + +/* ktlint-disable */ + +package org.gradle.kotlin.dsl + + +import org.gradle.api.Action +import org.gradle.api.Incubating +import org.gradle.api.NamedDomainObjectProvider +import org.gradle.api.Project +import org.gradle.api.Task +import org.gradle.api.artifacts.Configuration +import org.gradle.api.artifacts.ConfigurablePublishArtifact +import org.gradle.api.artifacts.ConfigurationContainer +import org.gradle.api.artifacts.Dependency +import org.gradle.api.artifacts.DependencyConstraint +import org.gradle.api.artifacts.ExternalModuleDependency +import org.gradle.api.artifacts.ModuleDependency +import org.gradle.api.artifacts.PublishArtifact +import org.gradle.api.artifacts.dsl.ArtifactHandler +import org.gradle.api.artifacts.dsl.DependencyConstraintHandler +import org.gradle.api.artifacts.dsl.DependencyHandler +import org.gradle.api.provider.Provider +import org.gradle.api.provider.ProviderConvertible +import org.gradle.api.tasks.TaskContainer +import org.gradle.api.tasks.TaskProvider + +import org.gradle.kotlin.dsl.* +import org.gradle.kotlin.dsl.accessors.runtime.* + + +/** + * Adds a dependency to the 'testFixturesDebugCompileOnlyDependenciesMetadata' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesDebugCompileOnlyDependenciesMetadata`(dependencyNotation: Any): Dependency? = + add("testFixturesDebugCompileOnlyDependenciesMetadata", dependencyNotation) + +/** + * Adds a dependency to the 'testFixturesDebugCompileOnlyDependenciesMetadata' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesDebugCompileOnlyDependenciesMetadata`( + dependencyNotation: String, + dependencyConfiguration: Action +): ExternalModuleDependency = addDependencyTo( + this, "testFixturesDebugCompileOnlyDependenciesMetadata", dependencyNotation, dependencyConfiguration +) as ExternalModuleDependency + +/** + * Adds a dependency to the 'testFixturesDebugCompileOnlyDependenciesMetadata' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesDebugCompileOnlyDependenciesMetadata`( + dependencyNotation: Provider<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "testFixturesDebugCompileOnlyDependenciesMetadata", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testFixturesDebugCompileOnlyDependenciesMetadata' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesDebugCompileOnlyDependenciesMetadata`( + dependencyNotation: ProviderConvertible<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "testFixturesDebugCompileOnlyDependenciesMetadata", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testFixturesDebugCompileOnlyDependenciesMetadata' configuration. + * + * @param group the group of the module to be added as a dependency. + * @param name the name of the module to be added as a dependency. + * @param version the optional version of the module to be added as a dependency. + * @param configuration the optional configuration of the module to be added as a dependency. + * @param classifier the optional classifier of the module artifact to be added as a dependency. + * @param ext the optional extension of the module artifact to be added as a dependency. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.create] + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesDebugCompileOnlyDependenciesMetadata`( + group: String, + name: String, + version: String? = null, + configuration: String? = null, + classifier: String? = null, + ext: String? = null, + dependencyConfiguration: Action? = null +): ExternalModuleDependency = addExternalModuleDependencyTo( + this, "testFixturesDebugCompileOnlyDependenciesMetadata", group, name, version, configuration, classifier, ext, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testFixturesDebugCompileOnlyDependenciesMetadata' configuration. + * + * @param dependency dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesDebugCompileOnlyDependenciesMetadata`( + dependency: T, + dependencyConfiguration: T.() -> Unit +): T = add("testFixturesDebugCompileOnlyDependenciesMetadata", dependency, dependencyConfiguration) + +/** + * Adds a dependency constraint to the 'testFixturesDebugCompileOnlyDependenciesMetadata' configuration. + * + * @param constraintNotation the dependency constraint notation + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`testFixturesDebugCompileOnlyDependenciesMetadata`(constraintNotation: Any): DependencyConstraint = + add("testFixturesDebugCompileOnlyDependenciesMetadata", constraintNotation) + +/** + * Adds a dependency constraint to the 'testFixturesDebugCompileOnlyDependenciesMetadata' configuration. + * + * @param constraintNotation the dependency constraint notation + * @param block the block to use to configure the dependency constraint + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`testFixturesDebugCompileOnlyDependenciesMetadata`(constraintNotation: Any, block: DependencyConstraint.() -> Unit): DependencyConstraint = + add("testFixturesDebugCompileOnlyDependenciesMetadata", constraintNotation, block) + +/** + * Adds an artifact to the 'testFixturesDebugCompileOnlyDependenciesMetadata' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`testFixturesDebugCompileOnlyDependenciesMetadata`(artifactNotation: Any): PublishArtifact = + add("testFixturesDebugCompileOnlyDependenciesMetadata", artifactNotation) + +/** + * Adds an artifact to the 'testFixturesDebugCompileOnlyDependenciesMetadata' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @param configureAction The action to execute to configure the artifact. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`testFixturesDebugCompileOnlyDependenciesMetadata`( + artifactNotation: Any, + configureAction: ConfigurablePublishArtifact.() -> Unit +): PublishArtifact = + add("testFixturesDebugCompileOnlyDependenciesMetadata", artifactNotation, configureAction) + + + diff --git a/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestFixturesDebugImplementationConfigurationAccessors.kt b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestFixturesDebugImplementationConfigurationAccessors.kt new file mode 100644 index 00000000..644e325b --- /dev/null +++ b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestFixturesDebugImplementationConfigurationAccessors.kt @@ -0,0 +1,213 @@ + +/* + * Copyright 2018 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +@file:Suppress( + "unused", + "nothing_to_inline", + "useless_cast", + "unchecked_cast", + "extension_shadowed_by_member", + "redundant_projection", + "RemoveRedundantBackticks", + "ObjectPropertyName", + "deprecation" +) +@file:org.gradle.api.Generated + +/* ktlint-disable */ + +package org.gradle.kotlin.dsl + + +import org.gradle.api.Action +import org.gradle.api.Incubating +import org.gradle.api.NamedDomainObjectProvider +import org.gradle.api.Project +import org.gradle.api.Task +import org.gradle.api.artifacts.Configuration +import org.gradle.api.artifacts.ConfigurablePublishArtifact +import org.gradle.api.artifacts.ConfigurationContainer +import org.gradle.api.artifacts.Dependency +import org.gradle.api.artifacts.DependencyConstraint +import org.gradle.api.artifacts.ExternalModuleDependency +import org.gradle.api.artifacts.ModuleDependency +import org.gradle.api.artifacts.PublishArtifact +import org.gradle.api.artifacts.dsl.ArtifactHandler +import org.gradle.api.artifacts.dsl.DependencyConstraintHandler +import org.gradle.api.artifacts.dsl.DependencyHandler +import org.gradle.api.provider.Provider +import org.gradle.api.provider.ProviderConvertible +import org.gradle.api.tasks.TaskContainer +import org.gradle.api.tasks.TaskProvider + +import org.gradle.kotlin.dsl.* +import org.gradle.kotlin.dsl.accessors.runtime.* + + +/** + * Adds a dependency to the 'testFixturesDebugImplementation' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesDebugImplementation`(dependencyNotation: Any): Dependency? = + add("testFixturesDebugImplementation", dependencyNotation) + +/** + * Adds a dependency to the 'testFixturesDebugImplementation' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesDebugImplementation`( + dependencyNotation: String, + dependencyConfiguration: Action +): ExternalModuleDependency = addDependencyTo( + this, "testFixturesDebugImplementation", dependencyNotation, dependencyConfiguration +) as ExternalModuleDependency + +/** + * Adds a dependency to the 'testFixturesDebugImplementation' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesDebugImplementation`( + dependencyNotation: Provider<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "testFixturesDebugImplementation", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testFixturesDebugImplementation' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesDebugImplementation`( + dependencyNotation: ProviderConvertible<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "testFixturesDebugImplementation", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testFixturesDebugImplementation' configuration. + * + * @param group the group of the module to be added as a dependency. + * @param name the name of the module to be added as a dependency. + * @param version the optional version of the module to be added as a dependency. + * @param configuration the optional configuration of the module to be added as a dependency. + * @param classifier the optional classifier of the module artifact to be added as a dependency. + * @param ext the optional extension of the module artifact to be added as a dependency. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.create] + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesDebugImplementation`( + group: String, + name: String, + version: String? = null, + configuration: String? = null, + classifier: String? = null, + ext: String? = null, + dependencyConfiguration: Action? = null +): ExternalModuleDependency = addExternalModuleDependencyTo( + this, "testFixturesDebugImplementation", group, name, version, configuration, classifier, ext, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testFixturesDebugImplementation' configuration. + * + * @param dependency dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesDebugImplementation`( + dependency: T, + dependencyConfiguration: T.() -> Unit +): T = add("testFixturesDebugImplementation", dependency, dependencyConfiguration) + +/** + * Adds a dependency constraint to the 'testFixturesDebugImplementation' configuration. + * + * @param constraintNotation the dependency constraint notation + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`testFixturesDebugImplementation`(constraintNotation: Any): DependencyConstraint = + add("testFixturesDebugImplementation", constraintNotation) + +/** + * Adds a dependency constraint to the 'testFixturesDebugImplementation' configuration. + * + * @param constraintNotation the dependency constraint notation + * @param block the block to use to configure the dependency constraint + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`testFixturesDebugImplementation`(constraintNotation: Any, block: DependencyConstraint.() -> Unit): DependencyConstraint = + add("testFixturesDebugImplementation", constraintNotation, block) + +/** + * Adds an artifact to the 'testFixturesDebugImplementation' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`testFixturesDebugImplementation`(artifactNotation: Any): PublishArtifact = + add("testFixturesDebugImplementation", artifactNotation) + +/** + * Adds an artifact to the 'testFixturesDebugImplementation' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @param configureAction The action to execute to configure the artifact. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`testFixturesDebugImplementation`( + artifactNotation: Any, + configureAction: ConfigurablePublishArtifact.() -> Unit +): PublishArtifact = + add("testFixturesDebugImplementation", artifactNotation, configureAction) + + + diff --git a/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestFixturesDebugImplementationDependenciesMetadataConfigurationAccessors.kt b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestFixturesDebugImplementationDependenciesMetadataConfigurationAccessors.kt new file mode 100644 index 00000000..93ef1490 --- /dev/null +++ b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestFixturesDebugImplementationDependenciesMetadataConfigurationAccessors.kt @@ -0,0 +1,213 @@ + +/* + * Copyright 2018 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +@file:Suppress( + "unused", + "nothing_to_inline", + "useless_cast", + "unchecked_cast", + "extension_shadowed_by_member", + "redundant_projection", + "RemoveRedundantBackticks", + "ObjectPropertyName", + "deprecation" +) +@file:org.gradle.api.Generated + +/* ktlint-disable */ + +package org.gradle.kotlin.dsl + + +import org.gradle.api.Action +import org.gradle.api.Incubating +import org.gradle.api.NamedDomainObjectProvider +import org.gradle.api.Project +import org.gradle.api.Task +import org.gradle.api.artifacts.Configuration +import org.gradle.api.artifacts.ConfigurablePublishArtifact +import org.gradle.api.artifacts.ConfigurationContainer +import org.gradle.api.artifacts.Dependency +import org.gradle.api.artifacts.DependencyConstraint +import org.gradle.api.artifacts.ExternalModuleDependency +import org.gradle.api.artifacts.ModuleDependency +import org.gradle.api.artifacts.PublishArtifact +import org.gradle.api.artifacts.dsl.ArtifactHandler +import org.gradle.api.artifacts.dsl.DependencyConstraintHandler +import org.gradle.api.artifacts.dsl.DependencyHandler +import org.gradle.api.provider.Provider +import org.gradle.api.provider.ProviderConvertible +import org.gradle.api.tasks.TaskContainer +import org.gradle.api.tasks.TaskProvider + +import org.gradle.kotlin.dsl.* +import org.gradle.kotlin.dsl.accessors.runtime.* + + +/** + * Adds a dependency to the 'testFixturesDebugImplementationDependenciesMetadata' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesDebugImplementationDependenciesMetadata`(dependencyNotation: Any): Dependency? = + add("testFixturesDebugImplementationDependenciesMetadata", dependencyNotation) + +/** + * Adds a dependency to the 'testFixturesDebugImplementationDependenciesMetadata' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesDebugImplementationDependenciesMetadata`( + dependencyNotation: String, + dependencyConfiguration: Action +): ExternalModuleDependency = addDependencyTo( + this, "testFixturesDebugImplementationDependenciesMetadata", dependencyNotation, dependencyConfiguration +) as ExternalModuleDependency + +/** + * Adds a dependency to the 'testFixturesDebugImplementationDependenciesMetadata' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesDebugImplementationDependenciesMetadata`( + dependencyNotation: Provider<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "testFixturesDebugImplementationDependenciesMetadata", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testFixturesDebugImplementationDependenciesMetadata' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesDebugImplementationDependenciesMetadata`( + dependencyNotation: ProviderConvertible<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "testFixturesDebugImplementationDependenciesMetadata", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testFixturesDebugImplementationDependenciesMetadata' configuration. + * + * @param group the group of the module to be added as a dependency. + * @param name the name of the module to be added as a dependency. + * @param version the optional version of the module to be added as a dependency. + * @param configuration the optional configuration of the module to be added as a dependency. + * @param classifier the optional classifier of the module artifact to be added as a dependency. + * @param ext the optional extension of the module artifact to be added as a dependency. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.create] + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesDebugImplementationDependenciesMetadata`( + group: String, + name: String, + version: String? = null, + configuration: String? = null, + classifier: String? = null, + ext: String? = null, + dependencyConfiguration: Action? = null +): ExternalModuleDependency = addExternalModuleDependencyTo( + this, "testFixturesDebugImplementationDependenciesMetadata", group, name, version, configuration, classifier, ext, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testFixturesDebugImplementationDependenciesMetadata' configuration. + * + * @param dependency dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesDebugImplementationDependenciesMetadata`( + dependency: T, + dependencyConfiguration: T.() -> Unit +): T = add("testFixturesDebugImplementationDependenciesMetadata", dependency, dependencyConfiguration) + +/** + * Adds a dependency constraint to the 'testFixturesDebugImplementationDependenciesMetadata' configuration. + * + * @param constraintNotation the dependency constraint notation + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`testFixturesDebugImplementationDependenciesMetadata`(constraintNotation: Any): DependencyConstraint = + add("testFixturesDebugImplementationDependenciesMetadata", constraintNotation) + +/** + * Adds a dependency constraint to the 'testFixturesDebugImplementationDependenciesMetadata' configuration. + * + * @param constraintNotation the dependency constraint notation + * @param block the block to use to configure the dependency constraint + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`testFixturesDebugImplementationDependenciesMetadata`(constraintNotation: Any, block: DependencyConstraint.() -> Unit): DependencyConstraint = + add("testFixturesDebugImplementationDependenciesMetadata", constraintNotation, block) + +/** + * Adds an artifact to the 'testFixturesDebugImplementationDependenciesMetadata' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`testFixturesDebugImplementationDependenciesMetadata`(artifactNotation: Any): PublishArtifact = + add("testFixturesDebugImplementationDependenciesMetadata", artifactNotation) + +/** + * Adds an artifact to the 'testFixturesDebugImplementationDependenciesMetadata' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @param configureAction The action to execute to configure the artifact. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`testFixturesDebugImplementationDependenciesMetadata`( + artifactNotation: Any, + configureAction: ConfigurablePublishArtifact.() -> Unit +): PublishArtifact = + add("testFixturesDebugImplementationDependenciesMetadata", artifactNotation, configureAction) + + + diff --git a/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestFixturesDebugIntransitiveDependenciesMetadataConfigurationAccessors.kt b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestFixturesDebugIntransitiveDependenciesMetadataConfigurationAccessors.kt new file mode 100644 index 00000000..5e8f9c90 --- /dev/null +++ b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestFixturesDebugIntransitiveDependenciesMetadataConfigurationAccessors.kt @@ -0,0 +1,213 @@ + +/* + * Copyright 2018 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +@file:Suppress( + "unused", + "nothing_to_inline", + "useless_cast", + "unchecked_cast", + "extension_shadowed_by_member", + "redundant_projection", + "RemoveRedundantBackticks", + "ObjectPropertyName", + "deprecation" +) +@file:org.gradle.api.Generated + +/* ktlint-disable */ + +package org.gradle.kotlin.dsl + + +import org.gradle.api.Action +import org.gradle.api.Incubating +import org.gradle.api.NamedDomainObjectProvider +import org.gradle.api.Project +import org.gradle.api.Task +import org.gradle.api.artifacts.Configuration +import org.gradle.api.artifacts.ConfigurablePublishArtifact +import org.gradle.api.artifacts.ConfigurationContainer +import org.gradle.api.artifacts.Dependency +import org.gradle.api.artifacts.DependencyConstraint +import org.gradle.api.artifacts.ExternalModuleDependency +import org.gradle.api.artifacts.ModuleDependency +import org.gradle.api.artifacts.PublishArtifact +import org.gradle.api.artifacts.dsl.ArtifactHandler +import org.gradle.api.artifacts.dsl.DependencyConstraintHandler +import org.gradle.api.artifacts.dsl.DependencyHandler +import org.gradle.api.provider.Provider +import org.gradle.api.provider.ProviderConvertible +import org.gradle.api.tasks.TaskContainer +import org.gradle.api.tasks.TaskProvider + +import org.gradle.kotlin.dsl.* +import org.gradle.kotlin.dsl.accessors.runtime.* + + +/** + * Adds a dependency to the 'testFixturesDebugIntransitiveDependenciesMetadata' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesDebugIntransitiveDependenciesMetadata`(dependencyNotation: Any): Dependency? = + add("testFixturesDebugIntransitiveDependenciesMetadata", dependencyNotation) + +/** + * Adds a dependency to the 'testFixturesDebugIntransitiveDependenciesMetadata' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesDebugIntransitiveDependenciesMetadata`( + dependencyNotation: String, + dependencyConfiguration: Action +): ExternalModuleDependency = addDependencyTo( + this, "testFixturesDebugIntransitiveDependenciesMetadata", dependencyNotation, dependencyConfiguration +) as ExternalModuleDependency + +/** + * Adds a dependency to the 'testFixturesDebugIntransitiveDependenciesMetadata' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesDebugIntransitiveDependenciesMetadata`( + dependencyNotation: Provider<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "testFixturesDebugIntransitiveDependenciesMetadata", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testFixturesDebugIntransitiveDependenciesMetadata' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesDebugIntransitiveDependenciesMetadata`( + dependencyNotation: ProviderConvertible<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "testFixturesDebugIntransitiveDependenciesMetadata", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testFixturesDebugIntransitiveDependenciesMetadata' configuration. + * + * @param group the group of the module to be added as a dependency. + * @param name the name of the module to be added as a dependency. + * @param version the optional version of the module to be added as a dependency. + * @param configuration the optional configuration of the module to be added as a dependency. + * @param classifier the optional classifier of the module artifact to be added as a dependency. + * @param ext the optional extension of the module artifact to be added as a dependency. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.create] + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesDebugIntransitiveDependenciesMetadata`( + group: String, + name: String, + version: String? = null, + configuration: String? = null, + classifier: String? = null, + ext: String? = null, + dependencyConfiguration: Action? = null +): ExternalModuleDependency = addExternalModuleDependencyTo( + this, "testFixturesDebugIntransitiveDependenciesMetadata", group, name, version, configuration, classifier, ext, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testFixturesDebugIntransitiveDependenciesMetadata' configuration. + * + * @param dependency dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesDebugIntransitiveDependenciesMetadata`( + dependency: T, + dependencyConfiguration: T.() -> Unit +): T = add("testFixturesDebugIntransitiveDependenciesMetadata", dependency, dependencyConfiguration) + +/** + * Adds a dependency constraint to the 'testFixturesDebugIntransitiveDependenciesMetadata' configuration. + * + * @param constraintNotation the dependency constraint notation + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`testFixturesDebugIntransitiveDependenciesMetadata`(constraintNotation: Any): DependencyConstraint = + add("testFixturesDebugIntransitiveDependenciesMetadata", constraintNotation) + +/** + * Adds a dependency constraint to the 'testFixturesDebugIntransitiveDependenciesMetadata' configuration. + * + * @param constraintNotation the dependency constraint notation + * @param block the block to use to configure the dependency constraint + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`testFixturesDebugIntransitiveDependenciesMetadata`(constraintNotation: Any, block: DependencyConstraint.() -> Unit): DependencyConstraint = + add("testFixturesDebugIntransitiveDependenciesMetadata", constraintNotation, block) + +/** + * Adds an artifact to the 'testFixturesDebugIntransitiveDependenciesMetadata' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`testFixturesDebugIntransitiveDependenciesMetadata`(artifactNotation: Any): PublishArtifact = + add("testFixturesDebugIntransitiveDependenciesMetadata", artifactNotation) + +/** + * Adds an artifact to the 'testFixturesDebugIntransitiveDependenciesMetadata' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @param configureAction The action to execute to configure the artifact. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`testFixturesDebugIntransitiveDependenciesMetadata`( + artifactNotation: Any, + configureAction: ConfigurablePublishArtifact.() -> Unit +): PublishArtifact = + add("testFixturesDebugIntransitiveDependenciesMetadata", artifactNotation, configureAction) + + + diff --git a/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestFixturesDebugRuntimeOnlyConfigurationAccessors.kt b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestFixturesDebugRuntimeOnlyConfigurationAccessors.kt new file mode 100644 index 00000000..4600b1e2 --- /dev/null +++ b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestFixturesDebugRuntimeOnlyConfigurationAccessors.kt @@ -0,0 +1,213 @@ + +/* + * Copyright 2018 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +@file:Suppress( + "unused", + "nothing_to_inline", + "useless_cast", + "unchecked_cast", + "extension_shadowed_by_member", + "redundant_projection", + "RemoveRedundantBackticks", + "ObjectPropertyName", + "deprecation" +) +@file:org.gradle.api.Generated + +/* ktlint-disable */ + +package org.gradle.kotlin.dsl + + +import org.gradle.api.Action +import org.gradle.api.Incubating +import org.gradle.api.NamedDomainObjectProvider +import org.gradle.api.Project +import org.gradle.api.Task +import org.gradle.api.artifacts.Configuration +import org.gradle.api.artifacts.ConfigurablePublishArtifact +import org.gradle.api.artifacts.ConfigurationContainer +import org.gradle.api.artifacts.Dependency +import org.gradle.api.artifacts.DependencyConstraint +import org.gradle.api.artifacts.ExternalModuleDependency +import org.gradle.api.artifacts.ModuleDependency +import org.gradle.api.artifacts.PublishArtifact +import org.gradle.api.artifacts.dsl.ArtifactHandler +import org.gradle.api.artifacts.dsl.DependencyConstraintHandler +import org.gradle.api.artifacts.dsl.DependencyHandler +import org.gradle.api.provider.Provider +import org.gradle.api.provider.ProviderConvertible +import org.gradle.api.tasks.TaskContainer +import org.gradle.api.tasks.TaskProvider + +import org.gradle.kotlin.dsl.* +import org.gradle.kotlin.dsl.accessors.runtime.* + + +/** + * Adds a dependency to the 'testFixturesDebugRuntimeOnly' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesDebugRuntimeOnly`(dependencyNotation: Any): Dependency? = + add("testFixturesDebugRuntimeOnly", dependencyNotation) + +/** + * Adds a dependency to the 'testFixturesDebugRuntimeOnly' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesDebugRuntimeOnly`( + dependencyNotation: String, + dependencyConfiguration: Action +): ExternalModuleDependency = addDependencyTo( + this, "testFixturesDebugRuntimeOnly", dependencyNotation, dependencyConfiguration +) as ExternalModuleDependency + +/** + * Adds a dependency to the 'testFixturesDebugRuntimeOnly' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesDebugRuntimeOnly`( + dependencyNotation: Provider<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "testFixturesDebugRuntimeOnly", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testFixturesDebugRuntimeOnly' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesDebugRuntimeOnly`( + dependencyNotation: ProviderConvertible<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "testFixturesDebugRuntimeOnly", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testFixturesDebugRuntimeOnly' configuration. + * + * @param group the group of the module to be added as a dependency. + * @param name the name of the module to be added as a dependency. + * @param version the optional version of the module to be added as a dependency. + * @param configuration the optional configuration of the module to be added as a dependency. + * @param classifier the optional classifier of the module artifact to be added as a dependency. + * @param ext the optional extension of the module artifact to be added as a dependency. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.create] + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesDebugRuntimeOnly`( + group: String, + name: String, + version: String? = null, + configuration: String? = null, + classifier: String? = null, + ext: String? = null, + dependencyConfiguration: Action? = null +): ExternalModuleDependency = addExternalModuleDependencyTo( + this, "testFixturesDebugRuntimeOnly", group, name, version, configuration, classifier, ext, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testFixturesDebugRuntimeOnly' configuration. + * + * @param dependency dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesDebugRuntimeOnly`( + dependency: T, + dependencyConfiguration: T.() -> Unit +): T = add("testFixturesDebugRuntimeOnly", dependency, dependencyConfiguration) + +/** + * Adds a dependency constraint to the 'testFixturesDebugRuntimeOnly' configuration. + * + * @param constraintNotation the dependency constraint notation + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`testFixturesDebugRuntimeOnly`(constraintNotation: Any): DependencyConstraint = + add("testFixturesDebugRuntimeOnly", constraintNotation) + +/** + * Adds a dependency constraint to the 'testFixturesDebugRuntimeOnly' configuration. + * + * @param constraintNotation the dependency constraint notation + * @param block the block to use to configure the dependency constraint + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`testFixturesDebugRuntimeOnly`(constraintNotation: Any, block: DependencyConstraint.() -> Unit): DependencyConstraint = + add("testFixturesDebugRuntimeOnly", constraintNotation, block) + +/** + * Adds an artifact to the 'testFixturesDebugRuntimeOnly' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`testFixturesDebugRuntimeOnly`(artifactNotation: Any): PublishArtifact = + add("testFixturesDebugRuntimeOnly", artifactNotation) + +/** + * Adds an artifact to the 'testFixturesDebugRuntimeOnly' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @param configureAction The action to execute to configure the artifact. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`testFixturesDebugRuntimeOnly`( + artifactNotation: Any, + configureAction: ConfigurablePublishArtifact.() -> Unit +): PublishArtifact = + add("testFixturesDebugRuntimeOnly", artifactNotation, configureAction) + + + diff --git a/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestFixturesDebugWearAppConfigurationAccessors.kt b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestFixturesDebugWearAppConfigurationAccessors.kt new file mode 100644 index 00000000..8128afc5 --- /dev/null +++ b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestFixturesDebugWearAppConfigurationAccessors.kt @@ -0,0 +1,213 @@ + +/* + * Copyright 2018 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +@file:Suppress( + "unused", + "nothing_to_inline", + "useless_cast", + "unchecked_cast", + "extension_shadowed_by_member", + "redundant_projection", + "RemoveRedundantBackticks", + "ObjectPropertyName", + "deprecation" +) +@file:org.gradle.api.Generated + +/* ktlint-disable */ + +package org.gradle.kotlin.dsl + + +import org.gradle.api.Action +import org.gradle.api.Incubating +import org.gradle.api.NamedDomainObjectProvider +import org.gradle.api.Project +import org.gradle.api.Task +import org.gradle.api.artifacts.Configuration +import org.gradle.api.artifacts.ConfigurablePublishArtifact +import org.gradle.api.artifacts.ConfigurationContainer +import org.gradle.api.artifacts.Dependency +import org.gradle.api.artifacts.DependencyConstraint +import org.gradle.api.artifacts.ExternalModuleDependency +import org.gradle.api.artifacts.ModuleDependency +import org.gradle.api.artifacts.PublishArtifact +import org.gradle.api.artifacts.dsl.ArtifactHandler +import org.gradle.api.artifacts.dsl.DependencyConstraintHandler +import org.gradle.api.artifacts.dsl.DependencyHandler +import org.gradle.api.provider.Provider +import org.gradle.api.provider.ProviderConvertible +import org.gradle.api.tasks.TaskContainer +import org.gradle.api.tasks.TaskProvider + +import org.gradle.kotlin.dsl.* +import org.gradle.kotlin.dsl.accessors.runtime.* + + +/** + * Adds a dependency to the 'testFixturesDebugWearApp' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesDebugWearApp`(dependencyNotation: Any): Dependency? = + add("testFixturesDebugWearApp", dependencyNotation) + +/** + * Adds a dependency to the 'testFixturesDebugWearApp' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesDebugWearApp`( + dependencyNotation: String, + dependencyConfiguration: Action +): ExternalModuleDependency = addDependencyTo( + this, "testFixturesDebugWearApp", dependencyNotation, dependencyConfiguration +) as ExternalModuleDependency + +/** + * Adds a dependency to the 'testFixturesDebugWearApp' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesDebugWearApp`( + dependencyNotation: Provider<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "testFixturesDebugWearApp", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testFixturesDebugWearApp' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesDebugWearApp`( + dependencyNotation: ProviderConvertible<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "testFixturesDebugWearApp", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testFixturesDebugWearApp' configuration. + * + * @param group the group of the module to be added as a dependency. + * @param name the name of the module to be added as a dependency. + * @param version the optional version of the module to be added as a dependency. + * @param configuration the optional configuration of the module to be added as a dependency. + * @param classifier the optional classifier of the module artifact to be added as a dependency. + * @param ext the optional extension of the module artifact to be added as a dependency. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.create] + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesDebugWearApp`( + group: String, + name: String, + version: String? = null, + configuration: String? = null, + classifier: String? = null, + ext: String? = null, + dependencyConfiguration: Action? = null +): ExternalModuleDependency = addExternalModuleDependencyTo( + this, "testFixturesDebugWearApp", group, name, version, configuration, classifier, ext, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testFixturesDebugWearApp' configuration. + * + * @param dependency dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesDebugWearApp`( + dependency: T, + dependencyConfiguration: T.() -> Unit +): T = add("testFixturesDebugWearApp", dependency, dependencyConfiguration) + +/** + * Adds a dependency constraint to the 'testFixturesDebugWearApp' configuration. + * + * @param constraintNotation the dependency constraint notation + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`testFixturesDebugWearApp`(constraintNotation: Any): DependencyConstraint = + add("testFixturesDebugWearApp", constraintNotation) + +/** + * Adds a dependency constraint to the 'testFixturesDebugWearApp' configuration. + * + * @param constraintNotation the dependency constraint notation + * @param block the block to use to configure the dependency constraint + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`testFixturesDebugWearApp`(constraintNotation: Any, block: DependencyConstraint.() -> Unit): DependencyConstraint = + add("testFixturesDebugWearApp", constraintNotation, block) + +/** + * Adds an artifact to the 'testFixturesDebugWearApp' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`testFixturesDebugWearApp`(artifactNotation: Any): PublishArtifact = + add("testFixturesDebugWearApp", artifactNotation) + +/** + * Adds an artifact to the 'testFixturesDebugWearApp' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @param configureAction The action to execute to configure the artifact. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`testFixturesDebugWearApp`( + artifactNotation: Any, + configureAction: ConfigurablePublishArtifact.() -> Unit +): PublishArtifact = + add("testFixturesDebugWearApp", artifactNotation, configureAction) + + + diff --git a/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestFixturesImplementationConfigurationAccessors.kt b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestFixturesImplementationConfigurationAccessors.kt new file mode 100644 index 00000000..4abf907a --- /dev/null +++ b/mobile/.gradle-cache/caches/8.7/kotlin-dsl/accessors/2a00c57e2162e09b0e92a6b7a8020ded/sources/org/gradle/kotlin/dsl/TestFixturesImplementationConfigurationAccessors.kt @@ -0,0 +1,213 @@ + +/* + * Copyright 2018 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +@file:Suppress( + "unused", + "nothing_to_inline", + "useless_cast", + "unchecked_cast", + "extension_shadowed_by_member", + "redundant_projection", + "RemoveRedundantBackticks", + "ObjectPropertyName", + "deprecation" +) +@file:org.gradle.api.Generated + +/* ktlint-disable */ + +package org.gradle.kotlin.dsl + + +import org.gradle.api.Action +import org.gradle.api.Incubating +import org.gradle.api.NamedDomainObjectProvider +import org.gradle.api.Project +import org.gradle.api.Task +import org.gradle.api.artifacts.Configuration +import org.gradle.api.artifacts.ConfigurablePublishArtifact +import org.gradle.api.artifacts.ConfigurationContainer +import org.gradle.api.artifacts.Dependency +import org.gradle.api.artifacts.DependencyConstraint +import org.gradle.api.artifacts.ExternalModuleDependency +import org.gradle.api.artifacts.ModuleDependency +import org.gradle.api.artifacts.PublishArtifact +import org.gradle.api.artifacts.dsl.ArtifactHandler +import org.gradle.api.artifacts.dsl.DependencyConstraintHandler +import org.gradle.api.artifacts.dsl.DependencyHandler +import org.gradle.api.provider.Provider +import org.gradle.api.provider.ProviderConvertible +import org.gradle.api.tasks.TaskContainer +import org.gradle.api.tasks.TaskProvider + +import org.gradle.kotlin.dsl.* +import org.gradle.kotlin.dsl.accessors.runtime.* + + +/** + * Adds a dependency to the 'testFixturesImplementation' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesImplementation`(dependencyNotation: Any): Dependency? = + add("testFixturesImplementation", dependencyNotation) + +/** + * Adds a dependency to the 'testFixturesImplementation' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesImplementation`( + dependencyNotation: String, + dependencyConfiguration: Action +): ExternalModuleDependency = addDependencyTo( + this, "testFixturesImplementation", dependencyNotation, dependencyConfiguration +) as ExternalModuleDependency + +/** + * Adds a dependency to the 'testFixturesImplementation' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesImplementation`( + dependencyNotation: Provider<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "testFixturesImplementation", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testFixturesImplementation' configuration. + * + * @param dependencyNotation notation for the dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesImplementation`( + dependencyNotation: ProviderConvertible<*>, + dependencyConfiguration: Action +): Unit = addConfiguredDependencyTo( + this, "testFixturesImplementation", dependencyNotation, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testFixturesImplementation' configuration. + * + * @param group the group of the module to be added as a dependency. + * @param name the name of the module to be added as a dependency. + * @param version the optional version of the module to be added as a dependency. + * @param configuration the optional configuration of the module to be added as a dependency. + * @param classifier the optional classifier of the module artifact to be added as a dependency. + * @param ext the optional extension of the module artifact to be added as a dependency. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.create] + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesImplementation`( + group: String, + name: String, + version: String? = null, + configuration: String? = null, + classifier: String? = null, + ext: String? = null, + dependencyConfiguration: Action? = null +): ExternalModuleDependency = addExternalModuleDependencyTo( + this, "testFixturesImplementation", group, name, version, configuration, classifier, ext, dependencyConfiguration +) + +/** + * Adds a dependency to the 'testFixturesImplementation' configuration. + * + * @param dependency dependency to be added. + * @param dependencyConfiguration expression to use to configure the dependency. + * @return The dependency. + * + * @see [DependencyHandler.add] + */ +fun DependencyHandler.`testFixturesImplementation`( + dependency: T, + dependencyConfiguration: T.() -> Unit +): T = add("testFixturesImplementation", dependency, dependencyConfiguration) + +/** + * Adds a dependency constraint to the 'testFixturesImplementation' configuration. + * + * @param constraintNotation the dependency constraint notation + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`testFixturesImplementation`(constraintNotation: Any): DependencyConstraint = + add("testFixturesImplementation", constraintNotation) + +/** + * Adds a dependency constraint to the 'testFixturesImplementation' configuration. + * + * @param constraintNotation the dependency constraint notation + * @param block the block to use to configure the dependency constraint + * + * @return the added dependency constraint + * + * @see [DependencyConstraintHandler.add] + */ +fun DependencyConstraintHandler.`testFixturesImplementation`(constraintNotation: Any, block: DependencyConstraint.() -> Unit): DependencyConstraint = + add("testFixturesImplementation", constraintNotation, block) + +/** + * Adds an artifact to the 'testFixturesImplementation' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`testFixturesImplementation`(artifactNotation: Any): PublishArtifact = + add("testFixturesImplementation", artifactNotation) + +/** + * Adds an artifact to the 'testFixturesImplementation' configuration. + * + * @param artifactNotation the group of the module to be added as a dependency. + * @param configureAction The action to execute to configure the artifact. + * @return The artifact. + * + * @see [ArtifactHandler.add] + */ +fun ArtifactHandler.`testFixturesImplementation`( + artifactNotation: Any, + configureAction: ConfigurablePublishArtifact.() -> Unit +): PublishArtifact = + add("testFixturesImplementation", artifactNotation, configureAction) + + +