* @param outgoing the buffer containing data to be wrapped
     * @throws DcerpcException if the wrapping operation fails
     */
    void wrap(NdrBuffer outgoing) throws DcerpcException;

    /**
     * Unwraps incoming DCERPC message data after security processing
     * @param incoming the buffer containing data to be unwrapped
     * @throws DcerpcException if the unwrapping operation fails
     */

        void testUnwrapToDfsReferralData() {
            DfsReferralData unwrapped = referralData.unwrap(DfsReferralData.class);
            assertSame(referralData, unwrapped);
        }

        @Test
        @DisplayName("Should unwrap to DfsReferralDataInternal interface")
        void testUnwrapToDfsReferralDataInternal() {
            DfsReferralDataInternal unwrapped = referralData.unwrap(DfsReferralDataInternal.class);

    /**
     * Unwrap the address to a specific type
     *
     * @param <T> the type to unwrap to
     * @param type the target type to unwrap to
     * @return instance for type, null if the type cannot be unwrapped
     */
    <T extends Address> T unwrap(Class<T> type);

    /**
     * Gets the host name of this address.
     *
     * @return the resolved host name, or the host address if it could not be resolved
     */

        public void testUnwrap() {
            when(smbPipeHandle.unwrap(SmbPipeHandleInternal.class)).thenReturn(mockSmbPipeHandleInternal);
            SmbPipeHandleInternal unwrapped = smbPipeHandle.unwrap(SmbPipeHandleInternal.class);
            assertSame(mockSmbPipeHandleInternal, unwrapped, "Unwrap should return the underlying handle implementation.");
        }

        /**

    @DisplayName("unwrap returns self for assignable type; throws for incompatible and null")
    void testUnwrap() {
        // Happy path: unwrap to concrete type
        SmbPipeHandleImpl unwrapped = target.unwrap(SmbPipeHandleImpl.class);
        assertSame(target, unwrapped);

        // Incompatible type: expect ClassCastException
        class OtherPipeHandle implements SmbPipeHandle {
            @Override

     */
    boolean isStale();

    /**
     * Unwraps this handle to the specified type.
     *
     * @param <T> the type to unwrap to
     * @param type the class of the type to unwrap to
     * @return unwrapped instance
     */
    <T extends SmbPipeHandle> T unwrap(Class<T> type);

     */
    @Test
    void testUnwrap() throws SmbException {
        SID sid = new SID(adminSidString);
        SID unwrapped = sid.unwrap(SID.class);
        assertNotNull(unwrapped);
        assertEquals(sid, unwrapped);

        assertThrows(ClassCastException.class, () -> sid.unwrap(String.class));
    }

    /**
     * Test the resolve method.
     *

        NbtAddress nbtAddress = new NbtAddress(mockName, testAddressInt, false, NbtAddress.H_NODE);
        NbtAddress unwrapped = nbtAddress.unwrap(NbtAddress.class);
        assertNotNull(unwrapped);
        assertSame(nbtAddress, unwrapped);

        // Test unwrap for incompatible type - NbtAddress implements NetbiosAddress so it should return itself

            signature = inspect.signature(call)
    return signature


def get_typed_signature(call: Callable[..., Any]) -> inspect.Signature:
    signature = _get_signature(call)
    unwrapped = inspect.unwrap(call)
    globalns = getattr(unwrapped, "__globals__", {})
    typed_params = [
        inspect.Parameter(
            name=param.name,
            kind=param.kind,
            default=param.default,

     */
    int getType();

    /**
     * Unwraps this SID to the specified type.
     *
     * @param <T> the type to unwrap to
     * @param type the class of the type to unwrap to
     * @return unwrapped instance
     */
    <T> T unwrap(Class<T> type);