}

func (muxConnectError) Op() Op {
	return OpMuxConnectError
}

type pongMsg struct {
	NotFound bool      `msg:"nf"`
	Err      *string   `msg:"e,allownil"`
	T        time.Time `msg:"t"`
}

func (pongMsg) Op() Op {
	return OpPong
}

type pingMsg struct {
	T time.Time `msg:"t"`
}

func (pingMsg) Op() Op {
	return OpPing

}

func newMuxStateless(ctx context.Context, msg message, c *Connection, handler StatelessHandler) *muxServer {
	var cancel context.CancelFunc
	ctx = setCaller(ctx, c.remote)
	if msg.DeadlineMS > 0 {
		ctx, cancel = context.WithTimeout(ctx, time.Duration(msg.DeadlineMS)*time.Millisecond)
	} else {
		ctx, cancel = context.WithCancel(ctx)
	}
	m := muxServer{
		ID:        msg.MuxID,
		RecvSeq:   msg.Seq + 1,
		SendSeq:   msg.Seq,

    }

    //
    // These are the only methods we need in our primordial logger
    //
    @Override
    public void error(String msg) {
        out.print(ERROR);
        out.println(msg);
    }

    @Override
    public void error(String msg, Throwable t) {
        error(msg);

        if (null != t) {
            t.printStackTrace(out);
        }
    }

    //
    // Don't need any of this
    //

	if ok, msg := assertCallbacks(createCallback, []string{"c3", "c1", "c2", "c4"}); !ok {
		t.Errorf("callbacks tests failed, got %v", msg)
	}

	// plugin 3
	createCallback.Before("*").Register("plugin_3_fn1", c5)
	if ok, msg := assertCallbacks(createCallback, []string{"c5", "c3", "c1", "c2", "c4"}); !ok {
		t.Errorf("callbacks tests failed, got %v", msg)
	}

	createCallback.After("*").Register("plugin_3_fn2", c6)

	}
	return m.sendLocked(msg)
}

// sendLocked the message. msg.Seq and msg.MuxID will be set.
// m.respMu must be held.
func (m *muxClient) sendLocked(msg message) error {
	dst := GetByteBufferCap(msg.Msgsize())
	msg.Seq = m.SendSeq
	msg.MuxID = m.MuxID
	msg.Flags |= m.BaseFlags
	if debugPrint {
		fmt.Println("Client sending", &msg, "to", m.parent.Remote)
	}
	m.SendSeq++

        "detail": [
            {
                "loc": ["body", "name"],
                "input": {},
                "msg": "Field required",
                "type": "missing",
            },
            {
                "loc": ["body", "price"],
                "input": {},
                "msg": "Field required",
                "type": "missing",
            },
            {

	if u.detail == "" {
		if u.msg != "" {
			return u.msg
		}
		return "<nil>"
	}
	return u.detail
}

// Msg - Replace the current error's message
func (u Err) Msg(m string) Err {
	e := u.Clone()
	e.msg = m
	return e
}

// Msgf - Replace the current error's message
func (u Err) Msgf(m string, args ...any) Err {
	e := u.Clone()
	if len(args) == 0 {
		e.msg = m
	} else {
		e.msg = fmt.Sprintf(m, args...)
	}

        "detail": [
            {
                "loc": ["body", "name"],
                "input": {},
                "msg": "Field required",
                "type": "missing",
            },
            {
                "loc": ["body", "price"],
                "input": {},
                "msg": "Field required",
                "type": "missing",
            },
        ]
    }

    assert response.status_code == 422, response.text
    assert response.json() == {
        "detail": [
            {
                "loc": ["path", "item_id"],
                "input": "-1",
                "msg": "Input should be greater than or equal to 0",
                "type": "greater_than_equal",
                "ctx": {"ge": 0},
            }
        ]
    }

        String msg = indent + artifact;
        msg += " (";
        if (replacement.getVersion() != null) {
            msg += "applying version: " + replacement.getVersion() + ";";
        }
        if (replacement.getScope() != null) {
            msg += "applying artifactScope: " + replacement.getScope();
        }
        msg += ")";
        logger.debug(msg);
    }

    @Override