/**
     * Determines if the request was processed successfully.
     *
     * @return true if no error occurred during processing (error is null), false otherwise
     */
    public boolean isSuccess() {
        return error == null;
    }

     */
    public boolean isSuccess() {
        return returnCode == ERROR_SUCCESS;
    }

    /**
     * Gets the error message for the current return code.
     *
     * @return a human-readable error message
     */
    public String getErrorMessage() {
        switch (returnCode) {
        case ERROR_SUCCESS:
            return "Success";
        case ERROR_INVALID_PARAMETER:

   *
   * The two values are independent: results can contain both (recoverable error), neither
   * (success), just an exception (permanent failure), or just a plan (non-exceptional retry).
   */
  data class ConnectResult(
    val plan: Plan,
    val nextPlan: Plan? = null,
    val throwable: Throwable? = null,
  ) {
    val isSuccess: Boolean
      get() = nextPlan == null && throwable == null
  }

     * The response sequence number should match the request sequence number.
     *
     * @return true if the response is valid
     */
    public boolean isValidResponse() {
        return isSuccess() && responseSequenceNumber == sequenceNumber;
    }

    @Override
    protected void encodeWitnessParameters(NdrBuffer buf) throws NdrException {
        // Encode input parameters for WitnessHeartbeat

    public ArtifactResolutionResult setUnresolvedArtifacts(final List<Artifact> unresolvedArtifacts) {
        this.missingArtifacts = unresolvedArtifacts;

        return this;
    }

    public boolean isSuccess() {
        return !(hasMissingArtifacts() || hasExceptions());
    }

    // ------------------------------------------------------------------------
    // Exceptions

            return info;
        }
        return null;
    }
    
    public void completeReconnect(String path, boolean success) {
        HandleInfo info = handles.get(path);
        if (info != null) {
            if (success) {
                info.updateAccessTime();
                info.reconnecting = false;
            } else {
                // Remove failed handle

        return data;
    }

    /**
     * Check if negotiation was successful
     *
     * @return true if successful
     */
    public boolean isSuccess() {
        return status == STATUS_SUCCESS;
    }

    // Getters and setters

    /**
     * Get the minimum SMB Direct protocol version
     *
     * @return minimum protocol version
     */

    
    public void recordOperation(String channelId, long bytes, long latency, boolean success) {
        ChannelStatistics stats = channelStats.computeIfAbsent(channelId, 
            k -> new ChannelStatistics());
            
        stats.operations.incrementAndGet();
        stats.latencyTotal.addAndGet(latency);
        
        if (success) {
            stats.bytesReceived.addAndGet(bytes);
        } else {

        // TODO: Integration point - send request through session.send()
        // Smb2IoctlResponse response = (Smb2IoctlResponse) session.send(request);
        // if (response.isSuccess()) {
        //     parseNetworkInterfaces(response.getOutputData());
        // }

        log.debug("FSCTL_QUERY_NETWORK_INTERFACE_INFO prepared but needs session integration");
    }

                    Smb2ChangeNotifyResponse response = (Smb2ChangeNotifyResponse) 
                        handle.directoryFile.getTree().send(request);
                    
                    if (response.isSuccess()) {
                        processChangeNotification(handle, response);
                    }
                    
                } catch (Exception e) {
                    if (handle.active) {