// type restrictions of a type, if any.
//
// For all types other than *types.TypeParam, *types.Interface, and
// *types.Union, this is just a single term with Tilde() == false and
// Type() == typ. For *types.TypeParam, *types.Interface, and *types.Union, see
// below.
//
// Structural type restrictions of a type parameter are created via

   * documentation for {@link Collection}:
   *
   * <blockquote>
   *
   * "Some collection implementations have restrictions on the elements that they may contain. For
   * example, some implementations prohibit null elements, and some have restrictions on the types
   * of their elements."
   *
   * </blockquote>
   */
  RESTRICTS_ELEMENTS,

  /**

 * It does not say anything about the actual entity (e.g. its path) or the identity of the creation rule.
 *
 * @see ModelRegistrations
 */
public interface NodeInitializer {

    Multimap<ModelActionRole, ModelAction> getActions(ModelReference<?> subject, ModelRuleDescriptor descriptor);

   * documentation for {@link Collection}:
   *
   * <blockquote>
   *
   * "Some collection implementations have restrictions on the elements that they may contain. For
   * example, some implementations prohibit null elements, and some have restrictions on the types
   * of their elements."
   *
   * </blockquote>
   */
  RESTRICTS_ELEMENTS,

  /**

            final ModelRuleDescriptor descriptor = ruleDefinition.getDescriptor();

            if (modelSchema instanceof SpecializedMapSchema) {
                registration.actions(SpecializedMapNodeInitializer.getActions(ModelReference.of(modelPath), descriptor, (SpecializedMapSchema<S, ?>) modelSchema));
            } else {

@J2ktIncompatible
@GwtIncompatible
@ElementTypesAreNonnullByDefault
public interface FinalizableReference {
  /**
   * Invoked on a background thread after the referent has been garbage collected unless security
   * restrictions prevented starting a background thread, in which case this method is invoked when
   * new references are created.
   */
  void finalizeReferent();

    public ProjectionOnlyNodeInitializer(ModelProjection... projections) {
        this.projections = projections;
    }

    @Override
    public Multimap<ModelActionRole, ModelAction> getActions(ModelReference<?> subject, ModelRuleDescriptor descriptor) {
        return ImmutableSetMultimap.<ModelActionRole, ModelAction>builder()

        def task = TestUtil.create(temporaryFolder).createTask(TestTask, project, name)
        assertTrue(TestTask.isAssignableFrom(task.getClass()))
        return task
    }

    def "can add action to a task via Task.getActions() List"() {
        setup:
        def task = createTask("task")
        when:
        def actions = task.actions
        and:
        def action = Mock(Action)

        actions.add(action)
        then:

										LocalObjectReference: api.LocalObjectReference{Name: "foo"},
									},
								},
							},
						},
					},
				},
			},
		},
	}
	// validate enforces restrictions on secret mounts when operation==create and subresource=='' or operation==update and subresource==ephemeralcontainers"

 * limitations under the License.
 */

package org.gradle.internal;

/**
 * Equivalent to {@code Transformer}, but does not declare nullability due to Java 6 restrictions.
 *
 * <p>A {@code Transformer} transforms objects of type.</p>
 *
 * <p>Implementations are free to return new objects or mutate the incoming value.</p>
 *
 * @param <OUT> The type the value is transformed to.