package cmd

// Code generated by github.com/tinylib/msgp DO NOT EDIT.

import (
	"github.com/tinylib/msgp/msgp"
)

// MarshalMsg implements msgp.Marshaler
func (z *MetricDescription) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 5
	// string "Namespace"
	o = append(o, 0x85, 0xa9, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65)
	o = msgp.AppendString(o, string(z.Namespace))

	err = mo.MarshalNext(in)
	return nil, err
}

func (mo MarshalOptions) MarshalNext(in interface{}) error {
	a := new(arshaler)
	a.marshal = func(MarshalOptions) error { return nil }
	return a.marshal(mo)
}

type arshaler struct {
	marshal func(MarshalOptions) error
}

type typedArshalers[Options any] struct {
	m M
}

	}
	dump, err := c.retrieveSortedEndpointsSlice(filter)
	if err != nil {
		return err
	}
	marshaller := make(proto.MessageSlice, 0, len(dump))
	for _, eds := range dump {
		marshaller = append(marshaller, eds)
	}
	out, err := json.MarshalIndent(marshaller, "", "    ")
	if err != nil {
		return err
	}
	if outputFormat == "yaml" {
		if out, err = yaml.JSONToYAML(out); err != nil {

	// returns the number of times Write() or WriteBytes() was called; it assumes that
	// you never wrote any newlines to the buffer yourself.
	Lines() int
}

var _ logr.Marshaler = &realLineBuffer{}

type realLineBuffer struct {
	b     bytes.Buffer
	lines int
}

// NewLineBuffer returns a new "real" LineBuffer
func NewLineBuffer() LineBuffer {
	return &realLineBuffer{}
}

						}
					}
				}
			case "yaml":
				if marshaled, err := yaml.Marshal(&version); err == nil {
					_, _ = fmt.Fprintln(cmd.OutOrStdout(), string(marshaled))
				}
			case "json":
				if marshaled, err := json.MarshalIndent(&version, "", "  "); err == nil {
					_, _ = fmt.Fprintln(cmd.OutOrStdout(), string(marshaled))
				}
			}

			return nil
		},
	}

*/

// Package direct provides functions for marshaling and unmarshaling between arbitrary Go values and
// CBOR data, with behavior that is compatible with that of the CBOR serializer. In particular,
// types that implement cbor.Marshaler and cbor.Unmarshaler should use these functions.
package direct

import (
	"k8s.io/apimachinery/pkg/runtime/serializer/cbor/internal/modes"
)

func Marshal(src interface{}) ([]byte, error) {

func (z rebalSaveOpts) EncodeMsg(en *msgp.Writer) (err error) {
	err = en.WriteUint8(uint8(z))
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z rebalSaveOpts) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	o = msgp.AppendUint8(o, uint8(z))
	return
}

// UnmarshalMsg implements msgp.Unmarshaler

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

import (
	"./a"
	"fmt"
)

func main() {
	_ = a.UnmarshalOptions1{
		Unmarshalers: a.UnmarshalFuncV2(func(opts a.UnmarshalOptions1, dec *a.Decoder1, val *interface{}) (err error) {
			return fmt.Errorf("error")
		}),
	}

func (z BucketBandwidthReport) EncodeMsg(en *msgp.Writer) (err error) {
	// map header, size 0
	_ = z
	err = en.Append(0x80)
	if err != nil {
		return
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z BucketBandwidthReport) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 0
	_ = z
	o = append(o, 0x80)
	return
}

				Follow:         true,
				Previous:       true,
				SinceSeconds:   &sinceSeconds,
				TailLines:      nil,
				SinceTime:      &sinceTime, // test a custom marshaller
				EmptyTime:      nil,        // test a nil custom marshaller without omitempty
				NonPointerTime: sinceTime,
			},