// Code generated by protoc-gen-microweb. DO NOT EDIT.
// source: v0.proto

package v0

import (
	"bytes"
	"encoding/json"
	"net/http"

	"github.com/go-chi/chi/v5"
	"github.com/go-chi/render"
	"github.com/golang/protobuf/jsonpb"
	merrors "go-micro.dev/v4/errors"

	ptypesempty "github.com/golang/protobuf/ptypes/empty"
)

type webBundleServiceHandler struct {
	r chi.Router
	h BundleServiceHandler
}

func (h *webBundleServiceHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	h.r.ServeHTTP(w, r)
}

func (h *webBundleServiceHandler) SaveBundle(w http.ResponseWriter, r *http.Request) {
	req := &SaveBundleRequest{}
	resp := &SaveBundleResponse{}

	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		http.Error(w, err.Error(), http.StatusPreconditionFailed)
		return
	}

	if err := h.h.SaveBundle(
		r.Context(),
		req,
		resp,
	); err != nil {
		if merr, ok := merrors.As(err); ok && merr.Code == http.StatusNotFound {
			http.Error(w, err.Error(), http.StatusNotFound)
		} else {
			http.Error(w, err.Error(), http.StatusBadRequest)
		}
		return
	}

	render.Status(r, http.StatusCreated)
	render.JSON(w, r, resp)
}

func (h *webBundleServiceHandler) GetBundle(w http.ResponseWriter, r *http.Request) {
	req := &GetBundleRequest{}
	resp := &GetBundleResponse{}

	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		http.Error(w, err.Error(), http.StatusPreconditionFailed)
		return
	}

	if err := h.h.GetBundle(
		r.Context(),
		req,
		resp,
	); err != nil {
		if merr, ok := merrors.As(err); ok && merr.Code == http.StatusNotFound {
			http.Error(w, err.Error(), http.StatusNotFound)
		} else {
			http.Error(w, err.Error(), http.StatusBadRequest)
		}
		return
	}

	render.Status(r, http.StatusCreated)
	render.JSON(w, r, resp)
}

func (h *webBundleServiceHandler) ListBundles(w http.ResponseWriter, r *http.Request) {
	req := &ListBundlesRequest{}
	resp := &ListBundlesResponse{}

	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		http.Error(w, err.Error(), http.StatusPreconditionFailed)
		return
	}

	if err := h.h.ListBundles(
		r.Context(),
		req,
		resp,
	); err != nil {
		if merr, ok := merrors.As(err); ok && merr.Code == http.StatusNotFound {
			http.Error(w, err.Error(), http.StatusNotFound)
		} else {
			http.Error(w, err.Error(), http.StatusBadRequest)
		}
		return
	}

	render.Status(r, http.StatusCreated)
	render.JSON(w, r, resp)
}

func (h *webBundleServiceHandler) AddSettingToBundle(w http.ResponseWriter, r *http.Request) {
	req := &AddSettingToBundleRequest{}
	resp := &AddSettingToBundleResponse{}

	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		http.Error(w, err.Error(), http.StatusPreconditionFailed)
		return
	}

	if err := h.h.AddSettingToBundle(
		r.Context(),
		req,
		resp,
	); err != nil {
		if merr, ok := merrors.As(err); ok && merr.Code == http.StatusNotFound {
			http.Error(w, err.Error(), http.StatusNotFound)
		} else {
			http.Error(w, err.Error(), http.StatusBadRequest)
		}
		return
	}

	render.Status(r, http.StatusCreated)
	render.JSON(w, r, resp)
}

func (h *webBundleServiceHandler) RemoveSettingFromBundle(w http.ResponseWriter, r *http.Request) {
	req := &RemoveSettingFromBundleRequest{}
	resp := &ptypesempty.Empty{}

	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		http.Error(w, err.Error(), http.StatusPreconditionFailed)
		return
	}

	if err := h.h.RemoveSettingFromBundle(
		r.Context(),
		req,
		resp,
	); err != nil {
		if merr, ok := merrors.As(err); ok && merr.Code == http.StatusNotFound {
			http.Error(w, err.Error(), http.StatusNotFound)
		} else {
			http.Error(w, err.Error(), http.StatusBadRequest)
		}
		return
	}

	render.Status(r, http.StatusNoContent)
	render.NoContent(w, r)
}

func RegisterBundleServiceWeb(r chi.Router, i BundleServiceHandler, middlewares ...func(http.Handler) http.Handler) {
	handler := &webBundleServiceHandler{
		r: r,
		h: i,
	}

	r.MethodFunc("POST", "/api/v0/settings/bundle-save", handler.SaveBundle)
	r.MethodFunc("POST", "/api/v0/settings/bundle-get", handler.GetBundle)
	r.MethodFunc("POST", "/api/v0/settings/bundles-list", handler.ListBundles)
	r.MethodFunc("POST", "/api/v0/settings/bundles-add-setting", handler.AddSettingToBundle)
	r.MethodFunc("POST", "/api/v0/settings/bundles-remove-setting", handler.RemoveSettingFromBundle)
}

type webValueServiceHandler struct {
	r chi.Router
	h ValueServiceHandler
}

func (h *webValueServiceHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	h.r.ServeHTTP(w, r)
}

func (h *webValueServiceHandler) SaveValue(w http.ResponseWriter, r *http.Request) {
	req := &SaveValueRequest{}
	resp := &SaveValueResponse{}

	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		http.Error(w, err.Error(), http.StatusPreconditionFailed)
		return
	}

	if err := h.h.SaveValue(
		r.Context(),
		req,
		resp,
	); err != nil {
		if merr, ok := merrors.As(err); ok && merr.Code == http.StatusNotFound {
			http.Error(w, err.Error(), http.StatusNotFound)
		} else {
			http.Error(w, err.Error(), http.StatusBadRequest)
		}
		return
	}

	render.Status(r, http.StatusCreated)
	render.JSON(w, r, resp)
}

func (h *webValueServiceHandler) GetValue(w http.ResponseWriter, r *http.Request) {
	req := &GetValueRequest{}
	resp := &GetValueResponse{}

	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		http.Error(w, err.Error(), http.StatusPreconditionFailed)
		return
	}

	if err := h.h.GetValue(
		r.Context(),
		req,
		resp,
	); err != nil {
		if merr, ok := merrors.As(err); ok && merr.Code == http.StatusNotFound {
			http.Error(w, err.Error(), http.StatusNotFound)
		} else {
			http.Error(w, err.Error(), http.StatusBadRequest)
		}
		return
	}

	render.Status(r, http.StatusCreated)
	render.JSON(w, r, resp)
}

func (h *webValueServiceHandler) ListValues(w http.ResponseWriter, r *http.Request) {
	req := &ListValuesRequest{}
	resp := &ListValuesResponse{}

	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		http.Error(w, err.Error(), http.StatusPreconditionFailed)
		return
	}

	if err := h.h.ListValues(
		r.Context(),
		req,
		resp,
	); err != nil {
		if merr, ok := merrors.As(err); ok && merr.Code == http.StatusNotFound {
			http.Error(w, err.Error(), http.StatusNotFound)
		} else {
			http.Error(w, err.Error(), http.StatusBadRequest)
		}
		return
	}

	render.Status(r, http.StatusCreated)
	render.JSON(w, r, resp)
}

func (h *webValueServiceHandler) GetValueByUniqueIdentifiers(w http.ResponseWriter, r *http.Request) {
	req := &GetValueByUniqueIdentifiersRequest{}
	resp := &GetValueResponse{}

	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		http.Error(w, err.Error(), http.StatusPreconditionFailed)
		return
	}

	if err := h.h.GetValueByUniqueIdentifiers(
		r.Context(),
		req,
		resp,
	); err != nil {
		if merr, ok := merrors.As(err); ok && merr.Code == http.StatusNotFound {
			http.Error(w, err.Error(), http.StatusNotFound)
		} else {
			http.Error(w, err.Error(), http.StatusBadRequest)
		}
		return
	}

	render.Status(r, http.StatusCreated)
	render.JSON(w, r, resp)
}

func RegisterValueServiceWeb(r chi.Router, i ValueServiceHandler, middlewares ...func(http.Handler) http.Handler) {
	handler := &webValueServiceHandler{
		r: r,
		h: i,
	}

	r.MethodFunc("POST", "/api/v0/settings/values-save", handler.SaveValue)
	r.MethodFunc("POST", "/api/v0/settings/values-get", handler.GetValue)
	r.MethodFunc("POST", "/api/v0/settings/values-list", handler.ListValues)
	r.MethodFunc("POST", "/api/v0/settings/values-get-by-unique-identifiers", handler.GetValueByUniqueIdentifiers)
}

type webRoleServiceHandler struct {
	r chi.Router
	h RoleServiceHandler
}

func (h *webRoleServiceHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	h.r.ServeHTTP(w, r)
}

func (h *webRoleServiceHandler) ListRoles(w http.ResponseWriter, r *http.Request) {
	req := &ListBundlesRequest{}
	resp := &ListBundlesResponse{}

	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		http.Error(w, err.Error(), http.StatusPreconditionFailed)
		return
	}

	if err := h.h.ListRoles(
		r.Context(),
		req,
		resp,
	); err != nil {
		if merr, ok := merrors.As(err); ok && merr.Code == http.StatusNotFound {
			http.Error(w, err.Error(), http.StatusNotFound)
		} else {
			http.Error(w, err.Error(), http.StatusBadRequest)
		}
		return
	}

	render.Status(r, http.StatusCreated)
	render.JSON(w, r, resp)
}

func (h *webRoleServiceHandler) ListRoleAssignments(w http.ResponseWriter, r *http.Request) {
	req := &ListRoleAssignmentsRequest{}
	resp := &ListRoleAssignmentsResponse{}

	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		http.Error(w, err.Error(), http.StatusPreconditionFailed)
		return
	}

	if err := h.h.ListRoleAssignments(
		r.Context(),
		req,
		resp,
	); err != nil {
		if merr, ok := merrors.As(err); ok && merr.Code == http.StatusNotFound {
			http.Error(w, err.Error(), http.StatusNotFound)
		} else {
			http.Error(w, err.Error(), http.StatusBadRequest)
		}
		return
	}

	render.Status(r, http.StatusCreated)
	render.JSON(w, r, resp)
}

func (h *webRoleServiceHandler) ListRoleAssignmentsFiltered(w http.ResponseWriter, r *http.Request) {
	req := &ListRoleAssignmentsFilteredRequest{}
	resp := &ListRoleAssignmentsResponse{}

	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		http.Error(w, err.Error(), http.StatusPreconditionFailed)
		return
	}

	if err := h.h.ListRoleAssignmentsFiltered(
		r.Context(),
		req,
		resp,
	); err != nil {
		if merr, ok := merrors.As(err); ok && merr.Code == http.StatusNotFound {
			http.Error(w, err.Error(), http.StatusNotFound)
		} else {
			http.Error(w, err.Error(), http.StatusBadRequest)
		}
		return
	}

	render.Status(r, http.StatusCreated)
	render.JSON(w, r, resp)
}

func (h *webRoleServiceHandler) AssignRoleToUser(w http.ResponseWriter, r *http.Request) {
	req := &AssignRoleToUserRequest{}
	resp := &AssignRoleToUserResponse{}

	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		http.Error(w, err.Error(), http.StatusPreconditionFailed)
		return
	}

	if err := h.h.AssignRoleToUser(
		r.Context(),
		req,
		resp,
	); err != nil {
		if merr, ok := merrors.As(err); ok && merr.Code == http.StatusNotFound {
			http.Error(w, err.Error(), http.StatusNotFound)
		} else {
			http.Error(w, err.Error(), http.StatusBadRequest)
		}
		return
	}

	render.Status(r, http.StatusCreated)
	render.JSON(w, r, resp)
}

func (h *webRoleServiceHandler) RemoveRoleFromUser(w http.ResponseWriter, r *http.Request) {
	req := &RemoveRoleFromUserRequest{}
	resp := &ptypesempty.Empty{}

	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		http.Error(w, err.Error(), http.StatusPreconditionFailed)
		return
	}

	if err := h.h.RemoveRoleFromUser(
		r.Context(),
		req,
		resp,
	); err != nil {
		if merr, ok := merrors.As(err); ok && merr.Code == http.StatusNotFound {
			http.Error(w, err.Error(), http.StatusNotFound)
		} else {
			http.Error(w, err.Error(), http.StatusBadRequest)
		}
		return
	}

	render.Status(r, http.StatusNoContent)
	render.NoContent(w, r)
}

func RegisterRoleServiceWeb(r chi.Router, i RoleServiceHandler, middlewares ...func(http.Handler) http.Handler) {
	handler := &webRoleServiceHandler{
		r: r,
		h: i,
	}

	r.MethodFunc("POST", "/api/v0/settings/roles-list", handler.ListRoles)
	r.MethodFunc("POST", "/api/v0/settings/assignments-list", handler.ListRoleAssignments)
	r.MethodFunc("POST", "/api/v0/settings/assignments-list-filtered", handler.ListRoleAssignmentsFiltered)
	r.MethodFunc("POST", "/api/v0/settings/assignments-add", handler.AssignRoleToUser)
	r.MethodFunc("POST", "/api/v0/settings/assignments-remove", handler.RemoveRoleFromUser)
}

type webPermissionServiceHandler struct {
	r chi.Router
	h PermissionServiceHandler
}

func (h *webPermissionServiceHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	h.r.ServeHTTP(w, r)
}

func (h *webPermissionServiceHandler) ListPermissions(w http.ResponseWriter, r *http.Request) {
	req := &ListPermissionsRequest{}
	resp := &ListPermissionsResponse{}

	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		http.Error(w, err.Error(), http.StatusPreconditionFailed)
		return
	}

	if err := h.h.ListPermissions(
		r.Context(),
		req,
		resp,
	); err != nil {
		if merr, ok := merrors.As(err); ok && merr.Code == http.StatusNotFound {
			http.Error(w, err.Error(), http.StatusNotFound)
		} else {
			http.Error(w, err.Error(), http.StatusBadRequest)
		}
		return
	}

	render.Status(r, http.StatusCreated)
	render.JSON(w, r, resp)
}

func (h *webPermissionServiceHandler) ListPermissionsByResource(w http.ResponseWriter, r *http.Request) {
	req := &ListPermissionsByResourceRequest{}
	resp := &ListPermissionsByResourceResponse{}

	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		http.Error(w, err.Error(), http.StatusPreconditionFailed)
		return
	}

	if err := h.h.ListPermissionsByResource(
		r.Context(),
		req,
		resp,
	); err != nil {
		if merr, ok := merrors.As(err); ok && merr.Code == http.StatusNotFound {
			http.Error(w, err.Error(), http.StatusNotFound)
		} else {
			http.Error(w, err.Error(), http.StatusBadRequest)
		}
		return
	}

	render.Status(r, http.StatusCreated)
	render.JSON(w, r, resp)
}

func (h *webPermissionServiceHandler) GetPermissionByID(w http.ResponseWriter, r *http.Request) {
	req := &GetPermissionByIDRequest{}
	resp := &GetPermissionByIDResponse{}

	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		http.Error(w, err.Error(), http.StatusPreconditionFailed)
		return
	}

	if err := h.h.GetPermissionByID(
		r.Context(),
		req,
		resp,
	); err != nil {
		if merr, ok := merrors.As(err); ok && merr.Code == http.StatusNotFound {
			http.Error(w, err.Error(), http.StatusNotFound)
		} else {
			http.Error(w, err.Error(), http.StatusBadRequest)
		}
		return
	}

	render.Status(r, http.StatusCreated)
	render.JSON(w, r, resp)
}

func RegisterPermissionServiceWeb(r chi.Router, i PermissionServiceHandler, middlewares ...func(http.Handler) http.Handler) {
	handler := &webPermissionServiceHandler{
		r: r,
		h: i,
	}

	r.MethodFunc("POST", "/api/v0/settings/permissions-list", handler.ListPermissions)
	r.MethodFunc("POST", "/api/v0/settings/permissions-list-by-resource", handler.ListPermissionsByResource)
	r.MethodFunc("POST", "/api/v0/settings/permissions-get-by-id", handler.GetPermissionByID)
}

// SaveBundleRequestJSONMarshaler describes the default jsonpb.Marshaler used by all
// instances of SaveBundleRequest. This struct is safe to replace or modify but
// should not be done so concurrently.
var SaveBundleRequestJSONMarshaler = new(jsonpb.Marshaler)

// MarshalJSON satisfies the encoding/json Marshaler interface. This method
// uses the more correct jsonpb package to correctly marshal the message.
func (m *SaveBundleRequest) MarshalJSON() ([]byte, error) {
	if m == nil {
		return json.Marshal(nil)
	}

	buf := &bytes.Buffer{}

	if err := SaveBundleRequestJSONMarshaler.Marshal(buf, m); err != nil {
		return nil, err
	}

	return buf.Bytes(), nil
}

var _ json.Marshaler = (*SaveBundleRequest)(nil)

// SaveBundleRequestJSONUnmarshaler describes the default jsonpb.Unmarshaler used by all
// instances of SaveBundleRequest. This struct is safe to replace or modify but
// should not be done so concurrently.
var SaveBundleRequestJSONUnmarshaler = new(jsonpb.Unmarshaler)

// UnmarshalJSON satisfies the encoding/json Unmarshaler interface. This method
// uses the more correct jsonpb package to correctly unmarshal the message.
func (m *SaveBundleRequest) UnmarshalJSON(b []byte) error {
	return SaveBundleRequestJSONUnmarshaler.Unmarshal(bytes.NewReader(b), m)
}

var _ json.Unmarshaler = (*SaveBundleRequest)(nil)

// SaveBundleResponseJSONMarshaler describes the default jsonpb.Marshaler used by all
// instances of SaveBundleResponse. This struct is safe to replace or modify but
// should not be done so concurrently.
var SaveBundleResponseJSONMarshaler = new(jsonpb.Marshaler)

// MarshalJSON satisfies the encoding/json Marshaler interface. This method
// uses the more correct jsonpb package to correctly marshal the message.
func (m *SaveBundleResponse) MarshalJSON() ([]byte, error) {
	if m == nil {
		return json.Marshal(nil)
	}

	buf := &bytes.Buffer{}

	if err := SaveBundleResponseJSONMarshaler.Marshal(buf, m); err != nil {
		return nil, err
	}

	return buf.Bytes(), nil
}

var _ json.Marshaler = (*SaveBundleResponse)(nil)

// SaveBundleResponseJSONUnmarshaler describes the default jsonpb.Unmarshaler used by all
// instances of SaveBundleResponse. This struct is safe to replace or modify but
// should not be done so concurrently.
var SaveBundleResponseJSONUnmarshaler = new(jsonpb.Unmarshaler)

// UnmarshalJSON satisfies the encoding/json Unmarshaler interface. This method
// uses the more correct jsonpb package to correctly unmarshal the message.
func (m *SaveBundleResponse) UnmarshalJSON(b []byte) error {
	return SaveBundleResponseJSONUnmarshaler.Unmarshal(bytes.NewReader(b), m)
}

var _ json.Unmarshaler = (*SaveBundleResponse)(nil)

// GetBundleRequestJSONMarshaler describes the default jsonpb.Marshaler used by all
// instances of GetBundleRequest. This struct is safe to replace or modify but
// should not be done so concurrently.
var GetBundleRequestJSONMarshaler = new(jsonpb.Marshaler)

// MarshalJSON satisfies the encoding/json Marshaler interface. This method
// uses the more correct jsonpb package to correctly marshal the message.
func (m *GetBundleRequest) MarshalJSON() ([]byte, error) {
	if m == nil {
		return json.Marshal(nil)
	}

	buf := &bytes.Buffer{}

	if err := GetBundleRequestJSONMarshaler.Marshal(buf, m); err != nil {
		return nil, err
	}

	return buf.Bytes(), nil
}

var _ json.Marshaler = (*GetBundleRequest)(nil)

// GetBundleRequestJSONUnmarshaler describes the default jsonpb.Unmarshaler used by all
// instances of GetBundleRequest. This struct is safe to replace or modify but
// should not be done so concurrently.
var GetBundleRequestJSONUnmarshaler = new(jsonpb.Unmarshaler)

// UnmarshalJSON satisfies the encoding/json Unmarshaler interface. This method
// uses the more correct jsonpb package to correctly unmarshal the message.
func (m *GetBundleRequest) UnmarshalJSON(b []byte) error {
	return GetBundleRequestJSONUnmarshaler.Unmarshal(bytes.NewReader(b), m)
}

var _ json.Unmarshaler = (*GetBundleRequest)(nil)

// GetBundleResponseJSONMarshaler describes the default jsonpb.Marshaler used by all
// instances of GetBundleResponse. This struct is safe to replace or modify but
// should not be done so concurrently.
var GetBundleResponseJSONMarshaler = new(jsonpb.Marshaler)

// MarshalJSON satisfies the encoding/json Marshaler interface. This method
// uses the more correct jsonpb package to correctly marshal the message.
func (m *GetBundleResponse) MarshalJSON() ([]byte, error) {
	if m == nil {
		return json.Marshal(nil)
	}

	buf := &bytes.Buffer{}

	if err := GetBundleResponseJSONMarshaler.Marshal(buf, m); err != nil {
		return nil, err
	}

	return buf.Bytes(), nil
}

var _ json.Marshaler = (*GetBundleResponse)(nil)

// GetBundleResponseJSONUnmarshaler describes the default jsonpb.Unmarshaler used by all
// instances of GetBundleResponse. This struct is safe to replace or modify but
// should not be done so concurrently.
var GetBundleResponseJSONUnmarshaler = new(jsonpb.Unmarshaler)

// UnmarshalJSON satisfies the encoding/json Unmarshaler interface. This method
// uses the more correct jsonpb package to correctly unmarshal the message.
func (m *GetBundleResponse) UnmarshalJSON(b []byte) error {
	return GetBundleResponseJSONUnmarshaler.Unmarshal(bytes.NewReader(b), m)
}

var _ json.Unmarshaler = (*GetBundleResponse)(nil)

// ListBundlesRequestJSONMarshaler describes the default jsonpb.Marshaler used by all
// instances of ListBundlesRequest. This struct is safe to replace or modify but
// should not be done so concurrently.
var ListBundlesRequestJSONMarshaler = new(jsonpb.Marshaler)

// MarshalJSON satisfies the encoding/json Marshaler interface. This method
// uses the more correct jsonpb package to correctly marshal the message.
func (m *ListBundlesRequest) MarshalJSON() ([]byte, error) {
	if m == nil {
		return json.Marshal(nil)
	}

	buf := &bytes.Buffer{}

	if err := ListBundlesRequestJSONMarshaler.Marshal(buf, m); err != nil {
		return nil, err
	}

	return buf.Bytes(), nil
}

var _ json.Marshaler = (*ListBundlesRequest)(nil)

// ListBundlesRequestJSONUnmarshaler describes the default jsonpb.Unmarshaler used by all
// instances of ListBundlesRequest. This struct is safe to replace or modify but
// should not be done so concurrently.
var ListBundlesRequestJSONUnmarshaler = new(jsonpb.Unmarshaler)

// UnmarshalJSON satisfies the encoding/json Unmarshaler interface. This method
// uses the more correct jsonpb package to correctly unmarshal the message.
func (m *ListBundlesRequest) UnmarshalJSON(b []byte) error {
	return ListBundlesRequestJSONUnmarshaler.Unmarshal(bytes.NewReader(b), m)
}

var _ json.Unmarshaler = (*ListBundlesRequest)(nil)

// ListBundlesResponseJSONMarshaler describes the default jsonpb.Marshaler used by all
// instances of ListBundlesResponse. This struct is safe to replace or modify but
// should not be done so concurrently.
var ListBundlesResponseJSONMarshaler = new(jsonpb.Marshaler)

// MarshalJSON satisfies the encoding/json Marshaler interface. This method
// uses the more correct jsonpb package to correctly marshal the message.
func (m *ListBundlesResponse) MarshalJSON() ([]byte, error) {
	if m == nil {
		return json.Marshal(nil)
	}

	buf := &bytes.Buffer{}

	if err := ListBundlesResponseJSONMarshaler.Marshal(buf, m); err != nil {
		return nil, err
	}

	return buf.Bytes(), nil
}

var _ json.Marshaler = (*ListBundlesResponse)(nil)

// ListBundlesResponseJSONUnmarshaler describes the default jsonpb.Unmarshaler used by all
// instances of ListBundlesResponse. This struct is safe to replace or modify but
// should not be done so concurrently.
var ListBundlesResponseJSONUnmarshaler = new(jsonpb.Unmarshaler)

// UnmarshalJSON satisfies the encoding/json Unmarshaler interface. This method
// uses the more correct jsonpb package to correctly unmarshal the message.
func (m *ListBundlesResponse) UnmarshalJSON(b []byte) error {
	return ListBundlesResponseJSONUnmarshaler.Unmarshal(bytes.NewReader(b), m)
}

var _ json.Unmarshaler = (*ListBundlesResponse)(nil)

// AddSettingToBundleRequestJSONMarshaler describes the default jsonpb.Marshaler used by all
// instances of AddSettingToBundleRequest. This struct is safe to replace or modify but
// should not be done so concurrently.
var AddSettingToBundleRequestJSONMarshaler = new(jsonpb.Marshaler)

// MarshalJSON satisfies the encoding/json Marshaler interface. This method
// uses the more correct jsonpb package to correctly marshal the message.
func (m *AddSettingToBundleRequest) MarshalJSON() ([]byte, error) {
	if m == nil {
		return json.Marshal(nil)
	}

	buf := &bytes.Buffer{}

	if err := AddSettingToBundleRequestJSONMarshaler.Marshal(buf, m); err != nil {
		return nil, err
	}

	return buf.Bytes(), nil
}

var _ json.Marshaler = (*AddSettingToBundleRequest)(nil)

// AddSettingToBundleRequestJSONUnmarshaler describes the default jsonpb.Unmarshaler used by all
// instances of AddSettingToBundleRequest. This struct is safe to replace or modify but
// should not be done so concurrently.
var AddSettingToBundleRequestJSONUnmarshaler = new(jsonpb.Unmarshaler)

// UnmarshalJSON satisfies the encoding/json Unmarshaler interface. This method
// uses the more correct jsonpb package to correctly unmarshal the message.
func (m *AddSettingToBundleRequest) UnmarshalJSON(b []byte) error {
	return AddSettingToBundleRequestJSONUnmarshaler.Unmarshal(bytes.NewReader(b), m)
}

var _ json.Unmarshaler = (*AddSettingToBundleRequest)(nil)

// AddSettingToBundleResponseJSONMarshaler describes the default jsonpb.Marshaler used by all
// instances of AddSettingToBundleResponse. This struct is safe to replace or modify but
// should not be done so concurrently.
var AddSettingToBundleResponseJSONMarshaler = new(jsonpb.Marshaler)

// MarshalJSON satisfies the encoding/json Marshaler interface. This method
// uses the more correct jsonpb package to correctly marshal the message.
func (m *AddSettingToBundleResponse) MarshalJSON() ([]byte, error) {
	if m == nil {
		return json.Marshal(nil)
	}

	buf := &bytes.Buffer{}

	if err := AddSettingToBundleResponseJSONMarshaler.Marshal(buf, m); err != nil {
		return nil, err
	}

	return buf.Bytes(), nil
}

var _ json.Marshaler = (*AddSettingToBundleResponse)(nil)

// AddSettingToBundleResponseJSONUnmarshaler describes the default jsonpb.Unmarshaler used by all
// instances of AddSettingToBundleResponse. This struct is safe to replace or modify but
// should not be done so concurrently.
var AddSettingToBundleResponseJSONUnmarshaler = new(jsonpb.Unmarshaler)

// UnmarshalJSON satisfies the encoding/json Unmarshaler interface. This method
// uses the more correct jsonpb package to correctly unmarshal the message.
func (m *AddSettingToBundleResponse) UnmarshalJSON(b []byte) error {
	return AddSettingToBundleResponseJSONUnmarshaler.Unmarshal(bytes.NewReader(b), m)
}

var _ json.Unmarshaler = (*AddSettingToBundleResponse)(nil)

// RemoveSettingFromBundleRequestJSONMarshaler describes the default jsonpb.Marshaler used by all
// instances of RemoveSettingFromBundleRequest. This struct is safe to replace or modify but
// should not be done so concurrently.
var RemoveSettingFromBundleRequestJSONMarshaler = new(jsonpb.Marshaler)

// MarshalJSON satisfies the encoding/json Marshaler interface. This method
// uses the more correct jsonpb package to correctly marshal the message.
func (m *RemoveSettingFromBundleRequest) MarshalJSON() ([]byte, error) {
	if m == nil {
		return json.Marshal(nil)
	}

	buf := &bytes.Buffer{}

	if err := RemoveSettingFromBundleRequestJSONMarshaler.Marshal(buf, m); err != nil {
		return nil, err
	}

	return buf.Bytes(), nil
}

var _ json.Marshaler = (*RemoveSettingFromBundleRequest)(nil)

// RemoveSettingFromBundleRequestJSONUnmarshaler describes the default jsonpb.Unmarshaler used by all
// instances of RemoveSettingFromBundleRequest. This struct is safe to replace or modify but
// should not be done so concurrently.
var RemoveSettingFromBundleRequestJSONUnmarshaler = new(jsonpb.Unmarshaler)

// UnmarshalJSON satisfies the encoding/json Unmarshaler interface. This method
// uses the more correct jsonpb package to correctly unmarshal the message.
func (m *RemoveSettingFromBundleRequest) UnmarshalJSON(b []byte) error {
	return RemoveSettingFromBundleRequestJSONUnmarshaler.Unmarshal(bytes.NewReader(b), m)
}

var _ json.Unmarshaler = (*RemoveSettingFromBundleRequest)(nil)

// SaveValueRequestJSONMarshaler describes the default jsonpb.Marshaler used by all
// instances of SaveValueRequest. This struct is safe to replace or modify but
// should not be done so concurrently.
var SaveValueRequestJSONMarshaler = new(jsonpb.Marshaler)

// MarshalJSON satisfies the encoding/json Marshaler interface. This method
// uses the more correct jsonpb package to correctly marshal the message.
func (m *SaveValueRequest) MarshalJSON() ([]byte, error) {
	if m == nil {
		return json.Marshal(nil)
	}

	buf := &bytes.Buffer{}

	if err := SaveValueRequestJSONMarshaler.Marshal(buf, m); err != nil {
		return nil, err
	}

	return buf.Bytes(), nil
}

var _ json.Marshaler = (*SaveValueRequest)(nil)

// SaveValueRequestJSONUnmarshaler describes the default jsonpb.Unmarshaler used by all
// instances of SaveValueRequest. This struct is safe to replace or modify but
// should not be done so concurrently.
var SaveValueRequestJSONUnmarshaler = new(jsonpb.Unmarshaler)

// UnmarshalJSON satisfies the encoding/json Unmarshaler interface. This method
// uses the more correct jsonpb package to correctly unmarshal the message.
func (m *SaveValueRequest) UnmarshalJSON(b []byte) error {
	return SaveValueRequestJSONUnmarshaler.Unmarshal(bytes.NewReader(b), m)
}

var _ json.Unmarshaler = (*SaveValueRequest)(nil)

// SaveValueResponseJSONMarshaler describes the default jsonpb.Marshaler used by all
// instances of SaveValueResponse. This struct is safe to replace or modify but
// should not be done so concurrently.
var SaveValueResponseJSONMarshaler = new(jsonpb.Marshaler)

// MarshalJSON satisfies the encoding/json Marshaler interface. This method
// uses the more correct jsonpb package to correctly marshal the message.
func (m *SaveValueResponse) MarshalJSON() ([]byte, error) {
	if m == nil {
		return json.Marshal(nil)
	}

	buf := &bytes.Buffer{}

	if err := SaveValueResponseJSONMarshaler.Marshal(buf, m); err != nil {
		return nil, err
	}

	return buf.Bytes(), nil
}

var _ json.Marshaler = (*SaveValueResponse)(nil)

// SaveValueResponseJSONUnmarshaler describes the default jsonpb.Unmarshaler used by all
// instances of SaveValueResponse. This struct is safe to replace or modify but
// should not be done so concurrently.
var SaveValueResponseJSONUnmarshaler = new(jsonpb.Unmarshaler)

// UnmarshalJSON satisfies the encoding/json Unmarshaler interface. This method
// uses the more correct jsonpb package to correctly unmarshal the message.
func (m *SaveValueResponse) UnmarshalJSON(b []byte) error {
	return SaveValueResponseJSONUnmarshaler.Unmarshal(bytes.NewReader(b), m)
}

var _ json.Unmarshaler = (*SaveValueResponse)(nil)

// GetValueRequestJSONMarshaler describes the default jsonpb.Marshaler used by all
// instances of GetValueRequest. This struct is safe to replace or modify but
// should not be done so concurrently.
var GetValueRequestJSONMarshaler = new(jsonpb.Marshaler)

// MarshalJSON satisfies the encoding/json Marshaler interface. This method
// uses the more correct jsonpb package to correctly marshal the message.
func (m *GetValueRequest) MarshalJSON() ([]byte, error) {
	if m == nil {
		return json.Marshal(nil)
	}

	buf := &bytes.Buffer{}

	if err := GetValueRequestJSONMarshaler.Marshal(buf, m); err != nil {
		return nil, err
	}

	return buf.Bytes(), nil
}

var _ json.Marshaler = (*GetValueRequest)(nil)

// GetValueRequestJSONUnmarshaler describes the default jsonpb.Unmarshaler used by all
// instances of GetValueRequest. This struct is safe to replace or modify but
// should not be done so concurrently.
var GetValueRequestJSONUnmarshaler = new(jsonpb.Unmarshaler)

// UnmarshalJSON satisfies the encoding/json Unmarshaler interface. This method
// uses the more correct jsonpb package to correctly unmarshal the message.
func (m *GetValueRequest) UnmarshalJSON(b []byte) error {
	return GetValueRequestJSONUnmarshaler.Unmarshal(bytes.NewReader(b), m)
}

var _ json.Unmarshaler = (*GetValueRequest)(nil)

// GetValueResponseJSONMarshaler describes the default jsonpb.Marshaler used by all
// instances of GetValueResponse. This struct is safe to replace or modify but
// should not be done so concurrently.
var GetValueResponseJSONMarshaler = new(jsonpb.Marshaler)

// MarshalJSON satisfies the encoding/json Marshaler interface. This method
// uses the more correct jsonpb package to correctly marshal the message.
func (m *GetValueResponse) MarshalJSON() ([]byte, error) {
	if m == nil {
		return json.Marshal(nil)
	}

	buf := &bytes.Buffer{}

	if err := GetValueResponseJSONMarshaler.Marshal(buf, m); err != nil {
		return nil, err
	}

	return buf.Bytes(), nil
}

var _ json.Marshaler = (*GetValueResponse)(nil)

// GetValueResponseJSONUnmarshaler describes the default jsonpb.Unmarshaler used by all
// instances of GetValueResponse. This struct is safe to replace or modify but
// should not be done so concurrently.
var GetValueResponseJSONUnmarshaler = new(jsonpb.Unmarshaler)

// UnmarshalJSON satisfies the encoding/json Unmarshaler interface. This method
// uses the more correct jsonpb package to correctly unmarshal the message.
func (m *GetValueResponse) UnmarshalJSON(b []byte) error {
	return GetValueResponseJSONUnmarshaler.Unmarshal(bytes.NewReader(b), m)
}

var _ json.Unmarshaler = (*GetValueResponse)(nil)

// ListValuesRequestJSONMarshaler describes the default jsonpb.Marshaler used by all
// instances of ListValuesRequest. This struct is safe to replace or modify but
// should not be done so concurrently.
var ListValuesRequestJSONMarshaler = new(jsonpb.Marshaler)

// MarshalJSON satisfies the encoding/json Marshaler interface. This method
// uses the more correct jsonpb package to correctly marshal the message.
func (m *ListValuesRequest) MarshalJSON() ([]byte, error) {
	if m == nil {
		return json.Marshal(nil)
	}

	buf := &bytes.Buffer{}

	if err := ListValuesRequestJSONMarshaler.Marshal(buf, m); err != nil {
		return nil, err
	}

	return buf.Bytes(), nil
}

var _ json.Marshaler = (*ListValuesRequest)(nil)

// ListValuesRequestJSONUnmarshaler describes the default jsonpb.Unmarshaler used by all
// instances of ListValuesRequest. This struct is safe to replace or modify but
// should not be done so concurrently.
var ListValuesRequestJSONUnmarshaler = new(jsonpb.Unmarshaler)

// UnmarshalJSON satisfies the encoding/json Unmarshaler interface. This method
// uses the more correct jsonpb package to correctly unmarshal the message.
func (m *ListValuesRequest) UnmarshalJSON(b []byte) error {
	return ListValuesRequestJSONUnmarshaler.Unmarshal(bytes.NewReader(b), m)
}

var _ json.Unmarshaler = (*ListValuesRequest)(nil)

// ListValuesResponseJSONMarshaler describes the default jsonpb.Marshaler used by all
// instances of ListValuesResponse. This struct is safe to replace or modify but
// should not be done so concurrently.
var ListValuesResponseJSONMarshaler = new(jsonpb.Marshaler)

// MarshalJSON satisfies the encoding/json Marshaler interface. This method
// uses the more correct jsonpb package to correctly marshal the message.
func (m *ListValuesResponse) MarshalJSON() ([]byte, error) {
	if m == nil {
		return json.Marshal(nil)
	}

	buf := &bytes.Buffer{}

	if err := ListValuesResponseJSONMarshaler.Marshal(buf, m); err != nil {
		return nil, err
	}

	return buf.Bytes(), nil
}

var _ json.Marshaler = (*ListValuesResponse)(nil)

// ListValuesResponseJSONUnmarshaler describes the default jsonpb.Unmarshaler used by all
// instances of ListValuesResponse. This struct is safe to replace or modify but
// should not be done so concurrently.
var ListValuesResponseJSONUnmarshaler = new(jsonpb.Unmarshaler)

// UnmarshalJSON satisfies the encoding/json Unmarshaler interface. This method
// uses the more correct jsonpb package to correctly unmarshal the message.
func (m *ListValuesResponse) UnmarshalJSON(b []byte) error {
	return ListValuesResponseJSONUnmarshaler.Unmarshal(bytes.NewReader(b), m)
}

var _ json.Unmarshaler = (*ListValuesResponse)(nil)

// GetValueByUniqueIdentifiersRequestJSONMarshaler describes the default jsonpb.Marshaler used by all
// instances of GetValueByUniqueIdentifiersRequest. This struct is safe to replace or modify but
// should not be done so concurrently.
var GetValueByUniqueIdentifiersRequestJSONMarshaler = new(jsonpb.Marshaler)

// MarshalJSON satisfies the encoding/json Marshaler interface. This method
// uses the more correct jsonpb package to correctly marshal the message.
func (m *GetValueByUniqueIdentifiersRequest) MarshalJSON() ([]byte, error) {
	if m == nil {
		return json.Marshal(nil)
	}

	buf := &bytes.Buffer{}

	if err := GetValueByUniqueIdentifiersRequestJSONMarshaler.Marshal(buf, m); err != nil {
		return nil, err
	}

	return buf.Bytes(), nil
}

var _ json.Marshaler = (*GetValueByUniqueIdentifiersRequest)(nil)

// GetValueByUniqueIdentifiersRequestJSONUnmarshaler describes the default jsonpb.Unmarshaler used by all
// instances of GetValueByUniqueIdentifiersRequest. This struct is safe to replace or modify but
// should not be done so concurrently.
var GetValueByUniqueIdentifiersRequestJSONUnmarshaler = new(jsonpb.Unmarshaler)

// UnmarshalJSON satisfies the encoding/json Unmarshaler interface. This method
// uses the more correct jsonpb package to correctly unmarshal the message.
func (m *GetValueByUniqueIdentifiersRequest) UnmarshalJSON(b []byte) error {
	return GetValueByUniqueIdentifiersRequestJSONUnmarshaler.Unmarshal(bytes.NewReader(b), m)
}

var _ json.Unmarshaler = (*GetValueByUniqueIdentifiersRequest)(nil)

// ListRoleAssignmentsRequestJSONMarshaler describes the default jsonpb.Marshaler used by all
// instances of ListRoleAssignmentsRequest. This struct is safe to replace or modify but
// should not be done so concurrently.
var ListRoleAssignmentsRequestJSONMarshaler = new(jsonpb.Marshaler)

// MarshalJSON satisfies the encoding/json Marshaler interface. This method
// uses the more correct jsonpb package to correctly marshal the message.
func (m *ListRoleAssignmentsRequest) MarshalJSON() ([]byte, error) {
	if m == nil {
		return json.Marshal(nil)
	}

	buf := &bytes.Buffer{}

	if err := ListRoleAssignmentsRequestJSONMarshaler.Marshal(buf, m); err != nil {
		return nil, err
	}

	return buf.Bytes(), nil
}

var _ json.Marshaler = (*ListRoleAssignmentsRequest)(nil)

// ListRoleAssignmentsRequestJSONUnmarshaler describes the default jsonpb.Unmarshaler used by all
// instances of ListRoleAssignmentsRequest. This struct is safe to replace or modify but
// should not be done so concurrently.
var ListRoleAssignmentsRequestJSONUnmarshaler = new(jsonpb.Unmarshaler)

// UnmarshalJSON satisfies the encoding/json Unmarshaler interface. This method
// uses the more correct jsonpb package to correctly unmarshal the message.
func (m *ListRoleAssignmentsRequest) UnmarshalJSON(b []byte) error {
	return ListRoleAssignmentsRequestJSONUnmarshaler.Unmarshal(bytes.NewReader(b), m)
}

var _ json.Unmarshaler = (*ListRoleAssignmentsRequest)(nil)

// ListRoleAssignmentsFilteredRequestJSONMarshaler describes the default jsonpb.Marshaler used by all
// instances of ListRoleAssignmentsFilteredRequest. This struct is safe to replace or modify but
// should not be done so concurrently.
var ListRoleAssignmentsFilteredRequestJSONMarshaler = new(jsonpb.Marshaler)

// MarshalJSON satisfies the encoding/json Marshaler interface. This method
// uses the more correct jsonpb package to correctly marshal the message.
func (m *ListRoleAssignmentsFilteredRequest) MarshalJSON() ([]byte, error) {
	if m == nil {
		return json.Marshal(nil)
	}

	buf := &bytes.Buffer{}

	if err := ListRoleAssignmentsFilteredRequestJSONMarshaler.Marshal(buf, m); err != nil {
		return nil, err
	}

	return buf.Bytes(), nil
}

var _ json.Marshaler = (*ListRoleAssignmentsFilteredRequest)(nil)

// ListRoleAssignmentsFilteredRequestJSONUnmarshaler describes the default jsonpb.Unmarshaler used by all
// instances of ListRoleAssignmentsFilteredRequest. This struct is safe to replace or modify but
// should not be done so concurrently.
var ListRoleAssignmentsFilteredRequestJSONUnmarshaler = new(jsonpb.Unmarshaler)

// UnmarshalJSON satisfies the encoding/json Unmarshaler interface. This method
// uses the more correct jsonpb package to correctly unmarshal the message.
func (m *ListRoleAssignmentsFilteredRequest) UnmarshalJSON(b []byte) error {
	return ListRoleAssignmentsFilteredRequestJSONUnmarshaler.Unmarshal(bytes.NewReader(b), m)
}

var _ json.Unmarshaler = (*ListRoleAssignmentsFilteredRequest)(nil)

// ListRoleAssignmentsResponseJSONMarshaler describes the default jsonpb.Marshaler used by all
// instances of ListRoleAssignmentsResponse. This struct is safe to replace or modify but
// should not be done so concurrently.
var ListRoleAssignmentsResponseJSONMarshaler = new(jsonpb.Marshaler)

// MarshalJSON satisfies the encoding/json Marshaler interface. This method
// uses the more correct jsonpb package to correctly marshal the message.
func (m *ListRoleAssignmentsResponse) MarshalJSON() ([]byte, error) {
	if m == nil {
		return json.Marshal(nil)
	}

	buf := &bytes.Buffer{}

	if err := ListRoleAssignmentsResponseJSONMarshaler.Marshal(buf, m); err != nil {
		return nil, err
	}

	return buf.Bytes(), nil
}

var _ json.Marshaler = (*ListRoleAssignmentsResponse)(nil)

// ListRoleAssignmentsResponseJSONUnmarshaler describes the default jsonpb.Unmarshaler used by all
// instances of ListRoleAssignmentsResponse. This struct is safe to replace or modify but
// should not be done so concurrently.
var ListRoleAssignmentsResponseJSONUnmarshaler = new(jsonpb.Unmarshaler)

// UnmarshalJSON satisfies the encoding/json Unmarshaler interface. This method
// uses the more correct jsonpb package to correctly unmarshal the message.
func (m *ListRoleAssignmentsResponse) UnmarshalJSON(b []byte) error {
	return ListRoleAssignmentsResponseJSONUnmarshaler.Unmarshal(bytes.NewReader(b), m)
}

var _ json.Unmarshaler = (*ListRoleAssignmentsResponse)(nil)

// AssignRoleToUserRequestJSONMarshaler describes the default jsonpb.Marshaler used by all
// instances of AssignRoleToUserRequest. This struct is safe to replace or modify but
// should not be done so concurrently.
var AssignRoleToUserRequestJSONMarshaler = new(jsonpb.Marshaler)

// MarshalJSON satisfies the encoding/json Marshaler interface. This method
// uses the more correct jsonpb package to correctly marshal the message.
func (m *AssignRoleToUserRequest) MarshalJSON() ([]byte, error) {
	if m == nil {
		return json.Marshal(nil)
	}

	buf := &bytes.Buffer{}

	if err := AssignRoleToUserRequestJSONMarshaler.Marshal(buf, m); err != nil {
		return nil, err
	}

	return buf.Bytes(), nil
}

var _ json.Marshaler = (*AssignRoleToUserRequest)(nil)

// AssignRoleToUserRequestJSONUnmarshaler describes the default jsonpb.Unmarshaler used by all
// instances of AssignRoleToUserRequest. This struct is safe to replace or modify but
// should not be done so concurrently.
var AssignRoleToUserRequestJSONUnmarshaler = new(jsonpb.Unmarshaler)

// UnmarshalJSON satisfies the encoding/json Unmarshaler interface. This method
// uses the more correct jsonpb package to correctly unmarshal the message.
func (m *AssignRoleToUserRequest) UnmarshalJSON(b []byte) error {
	return AssignRoleToUserRequestJSONUnmarshaler.Unmarshal(bytes.NewReader(b), m)
}

var _ json.Unmarshaler = (*AssignRoleToUserRequest)(nil)

// AssignRoleToUserResponseJSONMarshaler describes the default jsonpb.Marshaler used by all
// instances of AssignRoleToUserResponse. This struct is safe to replace or modify but
// should not be done so concurrently.
var AssignRoleToUserResponseJSONMarshaler = new(jsonpb.Marshaler)

// MarshalJSON satisfies the encoding/json Marshaler interface. This method
// uses the more correct jsonpb package to correctly marshal the message.
func (m *AssignRoleToUserResponse) MarshalJSON() ([]byte, error) {
	if m == nil {
		return json.Marshal(nil)
	}

	buf := &bytes.Buffer{}

	if err := AssignRoleToUserResponseJSONMarshaler.Marshal(buf, m); err != nil {
		return nil, err
	}

	return buf.Bytes(), nil
}

var _ json.Marshaler = (*AssignRoleToUserResponse)(nil)

// AssignRoleToUserResponseJSONUnmarshaler describes the default jsonpb.Unmarshaler used by all
// instances of AssignRoleToUserResponse. This struct is safe to replace or modify but
// should not be done so concurrently.
var AssignRoleToUserResponseJSONUnmarshaler = new(jsonpb.Unmarshaler)

// UnmarshalJSON satisfies the encoding/json Unmarshaler interface. This method
// uses the more correct jsonpb package to correctly unmarshal the message.
func (m *AssignRoleToUserResponse) UnmarshalJSON(b []byte) error {
	return AssignRoleToUserResponseJSONUnmarshaler.Unmarshal(bytes.NewReader(b), m)
}

var _ json.Unmarshaler = (*AssignRoleToUserResponse)(nil)

// RemoveRoleFromUserRequestJSONMarshaler describes the default jsonpb.Marshaler used by all
// instances of RemoveRoleFromUserRequest. This struct is safe to replace or modify but
// should not be done so concurrently.
var RemoveRoleFromUserRequestJSONMarshaler = new(jsonpb.Marshaler)

// MarshalJSON satisfies the encoding/json Marshaler interface. This method
// uses the more correct jsonpb package to correctly marshal the message.
func (m *RemoveRoleFromUserRequest) MarshalJSON() ([]byte, error) {
	if m == nil {
		return json.Marshal(nil)
	}

	buf := &bytes.Buffer{}

	if err := RemoveRoleFromUserRequestJSONMarshaler.Marshal(buf, m); err != nil {
		return nil, err
	}

	return buf.Bytes(), nil
}

var _ json.Marshaler = (*RemoveRoleFromUserRequest)(nil)

// RemoveRoleFromUserRequestJSONUnmarshaler describes the default jsonpb.Unmarshaler used by all
// instances of RemoveRoleFromUserRequest. This struct is safe to replace or modify but
// should not be done so concurrently.
var RemoveRoleFromUserRequestJSONUnmarshaler = new(jsonpb.Unmarshaler)

// UnmarshalJSON satisfies the encoding/json Unmarshaler interface. This method
// uses the more correct jsonpb package to correctly unmarshal the message.
func (m *RemoveRoleFromUserRequest) UnmarshalJSON(b []byte) error {
	return RemoveRoleFromUserRequestJSONUnmarshaler.Unmarshal(bytes.NewReader(b), m)
}

var _ json.Unmarshaler = (*RemoveRoleFromUserRequest)(nil)

// ListPermissionsRequestJSONMarshaler describes the default jsonpb.Marshaler used by all
// instances of ListPermissionsRequest. This struct is safe to replace or modify but
// should not be done so concurrently.
var ListPermissionsRequestJSONMarshaler = new(jsonpb.Marshaler)

// MarshalJSON satisfies the encoding/json Marshaler interface. This method
// uses the more correct jsonpb package to correctly marshal the message.
func (m *ListPermissionsRequest) MarshalJSON() ([]byte, error) {
	if m == nil {
		return json.Marshal(nil)
	}

	buf := &bytes.Buffer{}

	if err := ListPermissionsRequestJSONMarshaler.Marshal(buf, m); err != nil {
		return nil, err
	}

	return buf.Bytes(), nil
}

var _ json.Marshaler = (*ListPermissionsRequest)(nil)

// ListPermissionsRequestJSONUnmarshaler describes the default jsonpb.Unmarshaler used by all
// instances of ListPermissionsRequest. This struct is safe to replace or modify but
// should not be done so concurrently.
var ListPermissionsRequestJSONUnmarshaler = new(jsonpb.Unmarshaler)

// UnmarshalJSON satisfies the encoding/json Unmarshaler interface. This method
// uses the more correct jsonpb package to correctly unmarshal the message.
func (m *ListPermissionsRequest) UnmarshalJSON(b []byte) error {
	return ListPermissionsRequestJSONUnmarshaler.Unmarshal(bytes.NewReader(b), m)
}

var _ json.Unmarshaler = (*ListPermissionsRequest)(nil)

// ListPermissionsResponseJSONMarshaler describes the default jsonpb.Marshaler used by all
// instances of ListPermissionsResponse. This struct is safe to replace or modify but
// should not be done so concurrently.
var ListPermissionsResponseJSONMarshaler = new(jsonpb.Marshaler)

// MarshalJSON satisfies the encoding/json Marshaler interface. This method
// uses the more correct jsonpb package to correctly marshal the message.
func (m *ListPermissionsResponse) MarshalJSON() ([]byte, error) {
	if m == nil {
		return json.Marshal(nil)
	}

	buf := &bytes.Buffer{}

	if err := ListPermissionsResponseJSONMarshaler.Marshal(buf, m); err != nil {
		return nil, err
	}

	return buf.Bytes(), nil
}

var _ json.Marshaler = (*ListPermissionsResponse)(nil)

// ListPermissionsResponseJSONUnmarshaler describes the default jsonpb.Unmarshaler used by all
// instances of ListPermissionsResponse. This struct is safe to replace or modify but
// should not be done so concurrently.
var ListPermissionsResponseJSONUnmarshaler = new(jsonpb.Unmarshaler)

// UnmarshalJSON satisfies the encoding/json Unmarshaler interface. This method
// uses the more correct jsonpb package to correctly unmarshal the message.
func (m *ListPermissionsResponse) UnmarshalJSON(b []byte) error {
	return ListPermissionsResponseJSONUnmarshaler.Unmarshal(bytes.NewReader(b), m)
}

var _ json.Unmarshaler = (*ListPermissionsResponse)(nil)

// ListPermissionsByResourceRequestJSONMarshaler describes the default jsonpb.Marshaler used by all
// instances of ListPermissionsByResourceRequest. This struct is safe to replace or modify but
// should not be done so concurrently.
var ListPermissionsByResourceRequestJSONMarshaler = new(jsonpb.Marshaler)

// MarshalJSON satisfies the encoding/json Marshaler interface. This method
// uses the more correct jsonpb package to correctly marshal the message.
func (m *ListPermissionsByResourceRequest) MarshalJSON() ([]byte, error) {
	if m == nil {
		return json.Marshal(nil)
	}

	buf := &bytes.Buffer{}

	if err := ListPermissionsByResourceRequestJSONMarshaler.Marshal(buf, m); err != nil {
		return nil, err
	}

	return buf.Bytes(), nil
}

var _ json.Marshaler = (*ListPermissionsByResourceRequest)(nil)

// ListPermissionsByResourceRequestJSONUnmarshaler describes the default jsonpb.Unmarshaler used by all
// instances of ListPermissionsByResourceRequest. This struct is safe to replace or modify but
// should not be done so concurrently.
var ListPermissionsByResourceRequestJSONUnmarshaler = new(jsonpb.Unmarshaler)

// UnmarshalJSON satisfies the encoding/json Unmarshaler interface. This method
// uses the more correct jsonpb package to correctly unmarshal the message.
func (m *ListPermissionsByResourceRequest) UnmarshalJSON(b []byte) error {
	return ListPermissionsByResourceRequestJSONUnmarshaler.Unmarshal(bytes.NewReader(b), m)
}

var _ json.Unmarshaler = (*ListPermissionsByResourceRequest)(nil)

// ListPermissionsByResourceResponseJSONMarshaler describes the default jsonpb.Marshaler used by all
// instances of ListPermissionsByResourceResponse. This struct is safe to replace or modify but
// should not be done so concurrently.
var ListPermissionsByResourceResponseJSONMarshaler = new(jsonpb.Marshaler)

// MarshalJSON satisfies the encoding/json Marshaler interface. This method
// uses the more correct jsonpb package to correctly marshal the message.
func (m *ListPermissionsByResourceResponse) MarshalJSON() ([]byte, error) {
	if m == nil {
		return json.Marshal(nil)
	}

	buf := &bytes.Buffer{}

	if err := ListPermissionsByResourceResponseJSONMarshaler.Marshal(buf, m); err != nil {
		return nil, err
	}

	return buf.Bytes(), nil
}

var _ json.Marshaler = (*ListPermissionsByResourceResponse)(nil)

// ListPermissionsByResourceResponseJSONUnmarshaler describes the default jsonpb.Unmarshaler used by all
// instances of ListPermissionsByResourceResponse. This struct is safe to replace or modify but
// should not be done so concurrently.
var ListPermissionsByResourceResponseJSONUnmarshaler = new(jsonpb.Unmarshaler)

// UnmarshalJSON satisfies the encoding/json Unmarshaler interface. This method
// uses the more correct jsonpb package to correctly unmarshal the message.
func (m *ListPermissionsByResourceResponse) UnmarshalJSON(b []byte) error {
	return ListPermissionsByResourceResponseJSONUnmarshaler.Unmarshal(bytes.NewReader(b), m)
}

var _ json.Unmarshaler = (*ListPermissionsByResourceResponse)(nil)

// GetPermissionByIDRequestJSONMarshaler describes the default jsonpb.Marshaler used by all
// instances of GetPermissionByIDRequest. This struct is safe to replace or modify but
// should not be done so concurrently.
var GetPermissionByIDRequestJSONMarshaler = new(jsonpb.Marshaler)

// MarshalJSON satisfies the encoding/json Marshaler interface. This method
// uses the more correct jsonpb package to correctly marshal the message.
func (m *GetPermissionByIDRequest) MarshalJSON() ([]byte, error) {
	if m == nil {
		return json.Marshal(nil)
	}

	buf := &bytes.Buffer{}

	if err := GetPermissionByIDRequestJSONMarshaler.Marshal(buf, m); err != nil {
		return nil, err
	}

	return buf.Bytes(), nil
}

var _ json.Marshaler = (*GetPermissionByIDRequest)(nil)

// GetPermissionByIDRequestJSONUnmarshaler describes the default jsonpb.Unmarshaler used by all
// instances of GetPermissionByIDRequest. This struct is safe to replace or modify but
// should not be done so concurrently.
var GetPermissionByIDRequestJSONUnmarshaler = new(jsonpb.Unmarshaler)

// UnmarshalJSON satisfies the encoding/json Unmarshaler interface. This method
// uses the more correct jsonpb package to correctly unmarshal the message.
func (m *GetPermissionByIDRequest) UnmarshalJSON(b []byte) error {
	return GetPermissionByIDRequestJSONUnmarshaler.Unmarshal(bytes.NewReader(b), m)
}

var _ json.Unmarshaler = (*GetPermissionByIDRequest)(nil)

// GetPermissionByIDResponseJSONMarshaler describes the default jsonpb.Marshaler used by all
// instances of GetPermissionByIDResponse. This struct is safe to replace or modify but
// should not be done so concurrently.
var GetPermissionByIDResponseJSONMarshaler = new(jsonpb.Marshaler)

// MarshalJSON satisfies the encoding/json Marshaler interface. This method
// uses the more correct jsonpb package to correctly marshal the message.
func (m *GetPermissionByIDResponse) MarshalJSON() ([]byte, error) {
	if m == nil {
		return json.Marshal(nil)
	}

	buf := &bytes.Buffer{}

	if err := GetPermissionByIDResponseJSONMarshaler.Marshal(buf, m); err != nil {
		return nil, err
	}

	return buf.Bytes(), nil
}

var _ json.Marshaler = (*GetPermissionByIDResponse)(nil)

// GetPermissionByIDResponseJSONUnmarshaler describes the default jsonpb.Unmarshaler used by all
// instances of GetPermissionByIDResponse. This struct is safe to replace or modify but
// should not be done so concurrently.
var GetPermissionByIDResponseJSONUnmarshaler = new(jsonpb.Unmarshaler)

// UnmarshalJSON satisfies the encoding/json Unmarshaler interface. This method
// uses the more correct jsonpb package to correctly unmarshal the message.
func (m *GetPermissionByIDResponse) UnmarshalJSON(b []byte) error {
	return GetPermissionByIDResponseJSONUnmarshaler.Unmarshal(bytes.NewReader(b), m)
}

var _ json.Unmarshaler = (*GetPermissionByIDResponse)(nil)