// Required.
  optional MatchResources matchConstraints = 2;

  // Validations contain CEL expressions which is used to apply the validation.
  // Validations and AuditAnnotations may not both be empty; a minimum of one Validations or AuditAnnotations is
  // required.
  // +listType=atomic
  // +optional
  repeated Validation validations = 3;

   * @IgnoreJRERequirement somewhere that it will help.
   */
  private static <T extends @Nullable Object, E> void mapAndAdd(
      T t,
      Multiset<E> multiset,
      Function<? super T, ? extends E> elementFunction,
      ToIntFunction<? super T> countFunction) {
    multiset.add(checkNotNull(elementFunction.apply(t)), countFunction.applyAsInt(t));
  }

  /**

			Optional:    true,
			Type:        "string",
			Sensitive:   true,
			Secret:      true,
		},
		config.HelpKV{
			Key:         RolePolicy,
			Description: "policies to apply for plugin authorized users" + defaultHelpPostfix(RolePolicy),
			Type:        "string",
		},
		config.HelpKV{
			Key:         RoleID,
			Description: "unique ID to generate the ARN" + defaultHelpPostfix(RoleID),

    assertThat(other.port).isNotEqualTo(server.port)
    other.shutdown()
  }

  @Test
  fun statementStartsAndStops() {
    val called = AtomicBoolean()
    val statement =
      server.apply(
        object : Statement() {
          override fun evaluate() {
            called.set(true)
            server.url("/").toUrl().openConnection().connect()
          }
        },
        Description.EMPTY,

          pingIntervalMillis.toLong(),
          parse(
            responseHeaders,
          ),
          RealWebSocket.DEFAULT_MINIMUM_DEFLATE_SIZE,
          webSocketCloseTimeout,
        ).apply {
          if (client) {
            call =
              object : FailingCall() {
                override fun cancel() {
                  ******@****.***()
                }
              }

            len += pad8(bufferIndex);
        }
        else if ( compound && this.nextCommand == 0 && this.readSize > 0 ) {
            // TODO: only apply this for actual compound chains, or is this correct for single responses, too?
            // 3.2.5.1.9 Handling Compounded Responses
            // The final response in the compounded response chain will have NextCommand equal to 0,

    arraycopy(source, 0, copy, 0, size);
    return asList(copy);
  }

  private interface IteratorOperation {
    @Nullable Object execute(Iterator<?> iterator);
  }

  /**
   * Apply this method to both iterators and return normally only if both produce the same response.
   *
   * @see Stimulus#executeAndCompare(ListIterator, Iterator)
   */

      return insertionOrder;
    }

    static final Function<String, String> FUNCTION =
        new Function<String, String>() {
          @Override
          public String apply(String value) {
            return Ascii.toLowerCase(value);
          }
        };

    static final EntryTransformer<String, String, String> ENTRY_TRANSFORMER =

			// for file resources that don't have one specified.
			selectedNamespace = ctx.Namespace()
			if useKube {
				// apply default namespace if not specified and useKube is true
				selectedNamespace = ctx.NamespaceOrDefault(selectedNamespace)
				if selectedNamespace != "" {
					client, err := ctx.CLIClient()
					if err != nil {

### Server-side Apply graduates to GA