log.debug("No digest setup " + anonymous + " B " + isSignatureSetupRequired());
                }
                setSessionSetup(response);

                // Initialize multi-channel after successful session setup
                initializeMultiChannel();

                // Initialize witness support for fast failover
                initializeWitnessSupport();

                if (ex != null) {

            this.rawPayload = payload;
        }

        @Override
        public boolean verifySignature(byte[] data, int offset, int length) {
            return true; // Default to successful verification
        }

        public void setRetainPayload(boolean retain) {
            this.retainPayload = retain;
        }

        public byte[] getRawPayload() {
            return rawPayload;

     */
    public ApiResult(final ApiResponse response) {
        this.response = response;
    }

    /**
     * Represents the status of an API response.
     */
    public enum Status {
        /** Successful response status. */
        OK(0),
        /** Bad request status indicating client error. */
        BAD_REQUEST(1),
        /** System error status indicating server error. */
        SYSTEM_ERROR(2),

        added += q.drainTo(buffer, numElements - added);
        if (added < numElements) { // not enough elements immediately available; will have to poll
          E e; // written exactly once, by a successful (uninterrupted) invocation of #poll
          while (true) {
            try {
              e = q.poll(deadline - System.nanoTime(), NANOSECONDS);
              break;
            } catch (InterruptedException ex) {

   *
   *   o DIRTY lines track that an entry is actively being created or updated. Every successful
   *     DIRTY action should be followed by a CLEAN or REMOVE action. DIRTY lines without a matching
   *     CLEAN or REMOVE indicate that temporary files may need to be deleted.
   *
   *   o CLEAN lines track a cache entry that has been successfully published and may be read. A
   *     publish line is followed by the lengths of each of its values.

		// we return from this function.
		closeBitrotReaders(readers)
		if err != nil {
			// If we have successfully written all the content that was asked
			// by the client, but we still see an error - this would mean
			// that we have some parts or data blocks missing or corrupted
			// - attempt a heal to successfully heal them for future calls.
			if written == partLength {

    val response: Response = Response.Builder().build()
    val request: Request = response.request
    val protocol: Protocol = response.protocol
    val code: Int = response.code
    val successful: Boolean = response.isSuccessful
    val message: String = response.message
    val handshake: Handshake? = response.handshake
    val headersForName: List<String> = response.headers("")
    val header: String? = response.header("")

 * previous callable has returned -- and, if the previous callable was an {@link AsyncCallable}, not
 * until the {@code Future} it returned is {@linkplain Future#isDone done} (successful, failed, or
 * cancelled).
 *
 * <p>This class serializes execution of <i>submitted</i> tasks but not any <i>listeners</i> of
 * those tasks.
 *

        this.mid = mid;
    }

    /**
     * Chains another message to this message for compound operations.
     *
     * @param n the message to chain
     * @return whether chaining was successful
     */
    public boolean chain(final ServerMessageBlock2 n) {
        if (this.next != null) {
            return this.next.chain(n);
        }

        n.addFlags(SMB2_FLAGS_RELATED_OPERATIONS);

                                          long timeout, Smb2LeaseKey leaseKey) {
        HandleGuid guid = new HandleGuid();
        
        // Will be populated after successful create response
        HandleInfo info = new HandleInfo(path, guid, new byte[16], type, timeout, leaseKey);
        
        handles.put(path, info);
        guidToHandle.put(guid, info);