cacert-gosigner/pkg/messages/resolver.msgpackgen.go

// Code generated by msgpackgen. DO NOT EDIT.

package messages

import (
	"fmt"
	msgpack "github.com/shamaton/msgpackgen/msgpack"
	dec "github.com/shamaton/msgpackgen/msgpack/dec"
	enc "github.com/shamaton/msgpackgen/msgpack/enc"
	"time"
)

// RegisterGeneratedResolver registers generated resolver.
func RegisterGeneratedResolver() {
	msgpack.SetResolver(___encodeAsMap, ___encodeAsArray, ___decodeAsMap, ___decodeAsArray)
}

// encode
func ___encode(i interface{}) ([]byte, error) {
	if msgpack.StructAsArray() {
		return ___encodeAsArray(i)
	} else {
		return ___encodeAsMap(i)
	}
}

// encodeAsArray
func ___encodeAsArray(i interface{}) ([]byte, error) {
	switch v := i.(type) {
	case CAInfoCommand:
		encoder := enc.NewEncoder()
		size, err := ___calcArraySizeCAInfoCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, encoder)
		if err != nil {
			return nil, err
		}
		encoder.MakeBytes(size)
		b, offset, err := ___encodeArrayCAInfoCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, encoder, 0)
		if err != nil {
			return nil, err
		}
		if size != offset {
			return nil, fmt.Errorf("%s size / offset different %d : %d", "CAInfoCommand", size, offset)
		}
		return b, err
	case *CAInfoCommand:
		encoder := enc.NewEncoder()
		size, err := ___calcArraySizeCAInfoCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, encoder)
		if err != nil {
			return nil, err
		}
		encoder.MakeBytes(size)
		b, offset, err := ___encodeArrayCAInfoCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, encoder, 0)
		if err != nil {
			return nil, err
		}
		if size != offset {
			return nil, fmt.Errorf("%s size / offset different %d : %d", "CAInfoCommand", size, offset)
		}
		return b, err
	case FetchCRLCommand:
		encoder := enc.NewEncoder()
		size, err := ___calcArraySizeFetchCRLCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, encoder)
		if err != nil {
			return nil, err
		}
		encoder.MakeBytes(size)
		b, offset, err := ___encodeArrayFetchCRLCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, encoder, 0)
		if err != nil {
			return nil, err
		}
		if size != offset {
			return nil, fmt.Errorf("%s size / offset different %d : %d", "FetchCRLCommand", size, offset)
		}
		return b, err
	case *FetchCRLCommand:
		encoder := enc.NewEncoder()
		size, err := ___calcArraySizeFetchCRLCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, encoder)
		if err != nil {
			return nil, err
		}
		encoder.MakeBytes(size)
		b, offset, err := ___encodeArrayFetchCRLCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, encoder, 0)
		if err != nil {
			return nil, err
		}
		if size != offset {
			return nil, fmt.Errorf("%s size / offset different %d : %d", "FetchCRLCommand", size, offset)
		}
		return b, err
	case FetchCRLResponse:
		encoder := enc.NewEncoder()
		size, err := ___calcArraySizeFetchCRLResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, encoder)
		if err != nil {
			return nil, err
		}
		encoder.MakeBytes(size)
		b, offset, err := ___encodeArrayFetchCRLResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, encoder, 0)
		if err != nil {
			return nil, err
		}
		if size != offset {
			return nil, fmt.Errorf("%s size / offset different %d : %d", "FetchCRLResponse", size, offset)
		}
		return b, err
	case *FetchCRLResponse:
		encoder := enc.NewEncoder()
		size, err := ___calcArraySizeFetchCRLResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, encoder)
		if err != nil {
			return nil, err
		}
		encoder.MakeBytes(size)
		b, offset, err := ___encodeArrayFetchCRLResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, encoder, 0)
		if err != nil {
			return nil, err
		}
		if size != offset {
			return nil, fmt.Errorf("%s size / offset different %d : %d", "FetchCRLResponse", size, offset)
		}
		return b, err
	case HealthCommand:
		encoder := enc.NewEncoder()
		size, err := ___calcArraySizeHealthCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, encoder)
		if err != nil {
			return nil, err
		}
		encoder.MakeBytes(size)
		b, offset, err := ___encodeArrayHealthCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, encoder, 0)
		if err != nil {
			return nil, err
		}
		if size != offset {
			return nil, fmt.Errorf("%s size / offset different %d : %d", "HealthCommand", size, offset)
		}
		return b, err
	case *HealthCommand:
		encoder := enc.NewEncoder()
		size, err := ___calcArraySizeHealthCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, encoder)
		if err != nil {
			return nil, err
		}
		encoder.MakeBytes(size)
		b, offset, err := ___encodeArrayHealthCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, encoder, 0)
		if err != nil {
			return nil, err
		}
		if size != offset {
			return nil, fmt.Errorf("%s size / offset different %d : %d", "HealthCommand", size, offset)
		}
		return b, err
	case HealthInfo:
		encoder := enc.NewEncoder()
		size, err := ___calcArraySizeHealthInfo_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, encoder)
		if err != nil {
			return nil, err
		}
		encoder.MakeBytes(size)
		b, offset, err := ___encodeArrayHealthInfo_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, encoder, 0)
		if err != nil {
			return nil, err
		}
		if size != offset {
			return nil, fmt.Errorf("%s size / offset different %d : %d", "HealthInfo", size, offset)
		}
		return b, err
	case *HealthInfo:
		encoder := enc.NewEncoder()
		size, err := ___calcArraySizeHealthInfo_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, encoder)
		if err != nil {
			return nil, err
		}
		encoder.MakeBytes(size)
		b, offset, err := ___encodeArrayHealthInfo_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, encoder, 0)
		if err != nil {
			return nil, err
		}
		if size != offset {
			return nil, fmt.Errorf("%s size / offset different %d : %d", "HealthInfo", size, offset)
		}
		return b, err
	case HealthResponse:
		encoder := enc.NewEncoder()
		size, err := ___calcArraySizeHealthResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, encoder)
		if err != nil {
			return nil, err
		}
		encoder.MakeBytes(size)
		b, offset, err := ___encodeArrayHealthResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, encoder, 0)
		if err != nil {
			return nil, err
		}
		if size != offset {
			return nil, fmt.Errorf("%s size / offset different %d : %d", "HealthResponse", size, offset)
		}
		return b, err
	case *HealthResponse:
		encoder := enc.NewEncoder()
		size, err := ___calcArraySizeHealthResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, encoder)
		if err != nil {
			return nil, err
		}
		encoder.MakeBytes(size)
		b, offset, err := ___encodeArrayHealthResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, encoder, 0)
		if err != nil {
			return nil, err
		}
		if size != offset {
			return nil, fmt.Errorf("%s size / offset different %d : %d", "HealthResponse", size, offset)
		}
		return b, err
	case SignCertificateResponse:
		encoder := enc.NewEncoder()
		size, err := ___calcArraySizeSignCertificateResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, encoder)
		if err != nil {
			return nil, err
		}
		encoder.MakeBytes(size)
		b, offset, err := ___encodeArraySignCertificateResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, encoder, 0)
		if err != nil {
			return nil, err
		}
		if size != offset {
			return nil, fmt.Errorf("%s size / offset different %d : %d", "SignCertificateResponse", size, offset)
		}
		return b, err
	case *SignCertificateResponse:
		encoder := enc.NewEncoder()
		size, err := ___calcArraySizeSignCertificateResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, encoder)
		if err != nil {
			return nil, err
		}
		encoder.MakeBytes(size)
		b, offset, err := ___encodeArraySignCertificateResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, encoder, 0)
		if err != nil {
			return nil, err
		}
		if size != offset {
			return nil, fmt.Errorf("%s size / offset different %d : %d", "SignCertificateResponse", size, offset)
		}
		return b, err
	case RevokeCertificateCommand:
		encoder := enc.NewEncoder()
		size, err := ___calcArraySizeRevokeCertificateCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, encoder)
		if err != nil {
			return nil, err
		}
		encoder.MakeBytes(size)
		b, offset, err := ___encodeArrayRevokeCertificateCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, encoder, 0)
		if err != nil {
			return nil, err
		}
		if size != offset {
			return nil, fmt.Errorf("%s size / offset different %d : %d", "RevokeCertificateCommand", size, offset)
		}
		return b, err
	case *RevokeCertificateCommand:
		encoder := enc.NewEncoder()
		size, err := ___calcArraySizeRevokeCertificateCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, encoder)
		if err != nil {
			return nil, err
		}
		encoder.MakeBytes(size)
		b, offset, err := ___encodeArrayRevokeCertificateCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, encoder, 0)
		if err != nil {
			return nil, err
		}
		if size != offset {
			return nil, fmt.Errorf("%s size / offset different %d : %d", "RevokeCertificateCommand", size, offset)
		}
		return b, err
	case RevokeCertificateResponse:
		encoder := enc.NewEncoder()
		size, err := ___calcArraySizeRevokeCertificateResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, encoder)
		if err != nil {
			return nil, err
		}
		encoder.MakeBytes(size)
		b, offset, err := ___encodeArrayRevokeCertificateResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, encoder, 0)
		if err != nil {
			return nil, err
		}
		if size != offset {
			return nil, fmt.Errorf("%s size / offset different %d : %d", "RevokeCertificateResponse", size, offset)
		}
		return b, err
	case *RevokeCertificateResponse:
		encoder := enc.NewEncoder()
		size, err := ___calcArraySizeRevokeCertificateResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, encoder)
		if err != nil {
			return nil, err
		}
		encoder.MakeBytes(size)
		b, offset, err := ___encodeArrayRevokeCertificateResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, encoder, 0)
		if err != nil {
			return nil, err
		}
		if size != offset {
			return nil, fmt.Errorf("%s size / offset different %d : %d", "RevokeCertificateResponse", size, offset)
		}
		return b, err
	case SignOpenPGPCommand:
		encoder := enc.NewEncoder()
		size, err := ___calcArraySizeSignOpenPGPCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, encoder)
		if err != nil {
			return nil, err
		}
		encoder.MakeBytes(size)
		b, offset, err := ___encodeArraySignOpenPGPCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, encoder, 0)
		if err != nil {
			return nil, err
		}
		if size != offset {
			return nil, fmt.Errorf("%s size / offset different %d : %d", "SignOpenPGPCommand", size, offset)
		}
		return b, err
	case *SignOpenPGPCommand:
		encoder := enc.NewEncoder()
		size, err := ___calcArraySizeSignOpenPGPCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, encoder)
		if err != nil {
			return nil, err
		}
		encoder.MakeBytes(size)
		b, offset, err := ___encodeArraySignOpenPGPCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, encoder, 0)
		if err != nil {
			return nil, err
		}
		if size != offset {
			return nil, fmt.Errorf("%s size / offset different %d : %d", "SignOpenPGPCommand", size, offset)
		}
		return b, err
	case SignOpenPGPResponse:
		encoder := enc.NewEncoder()
		size, err := ___calcArraySizeSignOpenPGPResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, encoder)
		if err != nil {
			return nil, err
		}
		encoder.MakeBytes(size)
		b, offset, err := ___encodeArraySignOpenPGPResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, encoder, 0)
		if err != nil {
			return nil, err
		}
		if size != offset {
			return nil, fmt.Errorf("%s size / offset different %d : %d", "SignOpenPGPResponse", size, offset)
		}
		return b, err
	case *SignOpenPGPResponse:
		encoder := enc.NewEncoder()
		size, err := ___calcArraySizeSignOpenPGPResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, encoder)
		if err != nil {
			return nil, err
		}
		encoder.MakeBytes(size)
		b, offset, err := ___encodeArraySignOpenPGPResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, encoder, 0)
		if err != nil {
			return nil, err
		}
		if size != offset {
			return nil, fmt.Errorf("%s size / offset different %d : %d", "SignOpenPGPResponse", size, offset)
		}
		return b, err
	case ErrorResponse:
		encoder := enc.NewEncoder()
		size, err := ___calcArraySizeErrorResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, encoder)
		if err != nil {
			return nil, err
		}
		encoder.MakeBytes(size)
		b, offset, err := ___encodeArrayErrorResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, encoder, 0)
		if err != nil {
			return nil, err
		}
		if size != offset {
			return nil, fmt.Errorf("%s size / offset different %d : %d", "ErrorResponse", size, offset)
		}
		return b, err
	case *ErrorResponse:
		encoder := enc.NewEncoder()
		size, err := ___calcArraySizeErrorResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, encoder)
		if err != nil {
			return nil, err
		}
		encoder.MakeBytes(size)
		b, offset, err := ___encodeArrayErrorResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, encoder, 0)
		if err != nil {
			return nil, err
		}
		if size != offset {
			return nil, fmt.Errorf("%s size / offset different %d : %d", "ErrorResponse", size, offset)
		}
		return b, err
	}
	return nil, nil
}

// encodeAsMap
func ___encodeAsMap(i interface{}) ([]byte, error) {
	switch v := i.(type) {
	case CAInfoCommand:
		encoder := enc.NewEncoder()
		size, err := ___calcMapSizeCAInfoCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, encoder)
		if err != nil {
			return nil, err
		}
		encoder.MakeBytes(size)
		b, offset, err := ___encodeMapCAInfoCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, encoder, 0)
		if err != nil {
			return nil, err
		}
		if size != offset {
			return nil, fmt.Errorf("%s size / offset different %d : %d", "CAInfoCommand", size, offset)
		}
		return b, err
	case *CAInfoCommand:
		encoder := enc.NewEncoder()
		size, err := ___calcMapSizeCAInfoCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, encoder)
		if err != nil {
			return nil, err
		}
		encoder.MakeBytes(size)
		b, offset, err := ___encodeMapCAInfoCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, encoder, 0)
		if err != nil {
			return nil, err
		}
		if size != offset {
			return nil, fmt.Errorf("%s size / offset different %d : %d", "CAInfoCommand", size, offset)
		}
		return b, err
	case FetchCRLCommand:
		encoder := enc.NewEncoder()
		size, err := ___calcMapSizeFetchCRLCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, encoder)
		if err != nil {
			return nil, err
		}
		encoder.MakeBytes(size)
		b, offset, err := ___encodeMapFetchCRLCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, encoder, 0)
		if err != nil {
			return nil, err
		}
		if size != offset {
			return nil, fmt.Errorf("%s size / offset different %d : %d", "FetchCRLCommand", size, offset)
		}
		return b, err
	case *FetchCRLCommand:
		encoder := enc.NewEncoder()
		size, err := ___calcMapSizeFetchCRLCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, encoder)
		if err != nil {
			return nil, err
		}
		encoder.MakeBytes(size)
		b, offset, err := ___encodeMapFetchCRLCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, encoder, 0)
		if err != nil {
			return nil, err
		}
		if size != offset {
			return nil, fmt.Errorf("%s size / offset different %d : %d", "FetchCRLCommand", size, offset)
		}
		return b, err
	case FetchCRLResponse:
		encoder := enc.NewEncoder()
		size, err := ___calcMapSizeFetchCRLResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, encoder)
		if err != nil {
			return nil, err
		}
		encoder.MakeBytes(size)
		b, offset, err := ___encodeMapFetchCRLResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, encoder, 0)
		if err != nil {
			return nil, err
		}
		if size != offset {
			return nil, fmt.Errorf("%s size / offset different %d : %d", "FetchCRLResponse", size, offset)
		}
		return b, err
	case *FetchCRLResponse:
		encoder := enc.NewEncoder()
		size, err := ___calcMapSizeFetchCRLResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, encoder)
		if err != nil {
			return nil, err
		}
		encoder.MakeBytes(size)
		b, offset, err := ___encodeMapFetchCRLResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, encoder, 0)
		if err != nil {
			return nil, err
		}
		if size != offset {
			return nil, fmt.Errorf("%s size / offset different %d : %d", "FetchCRLResponse", size, offset)
		}
		return b, err
	case HealthCommand:
		encoder := enc.NewEncoder()
		size, err := ___calcMapSizeHealthCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, encoder)
		if err != nil {
			return nil, err
		}
		encoder.MakeBytes(size)
		b, offset, err := ___encodeMapHealthCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, encoder, 0)
		if err != nil {
			return nil, err
		}
		if size != offset {
			return nil, fmt.Errorf("%s size / offset different %d : %d", "HealthCommand", size, offset)
		}
		return b, err
	case *HealthCommand:
		encoder := enc.NewEncoder()
		size, err := ___calcMapSizeHealthCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, encoder)
		if err != nil {
			return nil, err
		}
		encoder.MakeBytes(size)
		b, offset, err := ___encodeMapHealthCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, encoder, 0)
		if err != nil {
			return nil, err
		}
		if size != offset {
			return nil, fmt.Errorf("%s size / offset different %d : %d", "HealthCommand", size, offset)
		}
		return b, err
	case HealthInfo:
		encoder := enc.NewEncoder()
		size, err := ___calcMapSizeHealthInfo_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, encoder)
		if err != nil {
			return nil, err
		}
		encoder.MakeBytes(size)
		b, offset, err := ___encodeMapHealthInfo_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, encoder, 0)
		if err != nil {
			return nil, err
		}
		if size != offset {
			return nil, fmt.Errorf("%s size / offset different %d : %d", "HealthInfo", size, offset)
		}
		return b, err
	case *HealthInfo:
		encoder := enc.NewEncoder()
		size, err := ___calcMapSizeHealthInfo_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, encoder)
		if err != nil {
			return nil, err
		}
		encoder.MakeBytes(size)
		b, offset, err := ___encodeMapHealthInfo_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, encoder, 0)
		if err != nil {
			return nil, err
		}
		if size != offset {
			return nil, fmt.Errorf("%s size / offset different %d : %d", "HealthInfo", size, offset)
		}
		return b, err
	case HealthResponse:
		encoder := enc.NewEncoder()
		size, err := ___calcMapSizeHealthResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, encoder)
		if err != nil {
			return nil, err
		}
		encoder.MakeBytes(size)
		b, offset, err := ___encodeMapHealthResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, encoder, 0)
		if err != nil {
			return nil, err
		}
		if size != offset {
			return nil, fmt.Errorf("%s size / offset different %d : %d", "HealthResponse", size, offset)
		}
		return b, err
	case *HealthResponse:
		encoder := enc.NewEncoder()
		size, err := ___calcMapSizeHealthResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, encoder)
		if err != nil {
			return nil, err
		}
		encoder.MakeBytes(size)
		b, offset, err := ___encodeMapHealthResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, encoder, 0)
		if err != nil {
			return nil, err
		}
		if size != offset {
			return nil, fmt.Errorf("%s size / offset different %d : %d", "HealthResponse", size, offset)
		}
		return b, err
	case SignCertificateResponse:
		encoder := enc.NewEncoder()
		size, err := ___calcMapSizeSignCertificateResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, encoder)
		if err != nil {
			return nil, err
		}
		encoder.MakeBytes(size)
		b, offset, err := ___encodeMapSignCertificateResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, encoder, 0)
		if err != nil {
			return nil, err
		}
		if size != offset {
			return nil, fmt.Errorf("%s size / offset different %d : %d", "SignCertificateResponse", size, offset)
		}
		return b, err
	case *SignCertificateResponse:
		encoder := enc.NewEncoder()
		size, err := ___calcMapSizeSignCertificateResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, encoder)
		if err != nil {
			return nil, err
		}
		encoder.MakeBytes(size)
		b, offset, err := ___encodeMapSignCertificateResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, encoder, 0)
		if err != nil {
			return nil, err
		}
		if size != offset {
			return nil, fmt.Errorf("%s size / offset different %d : %d", "SignCertificateResponse", size, offset)
		}
		return b, err
	case RevokeCertificateCommand:
		encoder := enc.NewEncoder()
		size, err := ___calcMapSizeRevokeCertificateCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, encoder)
		if err != nil {
			return nil, err
		}
		encoder.MakeBytes(size)
		b, offset, err := ___encodeMapRevokeCertificateCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, encoder, 0)
		if err != nil {
			return nil, err
		}
		if size != offset {
			return nil, fmt.Errorf("%s size / offset different %d : %d", "RevokeCertificateCommand", size, offset)
		}
		return b, err
	case *RevokeCertificateCommand:
		encoder := enc.NewEncoder()
		size, err := ___calcMapSizeRevokeCertificateCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, encoder)
		if err != nil {
			return nil, err
		}
		encoder.MakeBytes(size)
		b, offset, err := ___encodeMapRevokeCertificateCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, encoder, 0)
		if err != nil {
			return nil, err
		}
		if size != offset {
			return nil, fmt.Errorf("%s size / offset different %d : %d", "RevokeCertificateCommand", size, offset)
		}
		return b, err
	case RevokeCertificateResponse:
		encoder := enc.NewEncoder()
		size, err := ___calcMapSizeRevokeCertificateResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, encoder)
		if err != nil {
			return nil, err
		}
		encoder.MakeBytes(size)
		b, offset, err := ___encodeMapRevokeCertificateResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, encoder, 0)
		if err != nil {
			return nil, err
		}
		if size != offset {
			return nil, fmt.Errorf("%s size / offset different %d : %d", "RevokeCertificateResponse", size, offset)
		}
		return b, err
	case *RevokeCertificateResponse:
		encoder := enc.NewEncoder()
		size, err := ___calcMapSizeRevokeCertificateResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, encoder)
		if err != nil {
			return nil, err
		}
		encoder.MakeBytes(size)
		b, offset, err := ___encodeMapRevokeCertificateResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, encoder, 0)
		if err != nil {
			return nil, err
		}
		if size != offset {
			return nil, fmt.Errorf("%s size / offset different %d : %d", "RevokeCertificateResponse", size, offset)
		}
		return b, err
	case SignOpenPGPCommand:
		encoder := enc.NewEncoder()
		size, err := ___calcMapSizeSignOpenPGPCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, encoder)
		if err != nil {
			return nil, err
		}
		encoder.MakeBytes(size)
		b, offset, err := ___encodeMapSignOpenPGPCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, encoder, 0)
		if err != nil {
			return nil, err
		}
		if size != offset {
			return nil, fmt.Errorf("%s size / offset different %d : %d", "SignOpenPGPCommand", size, offset)
		}
		return b, err
	case *SignOpenPGPCommand:
		encoder := enc.NewEncoder()
		size, err := ___calcMapSizeSignOpenPGPCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, encoder)
		if err != nil {
			return nil, err
		}
		encoder.MakeBytes(size)
		b, offset, err := ___encodeMapSignOpenPGPCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, encoder, 0)
		if err != nil {
			return nil, err
		}
		if size != offset {
			return nil, fmt.Errorf("%s size / offset different %d : %d", "SignOpenPGPCommand", size, offset)
		}
		return b, err
	case SignOpenPGPResponse:
		encoder := enc.NewEncoder()
		size, err := ___calcMapSizeSignOpenPGPResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, encoder)
		if err != nil {
			return nil, err
		}
		encoder.MakeBytes(size)
		b, offset, err := ___encodeMapSignOpenPGPResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, encoder, 0)
		if err != nil {
			return nil, err
		}
		if size != offset {
			return nil, fmt.Errorf("%s size / offset different %d : %d", "SignOpenPGPResponse", size, offset)
		}
		return b, err
	case *SignOpenPGPResponse:
		encoder := enc.NewEncoder()
		size, err := ___calcMapSizeSignOpenPGPResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, encoder)
		if err != nil {
			return nil, err
		}
		encoder.MakeBytes(size)
		b, offset, err := ___encodeMapSignOpenPGPResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, encoder, 0)
		if err != nil {
			return nil, err
		}
		if size != offset {
			return nil, fmt.Errorf("%s size / offset different %d : %d", "SignOpenPGPResponse", size, offset)
		}
		return b, err
	case ErrorResponse:
		encoder := enc.NewEncoder()
		size, err := ___calcMapSizeErrorResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, encoder)
		if err != nil {
			return nil, err
		}
		encoder.MakeBytes(size)
		b, offset, err := ___encodeMapErrorResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, encoder, 0)
		if err != nil {
			return nil, err
		}
		if size != offset {
			return nil, fmt.Errorf("%s size / offset different %d : %d", "ErrorResponse", size, offset)
		}
		return b, err
	case *ErrorResponse:
		encoder := enc.NewEncoder()
		size, err := ___calcMapSizeErrorResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, encoder)
		if err != nil {
			return nil, err
		}
		encoder.MakeBytes(size)
		b, offset, err := ___encodeMapErrorResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, encoder, 0)
		if err != nil {
			return nil, err
		}
		if size != offset {
			return nil, fmt.Errorf("%s size / offset different %d : %d", "ErrorResponse", size, offset)
		}
		return b, err
	}
	return nil, nil
}

// decode
func ___decode(data []byte, i interface{}) (bool, error) {
	if msgpack.StructAsArray() {
		return ___decodeAsArray(data, i)
	} else {
		return ___decodeAsMap(data, i)
	}
}

// decodeAsArray
func ___decodeAsArray(data []byte, i interface{}) (bool, error) {
	switch v := i.(type) {
	case *CAInfoCommand:
		decoder := dec.NewDecoder(data)
		offset, err := ___decodeArrayCAInfoCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, decoder, 0)
		if err == nil && offset != decoder.Len() {
			return true, fmt.Errorf("read length is different [%d] [%d] ", offset, decoder.Len())
		}
		return true, err
	case **CAInfoCommand:
		decoder := dec.NewDecoder(data)
		offset, err := ___decodeArrayCAInfoCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, decoder, 0)
		if err == nil && offset != decoder.Len() {
			return true, fmt.Errorf("read length is different [%d] [%d] ", offset, decoder.Len())
		}
		return true, err
	case *FetchCRLCommand:
		decoder := dec.NewDecoder(data)
		offset, err := ___decodeArrayFetchCRLCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, decoder, 0)
		if err == nil && offset != decoder.Len() {
			return true, fmt.Errorf("read length is different [%d] [%d] ", offset, decoder.Len())
		}
		return true, err
	case **FetchCRLCommand:
		decoder := dec.NewDecoder(data)
		offset, err := ___decodeArrayFetchCRLCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, decoder, 0)
		if err == nil && offset != decoder.Len() {
			return true, fmt.Errorf("read length is different [%d] [%d] ", offset, decoder.Len())
		}
		return true, err
	case *FetchCRLResponse:
		decoder := dec.NewDecoder(data)
		offset, err := ___decodeArrayFetchCRLResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, decoder, 0)
		if err == nil && offset != decoder.Len() {
			return true, fmt.Errorf("read length is different [%d] [%d] ", offset, decoder.Len())
		}
		return true, err
	case **FetchCRLResponse:
		decoder := dec.NewDecoder(data)
		offset, err := ___decodeArrayFetchCRLResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, decoder, 0)
		if err == nil && offset != decoder.Len() {
			return true, fmt.Errorf("read length is different [%d] [%d] ", offset, decoder.Len())
		}
		return true, err
	case *HealthCommand:
		decoder := dec.NewDecoder(data)
		offset, err := ___decodeArrayHealthCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, decoder, 0)
		if err == nil && offset != decoder.Len() {
			return true, fmt.Errorf("read length is different [%d] [%d] ", offset, decoder.Len())
		}
		return true, err
	case **HealthCommand:
		decoder := dec.NewDecoder(data)
		offset, err := ___decodeArrayHealthCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, decoder, 0)
		if err == nil && offset != decoder.Len() {
			return true, fmt.Errorf("read length is different [%d] [%d] ", offset, decoder.Len())
		}
		return true, err
	case *HealthInfo:
		decoder := dec.NewDecoder(data)
		offset, err := ___decodeArrayHealthInfo_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, decoder, 0)
		if err == nil && offset != decoder.Len() {
			return true, fmt.Errorf("read length is different [%d] [%d] ", offset, decoder.Len())
		}
		return true, err
	case **HealthInfo:
		decoder := dec.NewDecoder(data)
		offset, err := ___decodeArrayHealthInfo_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, decoder, 0)
		if err == nil && offset != decoder.Len() {
			return true, fmt.Errorf("read length is different [%d] [%d] ", offset, decoder.Len())
		}
		return true, err
	case *HealthResponse:
		decoder := dec.NewDecoder(data)
		offset, err := ___decodeArrayHealthResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, decoder, 0)
		if err == nil && offset != decoder.Len() {
			return true, fmt.Errorf("read length is different [%d] [%d] ", offset, decoder.Len())
		}
		return true, err
	case **HealthResponse:
		decoder := dec.NewDecoder(data)
		offset, err := ___decodeArrayHealthResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, decoder, 0)
		if err == nil && offset != decoder.Len() {
			return true, fmt.Errorf("read length is different [%d] [%d] ", offset, decoder.Len())
		}
		return true, err
	case *SignCertificateResponse:
		decoder := dec.NewDecoder(data)
		offset, err := ___decodeArraySignCertificateResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, decoder, 0)
		if err == nil && offset != decoder.Len() {
			return true, fmt.Errorf("read length is different [%d] [%d] ", offset, decoder.Len())
		}
		return true, err
	case **SignCertificateResponse:
		decoder := dec.NewDecoder(data)
		offset, err := ___decodeArraySignCertificateResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, decoder, 0)
		if err == nil && offset != decoder.Len() {
			return true, fmt.Errorf("read length is different [%d] [%d] ", offset, decoder.Len())
		}
		return true, err
	case *RevokeCertificateCommand:
		decoder := dec.NewDecoder(data)
		offset, err := ___decodeArrayRevokeCertificateCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, decoder, 0)
		if err == nil && offset != decoder.Len() {
			return true, fmt.Errorf("read length is different [%d] [%d] ", offset, decoder.Len())
		}
		return true, err
	case **RevokeCertificateCommand:
		decoder := dec.NewDecoder(data)
		offset, err := ___decodeArrayRevokeCertificateCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, decoder, 0)
		if err == nil && offset != decoder.Len() {
			return true, fmt.Errorf("read length is different [%d] [%d] ", offset, decoder.Len())
		}
		return true, err
	case *RevokeCertificateResponse:
		decoder := dec.NewDecoder(data)
		offset, err := ___decodeArrayRevokeCertificateResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, decoder, 0)
		if err == nil && offset != decoder.Len() {
			return true, fmt.Errorf("read length is different [%d] [%d] ", offset, decoder.Len())
		}
		return true, err
	case **RevokeCertificateResponse:
		decoder := dec.NewDecoder(data)
		offset, err := ___decodeArrayRevokeCertificateResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, decoder, 0)
		if err == nil && offset != decoder.Len() {
			return true, fmt.Errorf("read length is different [%d] [%d] ", offset, decoder.Len())
		}
		return true, err
	case *SignOpenPGPCommand:
		decoder := dec.NewDecoder(data)
		offset, err := ___decodeArraySignOpenPGPCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, decoder, 0)
		if err == nil && offset != decoder.Len() {
			return true, fmt.Errorf("read length is different [%d] [%d] ", offset, decoder.Len())
		}
		return true, err
	case **SignOpenPGPCommand:
		decoder := dec.NewDecoder(data)
		offset, err := ___decodeArraySignOpenPGPCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, decoder, 0)
		if err == nil && offset != decoder.Len() {
			return true, fmt.Errorf("read length is different [%d] [%d] ", offset, decoder.Len())
		}
		return true, err
	case *SignOpenPGPResponse:
		decoder := dec.NewDecoder(data)
		offset, err := ___decodeArraySignOpenPGPResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, decoder, 0)
		if err == nil && offset != decoder.Len() {
			return true, fmt.Errorf("read length is different [%d] [%d] ", offset, decoder.Len())
		}
		return true, err
	case **SignOpenPGPResponse:
		decoder := dec.NewDecoder(data)
		offset, err := ___decodeArraySignOpenPGPResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, decoder, 0)
		if err == nil && offset != decoder.Len() {
			return true, fmt.Errorf("read length is different [%d] [%d] ", offset, decoder.Len())
		}
		return true, err
	case *ErrorResponse:
		decoder := dec.NewDecoder(data)
		offset, err := ___decodeArrayErrorResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, decoder, 0)
		if err == nil && offset != decoder.Len() {
			return true, fmt.Errorf("read length is different [%d] [%d] ", offset, decoder.Len())
		}
		return true, err
	case **ErrorResponse:
		decoder := dec.NewDecoder(data)
		offset, err := ___decodeArrayErrorResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, decoder, 0)
		if err == nil && offset != decoder.Len() {
			return true, fmt.Errorf("read length is different [%d] [%d] ", offset, decoder.Len())
		}
		return true, err
	}
	return false, nil
}

// decodeAsMap
func ___decodeAsMap(data []byte, i interface{}) (bool, error) {
	switch v := i.(type) {
	case *CAInfoCommand:
		decoder := dec.NewDecoder(data)
		offset, err := ___decodeMapCAInfoCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, decoder, 0)
		if err == nil && offset != decoder.Len() {
			return true, fmt.Errorf("read length is different [%d] [%d] ", offset, decoder.Len())
		}
		return true, err
	case **CAInfoCommand:
		decoder := dec.NewDecoder(data)
		offset, err := ___decodeMapCAInfoCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, decoder, 0)
		if err == nil && offset != decoder.Len() {
			return true, fmt.Errorf("read length is different [%d] [%d] ", offset, decoder.Len())
		}
		return true, err
	case *FetchCRLCommand:
		decoder := dec.NewDecoder(data)
		offset, err := ___decodeMapFetchCRLCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, decoder, 0)
		if err == nil && offset != decoder.Len() {
			return true, fmt.Errorf("read length is different [%d] [%d] ", offset, decoder.Len())
		}
		return true, err
	case **FetchCRLCommand:
		decoder := dec.NewDecoder(data)
		offset, err := ___decodeMapFetchCRLCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, decoder, 0)
		if err == nil && offset != decoder.Len() {
			return true, fmt.Errorf("read length is different [%d] [%d] ", offset, decoder.Len())
		}
		return true, err
	case *FetchCRLResponse:
		decoder := dec.NewDecoder(data)
		offset, err := ___decodeMapFetchCRLResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, decoder, 0)
		if err == nil && offset != decoder.Len() {
			return true, fmt.Errorf("read length is different [%d] [%d] ", offset, decoder.Len())
		}
		return true, err
	case **FetchCRLResponse:
		decoder := dec.NewDecoder(data)
		offset, err := ___decodeMapFetchCRLResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, decoder, 0)
		if err == nil && offset != decoder.Len() {
			return true, fmt.Errorf("read length is different [%d] [%d] ", offset, decoder.Len())
		}
		return true, err
	case *HealthCommand:
		decoder := dec.NewDecoder(data)
		offset, err := ___decodeMapHealthCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, decoder, 0)
		if err == nil && offset != decoder.Len() {
			return true, fmt.Errorf("read length is different [%d] [%d] ", offset, decoder.Len())
		}
		return true, err
	case **HealthCommand:
		decoder := dec.NewDecoder(data)
		offset, err := ___decodeMapHealthCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, decoder, 0)
		if err == nil && offset != decoder.Len() {
			return true, fmt.Errorf("read length is different [%d] [%d] ", offset, decoder.Len())
		}
		return true, err
	case *HealthInfo:
		decoder := dec.NewDecoder(data)
		offset, err := ___decodeMapHealthInfo_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, decoder, 0)
		if err == nil && offset != decoder.Len() {
			return true, fmt.Errorf("read length is different [%d] [%d] ", offset, decoder.Len())
		}
		return true, err
	case **HealthInfo:
		decoder := dec.NewDecoder(data)
		offset, err := ___decodeMapHealthInfo_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, decoder, 0)
		if err == nil && offset != decoder.Len() {
			return true, fmt.Errorf("read length is different [%d] [%d] ", offset, decoder.Len())
		}
		return true, err
	case *HealthResponse:
		decoder := dec.NewDecoder(data)
		offset, err := ___decodeMapHealthResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, decoder, 0)
		if err == nil && offset != decoder.Len() {
			return true, fmt.Errorf("read length is different [%d] [%d] ", offset, decoder.Len())
		}
		return true, err
	case **HealthResponse:
		decoder := dec.NewDecoder(data)
		offset, err := ___decodeMapHealthResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, decoder, 0)
		if err == nil && offset != decoder.Len() {
			return true, fmt.Errorf("read length is different [%d] [%d] ", offset, decoder.Len())
		}
		return true, err
	case *SignCertificateResponse:
		decoder := dec.NewDecoder(data)
		offset, err := ___decodeMapSignCertificateResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, decoder, 0)
		if err == nil && offset != decoder.Len() {
			return true, fmt.Errorf("read length is different [%d] [%d] ", offset, decoder.Len())
		}
		return true, err
	case **SignCertificateResponse:
		decoder := dec.NewDecoder(data)
		offset, err := ___decodeMapSignCertificateResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, decoder, 0)
		if err == nil && offset != decoder.Len() {
			return true, fmt.Errorf("read length is different [%d] [%d] ", offset, decoder.Len())
		}
		return true, err
	case *RevokeCertificateCommand:
		decoder := dec.NewDecoder(data)
		offset, err := ___decodeMapRevokeCertificateCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, decoder, 0)
		if err == nil && offset != decoder.Len() {
			return true, fmt.Errorf("read length is different [%d] [%d] ", offset, decoder.Len())
		}
		return true, err
	case **RevokeCertificateCommand:
		decoder := dec.NewDecoder(data)
		offset, err := ___decodeMapRevokeCertificateCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, decoder, 0)
		if err == nil && offset != decoder.Len() {
			return true, fmt.Errorf("read length is different [%d] [%d] ", offset, decoder.Len())
		}
		return true, err
	case *RevokeCertificateResponse:
		decoder := dec.NewDecoder(data)
		offset, err := ___decodeMapRevokeCertificateResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, decoder, 0)
		if err == nil && offset != decoder.Len() {
			return true, fmt.Errorf("read length is different [%d] [%d] ", offset, decoder.Len())
		}
		return true, err
	case **RevokeCertificateResponse:
		decoder := dec.NewDecoder(data)
		offset, err := ___decodeMapRevokeCertificateResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, decoder, 0)
		if err == nil && offset != decoder.Len() {
			return true, fmt.Errorf("read length is different [%d] [%d] ", offset, decoder.Len())
		}
		return true, err
	case *SignOpenPGPCommand:
		decoder := dec.NewDecoder(data)
		offset, err := ___decodeMapSignOpenPGPCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, decoder, 0)
		if err == nil && offset != decoder.Len() {
			return true, fmt.Errorf("read length is different [%d] [%d] ", offset, decoder.Len())
		}
		return true, err
	case **SignOpenPGPCommand:
		decoder := dec.NewDecoder(data)
		offset, err := ___decodeMapSignOpenPGPCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, decoder, 0)
		if err == nil && offset != decoder.Len() {
			return true, fmt.Errorf("read length is different [%d] [%d] ", offset, decoder.Len())
		}
		return true, err
	case *SignOpenPGPResponse:
		decoder := dec.NewDecoder(data)
		offset, err := ___decodeMapSignOpenPGPResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, decoder, 0)
		if err == nil && offset != decoder.Len() {
			return true, fmt.Errorf("read length is different [%d] [%d] ", offset, decoder.Len())
		}
		return true, err
	case **SignOpenPGPResponse:
		decoder := dec.NewDecoder(data)
		offset, err := ___decodeMapSignOpenPGPResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, decoder, 0)
		if err == nil && offset != decoder.Len() {
			return true, fmt.Errorf("read length is different [%d] [%d] ", offset, decoder.Len())
		}
		return true, err
	case *ErrorResponse:
		decoder := dec.NewDecoder(data)
		offset, err := ___decodeMapErrorResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v, decoder, 0)
		if err == nil && offset != decoder.Len() {
			return true, fmt.Errorf("read length is different [%d] [%d] ", offset, decoder.Len())
		}
		return true, err
	case **ErrorResponse:
		decoder := dec.NewDecoder(data)
		offset, err := ___decodeMapErrorResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(*v, decoder, 0)
		if err == nil && offset != decoder.Len() {
			return true, fmt.Errorf("read length is different [%d] [%d] ", offset, decoder.Len())
		}
		return true, err
	}
	return false, nil
}

// calculate size from git.cacert.org/cacert-gosigner/pkg/messages.CAInfoCommand
func ___calcArraySizeCAInfoCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v CAInfoCommand, encoder *enc.Encoder) (int, error) {
	size := 0
	size += encoder.CalcStructHeaderFix(1)
	size += encoder.CalcString(v.Name)
	return size, nil
}

// calculate size from git.cacert.org/cacert-gosigner/pkg/messages.CAInfoCommand
func ___calcMapSizeCAInfoCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v CAInfoCommand, encoder *enc.Encoder) (int, error) {
	size := 0
	size += encoder.CalcStructHeaderFix(1)
	size += encoder.CalcStringFix(4)
	size += encoder.CalcString(v.Name)
	return size, nil
}

// encode from git.cacert.org/cacert-gosigner/pkg/messages.CAInfoCommand
func ___encodeArrayCAInfoCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v CAInfoCommand, encoder *enc.Encoder, offset int) ([]byte, int, error) {
	var err error
	offset = encoder.WriteStructHeaderFixAsArray(1, offset)
	offset = encoder.WriteString(v.Name, offset)
	return encoder.EncodedBytes(), offset, err
}

// encode from git.cacert.org/cacert-gosigner/pkg/messages.CAInfoCommand
func ___encodeMapCAInfoCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v CAInfoCommand, encoder *enc.Encoder, offset int) ([]byte, int, error) {
	var err error
	offset = encoder.WriteStructHeaderFixAsMap(1, offset)
	offset = encoder.WriteStringFix("name", 4, offset)
	offset = encoder.WriteString(v.Name, offset)
	return encoder.EncodedBytes(), offset, err
}

// decode to git.cacert.org/cacert-gosigner/pkg/messages.CAInfoCommand
func ___decodeArrayCAInfoCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v *CAInfoCommand, decoder *dec.Decoder, offset int) (int, error) {
	offset, err := decoder.CheckStructHeader(1, offset)
	if err != nil {
		return 0, err
	}
	{
		var vv string
		vv, offset, err = decoder.AsString(offset)
		if err != nil {
			return 0, err
		}
		v.Name = vv
	}
	return offset, err
}

// decode to git.cacert.org/cacert-gosigner/pkg/messages.CAInfoCommand
func ___decodeMapCAInfoCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v *CAInfoCommand, decoder *dec.Decoder, offset int) (int, error) {
	keys := [][]byte{
		{uint8(0x6e), uint8(0x61), uint8(0x6d), uint8(0x65)}, // name
	}
	offset, err := decoder.CheckStructHeader(1, offset)
	if err != nil {
		return 0, err
	}
	count := 0
	for count < 1 {
		var dataKey []byte
		dataKey, offset, err = decoder.AsStringBytes(offset)
		if err != nil {
			return 0, err
		}
		fieldIndex := -1
		for i, key := range keys {
			if len(dataKey) != len(key) {
				continue
			}
			fieldIndex = i
			for dataKeyIndex := range dataKey {
				if dataKey[dataKeyIndex] != key[dataKeyIndex] {
					fieldIndex = -1
					break
				}
			}
			if fieldIndex >= 0 {
				break
			}
		}
		switch fieldIndex {
		case 0:
			{
				var vv string
				vv, offset, err = decoder.AsString(offset)
				if err != nil {
					return 0, err
				}
				v.Name = vv
			}
			count++
		default:
			return 0, fmt.Errorf("unknown key[%s] found", string(dataKey))
		}
	}
	return offset, err
}

// calculate size from git.cacert.org/cacert-gosigner/pkg/messages.FetchCRLCommand
func ___calcArraySizeFetchCRLCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v FetchCRLCommand, encoder *enc.Encoder) (int, error) {
	size := 0
	size += encoder.CalcStructHeaderFix(2)
	size += encoder.CalcString(v.IssuerID)
	if v.LastKnownID != nil {
		s, err := encoder.CalcSliceLength(len(v.LastKnownID), true)
		if err != nil {
			return 0, err
		}
		size += s
		for _, vv := range v.LastKnownID {
			size += encoder.CalcByte(vv)
		}
	} else {
		size += encoder.CalcNil()
	}
	return size, nil
}

// calculate size from git.cacert.org/cacert-gosigner/pkg/messages.FetchCRLCommand
func ___calcMapSizeFetchCRLCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v FetchCRLCommand, encoder *enc.Encoder) (int, error) {
	size := 0
	size += encoder.CalcStructHeaderFix(2)
	size += encoder.CalcStringFix(9)
	size += encoder.CalcString(v.IssuerID)
	size += encoder.CalcStringFix(13)
	if v.LastKnownID != nil {
		s, err := encoder.CalcSliceLength(len(v.LastKnownID), true)
		if err != nil {
			return 0, err
		}
		size += s
		for _, vv := range v.LastKnownID {
			size += encoder.CalcByte(vv)
		}
	} else {
		size += encoder.CalcNil()
	}
	return size, nil
}

// encode from git.cacert.org/cacert-gosigner/pkg/messages.FetchCRLCommand
func ___encodeArrayFetchCRLCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v FetchCRLCommand, encoder *enc.Encoder, offset int) ([]byte, int, error) {
	var err error
	offset = encoder.WriteStructHeaderFixAsArray(2, offset)
	offset = encoder.WriteString(v.IssuerID, offset)
	if v.LastKnownID != nil {
		offset = encoder.WriteSliceLength(len(v.LastKnownID), offset, true)
		for _, vv := range v.LastKnownID {
			offset = encoder.WriteByte(vv, offset)
		}
	} else {
		offset = encoder.WriteNil(offset)
	}
	return encoder.EncodedBytes(), offset, err
}

// encode from git.cacert.org/cacert-gosigner/pkg/messages.FetchCRLCommand
func ___encodeMapFetchCRLCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v FetchCRLCommand, encoder *enc.Encoder, offset int) ([]byte, int, error) {
	var err error
	offset = encoder.WriteStructHeaderFixAsMap(2, offset)
	offset = encoder.WriteStringFix("issuer_id", 9, offset)
	offset = encoder.WriteString(v.IssuerID, offset)
	offset = encoder.WriteStringFix("last_known_id", 13, offset)
	if v.LastKnownID != nil {
		offset = encoder.WriteSliceLength(len(v.LastKnownID), offset, true)
		for _, vv := range v.LastKnownID {
			offset = encoder.WriteByte(vv, offset)
		}
	} else {
		offset = encoder.WriteNil(offset)
	}
	return encoder.EncodedBytes(), offset, err
}

// decode to git.cacert.org/cacert-gosigner/pkg/messages.FetchCRLCommand
func ___decodeArrayFetchCRLCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v *FetchCRLCommand, decoder *dec.Decoder, offset int) (int, error) {
	offset, err := decoder.CheckStructHeader(2, offset)
	if err != nil {
		return 0, err
	}
	{
		var vv string
		vv, offset, err = decoder.AsString(offset)
		if err != nil {
			return 0, err
		}
		v.IssuerID = vv
	}
	if !decoder.IsCodeNil(offset) {
		var vv []byte
		var vvl int
		vvl, offset, err = decoder.SliceLength(offset)
		if err != nil {
			return 0, err
		}
		vv = make([]byte, vvl)
		for vvi := range vv {
			var vvv byte
			vvv, offset, err = decoder.AsByte(offset)
			if err != nil {
				return 0, err
			}
			vv[vvi] = vvv
		}
		v.LastKnownID = vv
	} else {
		offset++
	}
	return offset, err
}

// decode to git.cacert.org/cacert-gosigner/pkg/messages.FetchCRLCommand
func ___decodeMapFetchCRLCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v *FetchCRLCommand, decoder *dec.Decoder, offset int) (int, error) {
	keys := [][]byte{
		{uint8(0x69), uint8(0x73), uint8(0x73), uint8(0x75), uint8(0x65), uint8(0x72), uint8(0x5f), uint8(0x69), uint8(0x64)},                                                     // issuer_id
		{uint8(0x6c), uint8(0x61), uint8(0x73), uint8(0x74), uint8(0x5f), uint8(0x6b), uint8(0x6e), uint8(0x6f), uint8(0x77), uint8(0x6e), uint8(0x5f), uint8(0x69), uint8(0x64)}, // last_known_id
	}
	offset, err := decoder.CheckStructHeader(2, offset)
	if err != nil {
		return 0, err
	}
	count := 0
	for count < 2 {
		var dataKey []byte
		dataKey, offset, err = decoder.AsStringBytes(offset)
		if err != nil {
			return 0, err
		}
		fieldIndex := -1
		for i, key := range keys {
			if len(dataKey) != len(key) {
				continue
			}
			fieldIndex = i
			for dataKeyIndex := range dataKey {
				if dataKey[dataKeyIndex] != key[dataKeyIndex] {
					fieldIndex = -1
					break
				}
			}
			if fieldIndex >= 0 {
				break
			}
		}
		switch fieldIndex {
		case 0:
			{
				var vv string
				vv, offset, err = decoder.AsString(offset)
				if err != nil {
					return 0, err
				}
				v.IssuerID = vv
			}
			count++
		case 1:
			if !decoder.IsCodeNil(offset) {
				var vv []byte
				var vvl int
				vvl, offset, err = decoder.SliceLength(offset)
				if err != nil {
					return 0, err
				}
				vv = make([]byte, vvl)
				for vvi := range vv {
					var vvv byte
					vvv, offset, err = decoder.AsByte(offset)
					if err != nil {
						return 0, err
					}
					vv[vvi] = vvv
				}
				v.LastKnownID = vv
			} else {
				offset++
			}
			count++
		default:
			return 0, fmt.Errorf("unknown key[%s] found", string(dataKey))
		}
	}
	return offset, err
}

// calculate size from git.cacert.org/cacert-gosigner/pkg/messages.FetchCRLResponse
func ___calcArraySizeFetchCRLResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v FetchCRLResponse, encoder *enc.Encoder) (int, error) {
	size := 0
	size += encoder.CalcStructHeaderFix(5)
	size += encoder.CalcString(v.IssuerID)
	size += encoder.CalcBool(v.IsDelta)
	size += encoder.CalcBool(v.UnChanged)
	if v.CRLData != nil {
		s, err := encoder.CalcSliceLength(len(v.CRLData), true)
		if err != nil {
			return 0, err
		}
		size += s
		for _, vv := range v.CRLData {
			size += encoder.CalcByte(vv)
		}
	} else {
		size += encoder.CalcNil()
	}
	if v.CRLNumber != nil {
		s, err := encoder.CalcSliceLength(len(v.CRLNumber), true)
		if err != nil {
			return 0, err
		}
		size += s
		for _, vv := range v.CRLNumber {
			size += encoder.CalcByte(vv)
		}
	} else {
		size += encoder.CalcNil()
	}
	return size, nil
}

// calculate size from git.cacert.org/cacert-gosigner/pkg/messages.FetchCRLResponse
func ___calcMapSizeFetchCRLResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v FetchCRLResponse, encoder *enc.Encoder) (int, error) {
	size := 0
	size += encoder.CalcStructHeaderFix(5)
	size += encoder.CalcStringFix(9)
	size += encoder.CalcString(v.IssuerID)
	size += encoder.CalcStringFix(8)
	size += encoder.CalcBool(v.IsDelta)
	size += encoder.CalcStringFix(9)
	size += encoder.CalcBool(v.UnChanged)
	size += encoder.CalcStringFix(8)
	if v.CRLData != nil {
		s, err := encoder.CalcSliceLength(len(v.CRLData), true)
		if err != nil {
			return 0, err
		}
		size += s
		for _, vv := range v.CRLData {
			size += encoder.CalcByte(vv)
		}
	} else {
		size += encoder.CalcNil()
	}
	size += encoder.CalcStringFix(10)
	if v.CRLNumber != nil {
		s, err := encoder.CalcSliceLength(len(v.CRLNumber), true)
		if err != nil {
			return 0, err
		}
		size += s
		for _, vv := range v.CRLNumber {
			size += encoder.CalcByte(vv)
		}
	} else {
		size += encoder.CalcNil()
	}
	return size, nil
}

// encode from git.cacert.org/cacert-gosigner/pkg/messages.FetchCRLResponse
func ___encodeArrayFetchCRLResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v FetchCRLResponse, encoder *enc.Encoder, offset int) ([]byte, int, error) {
	var err error
	offset = encoder.WriteStructHeaderFixAsArray(5, offset)
	offset = encoder.WriteString(v.IssuerID, offset)
	offset = encoder.WriteBool(v.IsDelta, offset)
	offset = encoder.WriteBool(v.UnChanged, offset)
	if v.CRLData != nil {
		offset = encoder.WriteSliceLength(len(v.CRLData), offset, true)
		for _, vv := range v.CRLData {
			offset = encoder.WriteByte(vv, offset)
		}
	} else {
		offset = encoder.WriteNil(offset)
	}
	if v.CRLNumber != nil {
		offset = encoder.WriteSliceLength(len(v.CRLNumber), offset, true)
		for _, vv := range v.CRLNumber {
			offset = encoder.WriteByte(vv, offset)
		}
	} else {
		offset = encoder.WriteNil(offset)
	}
	return encoder.EncodedBytes(), offset, err
}

// encode from git.cacert.org/cacert-gosigner/pkg/messages.FetchCRLResponse
func ___encodeMapFetchCRLResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v FetchCRLResponse, encoder *enc.Encoder, offset int) ([]byte, int, error) {
	var err error
	offset = encoder.WriteStructHeaderFixAsMap(5, offset)
	offset = encoder.WriteStringFix("issuer_id", 9, offset)
	offset = encoder.WriteString(v.IssuerID, offset)
	offset = encoder.WriteStringFix("is_delta", 8, offset)
	offset = encoder.WriteBool(v.IsDelta, offset)
	offset = encoder.WriteStringFix("unchanged", 9, offset)
	offset = encoder.WriteBool(v.UnChanged, offset)
	offset = encoder.WriteStringFix("crl_data", 8, offset)
	if v.CRLData != nil {
		offset = encoder.WriteSliceLength(len(v.CRLData), offset, true)
		for _, vv := range v.CRLData {
			offset = encoder.WriteByte(vv, offset)
		}
	} else {
		offset = encoder.WriteNil(offset)
	}
	offset = encoder.WriteStringFix("crl_number", 10, offset)
	if v.CRLNumber != nil {
		offset = encoder.WriteSliceLength(len(v.CRLNumber), offset, true)
		for _, vv := range v.CRLNumber {
			offset = encoder.WriteByte(vv, offset)
		}
	} else {
		offset = encoder.WriteNil(offset)
	}
	return encoder.EncodedBytes(), offset, err
}

// decode to git.cacert.org/cacert-gosigner/pkg/messages.FetchCRLResponse
func ___decodeArrayFetchCRLResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v *FetchCRLResponse, decoder *dec.Decoder, offset int) (int, error) {
	offset, err := decoder.CheckStructHeader(5, offset)
	if err != nil {
		return 0, err
	}
	{
		var vv string
		vv, offset, err = decoder.AsString(offset)
		if err != nil {
			return 0, err
		}
		v.IssuerID = vv
	}
	{
		var vv bool
		vv, offset, err = decoder.AsBool(offset)
		if err != nil {
			return 0, err
		}
		v.IsDelta = vv
	}
	{
		var vv bool
		vv, offset, err = decoder.AsBool(offset)
		if err != nil {
			return 0, err
		}
		v.UnChanged = vv
	}
	if !decoder.IsCodeNil(offset) {
		var vv []byte
		var vvl int
		vvl, offset, err = decoder.SliceLength(offset)
		if err != nil {
			return 0, err
		}
		vv = make([]byte, vvl)
		for vvi := range vv {
			var vvv byte
			vvv, offset, err = decoder.AsByte(offset)
			if err != nil {
				return 0, err
			}
			vv[vvi] = vvv
		}
		v.CRLData = vv
	} else {
		offset++
	}
	if !decoder.IsCodeNil(offset) {
		var vv []byte
		var vvl int
		vvl, offset, err = decoder.SliceLength(offset)
		if err != nil {
			return 0, err
		}
		vv = make([]byte, vvl)
		for vvi := range vv {
			var vvv byte
			vvv, offset, err = decoder.AsByte(offset)
			if err != nil {
				return 0, err
			}
			vv[vvi] = vvv
		}
		v.CRLNumber = vv
	} else {
		offset++
	}
	return offset, err
}

// decode to git.cacert.org/cacert-gosigner/pkg/messages.FetchCRLResponse
func ___decodeMapFetchCRLResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v *FetchCRLResponse, decoder *dec.Decoder, offset int) (int, error) {
	keys := [][]byte{
		{uint8(0x69), uint8(0x73), uint8(0x73), uint8(0x75), uint8(0x65), uint8(0x72), uint8(0x5f), uint8(0x69), uint8(0x64)},              // issuer_id
		{uint8(0x69), uint8(0x73), uint8(0x5f), uint8(0x64), uint8(0x65), uint8(0x6c), uint8(0x74), uint8(0x61)},                           // is_delta
		{uint8(0x75), uint8(0x6e), uint8(0x63), uint8(0x68), uint8(0x61), uint8(0x6e), uint8(0x67), uint8(0x65), uint8(0x64)},              // unchanged
		{uint8(0x63), uint8(0x72), uint8(0x6c), uint8(0x5f), uint8(0x64), uint8(0x61), uint8(0x74), uint8(0x61)},                           // crl_data
		{uint8(0x63), uint8(0x72), uint8(0x6c), uint8(0x5f), uint8(0x6e), uint8(0x75), uint8(0x6d), uint8(0x62), uint8(0x65), uint8(0x72)}, // crl_number
	}
	offset, err := decoder.CheckStructHeader(5, offset)
	if err != nil {
		return 0, err
	}
	count := 0
	for count < 5 {
		var dataKey []byte
		dataKey, offset, err = decoder.AsStringBytes(offset)
		if err != nil {
			return 0, err
		}
		fieldIndex := -1
		for i, key := range keys {
			if len(dataKey) != len(key) {
				continue
			}
			fieldIndex = i
			for dataKeyIndex := range dataKey {
				if dataKey[dataKeyIndex] != key[dataKeyIndex] {
					fieldIndex = -1
					break
				}
			}
			if fieldIndex >= 0 {
				break
			}
		}
		switch fieldIndex {
		case 0:
			{
				var vv string
				vv, offset, err = decoder.AsString(offset)
				if err != nil {
					return 0, err
				}
				v.IssuerID = vv
			}
			count++
		case 1:
			{
				var vv bool
				vv, offset, err = decoder.AsBool(offset)
				if err != nil {
					return 0, err
				}
				v.IsDelta = vv
			}
			count++
		case 2:
			{
				var vv bool
				vv, offset, err = decoder.AsBool(offset)
				if err != nil {
					return 0, err
				}
				v.UnChanged = vv
			}
			count++
		case 3:
			if !decoder.IsCodeNil(offset) {
				var vv []byte
				var vvl int
				vvl, offset, err = decoder.SliceLength(offset)
				if err != nil {
					return 0, err
				}
				vv = make([]byte, vvl)
				for vvi := range vv {
					var vvv byte
					vvv, offset, err = decoder.AsByte(offset)
					if err != nil {
						return 0, err
					}
					vv[vvi] = vvv
				}
				v.CRLData = vv
			} else {
				offset++
			}
			count++
		case 4:
			if !decoder.IsCodeNil(offset) {
				var vv []byte
				var vvl int
				vvl, offset, err = decoder.SliceLength(offset)
				if err != nil {
					return 0, err
				}
				vv = make([]byte, vvl)
				for vvi := range vv {
					var vvv byte
					vvv, offset, err = decoder.AsByte(offset)
					if err != nil {
						return 0, err
					}
					vv[vvi] = vvv
				}
				v.CRLNumber = vv
			} else {
				offset++
			}
			count++
		default:
			return 0, fmt.Errorf("unknown key[%s] found", string(dataKey))
		}
	}
	return offset, err
}

// calculate size from git.cacert.org/cacert-gosigner/pkg/messages.HealthCommand
func ___calcArraySizeHealthCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v HealthCommand, encoder *enc.Encoder) (int, error) {
	size := 0
	size += encoder.CalcStructHeaderFix(0)
	return size, nil
}

// calculate size from git.cacert.org/cacert-gosigner/pkg/messages.HealthCommand
func ___calcMapSizeHealthCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v HealthCommand, encoder *enc.Encoder) (int, error) {
	size := 0
	size += encoder.CalcStructHeaderFix(0)
	return size, nil
}

// encode from git.cacert.org/cacert-gosigner/pkg/messages.HealthCommand
func ___encodeArrayHealthCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v HealthCommand, encoder *enc.Encoder, offset int) ([]byte, int, error) {
	var err error
	offset = encoder.WriteStructHeaderFixAsArray(0, offset)
	return encoder.EncodedBytes(), offset, err
}

// encode from git.cacert.org/cacert-gosigner/pkg/messages.HealthCommand
func ___encodeMapHealthCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v HealthCommand, encoder *enc.Encoder, offset int) ([]byte, int, error) {
	var err error
	offset = encoder.WriteStructHeaderFixAsMap(0, offset)
	return encoder.EncodedBytes(), offset, err
}

// decode to git.cacert.org/cacert-gosigner/pkg/messages.HealthCommand
func ___decodeArrayHealthCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v *HealthCommand, decoder *dec.Decoder, offset int) (int, error) {
	offset, err := decoder.CheckStructHeader(0, offset)
	if err != nil {
		return 0, err
	}
	return offset, err
}

// decode to git.cacert.org/cacert-gosigner/pkg/messages.HealthCommand
func ___decodeMapHealthCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v *HealthCommand, decoder *dec.Decoder, offset int) (int, error) {
	keys := [][]byte{}
	offset, err := decoder.CheckStructHeader(0, offset)
	if err != nil {
		return 0, err
	}
	count := 0
	for count < 0 {
		var dataKey []byte
		dataKey, offset, err = decoder.AsStringBytes(offset)
		if err != nil {
			return 0, err
		}
		fieldIndex := -1
		for i, key := range keys {
			if len(dataKey) != len(key) {
				continue
			}
			fieldIndex = i
			for dataKeyIndex := range dataKey {
				if dataKey[dataKeyIndex] != key[dataKeyIndex] {
					fieldIndex = -1
					break
				}
			}
			if fieldIndex >= 0 {
				break
			}
		}
		switch fieldIndex {
		default:
			return 0, fmt.Errorf("unknown key[%s] found", string(dataKey))
		}
	}
	return offset, err
}

// calculate size from git.cacert.org/cacert-gosigner/pkg/messages.HealthInfo
func ___calcArraySizeHealthInfo_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v HealthInfo, encoder *enc.Encoder) (int, error) {
	size := 0
	size += encoder.CalcStructHeaderFix(3)
	size += encoder.CalcString(v.Source)
	size += encoder.CalcBool(v.Healthy)
	if v.MoreInfo != nil {
		s, err := encoder.CalcMapLength(len(v.MoreInfo))
		if err != nil {
			return 0, err
		}
		size += s
		for kk, vv := range v.MoreInfo {
			size += encoder.CalcString(kk)
			size += encoder.CalcString(vv)
		}
	} else {
		size += encoder.CalcNil()
	}
	return size, nil
}

// calculate size from git.cacert.org/cacert-gosigner/pkg/messages.HealthInfo
func ___calcMapSizeHealthInfo_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v HealthInfo, encoder *enc.Encoder) (int, error) {
	size := 0
	size += encoder.CalcStructHeaderFix(3)
	size += encoder.CalcStringFix(6)
	size += encoder.CalcString(v.Source)
	size += encoder.CalcStringFix(7)
	size += encoder.CalcBool(v.Healthy)
	size += encoder.CalcStringFix(8)
	if v.MoreInfo != nil {
		s, err := encoder.CalcMapLength(len(v.MoreInfo))
		if err != nil {
			return 0, err
		}
		size += s
		for kk, vv := range v.MoreInfo {
			size += encoder.CalcString(kk)
			size += encoder.CalcString(vv)
		}
	} else {
		size += encoder.CalcNil()
	}
	return size, nil
}

// encode from git.cacert.org/cacert-gosigner/pkg/messages.HealthInfo
func ___encodeArrayHealthInfo_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v HealthInfo, encoder *enc.Encoder, offset int) ([]byte, int, error) {
	var err error
	offset = encoder.WriteStructHeaderFixAsArray(3, offset)
	offset = encoder.WriteString(v.Source, offset)
	offset = encoder.WriteBool(v.Healthy, offset)
	if v.MoreInfo != nil {
		offset = encoder.WriteMapLength(len(v.MoreInfo), offset)
		for kk, vv := range v.MoreInfo {
			offset = encoder.WriteString(kk, offset)
			offset = encoder.WriteString(vv, offset)
		}
	} else {
		offset = encoder.WriteNil(offset)
	}
	return encoder.EncodedBytes(), offset, err
}

// encode from git.cacert.org/cacert-gosigner/pkg/messages.HealthInfo
func ___encodeMapHealthInfo_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v HealthInfo, encoder *enc.Encoder, offset int) ([]byte, int, error) {
	var err error
	offset = encoder.WriteStructHeaderFixAsMap(3, offset)
	offset = encoder.WriteStringFix("Source", 6, offset)
	offset = encoder.WriteString(v.Source, offset)
	offset = encoder.WriteStringFix("Healthy", 7, offset)
	offset = encoder.WriteBool(v.Healthy, offset)
	offset = encoder.WriteStringFix("MoreInfo", 8, offset)
	if v.MoreInfo != nil {
		offset = encoder.WriteMapLength(len(v.MoreInfo), offset)
		for kk, vv := range v.MoreInfo {
			offset = encoder.WriteString(kk, offset)
			offset = encoder.WriteString(vv, offset)
		}
	} else {
		offset = encoder.WriteNil(offset)
	}
	return encoder.EncodedBytes(), offset, err
}

// decode to git.cacert.org/cacert-gosigner/pkg/messages.HealthInfo
func ___decodeArrayHealthInfo_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v *HealthInfo, decoder *dec.Decoder, offset int) (int, error) {
	offset, err := decoder.CheckStructHeader(3, offset)
	if err != nil {
		return 0, err
	}
	{
		var vv string
		vv, offset, err = decoder.AsString(offset)
		if err != nil {
			return 0, err
		}
		v.Source = vv
	}
	{
		var vv bool
		vv, offset, err = decoder.AsBool(offset)
		if err != nil {
			return 0, err
		}
		v.Healthy = vv
	}
	if !decoder.IsCodeNil(offset) {
		var vv map[string]string
		var vvl int
		vvl, offset, err = decoder.MapLength(offset)
		if err != nil {
			return 0, err
		}
		vv = make(map[string]string, vvl)
		for vvi := 0; vvi < vvl; vvi++ {
			var kkv string
			kkv, offset, err = decoder.AsString(offset)
			if err != nil {
				return 0, err
			}
			var vvv string
			vvv, offset, err = decoder.AsString(offset)
			if err != nil {
				return 0, err
			}
			vv[kkv] = vvv
		}
		v.MoreInfo = vv
	} else {
		offset++
	}
	return offset, err
}

// decode to git.cacert.org/cacert-gosigner/pkg/messages.HealthInfo
func ___decodeMapHealthInfo_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v *HealthInfo, decoder *dec.Decoder, offset int) (int, error) {
	keys := [][]byte{
		{uint8(0x53), uint8(0x6f), uint8(0x75), uint8(0x72), uint8(0x63), uint8(0x65)},                           // Source
		{uint8(0x48), uint8(0x65), uint8(0x61), uint8(0x6c), uint8(0x74), uint8(0x68), uint8(0x79)},              // Healthy
		{uint8(0x4d), uint8(0x6f), uint8(0x72), uint8(0x65), uint8(0x49), uint8(0x6e), uint8(0x66), uint8(0x6f)}, // MoreInfo
	}
	offset, err := decoder.CheckStructHeader(3, offset)
	if err != nil {
		return 0, err
	}
	count := 0
	for count < 3 {
		var dataKey []byte
		dataKey, offset, err = decoder.AsStringBytes(offset)
		if err != nil {
			return 0, err
		}
		fieldIndex := -1
		for i, key := range keys {
			if len(dataKey) != len(key) {
				continue
			}
			fieldIndex = i
			for dataKeyIndex := range dataKey {
				if dataKey[dataKeyIndex] != key[dataKeyIndex] {
					fieldIndex = -1
					break
				}
			}
			if fieldIndex >= 0 {
				break
			}
		}
		switch fieldIndex {
		case 0:
			{
				var vv string
				vv, offset, err = decoder.AsString(offset)
				if err != nil {
					return 0, err
				}
				v.Source = vv
			}
			count++
		case 1:
			{
				var vv bool
				vv, offset, err = decoder.AsBool(offset)
				if err != nil {
					return 0, err
				}
				v.Healthy = vv
			}
			count++
		case 2:
			if !decoder.IsCodeNil(offset) {
				var vv map[string]string
				var vvl int
				vvl, offset, err = decoder.MapLength(offset)
				if err != nil {
					return 0, err
				}
				vv = make(map[string]string, vvl)
				for vvi := 0; vvi < vvl; vvi++ {
					var kkv string
					kkv, offset, err = decoder.AsString(offset)
					if err != nil {
						return 0, err
					}
					var vvv string
					vvv, offset, err = decoder.AsString(offset)
					if err != nil {
						return 0, err
					}
					vv[kkv] = vvv
				}
				v.MoreInfo = vv
			} else {
				offset++
			}
			count++
		default:
			return 0, fmt.Errorf("unknown key[%s] found", string(dataKey))
		}
	}
	return offset, err
}

// calculate size from git.cacert.org/cacert-gosigner/pkg/messages.HealthResponse
func ___calcArraySizeHealthResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v HealthResponse, encoder *enc.Encoder) (int, error) {
	size := 0
	size += encoder.CalcStructHeaderFix(3)
	size += encoder.CalcString(v.Version)
	size += encoder.CalcBool(v.Healthy)
	if v.Info != nil {
		s, err := encoder.CalcSliceLength(len(v.Info), false)
		if err != nil {
			return 0, err
		}
		size += s
		for _, vv := range v.Info {
			if vv != nil {
				vvp := *vv
				size_vvp, err := ___calcArraySizeHealthInfo_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(vvp, encoder)
				if err != nil {
					return 0, err
				}
				size += size_vvp
			} else {
				size += encoder.CalcNil()
			}
		}
	} else {
		size += encoder.CalcNil()
	}
	return size, nil
}

// calculate size from git.cacert.org/cacert-gosigner/pkg/messages.HealthResponse
func ___calcMapSizeHealthResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v HealthResponse, encoder *enc.Encoder) (int, error) {
	size := 0
	size += encoder.CalcStructHeaderFix(3)
	size += encoder.CalcStringFix(7)
	size += encoder.CalcString(v.Version)
	size += encoder.CalcStringFix(7)
	size += encoder.CalcBool(v.Healthy)
	size += encoder.CalcStringFix(4)
	if v.Info != nil {
		s, err := encoder.CalcSliceLength(len(v.Info), false)
		if err != nil {
			return 0, err
		}
		size += s
		for _, vv := range v.Info {
			if vv != nil {
				vvp := *vv
				size_vvp, err := ___calcMapSizeHealthInfo_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(vvp, encoder)
				if err != nil {
					return 0, err
				}
				size += size_vvp
			} else {
				size += encoder.CalcNil()
			}
		}
	} else {
		size += encoder.CalcNil()
	}
	return size, nil
}

// encode from git.cacert.org/cacert-gosigner/pkg/messages.HealthResponse
func ___encodeArrayHealthResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v HealthResponse, encoder *enc.Encoder, offset int) ([]byte, int, error) {
	var err error
	offset = encoder.WriteStructHeaderFixAsArray(3, offset)
	offset = encoder.WriteString(v.Version, offset)
	offset = encoder.WriteBool(v.Healthy, offset)
	if v.Info != nil {
		offset = encoder.WriteSliceLength(len(v.Info), offset, false)
		for _, vv := range v.Info {
			if vv != nil {
				vvp := *vv
				_, offset, err = ___encodeArrayHealthInfo_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(vvp, encoder, offset)
				if err != nil {
					return nil, 0, err
				}
			} else {
				offset = encoder.WriteNil(offset)
			}
		}
	} else {
		offset = encoder.WriteNil(offset)
	}
	return encoder.EncodedBytes(), offset, err
}

// encode from git.cacert.org/cacert-gosigner/pkg/messages.HealthResponse
func ___encodeMapHealthResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v HealthResponse, encoder *enc.Encoder, offset int) ([]byte, int, error) {
	var err error
	offset = encoder.WriteStructHeaderFixAsMap(3, offset)
	offset = encoder.WriteStringFix("version", 7, offset)
	offset = encoder.WriteString(v.Version, offset)
	offset = encoder.WriteStringFix("healthy", 7, offset)
	offset = encoder.WriteBool(v.Healthy, offset)
	offset = encoder.WriteStringFix("Info", 4, offset)
	if v.Info != nil {
		offset = encoder.WriteSliceLength(len(v.Info), offset, false)
		for _, vv := range v.Info {
			if vv != nil {
				vvp := *vv
				_, offset, err = ___encodeMapHealthInfo_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(vvp, encoder, offset)
				if err != nil {
					return nil, 0, err
				}
			} else {
				offset = encoder.WriteNil(offset)
			}
		}
	} else {
		offset = encoder.WriteNil(offset)
	}
	return encoder.EncodedBytes(), offset, err
}

// decode to git.cacert.org/cacert-gosigner/pkg/messages.HealthResponse
func ___decodeArrayHealthResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v *HealthResponse, decoder *dec.Decoder, offset int) (int, error) {
	offset, err := decoder.CheckStructHeader(3, offset)
	if err != nil {
		return 0, err
	}
	{
		var vv string
		vv, offset, err = decoder.AsString(offset)
		if err != nil {
			return 0, err
		}
		v.Version = vv
	}
	{
		var vv bool
		vv, offset, err = decoder.AsBool(offset)
		if err != nil {
			return 0, err
		}
		v.Healthy = vv
	}
	if !decoder.IsCodeNil(offset) {
		var vv []*HealthInfo
		var vvl int
		vvl, offset, err = decoder.SliceLength(offset)
		if err != nil {
			return 0, err
		}
		vv = make([]*HealthInfo, vvl)
		for vvi := range vv {
			var vvv *HealthInfo
			if !decoder.IsCodeNil(offset) {
				var vvvp HealthInfo
				offset, err = ___decodeArrayHealthInfo_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(&vvvp, decoder, offset)
				if err != nil {
					return 0, err
				}
				vvv = &vvvp
			} else {
				offset++
			}
			vv[vvi] = vvv
		}
		v.Info = vv
	} else {
		offset++
	}
	return offset, err
}

// decode to git.cacert.org/cacert-gosigner/pkg/messages.HealthResponse
func ___decodeMapHealthResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v *HealthResponse, decoder *dec.Decoder, offset int) (int, error) {
	keys := [][]byte{
		{uint8(0x76), uint8(0x65), uint8(0x72), uint8(0x73), uint8(0x69), uint8(0x6f), uint8(0x6e)}, // version
		{uint8(0x68), uint8(0x65), uint8(0x61), uint8(0x6c), uint8(0x74), uint8(0x68), uint8(0x79)}, // healthy
		{uint8(0x49), uint8(0x6e), uint8(0x66), uint8(0x6f)},                                        // Info
	}
	offset, err := decoder.CheckStructHeader(3, offset)
	if err != nil {
		return 0, err
	}
	count := 0
	for count < 3 {
		var dataKey []byte
		dataKey, offset, err = decoder.AsStringBytes(offset)
		if err != nil {
			return 0, err
		}
		fieldIndex := -1
		for i, key := range keys {
			if len(dataKey) != len(key) {
				continue
			}
			fieldIndex = i
			for dataKeyIndex := range dataKey {
				if dataKey[dataKeyIndex] != key[dataKeyIndex] {
					fieldIndex = -1
					break
				}
			}
			if fieldIndex >= 0 {
				break
			}
		}
		switch fieldIndex {
		case 0:
			{
				var vv string
				vv, offset, err = decoder.AsString(offset)
				if err != nil {
					return 0, err
				}
				v.Version = vv
			}
			count++
		case 1:
			{
				var vv bool
				vv, offset, err = decoder.AsBool(offset)
				if err != nil {
					return 0, err
				}
				v.Healthy = vv
			}
			count++
		case 2:
			if !decoder.IsCodeNil(offset) {
				var vv []*HealthInfo
				var vvl int
				vvl, offset, err = decoder.SliceLength(offset)
				if err != nil {
					return 0, err
				}
				vv = make([]*HealthInfo, vvl)
				for vvi := range vv {
					var vvv *HealthInfo
					if !decoder.IsCodeNil(offset) {
						var vvvp HealthInfo
						offset, err = ___decodeMapHealthInfo_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(&vvvp, decoder, offset)
						if err != nil {
							return 0, err
						}
						vvv = &vvvp
					} else {
						offset++
					}
					vv[vvi] = vvv
				}
				v.Info = vv
			} else {
				offset++
			}
			count++
		default:
			return 0, fmt.Errorf("unknown key[%s] found", string(dataKey))
		}
	}
	return offset, err
}

// calculate size from git.cacert.org/cacert-gosigner/pkg/messages.SignCertificateResponse
func ___calcArraySizeSignCertificateResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v SignCertificateResponse, encoder *enc.Encoder) (int, error) {
	size := 0
	size += encoder.CalcStructHeaderFix(1)
	if v.CertificateData != nil {
		s, err := encoder.CalcSliceLength(len(v.CertificateData), true)
		if err != nil {
			return 0, err
		}
		size += s
		for _, vv := range v.CertificateData {
			size += encoder.CalcByte(vv)
		}
	} else {
		size += encoder.CalcNil()
	}
	return size, nil
}

// calculate size from git.cacert.org/cacert-gosigner/pkg/messages.SignCertificateResponse
func ___calcMapSizeSignCertificateResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v SignCertificateResponse, encoder *enc.Encoder) (int, error) {
	size := 0
	size += encoder.CalcStructHeaderFix(1)
	size += encoder.CalcStringFix(9)
	if v.CertificateData != nil {
		s, err := encoder.CalcSliceLength(len(v.CertificateData), true)
		if err != nil {
			return 0, err
		}
		size += s
		for _, vv := range v.CertificateData {
			size += encoder.CalcByte(vv)
		}
	} else {
		size += encoder.CalcNil()
	}
	return size, nil
}

// encode from git.cacert.org/cacert-gosigner/pkg/messages.SignCertificateResponse
func ___encodeArraySignCertificateResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v SignCertificateResponse, encoder *enc.Encoder, offset int) ([]byte, int, error) {
	var err error
	offset = encoder.WriteStructHeaderFixAsArray(1, offset)
	if v.CertificateData != nil {
		offset = encoder.WriteSliceLength(len(v.CertificateData), offset, true)
		for _, vv := range v.CertificateData {
			offset = encoder.WriteByte(vv, offset)
		}
	} else {
		offset = encoder.WriteNil(offset)
	}
	return encoder.EncodedBytes(), offset, err
}

// encode from git.cacert.org/cacert-gosigner/pkg/messages.SignCertificateResponse
func ___encodeMapSignCertificateResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v SignCertificateResponse, encoder *enc.Encoder, offset int) ([]byte, int, error) {
	var err error
	offset = encoder.WriteStructHeaderFixAsMap(1, offset)
	offset = encoder.WriteStringFix("cert_data", 9, offset)
	if v.CertificateData != nil {
		offset = encoder.WriteSliceLength(len(v.CertificateData), offset, true)
		for _, vv := range v.CertificateData {
			offset = encoder.WriteByte(vv, offset)
		}
	} else {
		offset = encoder.WriteNil(offset)
	}
	return encoder.EncodedBytes(), offset, err
}

// decode to git.cacert.org/cacert-gosigner/pkg/messages.SignCertificateResponse
func ___decodeArraySignCertificateResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v *SignCertificateResponse, decoder *dec.Decoder, offset int) (int, error) {
	offset, err := decoder.CheckStructHeader(1, offset)
	if err != nil {
		return 0, err
	}
	if !decoder.IsCodeNil(offset) {
		var vv []byte
		var vvl int
		vvl, offset, err = decoder.SliceLength(offset)
		if err != nil {
			return 0, err
		}
		vv = make([]byte, vvl)
		for vvi := range vv {
			var vvv byte
			vvv, offset, err = decoder.AsByte(offset)
			if err != nil {
				return 0, err
			}
			vv[vvi] = vvv
		}
		v.CertificateData = vv
	} else {
		offset++
	}
	return offset, err
}

// decode to git.cacert.org/cacert-gosigner/pkg/messages.SignCertificateResponse
func ___decodeMapSignCertificateResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v *SignCertificateResponse, decoder *dec.Decoder, offset int) (int, error) {
	keys := [][]byte{
		{uint8(0x63), uint8(0x65), uint8(0x72), uint8(0x74), uint8(0x5f), uint8(0x64), uint8(0x61), uint8(0x74), uint8(0x61)}, // cert_data
	}
	offset, err := decoder.CheckStructHeader(1, offset)
	if err != nil {
		return 0, err
	}
	count := 0
	for count < 1 {
		var dataKey []byte
		dataKey, offset, err = decoder.AsStringBytes(offset)
		if err != nil {
			return 0, err
		}
		fieldIndex := -1
		for i, key := range keys {
			if len(dataKey) != len(key) {
				continue
			}
			fieldIndex = i
			for dataKeyIndex := range dataKey {
				if dataKey[dataKeyIndex] != key[dataKeyIndex] {
					fieldIndex = -1
					break
				}
			}
			if fieldIndex >= 0 {
				break
			}
		}
		switch fieldIndex {
		case 0:
			if !decoder.IsCodeNil(offset) {
				var vv []byte
				var vvl int
				vvl, offset, err = decoder.SliceLength(offset)
				if err != nil {
					return 0, err
				}
				vv = make([]byte, vvl)
				for vvi := range vv {
					var vvv byte
					vvv, offset, err = decoder.AsByte(offset)
					if err != nil {
						return 0, err
					}
					vv[vvi] = vvv
				}
				v.CertificateData = vv
			} else {
				offset++
			}
			count++
		default:
			return 0, fmt.Errorf("unknown key[%s] found", string(dataKey))
		}
	}
	return offset, err
}

// calculate size from git.cacert.org/cacert-gosigner/pkg/messages.RevokeCertificateCommand
func ___calcArraySizeRevokeCertificateCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v RevokeCertificateCommand, encoder *enc.Encoder) (int, error) {
	size := 0
	size += encoder.CalcStructHeaderFix(3)
	size += encoder.CalcString(v.IssuerID)
	if v.Serial != nil {
		s, err := encoder.CalcSliceLength(len(v.Serial), true)
		if err != nil {
			return 0, err
		}
		size += s
		for _, vv := range v.Serial {
			size += encoder.CalcByte(vv)
		}
	} else {
		size += encoder.CalcNil()
	}
	size += encoder.CalcString(v.Reason)
	return size, nil
}

// calculate size from git.cacert.org/cacert-gosigner/pkg/messages.RevokeCertificateCommand
func ___calcMapSizeRevokeCertificateCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v RevokeCertificateCommand, encoder *enc.Encoder) (int, error) {
	size := 0
	size += encoder.CalcStructHeaderFix(3)
	size += encoder.CalcStringFix(9)
	size += encoder.CalcString(v.IssuerID)
	size += encoder.CalcStringFix(13)
	if v.Serial != nil {
		s, err := encoder.CalcSliceLength(len(v.Serial), true)
		if err != nil {
			return 0, err
		}
		size += s
		for _, vv := range v.Serial {
			size += encoder.CalcByte(vv)
		}
	} else {
		size += encoder.CalcNil()
	}
	size += encoder.CalcStringFix(6)
	size += encoder.CalcString(v.Reason)
	return size, nil
}

// encode from git.cacert.org/cacert-gosigner/pkg/messages.RevokeCertificateCommand
func ___encodeArrayRevokeCertificateCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v RevokeCertificateCommand, encoder *enc.Encoder, offset int) ([]byte, int, error) {
	var err error
	offset = encoder.WriteStructHeaderFixAsArray(3, offset)
	offset = encoder.WriteString(v.IssuerID, offset)
	if v.Serial != nil {
		offset = encoder.WriteSliceLength(len(v.Serial), offset, true)
		for _, vv := range v.Serial {
			offset = encoder.WriteByte(vv, offset)
		}
	} else {
		offset = encoder.WriteNil(offset)
	}
	offset = encoder.WriteString(v.Reason, offset)
	return encoder.EncodedBytes(), offset, err
}

// encode from git.cacert.org/cacert-gosigner/pkg/messages.RevokeCertificateCommand
func ___encodeMapRevokeCertificateCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v RevokeCertificateCommand, encoder *enc.Encoder, offset int) ([]byte, int, error) {
	var err error
	offset = encoder.WriteStructHeaderFixAsMap(3, offset)
	offset = encoder.WriteStringFix("issuer_id", 9, offset)
	offset = encoder.WriteString(v.IssuerID, offset)
	offset = encoder.WriteStringFix("serial_number", 13, offset)
	if v.Serial != nil {
		offset = encoder.WriteSliceLength(len(v.Serial), offset, true)
		for _, vv := range v.Serial {
			offset = encoder.WriteByte(vv, offset)
		}
	} else {
		offset = encoder.WriteNil(offset)
	}
	offset = encoder.WriteStringFix("reason", 6, offset)
	offset = encoder.WriteString(v.Reason, offset)
	return encoder.EncodedBytes(), offset, err
}

// decode to git.cacert.org/cacert-gosigner/pkg/messages.RevokeCertificateCommand
func ___decodeArrayRevokeCertificateCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v *RevokeCertificateCommand, decoder *dec.Decoder, offset int) (int, error) {
	offset, err := decoder.CheckStructHeader(3, offset)
	if err != nil {
		return 0, err
	}
	{
		var vv string
		vv, offset, err = decoder.AsString(offset)
		if err != nil {
			return 0, err
		}
		v.IssuerID = vv
	}
	if !decoder.IsCodeNil(offset) {
		var vv []byte
		var vvl int
		vvl, offset, err = decoder.SliceLength(offset)
		if err != nil {
			return 0, err
		}
		vv = make([]byte, vvl)
		for vvi := range vv {
			var vvv byte
			vvv, offset, err = decoder.AsByte(offset)
			if err != nil {
				return 0, err
			}
			vv[vvi] = vvv
		}
		v.Serial = vv
	} else {
		offset++
	}
	{
		var vv string
		vv, offset, err = decoder.AsString(offset)
		if err != nil {
			return 0, err
		}
		v.Reason = vv
	}
	return offset, err
}

// decode to git.cacert.org/cacert-gosigner/pkg/messages.RevokeCertificateCommand
func ___decodeMapRevokeCertificateCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v *RevokeCertificateCommand, decoder *dec.Decoder, offset int) (int, error) {
	keys := [][]byte{
		{uint8(0x69), uint8(0x73), uint8(0x73), uint8(0x75), uint8(0x65), uint8(0x72), uint8(0x5f), uint8(0x69), uint8(0x64)},                                                     // issuer_id
		{uint8(0x73), uint8(0x65), uint8(0x72), uint8(0x69), uint8(0x61), uint8(0x6c), uint8(0x5f), uint8(0x6e), uint8(0x75), uint8(0x6d), uint8(0x62), uint8(0x65), uint8(0x72)}, // serial_number
		{uint8(0x72), uint8(0x65), uint8(0x61), uint8(0x73), uint8(0x6f), uint8(0x6e)},                                                                                            // reason
	}
	offset, err := decoder.CheckStructHeader(3, offset)
	if err != nil {
		return 0, err
	}
	count := 0
	for count < 3 {
		var dataKey []byte
		dataKey, offset, err = decoder.AsStringBytes(offset)
		if err != nil {
			return 0, err
		}
		fieldIndex := -1
		for i, key := range keys {
			if len(dataKey) != len(key) {
				continue
			}
			fieldIndex = i
			for dataKeyIndex := range dataKey {
				if dataKey[dataKeyIndex] != key[dataKeyIndex] {
					fieldIndex = -1
					break
				}
			}
			if fieldIndex >= 0 {
				break
			}
		}
		switch fieldIndex {
		case 0:
			{
				var vv string
				vv, offset, err = decoder.AsString(offset)
				if err != nil {
					return 0, err
				}
				v.IssuerID = vv
			}
			count++
		case 1:
			if !decoder.IsCodeNil(offset) {
				var vv []byte
				var vvl int
				vvl, offset, err = decoder.SliceLength(offset)
				if err != nil {
					return 0, err
				}
				vv = make([]byte, vvl)
				for vvi := range vv {
					var vvv byte
					vvv, offset, err = decoder.AsByte(offset)
					if err != nil {
						return 0, err
					}
					vv[vvi] = vvv
				}
				v.Serial = vv
			} else {
				offset++
			}
			count++
		case 2:
			{
				var vv string
				vv, offset, err = decoder.AsString(offset)
				if err != nil {
					return 0, err
				}
				v.Reason = vv
			}
			count++
		default:
			return 0, fmt.Errorf("unknown key[%s] found", string(dataKey))
		}
	}
	return offset, err
}

// calculate size from git.cacert.org/cacert-gosigner/pkg/messages.RevokeCertificateResponse
func ___calcArraySizeRevokeCertificateResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v RevokeCertificateResponse, encoder *enc.Encoder) (int, error) {
	size := 0
	size += encoder.CalcStructHeaderFix(3)
	size += encoder.CalcString(v.IssuerID)
	if v.Serial != nil {
		s, err := encoder.CalcSliceLength(len(v.Serial), true)
		if err != nil {
			return 0, err
		}
		size += s
		for _, vv := range v.Serial {
			size += encoder.CalcByte(vv)
		}
	} else {
		size += encoder.CalcNil()
	}
	size += encoder.CalcTime(v.RevokedAt)
	return size, nil
}

// calculate size from git.cacert.org/cacert-gosigner/pkg/messages.RevokeCertificateResponse
func ___calcMapSizeRevokeCertificateResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v RevokeCertificateResponse, encoder *enc.Encoder) (int, error) {
	size := 0
	size += encoder.CalcStructHeaderFix(3)
	size += encoder.CalcStringFix(9)
	size += encoder.CalcString(v.IssuerID)
	size += encoder.CalcStringFix(13)
	if v.Serial != nil {
		s, err := encoder.CalcSliceLength(len(v.Serial), true)
		if err != nil {
			return 0, err
		}
		size += s
		for _, vv := range v.Serial {
			size += encoder.CalcByte(vv)
		}
	} else {
		size += encoder.CalcNil()
	}
	size += encoder.CalcStringFix(10)
	size += encoder.CalcTime(v.RevokedAt)
	return size, nil
}

// encode from git.cacert.org/cacert-gosigner/pkg/messages.RevokeCertificateResponse
func ___encodeArrayRevokeCertificateResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v RevokeCertificateResponse, encoder *enc.Encoder, offset int) ([]byte, int, error) {
	var err error
	offset = encoder.WriteStructHeaderFixAsArray(3, offset)
	offset = encoder.WriteString(v.IssuerID, offset)
	if v.Serial != nil {
		offset = encoder.WriteSliceLength(len(v.Serial), offset, true)
		for _, vv := range v.Serial {
			offset = encoder.WriteByte(vv, offset)
		}
	} else {
		offset = encoder.WriteNil(offset)
	}
	offset = encoder.WriteTime(v.RevokedAt, offset)
	return encoder.EncodedBytes(), offset, err
}

// encode from git.cacert.org/cacert-gosigner/pkg/messages.RevokeCertificateResponse
func ___encodeMapRevokeCertificateResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v RevokeCertificateResponse, encoder *enc.Encoder, offset int) ([]byte, int, error) {
	var err error
	offset = encoder.WriteStructHeaderFixAsMap(3, offset)
	offset = encoder.WriteStringFix("issuer_id", 9, offset)
	offset = encoder.WriteString(v.IssuerID, offset)
	offset = encoder.WriteStringFix("serial_number", 13, offset)
	if v.Serial != nil {
		offset = encoder.WriteSliceLength(len(v.Serial), offset, true)
		for _, vv := range v.Serial {
			offset = encoder.WriteByte(vv, offset)
		}
	} else {
		offset = encoder.WriteNil(offset)
	}
	offset = encoder.WriteStringFix("revoked_at", 10, offset)
	offset = encoder.WriteTime(v.RevokedAt, offset)
	return encoder.EncodedBytes(), offset, err
}

// decode to git.cacert.org/cacert-gosigner/pkg/messages.RevokeCertificateResponse
func ___decodeArrayRevokeCertificateResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v *RevokeCertificateResponse, decoder *dec.Decoder, offset int) (int, error) {
	offset, err := decoder.CheckStructHeader(3, offset)
	if err != nil {
		return 0, err
	}
	{
		var vv string
		vv, offset, err = decoder.AsString(offset)
		if err != nil {
			return 0, err
		}
		v.IssuerID = vv
	}
	if !decoder.IsCodeNil(offset) {
		var vv []byte
		var vvl int
		vvl, offset, err = decoder.SliceLength(offset)
		if err != nil {
			return 0, err
		}
		vv = make([]byte, vvl)
		for vvi := range vv {
			var vvv byte
			vvv, offset, err = decoder.AsByte(offset)
			if err != nil {
				return 0, err
			}
			vv[vvi] = vvv
		}
		v.Serial = vv
	} else {
		offset++
	}
	{
		var vv time.Time
		vv, offset, err = decoder.AsDateTime(offset)
		if err != nil {
			return 0, err
		}
		v.RevokedAt = vv
	}
	return offset, err
}

// decode to git.cacert.org/cacert-gosigner/pkg/messages.RevokeCertificateResponse
func ___decodeMapRevokeCertificateResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v *RevokeCertificateResponse, decoder *dec.Decoder, offset int) (int, error) {
	keys := [][]byte{
		{uint8(0x69), uint8(0x73), uint8(0x73), uint8(0x75), uint8(0x65), uint8(0x72), uint8(0x5f), uint8(0x69), uint8(0x64)},                                                     // issuer_id
		{uint8(0x73), uint8(0x65), uint8(0x72), uint8(0x69), uint8(0x61), uint8(0x6c), uint8(0x5f), uint8(0x6e), uint8(0x75), uint8(0x6d), uint8(0x62), uint8(0x65), uint8(0x72)}, // serial_number
		{uint8(0x72), uint8(0x65), uint8(0x76), uint8(0x6f), uint8(0x6b), uint8(0x65), uint8(0x64), uint8(0x5f), uint8(0x61), uint8(0x74)},                                        // revoked_at
	}
	offset, err := decoder.CheckStructHeader(3, offset)
	if err != nil {
		return 0, err
	}
	count := 0
	for count < 3 {
		var dataKey []byte
		dataKey, offset, err = decoder.AsStringBytes(offset)
		if err != nil {
			return 0, err
		}
		fieldIndex := -1
		for i, key := range keys {
			if len(dataKey) != len(key) {
				continue
			}
			fieldIndex = i
			for dataKeyIndex := range dataKey {
				if dataKey[dataKeyIndex] != key[dataKeyIndex] {
					fieldIndex = -1
					break
				}
			}
			if fieldIndex >= 0 {
				break
			}
		}
		switch fieldIndex {
		case 0:
			{
				var vv string
				vv, offset, err = decoder.AsString(offset)
				if err != nil {
					return 0, err
				}
				v.IssuerID = vv
			}
			count++
		case 1:
			if !decoder.IsCodeNil(offset) {
				var vv []byte
				var vvl int
				vvl, offset, err = decoder.SliceLength(offset)
				if err != nil {
					return 0, err
				}
				vv = make([]byte, vvl)
				for vvi := range vv {
					var vvv byte
					vvv, offset, err = decoder.AsByte(offset)
					if err != nil {
						return 0, err
					}
					vv[vvi] = vvv
				}
				v.Serial = vv
			} else {
				offset++
			}
			count++
		case 2:
			{
				var vv time.Time
				vv, offset, err = decoder.AsDateTime(offset)
				if err != nil {
					return 0, err
				}
				v.RevokedAt = vv
			}
			count++
		default:
			return 0, fmt.Errorf("unknown key[%s] found", string(dataKey))
		}
	}
	return offset, err
}

// calculate size from git.cacert.org/cacert-gosigner/pkg/messages.SignOpenPGPCommand
func ___calcArraySizeSignOpenPGPCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v SignOpenPGPCommand, encoder *enc.Encoder) (int, error) {
	size := 0
	size += encoder.CalcStructHeaderFix(5)
	size += encoder.CalcString(v.IssuerID)
	size += encoder.CalcString(v.ProfileName)
	if v.PublicKey != nil {
		s, err := encoder.CalcSliceLength(len(v.PublicKey), true)
		if err != nil {
			return 0, err
		}
		size += s
		for _, vv := range v.PublicKey {
			size += encoder.CalcByte(vv)
		}
	} else {
		size += encoder.CalcNil()
	}
	size += encoder.CalcString(v.CommonName)
	if v.EmailAddresses != nil {
		s, err := encoder.CalcSliceLength(len(v.EmailAddresses), false)
		if err != nil {
			return 0, err
		}
		size += s
		for _, vv := range v.EmailAddresses {
			size += encoder.CalcString(vv)
		}
	} else {
		size += encoder.CalcNil()
	}
	return size, nil
}

// calculate size from git.cacert.org/cacert-gosigner/pkg/messages.SignOpenPGPCommand
func ___calcMapSizeSignOpenPGPCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v SignOpenPGPCommand, encoder *enc.Encoder) (int, error) {
	size := 0
	size += encoder.CalcStructHeaderFix(5)
	size += encoder.CalcStringFix(9)
	size += encoder.CalcString(v.IssuerID)
	size += encoder.CalcStringFix(12)
	size += encoder.CalcString(v.ProfileName)
	size += encoder.CalcStringFix(10)
	if v.PublicKey != nil {
		s, err := encoder.CalcSliceLength(len(v.PublicKey), true)
		if err != nil {
			return 0, err
		}
		size += s
		for _, vv := range v.PublicKey {
			size += encoder.CalcByte(vv)
		}
	} else {
		size += encoder.CalcNil()
	}
	size += encoder.CalcStringFix(2)
	size += encoder.CalcString(v.CommonName)
	size += encoder.CalcStringFix(15)
	if v.EmailAddresses != nil {
		s, err := encoder.CalcSliceLength(len(v.EmailAddresses), false)
		if err != nil {
			return 0, err
		}
		size += s
		for _, vv := range v.EmailAddresses {
			size += encoder.CalcString(vv)
		}
	} else {
		size += encoder.CalcNil()
	}
	return size, nil
}

// encode from git.cacert.org/cacert-gosigner/pkg/messages.SignOpenPGPCommand
func ___encodeArraySignOpenPGPCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v SignOpenPGPCommand, encoder *enc.Encoder, offset int) ([]byte, int, error) {
	var err error
	offset = encoder.WriteStructHeaderFixAsArray(5, offset)
	offset = encoder.WriteString(v.IssuerID, offset)
	offset = encoder.WriteString(v.ProfileName, offset)
	if v.PublicKey != nil {
		offset = encoder.WriteSliceLength(len(v.PublicKey), offset, true)
		for _, vv := range v.PublicKey {
			offset = encoder.WriteByte(vv, offset)
		}
	} else {
		offset = encoder.WriteNil(offset)
	}
	offset = encoder.WriteString(v.CommonName, offset)
	if v.EmailAddresses != nil {
		offset = encoder.WriteSliceLength(len(v.EmailAddresses), offset, false)
		for _, vv := range v.EmailAddresses {
			offset = encoder.WriteString(vv, offset)
		}
	} else {
		offset = encoder.WriteNil(offset)
	}
	return encoder.EncodedBytes(), offset, err
}

// encode from git.cacert.org/cacert-gosigner/pkg/messages.SignOpenPGPCommand
func ___encodeMapSignOpenPGPCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v SignOpenPGPCommand, encoder *enc.Encoder, offset int) ([]byte, int, error) {
	var err error
	offset = encoder.WriteStructHeaderFixAsMap(5, offset)
	offset = encoder.WriteStringFix("issuer_id", 9, offset)
	offset = encoder.WriteString(v.IssuerID, offset)
	offset = encoder.WriteStringFix("profile_name", 12, offset)
	offset = encoder.WriteString(v.ProfileName, offset)
	offset = encoder.WriteStringFix("public_key", 10, offset)
	if v.PublicKey != nil {
		offset = encoder.WriteSliceLength(len(v.PublicKey), offset, true)
		for _, vv := range v.PublicKey {
			offset = encoder.WriteByte(vv, offset)
		}
	} else {
		offset = encoder.WriteNil(offset)
	}
	offset = encoder.WriteStringFix("cn", 2, offset)
	offset = encoder.WriteString(v.CommonName, offset)
	offset = encoder.WriteStringFix("email_addresses", 15, offset)
	if v.EmailAddresses != nil {
		offset = encoder.WriteSliceLength(len(v.EmailAddresses), offset, false)
		for _, vv := range v.EmailAddresses {
			offset = encoder.WriteString(vv, offset)
		}
	} else {
		offset = encoder.WriteNil(offset)
	}
	return encoder.EncodedBytes(), offset, err
}

// decode to git.cacert.org/cacert-gosigner/pkg/messages.SignOpenPGPCommand
func ___decodeArraySignOpenPGPCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v *SignOpenPGPCommand, decoder *dec.Decoder, offset int) (int, error) {
	offset, err := decoder.CheckStructHeader(5, offset)
	if err != nil {
		return 0, err
	}
	{
		var vv string
		vv, offset, err = decoder.AsString(offset)
		if err != nil {
			return 0, err
		}
		v.IssuerID = vv
	}
	{
		var vv string
		vv, offset, err = decoder.AsString(offset)
		if err != nil {
			return 0, err
		}
		v.ProfileName = vv
	}
	if !decoder.IsCodeNil(offset) {
		var vv []byte
		var vvl int
		vvl, offset, err = decoder.SliceLength(offset)
		if err != nil {
			return 0, err
		}
		vv = make([]byte, vvl)
		for vvi := range vv {
			var vvv byte
			vvv, offset, err = decoder.AsByte(offset)
			if err != nil {
				return 0, err
			}
			vv[vvi] = vvv
		}
		v.PublicKey = vv
	} else {
		offset++
	}
	{
		var vv string
		vv, offset, err = decoder.AsString(offset)
		if err != nil {
			return 0, err
		}
		v.CommonName = vv
	}
	if !decoder.IsCodeNil(offset) {
		var vv []string
		var vvl int
		vvl, offset, err = decoder.SliceLength(offset)
		if err != nil {
			return 0, err
		}
		vv = make([]string, vvl)
		for vvi := range vv {
			var vvv string
			vvv, offset, err = decoder.AsString(offset)
			if err != nil {
				return 0, err
			}
			vv[vvi] = vvv
		}
		v.EmailAddresses = vv
	} else {
		offset++
	}
	return offset, err
}

// decode to git.cacert.org/cacert-gosigner/pkg/messages.SignOpenPGPCommand
func ___decodeMapSignOpenPGPCommand_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v *SignOpenPGPCommand, decoder *dec.Decoder, offset int) (int, error) {
	keys := [][]byte{
		{uint8(0x69), uint8(0x73), uint8(0x73), uint8(0x75), uint8(0x65), uint8(0x72), uint8(0x5f), uint8(0x69), uint8(0x64)},                                        // issuer_id
		{uint8(0x70), uint8(0x72), uint8(0x6f), uint8(0x66), uint8(0x69), uint8(0x6c), uint8(0x65), uint8(0x5f), uint8(0x6e), uint8(0x61), uint8(0x6d), uint8(0x65)}, // profile_name
		{uint8(0x70), uint8(0x75), uint8(0x62), uint8(0x6c), uint8(0x69), uint8(0x63), uint8(0x5f), uint8(0x6b), uint8(0x65), uint8(0x79)},                           // public_key
		{uint8(0x63), uint8(0x6e)}, // cn
		{uint8(0x65), uint8(0x6d), uint8(0x61), uint8(0x69), uint8(0x6c), uint8(0x5f), uint8(0x61), uint8(0x64), uint8(0x64), uint8(0x72), uint8(0x65), uint8(0x73), uint8(0x73), uint8(0x65), uint8(0x73)}, // email_addresses
	}
	offset, err := decoder.CheckStructHeader(5, offset)
	if err != nil {
		return 0, err
	}
	count := 0
	for count < 5 {
		var dataKey []byte
		dataKey, offset, err = decoder.AsStringBytes(offset)
		if err != nil {
			return 0, err
		}
		fieldIndex := -1
		for i, key := range keys {
			if len(dataKey) != len(key) {
				continue
			}
			fieldIndex = i
			for dataKeyIndex := range dataKey {
				if dataKey[dataKeyIndex] != key[dataKeyIndex] {
					fieldIndex = -1
					break
				}
			}
			if fieldIndex >= 0 {
				break
			}
		}
		switch fieldIndex {
		case 0:
			{
				var vv string
				vv, offset, err = decoder.AsString(offset)
				if err != nil {
					return 0, err
				}
				v.IssuerID = vv
			}
			count++
		case 1:
			{
				var vv string
				vv, offset, err = decoder.AsString(offset)
				if err != nil {
					return 0, err
				}
				v.ProfileName = vv
			}
			count++
		case 2:
			if !decoder.IsCodeNil(offset) {
				var vv []byte
				var vvl int
				vvl, offset, err = decoder.SliceLength(offset)
				if err != nil {
					return 0, err
				}
				vv = make([]byte, vvl)
				for vvi := range vv {
					var vvv byte
					vvv, offset, err = decoder.AsByte(offset)
					if err != nil {
						return 0, err
					}
					vv[vvi] = vvv
				}
				v.PublicKey = vv
			} else {
				offset++
			}
			count++
		case 3:
			{
				var vv string
				vv, offset, err = decoder.AsString(offset)
				if err != nil {
					return 0, err
				}
				v.CommonName = vv
			}
			count++
		case 4:
			if !decoder.IsCodeNil(offset) {
				var vv []string
				var vvl int
				vvl, offset, err = decoder.SliceLength(offset)
				if err != nil {
					return 0, err
				}
				vv = make([]string, vvl)
				for vvi := range vv {
					var vvv string
					vvv, offset, err = decoder.AsString(offset)
					if err != nil {
						return 0, err
					}
					vv[vvi] = vvv
				}
				v.EmailAddresses = vv
			} else {
				offset++
			}
			count++
		default:
			return 0, fmt.Errorf("unknown key[%s] found", string(dataKey))
		}
	}
	return offset, err
}

// calculate size from git.cacert.org/cacert-gosigner/pkg/messages.SignOpenPGPResponse
func ___calcArraySizeSignOpenPGPResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v SignOpenPGPResponse, encoder *enc.Encoder) (int, error) {
	size := 0
	size += encoder.CalcStructHeaderFix(1)
	if v.SignatureData != nil {
		s, err := encoder.CalcSliceLength(len(v.SignatureData), true)
		if err != nil {
			return 0, err
		}
		size += s
		for _, vv := range v.SignatureData {
			size += encoder.CalcByte(vv)
		}
	} else {
		size += encoder.CalcNil()
	}
	return size, nil
}

// calculate size from git.cacert.org/cacert-gosigner/pkg/messages.SignOpenPGPResponse
func ___calcMapSizeSignOpenPGPResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v SignOpenPGPResponse, encoder *enc.Encoder) (int, error) {
	size := 0
	size += encoder.CalcStructHeaderFix(1)
	size += encoder.CalcStringFix(14)
	if v.SignatureData != nil {
		s, err := encoder.CalcSliceLength(len(v.SignatureData), true)
		if err != nil {
			return 0, err
		}
		size += s
		for _, vv := range v.SignatureData {
			size += encoder.CalcByte(vv)
		}
	} else {
		size += encoder.CalcNil()
	}
	return size, nil
}

// encode from git.cacert.org/cacert-gosigner/pkg/messages.SignOpenPGPResponse
func ___encodeArraySignOpenPGPResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v SignOpenPGPResponse, encoder *enc.Encoder, offset int) ([]byte, int, error) {
	var err error
	offset = encoder.WriteStructHeaderFixAsArray(1, offset)
	if v.SignatureData != nil {
		offset = encoder.WriteSliceLength(len(v.SignatureData), offset, true)
		for _, vv := range v.SignatureData {
			offset = encoder.WriteByte(vv, offset)
		}
	} else {
		offset = encoder.WriteNil(offset)
	}
	return encoder.EncodedBytes(), offset, err
}

// encode from git.cacert.org/cacert-gosigner/pkg/messages.SignOpenPGPResponse
func ___encodeMapSignOpenPGPResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v SignOpenPGPResponse, encoder *enc.Encoder, offset int) ([]byte, int, error) {
	var err error
	offset = encoder.WriteStructHeaderFixAsMap(1, offset)
	offset = encoder.WriteStringFix("signature_data", 14, offset)
	if v.SignatureData != nil {
		offset = encoder.WriteSliceLength(len(v.SignatureData), offset, true)
		for _, vv := range v.SignatureData {
			offset = encoder.WriteByte(vv, offset)
		}
	} else {
		offset = encoder.WriteNil(offset)
	}
	return encoder.EncodedBytes(), offset, err
}

// decode to git.cacert.org/cacert-gosigner/pkg/messages.SignOpenPGPResponse
func ___decodeArraySignOpenPGPResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v *SignOpenPGPResponse, decoder *dec.Decoder, offset int) (int, error) {
	offset, err := decoder.CheckStructHeader(1, offset)
	if err != nil {
		return 0, err
	}
	if !decoder.IsCodeNil(offset) {
		var vv []byte
		var vvl int
		vvl, offset, err = decoder.SliceLength(offset)
		if err != nil {
			return 0, err
		}
		vv = make([]byte, vvl)
		for vvi := range vv {
			var vvv byte
			vvv, offset, err = decoder.AsByte(offset)
			if err != nil {
				return 0, err
			}
			vv[vvi] = vvv
		}
		v.SignatureData = vv
	} else {
		offset++
	}
	return offset, err
}

// decode to git.cacert.org/cacert-gosigner/pkg/messages.SignOpenPGPResponse
func ___decodeMapSignOpenPGPResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v *SignOpenPGPResponse, decoder *dec.Decoder, offset int) (int, error) {
	keys := [][]byte{
		{uint8(0x73), uint8(0x69), uint8(0x67), uint8(0x6e), uint8(0x61), uint8(0x74), uint8(0x75), uint8(0x72), uint8(0x65), uint8(0x5f), uint8(0x64), uint8(0x61), uint8(0x74), uint8(0x61)}, // signature_data
	}
	offset, err := decoder.CheckStructHeader(1, offset)
	if err != nil {
		return 0, err
	}
	count := 0
	for count < 1 {
		var dataKey []byte
		dataKey, offset, err = decoder.AsStringBytes(offset)
		if err != nil {
			return 0, err
		}
		fieldIndex := -1
		for i, key := range keys {
			if len(dataKey) != len(key) {
				continue
			}
			fieldIndex = i
			for dataKeyIndex := range dataKey {
				if dataKey[dataKeyIndex] != key[dataKeyIndex] {
					fieldIndex = -1
					break
				}
			}
			if fieldIndex >= 0 {
				break
			}
		}
		switch fieldIndex {
		case 0:
			if !decoder.IsCodeNil(offset) {
				var vv []byte
				var vvl int
				vvl, offset, err = decoder.SliceLength(offset)
				if err != nil {
					return 0, err
				}
				vv = make([]byte, vvl)
				for vvi := range vv {
					var vvv byte
					vvv, offset, err = decoder.AsByte(offset)
					if err != nil {
						return 0, err
					}
					vv[vvi] = vvv
				}
				v.SignatureData = vv
			} else {
				offset++
			}
			count++
		default:
			return 0, fmt.Errorf("unknown key[%s] found", string(dataKey))
		}
	}
	return offset, err
}

// calculate size from git.cacert.org/cacert-gosigner/pkg/messages.ErrorResponse
func ___calcArraySizeErrorResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v ErrorResponse, encoder *enc.Encoder) (int, error) {
	size := 0
	size += encoder.CalcStructHeaderFix(1)
	size += encoder.CalcString(v.Message)
	return size, nil
}

// calculate size from git.cacert.org/cacert-gosigner/pkg/messages.ErrorResponse
func ___calcMapSizeErrorResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v ErrorResponse, encoder *enc.Encoder) (int, error) {
	size := 0
	size += encoder.CalcStructHeaderFix(1)
	size += encoder.CalcStringFix(7)
	size += encoder.CalcString(v.Message)
	return size, nil
}

// encode from git.cacert.org/cacert-gosigner/pkg/messages.ErrorResponse
func ___encodeArrayErrorResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v ErrorResponse, encoder *enc.Encoder, offset int) ([]byte, int, error) {
	var err error
	offset = encoder.WriteStructHeaderFixAsArray(1, offset)
	offset = encoder.WriteString(v.Message, offset)
	return encoder.EncodedBytes(), offset, err
}

// encode from git.cacert.org/cacert-gosigner/pkg/messages.ErrorResponse
func ___encodeMapErrorResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v ErrorResponse, encoder *enc.Encoder, offset int) ([]byte, int, error) {
	var err error
	offset = encoder.WriteStructHeaderFixAsMap(1, offset)
	offset = encoder.WriteStringFix("message", 7, offset)
	offset = encoder.WriteString(v.Message, offset)
	return encoder.EncodedBytes(), offset, err
}

// decode to git.cacert.org/cacert-gosigner/pkg/messages.ErrorResponse
func ___decodeArrayErrorResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v *ErrorResponse, decoder *dec.Decoder, offset int) (int, error) {
	offset, err := decoder.CheckStructHeader(1, offset)
	if err != nil {
		return 0, err
	}
	{
		var vv string
		vv, offset, err = decoder.AsString(offset)
		if err != nil {
			return 0, err
		}
		v.Message = vv
	}
	return offset, err
}

// decode to git.cacert.org/cacert-gosigner/pkg/messages.ErrorResponse
func ___decodeMapErrorResponse_e587a81c7cb163b35488bdef0f58c292f99f4bd65a81377f81e5b18c3d86855d(v *ErrorResponse, decoder *dec.Decoder, offset int) (int, error) {
	keys := [][]byte{
		{uint8(0x6d), uint8(0x65), uint8(0x73), uint8(0x73), uint8(0x61), uint8(0x67), uint8(0x65)}, // message
	}
	offset, err := decoder.CheckStructHeader(1, offset)
	if err != nil {
		return 0, err
	}
	count := 0
	for count < 1 {
		var dataKey []byte
		dataKey, offset, err = decoder.AsStringBytes(offset)
		if err != nil {
			return 0, err
		}
		fieldIndex := -1
		for i, key := range keys {
			if len(dataKey) != len(key) {
				continue
			}
			fieldIndex = i
			for dataKeyIndex := range dataKey {
				if dataKey[dataKeyIndex] != key[dataKeyIndex] {
					fieldIndex = -1
					break
				}
			}
			if fieldIndex >= 0 {
				break
			}
		}
		switch fieldIndex {
		case 0:
			{
				var vv string
				vv, offset, err = decoder.AsString(offset)
				if err != nil {
					return 0, err
				}
				v.Message = vv
			}
			count++
		default:
			return 0, fmt.Errorf("unknown key[%s] found", string(dataKey))
		}
	}
	return offset, err
}