* Example:
 * </p>
 * <pre>
 * public interface MyFlowParameters extends FlowParameters {
 *    Property&lt;String&gt; getString();
 *   {@literal @}ServiceReference Property&lt;MyBuildService&gt; getBuildService();
 * }
 * </pre>
 *
 * @see FlowAction
 * @since 8.1
 */
@Incubating
public interface FlowParameters {
    /**
     * Used for {@link FlowAction dataflow actions} without parameters.
     *

    }

    private
    fun <P : FlowParameters, T : FlowAction<P>> parametersTypeOf(action: Class<T>): Class<P>? =
        isolationScheme.parameterTypeFor(action)
}


data class RegisteredFlowAction(
    val type: Class<out FlowAction<FlowParameters>>,
    val parameters: FlowParameters?
)


private
class DefaultFlowScopeRegistration<P : FlowParameters> : FlowScope.Registration<P>

 *         });
 *     }
 * }
 * </pre>
 *
 * @param <P> Parameter type for the dataflow action. Should be {@link FlowParameters.None} if the action does not have parameters.
 * @see FlowScope
 * @see FlowProviders
 * @since 8.1
 */
@Incubating
public interface FlowAction<P extends FlowParameters> {

    void execute(P parameters) throws Exception;

import org.gradle.api.flow.FlowAction;
import org.gradle.api.flow.FlowParameters;
import org.gradle.api.provider.Property;
import org.gradle.api.services.ServiceReference;
import org.gradle.api.tasks.Input;

import java.io.File;

public abstract class SoundPlay implements FlowAction<SoundPlay.Parameters> {
    interface Parameters extends FlowParameters {
        @ServiceReference // <1>

                }
            }

            class FlowActionInjection implements FlowAction<FlowParameters.None> {

                private final $serviceType.name service

                @Inject
                FlowActionInjection($serviceType.name service) {}

                void execute(FlowParameters.None parameters) {
                    println("(green)")
                }
            }

- The parameters type is also a <<custom_gradle_types.adoc#custom_gradle_types,custom Gradle type>>.
- The action implementation gets the parameters as an argument of the `execute` method.

When the action requires no parameters, you can use link:{javadocPath}/org/gradle/api/flow/FlowParameters.None.html[FlowParameters.None] as the type of parameter.

    services: ServiceRegistry
) {
    fun <P : FlowParameters> newInstance(parametersType: Class<P>, configure: (P) -> Unit): P {
        return instantiator.newInstance(parametersType).also {
            configure(it)
            validate(parametersType, it)
        }
    }

    private
    fun <P : FlowParameters> validate(type: Class<P>, parameters: P) {

 * limitations under the License.
 */

package org.gradle.internal.flow.services

import org.gradle.api.file.ArchiveOperations
import org.gradle.api.file.FileSystemOperations
import org.gradle.api.flow.FlowParameters
import org.gradle.internal.instantiation.InstantiatorFactory
import org.gradle.internal.service.DefaultServiceRegistry
import org.gradle.internal.service.ServiceRegistry
import org.gradle.internal.service.scopes.Scope

     * @param <P> the parameters defined by the given {@link FlowAction dataflow action} type.
     * @return a {@link Registration} object representing the registered action.
     */
    <P extends FlowParameters> Registration<P> always(
        Class<? extends FlowAction<P>> action,
        Action<? super FlowActionSpec<P>> configure
    );

    /**
     * Represents a registered {@link FlowAction dataflow action}.
     *

                        }
                    }
                }
            }

            class SetLavaLampColor implements FlowAction<Parameters> {

                interface Parameters extends FlowParameters {
                    @ServiceReference("lamp") Property<LavaLamp> getLamp()
                    @Input Property<String> getColor()
                }

                void execute(Parameters parameters) {