* `apiKey`: an application specific key that can come from:
    * A query parameter.
    * A header.
    * A cookie.
* `http`: standard HTTP authentication systems, including:
    * `bearer`: a header `Authorization` with a value of `Bearer ` plus a token. This is inherited from OAuth2.
    * HTTP Basic authentication.
    * HTTP Digest, etc.
* `oauth2`: all the OAuth2 ways to handle security (called "flows").

// [io.ByteScanner], and [io.RuneScanner] interfaces by reading from
// a byte slice.
// Unlike a [Buffer], a Reader is read-only and supports seeking.
// The zero value for Reader operates like a Reader of an empty slice.
type Reader struct {
	s        []byte
	i        int64 // current reading index
	prevRune int   // index of previous rune; or < 0
}

    ACTIVE(5),          // Actively transferring data
    FAILED(6),          // Connection failed
    CLOSING(7);         // Closing connection
    
    private final int value;
    
    ChannelState(int value) {
        this.value = value;
    }
}
```

### 3.2 Channel Capabilities
```java
public class Smb2ChannelCapabilities {
    // Multi-channel specific capabilities

            doColumn("updatedBy");
        }

        public void columnUpdatedTime() {
            doColumn("updatedTime");
        }

        public void columnValue() {
            doColumn("value");
        }
    }

        @DisplayName("Reads structure size 4 and returns 4 for various start indexes")
        void returnsFour_whenStructureSizeIsFour(int start) throws Exception {
            // Arrange: build a buffer that has the little-endian value 4 at 'start'
            int len = start + 2; // need at least two bytes from start
            byte[] buffer = new byte[len + 3];
            SMBUtil.writeInt2(4, buffer, start);

 *
 * @since 4.0.0
 */
@Experimental
@Consumer
@Named
public interface ModelParser extends SpiService {

    /**
     * Option that can be specified in the options map.  The value should be a Boolean.
     */
    String STRICT = "strict";

    /**
     * Locates the pom in the given directory.
     *
     * @param dir the directory to locate the pom for, never {@code null}

    public int getRequestType() {
        return requestType;
    }

    /**
     * Sets the request type
     *
     * @param requestType The requestType to set.
     *                    The Request type value should be either
     *                    <code>TransferEvent.REQUEST_GET</code> or <code>TransferEvent.REQUEST_PUT</code>.
     * @throws IllegalArgumentException when
     */

     *
     * @throws GeneralSecurityException
     */
    @Test
    void testCalculateMacArcfourHMACMD5() throws GeneralSecurityException {
        // Using a key with a known value for reproducibility
        SecretKeySpec key = new SecretKeySpec(new byte[16], "ARCFOUR");
        byte[] mac = PacMac.calculateMacArcfourHMACMD5(3, key, TEST_DATA);
        assertNotNull(mac);

  An example claim validation rule expression that matches the validation automatically
  applied when username.claim is set to 'email' is 'claims.?email_verified.orValue(true) == true'. 
  By explicitly comparing the value to true, we let type-checking see the result will be a boolean, 

    }
    while (!buffer.exhausted()) {
      var publicSuffix = buffer.readUtf8LineStrict()
      if (publicSuffix.contains("*")) {
        // A wildcard rule, let's replace the wildcard with a value.
        publicSuffix = publicSuffix.replace("\\*".toRegex(), "square")
      }
      assertThat(publicSuffixDatabase.getEffectiveTldPlusOne(publicSuffix)).isNull()
      val test = "foobar.$publicSuffix"