*
     * @return file create time
     */
    long getCreateTime();

    /**
     * Gets the file last write time.
     *
     * @return file last write time
     */
    long getLastWriteTime();

    /**
     * Gets the file last access time.
     *
     * @return file last access time
     */
    long getLastAccessTime();

    /**
     * Gets the file size in bytes.
     *

    @Test
    @DisplayName("Test Response interface methods - getExpiration")
    void testGetExpiration() {
        // Given
        Long expectedExpiration = System.currentTimeMillis() + 30000L;
        when(response.getExpiration()).thenReturn(expectedExpiration);

        // When
        Long actualExpiration = response.getExpiration();

        // Then
        assertEquals(expectedExpiration, actualExpiration);

    /** Total execution time for all operations */
    protected volatile long executeTime = 0;

    /** List of documents waiting to be indexed */
    protected final DocList docList = new DocList();

    /** Maximum size of document requests in bytes */
    protected long maxDocumentRequestSize;

    /** Maximum number of documents to cache before indexing */

                    int safeShift = Math.min(MAX_BACKOFF_SHIFT, Math.max(0, retryCount - 1));
                    long multiplier = 1L << safeShift;
                    // Check for potential overflow before multiplication
                    long delay = (retryDelayMs > Long.MAX_VALUE / multiplier) ? MAX_RETRY_DELAY
                            : Math.min(MAX_RETRY_DELAY, retryDelayMs * multiplier);

    /**
     * Returns the access count.
     * @return The access count.
     */
    public long getAccessCount() {
        return accessCount.get();
    }

    /**
     * Increments the access count and returns the new value.
     * @return The incremented access count.
     */
    public long incrementAndGetAccessCount() {
        return accessCount.incrementAndGet();
    }

    /**

    private final AtomicLong bytesEncrypted = new AtomicLong(0);
    private long encryptionStartTime = System.currentTimeMillis();

    // Configurable key rotation limits with defaults
    private volatile long keyRotationBytesLimit = 1L << 30; // Default: 1GB
    private volatile long keyRotationTimeLimit = 24 * 60 * 60 * 1000L; // Default: 24 hours

    // Rotation metrics

      "sortOrder": {
        "type": "integer"
      },
      "createdBy": {
        "type": "keyword"
      },
      "createdTime": {
        "type": "long"
      },
      "updatedBy": {
        "type": "keyword"
      },
      "updatedTime": {
        "type": "long"
      },
      "description" : {
        "type": "text",
        "analyzer": "standard_analyzer"
      }
    }

            return bytesToRead;

        } catch (Exception e) {
            state = RdmaConnectionState.ERROR;
            throw new IOException("DiSNI RDMA read failed", e);
        }
    }

    @Override
    public int write(ByteBuffer buffer, long remoteAddress, int remoteKey, int length) throws IOException {

      T target, Class<T> interfaceType, long timeoutDuration, TimeUnit timeoutUnit) {
    checkNotNull(target);
    checkNotNull(interfaceType);
    checkNotNull(timeoutUnit);
    return target; // ha ha
  }

  @CanIgnoreReturnValue // TODO(kak): consider removing this
  @Override
  @ParametricNullness
  public <T extends @Nullable Object> T callWithTimeout(

    }

    @Override
    public void transferProgress(TransferEvent transferEvent, byte[] buffer, int length) {
        Long transferred;
        synchronized (transfers) {
            transferred = transfers.get(transferEvent.getResource());
            if (transferred == null) {
                transferred = (long) length;
            } else {
                transferred = transferred + length;
            }