hashpb_helpers.pb.go

// Code generated by protoc-gen-go-hashpb. Do not edit.
// protoc-gen-go-hashpb v0.3.1

package privatev1

import (
	v1 "github.com/cerbos/cerbos/api/genpb/cerbos/audit/v1"
	v11 "github.com/cerbos/cerbos/api/genpb/cerbos/engine/v1"
	v12 "github.com/cerbos/cerbos/api/genpb/cerbos/policy/v1"
	v13 "github.com/cerbos/cerbos/api/genpb/cerbos/request/v1"
	v14 "github.com/cerbos/cerbos/api/genpb/cerbos/response/v1"
	v15 "github.com/cerbos/cerbos/api/genpb/cerbos/runtime/v1"
	v16 "github.com/cerbos/cerbos/api/genpb/cerbos/schema/v1"
	v17 "github.com/cerbos/cerbos/api/genpb/cerbos/source/v1"
	protowire "google.golang.org/protobuf/encoding/protowire"
	anypb "google.golang.org/protobuf/types/known/anypb"
	durationpb "google.golang.org/protobuf/types/known/durationpb"
	emptypb "google.golang.org/protobuf/types/known/emptypb"
	structpb "google.golang.org/protobuf/types/known/structpb"
	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
	wrapperspb "google.golang.org/protobuf/types/known/wrapperspb"
	hash "hash"
	math "math"
	sort "sort"
)

func cerbos_audit_v1_AuditTrail_hashpb_sum(m *v1.AuditTrail, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.audit.v1.AuditTrail.effective_policies"]; !ok {
		if len(m.EffectivePolicies) > 0 {
			keys := make([]string, len(m.EffectivePolicies))
			i := 0
			for k := range m.EffectivePolicies {
				keys[i] = k
				i++
			}

			sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

			for _, k := range keys {
				if m.EffectivePolicies[k] != nil {
					cerbos_policy_v1_SourceAttributes_hashpb_sum(m.EffectivePolicies[k], hasher, ignore)
				}

			}
		}
	}
}

func cerbos_audit_v1_DecisionLogEntry_CheckResources_hashpb_sum(m *v1.DecisionLogEntry_CheckResources, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.audit.v1.DecisionLogEntry.CheckResources.inputs"]; !ok {
		if len(m.Inputs) > 0 {
			for _, v := range m.Inputs {
				if v != nil {
					cerbos_engine_v1_CheckInput_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
	if _, ok := ignore["cerbos.audit.v1.DecisionLogEntry.CheckResources.outputs"]; !ok {
		if len(m.Outputs) > 0 {
			for _, v := range m.Outputs {
				if v != nil {
					cerbos_engine_v1_CheckOutput_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
	if _, ok := ignore["cerbos.audit.v1.DecisionLogEntry.CheckResources.error"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetError()))

	}
}

func cerbos_audit_v1_DecisionLogEntry_PlanResources_hashpb_sum(m *v1.DecisionLogEntry_PlanResources, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.audit.v1.DecisionLogEntry.PlanResources.input"]; !ok {
		if m.GetInput() != nil {
			cerbos_engine_v1_PlanResourcesInput_hashpb_sum(m.GetInput(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.audit.v1.DecisionLogEntry.PlanResources.output"]; !ok {
		if m.GetOutput() != nil {
			cerbos_engine_v1_PlanResourcesOutput_hashpb_sum(m.GetOutput(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.audit.v1.DecisionLogEntry.PlanResources.error"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetError()))

	}
}

func cerbos_audit_v1_DecisionLogEntry_hashpb_sum(m *v1.DecisionLogEntry, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.audit.v1.DecisionLogEntry.call_id"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetCallId()))

	}
	if _, ok := ignore["cerbos.audit.v1.DecisionLogEntry.timestamp"]; !ok {
		if m.GetTimestamp() != nil {
			google_protobuf_Timestamp_hashpb_sum(m.GetTimestamp(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.audit.v1.DecisionLogEntry.peer"]; !ok {
		if m.GetPeer() != nil {
			cerbos_audit_v1_Peer_hashpb_sum(m.GetPeer(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.audit.v1.DecisionLogEntry.inputs"]; !ok {
		if len(m.Inputs) > 0 {
			for _, v := range m.Inputs {
				if v != nil {
					cerbos_engine_v1_CheckInput_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
	if _, ok := ignore["cerbos.audit.v1.DecisionLogEntry.outputs"]; !ok {
		if len(m.Outputs) > 0 {
			for _, v := range m.Outputs {
				if v != nil {
					cerbos_engine_v1_CheckOutput_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
	if _, ok := ignore["cerbos.audit.v1.DecisionLogEntry.error"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetError()))

	}
	if m.Method != nil {
		if _, ok := ignore["cerbos.audit.v1.DecisionLogEntry.method"]; !ok {
			switch t := m.Method.(type) {
			case *v1.DecisionLogEntry_CheckResources_:
				if t.CheckResources != nil {
					cerbos_audit_v1_DecisionLogEntry_CheckResources_hashpb_sum(t.CheckResources, hasher, ignore)
				}

			case *v1.DecisionLogEntry_PlanResources_:
				if t.PlanResources != nil {
					cerbos_audit_v1_DecisionLogEntry_PlanResources_hashpb_sum(t.PlanResources, hasher, ignore)
				}

			}
		}
	}
	if _, ok := ignore["cerbos.audit.v1.DecisionLogEntry.metadata"]; !ok {
		if len(m.Metadata) > 0 {
			keys := make([]string, len(m.Metadata))
			i := 0
			for k := range m.Metadata {
				keys[i] = k
				i++
			}

			sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

			for _, k := range keys {
				if m.Metadata[k] != nil {
					cerbos_audit_v1_MetaValues_hashpb_sum(m.Metadata[k], hasher, ignore)
				}

			}
		}
	}
	if _, ok := ignore["cerbos.audit.v1.DecisionLogEntry.audit_trail"]; !ok {
		if m.GetAuditTrail() != nil {
			cerbos_audit_v1_AuditTrail_hashpb_sum(m.GetAuditTrail(), hasher, ignore)
		}

	}
}

func cerbos_audit_v1_MetaValues_hashpb_sum(m *v1.MetaValues, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.audit.v1.MetaValues.values"]; !ok {
		if len(m.Values) > 0 {
			for _, v := range m.Values {
				_, _ = hasher.Write(protowire.AppendString(nil, v))

			}
		}
	}
}

func cerbos_audit_v1_Peer_hashpb_sum(m *v1.Peer, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.audit.v1.Peer.address"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetAddress()))

	}
	if _, ok := ignore["cerbos.audit.v1.Peer.auth_info"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetAuthInfo()))

	}
	if _, ok := ignore["cerbos.audit.v1.Peer.user_agent"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetUserAgent()))

	}
	if _, ok := ignore["cerbos.audit.v1.Peer.forwarded_for"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetForwardedFor()))

	}
}

func cerbos_engine_v1_AuxData_hashpb_sum(m *v11.AuxData, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.engine.v1.AuxData.jwt"]; !ok {
		if len(m.Jwt) > 0 {
			keys := make([]string, len(m.Jwt))
			i := 0
			for k := range m.Jwt {
				keys[i] = k
				i++
			}

			sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

			for _, k := range keys {
				if m.Jwt[k] != nil {
					google_protobuf_Value_hashpb_sum(m.Jwt[k], hasher, ignore)
				}

			}
		}
	}
}

func cerbos_engine_v1_CheckInput_hashpb_sum(m *v11.CheckInput, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.engine.v1.CheckInput.request_id"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetRequestId()))

	}
	if _, ok := ignore["cerbos.engine.v1.CheckInput.resource"]; !ok {
		if m.GetResource() != nil {
			cerbos_engine_v1_Resource_hashpb_sum(m.GetResource(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.engine.v1.CheckInput.principal"]; !ok {
		if m.GetPrincipal() != nil {
			cerbos_engine_v1_Principal_hashpb_sum(m.GetPrincipal(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.engine.v1.CheckInput.actions"]; !ok {
		if len(m.Actions) > 0 {
			for _, v := range m.Actions {
				_, _ = hasher.Write(protowire.AppendString(nil, v))

			}
		}
	}
	if _, ok := ignore["cerbos.engine.v1.CheckInput.aux_data"]; !ok {
		if m.GetAuxData() != nil {
			cerbos_engine_v1_AuxData_hashpb_sum(m.GetAuxData(), hasher, ignore)
		}

	}
}

func cerbos_engine_v1_CheckOutput_ActionEffect_hashpb_sum(m *v11.CheckOutput_ActionEffect, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.engine.v1.CheckOutput.ActionEffect.effect"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(m.GetEffect())))

	}
	if _, ok := ignore["cerbos.engine.v1.CheckOutput.ActionEffect.policy"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetPolicy()))

	}
	if _, ok := ignore["cerbos.engine.v1.CheckOutput.ActionEffect.scope"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetScope()))

	}
}

func cerbos_engine_v1_CheckOutput_hashpb_sum(m *v11.CheckOutput, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.engine.v1.CheckOutput.request_id"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetRequestId()))

	}
	if _, ok := ignore["cerbos.engine.v1.CheckOutput.resource_id"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetResourceId()))

	}
	if _, ok := ignore["cerbos.engine.v1.CheckOutput.actions"]; !ok {
		if len(m.Actions) > 0 {
			keys := make([]string, len(m.Actions))
			i := 0
			for k := range m.Actions {
				keys[i] = k
				i++
			}

			sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

			for _, k := range keys {
				if m.Actions[k] != nil {
					cerbos_engine_v1_CheckOutput_ActionEffect_hashpb_sum(m.Actions[k], hasher, ignore)
				}

			}
		}
	}
	if _, ok := ignore["cerbos.engine.v1.CheckOutput.effective_derived_roles"]; !ok {
		if len(m.EffectiveDerivedRoles) > 0 {
			for _, v := range m.EffectiveDerivedRoles {
				_, _ = hasher.Write(protowire.AppendString(nil, v))

			}
		}
	}
	if _, ok := ignore["cerbos.engine.v1.CheckOutput.validation_errors"]; !ok {
		if len(m.ValidationErrors) > 0 {
			for _, v := range m.ValidationErrors {
				if v != nil {
					cerbos_schema_v1_ValidationError_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
	if _, ok := ignore["cerbos.engine.v1.CheckOutput.outputs"]; !ok {
		if len(m.Outputs) > 0 {
			for _, v := range m.Outputs {
				if v != nil {
					cerbos_engine_v1_OutputEntry_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
}

func cerbos_engine_v1_OutputEntry_hashpb_sum(m *v11.OutputEntry, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.engine.v1.OutputEntry.src"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetSrc()))

	}
	if _, ok := ignore["cerbos.engine.v1.OutputEntry.val"]; !ok {
		if m.GetVal() != nil {
			google_protobuf_Value_hashpb_sum(m.GetVal(), hasher, ignore)
		}

	}
}

func cerbos_engine_v1_PlanResourcesFilter_Expression_Operand_hashpb_sum(m *v11.PlanResourcesFilter_Expression_Operand, hasher hash.Hash, ignore map[string]struct{}) {
	if m.Node != nil {
		if _, ok := ignore["cerbos.engine.v1.PlanResourcesFilter.Expression.Operand.node"]; !ok {
			switch t := m.Node.(type) {
			case *v11.PlanResourcesFilter_Expression_Operand_Value:
				if t.Value != nil {
					google_protobuf_Value_hashpb_sum(t.Value, hasher, ignore)
				}

			case *v11.PlanResourcesFilter_Expression_Operand_Expression:
				if t.Expression != nil {
					cerbos_engine_v1_PlanResourcesFilter_Expression_hashpb_sum(t.Expression, hasher, ignore)
				}

			case *v11.PlanResourcesFilter_Expression_Operand_Variable:
				_, _ = hasher.Write(protowire.AppendString(nil, t.Variable))

			}
		}
	}
}

func cerbos_engine_v1_PlanResourcesFilter_Expression_hashpb_sum(m *v11.PlanResourcesFilter_Expression, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.engine.v1.PlanResourcesFilter.Expression.operator"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetOperator()))

	}
	if _, ok := ignore["cerbos.engine.v1.PlanResourcesFilter.Expression.operands"]; !ok {
		if len(m.Operands) > 0 {
			for _, v := range m.Operands {
				if v != nil {
					cerbos_engine_v1_PlanResourcesFilter_Expression_Operand_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
}

func cerbos_engine_v1_PlanResourcesFilter_hashpb_sum(m *v11.PlanResourcesFilter, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.engine.v1.PlanResourcesFilter.kind"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(m.GetKind())))

	}
	if _, ok := ignore["cerbos.engine.v1.PlanResourcesFilter.condition"]; !ok {
		if m.GetCondition() != nil {
			cerbos_engine_v1_PlanResourcesFilter_Expression_Operand_hashpb_sum(m.GetCondition(), hasher, ignore)
		}

	}
}

func cerbos_engine_v1_PlanResourcesInput_Resource_hashpb_sum(m *v11.PlanResourcesInput_Resource, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.engine.v1.PlanResourcesInput.Resource.kind"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetKind()))

	}
	if _, ok := ignore["cerbos.engine.v1.PlanResourcesInput.Resource.attr"]; !ok {
		if len(m.Attr) > 0 {
			keys := make([]string, len(m.Attr))
			i := 0
			for k := range m.Attr {
				keys[i] = k
				i++
			}

			sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

			for _, k := range keys {
				if m.Attr[k] != nil {
					google_protobuf_Value_hashpb_sum(m.Attr[k], hasher, ignore)
				}

			}
		}
	}
	if _, ok := ignore["cerbos.engine.v1.PlanResourcesInput.Resource.policy_version"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetPolicyVersion()))

	}
	if _, ok := ignore["cerbos.engine.v1.PlanResourcesInput.Resource.scope"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetScope()))

	}
}

func cerbos_engine_v1_PlanResourcesInput_hashpb_sum(m *v11.PlanResourcesInput, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.engine.v1.PlanResourcesInput.request_id"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetRequestId()))

	}
	if _, ok := ignore["cerbos.engine.v1.PlanResourcesInput.action"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetAction()))

	}
	if _, ok := ignore["cerbos.engine.v1.PlanResourcesInput.principal"]; !ok {
		if m.GetPrincipal() != nil {
			cerbos_engine_v1_Principal_hashpb_sum(m.GetPrincipal(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.engine.v1.PlanResourcesInput.resource"]; !ok {
		if m.GetResource() != nil {
			cerbos_engine_v1_PlanResourcesInput_Resource_hashpb_sum(m.GetResource(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.engine.v1.PlanResourcesInput.aux_data"]; !ok {
		if m.GetAuxData() != nil {
			cerbos_engine_v1_AuxData_hashpb_sum(m.GetAuxData(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.engine.v1.PlanResourcesInput.include_meta"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, protowire.EncodeBool(m.GetIncludeMeta())))

	}
}

func cerbos_engine_v1_PlanResourcesOutput_hashpb_sum(m *v11.PlanResourcesOutput, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.engine.v1.PlanResourcesOutput.request_id"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetRequestId()))

	}
	if _, ok := ignore["cerbos.engine.v1.PlanResourcesOutput.action"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetAction()))

	}
	if _, ok := ignore["cerbos.engine.v1.PlanResourcesOutput.kind"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetKind()))

	}
	if _, ok := ignore["cerbos.engine.v1.PlanResourcesOutput.policy_version"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetPolicyVersion()))

	}
	if _, ok := ignore["cerbos.engine.v1.PlanResourcesOutput.scope"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetScope()))

	}
	if _, ok := ignore["cerbos.engine.v1.PlanResourcesOutput.filter"]; !ok {
		if m.GetFilter() != nil {
			cerbos_engine_v1_PlanResourcesFilter_hashpb_sum(m.GetFilter(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.engine.v1.PlanResourcesOutput.filter_debug"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetFilterDebug()))

	}
	if _, ok := ignore["cerbos.engine.v1.PlanResourcesOutput.validation_errors"]; !ok {
		if len(m.ValidationErrors) > 0 {
			for _, v := range m.ValidationErrors {
				if v != nil {
					cerbos_schema_v1_ValidationError_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
}

func cerbos_engine_v1_Principal_hashpb_sum(m *v11.Principal, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.engine.v1.Principal.id"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetId()))

	}
	if _, ok := ignore["cerbos.engine.v1.Principal.policy_version"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetPolicyVersion()))

	}
	if _, ok := ignore["cerbos.engine.v1.Principal.roles"]; !ok {
		if len(m.Roles) > 0 {
			for _, v := range m.Roles {
				_, _ = hasher.Write(protowire.AppendString(nil, v))

			}
		}
	}
	if _, ok := ignore["cerbos.engine.v1.Principal.attr"]; !ok {
		if len(m.Attr) > 0 {
			keys := make([]string, len(m.Attr))
			i := 0
			for k := range m.Attr {
				keys[i] = k
				i++
			}

			sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

			for _, k := range keys {
				if m.Attr[k] != nil {
					google_protobuf_Value_hashpb_sum(m.Attr[k], hasher, ignore)
				}

			}
		}
	}
	if _, ok := ignore["cerbos.engine.v1.Principal.scope"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetScope()))

	}
}

func cerbos_engine_v1_Request_Principal_hashpb_sum(m *v11.Request_Principal, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.engine.v1.Request.Principal.id"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetId()))

	}
	if _, ok := ignore["cerbos.engine.v1.Request.Principal.roles"]; !ok {
		if len(m.Roles) > 0 {
			for _, v := range m.Roles {
				_, _ = hasher.Write(protowire.AppendString(nil, v))

			}
		}
	}
	if _, ok := ignore["cerbos.engine.v1.Request.Principal.attr"]; !ok {
		if len(m.Attr) > 0 {
			keys := make([]string, len(m.Attr))
			i := 0
			for k := range m.Attr {
				keys[i] = k
				i++
			}

			sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

			for _, k := range keys {
				if m.Attr[k] != nil {
					google_protobuf_Value_hashpb_sum(m.Attr[k], hasher, ignore)
				}

			}
		}
	}
}

func cerbos_engine_v1_Request_Resource_hashpb_sum(m *v11.Request_Resource, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.engine.v1.Request.Resource.kind"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetKind()))

	}
	if _, ok := ignore["cerbos.engine.v1.Request.Resource.id"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetId()))

	}
	if _, ok := ignore["cerbos.engine.v1.Request.Resource.attr"]; !ok {
		if len(m.Attr) > 0 {
			keys := make([]string, len(m.Attr))
			i := 0
			for k := range m.Attr {
				keys[i] = k
				i++
			}

			sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

			for _, k := range keys {
				if m.Attr[k] != nil {
					google_protobuf_Value_hashpb_sum(m.Attr[k], hasher, ignore)
				}

			}
		}
	}
}

func cerbos_engine_v1_Request_hashpb_sum(m *v11.Request, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.engine.v1.Request.principal"]; !ok {
		if m.GetPrincipal() != nil {
			cerbos_engine_v1_Request_Principal_hashpb_sum(m.GetPrincipal(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.engine.v1.Request.resource"]; !ok {
		if m.GetResource() != nil {
			cerbos_engine_v1_Request_Resource_hashpb_sum(m.GetResource(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.engine.v1.Request.aux_data"]; !ok {
		if m.GetAuxData() != nil {
			cerbos_engine_v1_AuxData_hashpb_sum(m.GetAuxData(), hasher, ignore)
		}

	}
}

func cerbos_engine_v1_Resource_hashpb_sum(m *v11.Resource, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.engine.v1.Resource.kind"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetKind()))

	}
	if _, ok := ignore["cerbos.engine.v1.Resource.policy_version"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetPolicyVersion()))

	}
	if _, ok := ignore["cerbos.engine.v1.Resource.id"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetId()))

	}
	if _, ok := ignore["cerbos.engine.v1.Resource.attr"]; !ok {
		if len(m.Attr) > 0 {
			keys := make([]string, len(m.Attr))
			i := 0
			for k := range m.Attr {
				keys[i] = k
				i++
			}

			sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

			for _, k := range keys {
				if m.Attr[k] != nil {
					google_protobuf_Value_hashpb_sum(m.Attr[k], hasher, ignore)
				}

			}
		}
	}
	if _, ok := ignore["cerbos.engine.v1.Resource.scope"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetScope()))

	}
}

func cerbos_engine_v1_Trace_Component_Variable_hashpb_sum(m *v11.Trace_Component_Variable, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.engine.v1.Trace.Component.Variable.name"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetName()))

	}
	if _, ok := ignore["cerbos.engine.v1.Trace.Component.Variable.expr"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetExpr()))

	}
}

func cerbos_engine_v1_Trace_Component_hashpb_sum(m *v11.Trace_Component, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.engine.v1.Trace.Component.kind"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(m.GetKind())))

	}
	if m.Details != nil {
		if _, ok := ignore["cerbos.engine.v1.Trace.Component.details"]; !ok {
			switch t := m.Details.(type) {
			case *v11.Trace_Component_Action:
				_, _ = hasher.Write(protowire.AppendString(nil, t.Action))

			case *v11.Trace_Component_DerivedRole:
				_, _ = hasher.Write(protowire.AppendString(nil, t.DerivedRole))

			case *v11.Trace_Component_Expr:
				_, _ = hasher.Write(protowire.AppendString(nil, t.Expr))

			case *v11.Trace_Component_Index:
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(t.Index)))

			case *v11.Trace_Component_Policy:
				_, _ = hasher.Write(protowire.AppendString(nil, t.Policy))

			case *v11.Trace_Component_Resource:
				_, _ = hasher.Write(protowire.AppendString(nil, t.Resource))

			case *v11.Trace_Component_Rule:
				_, _ = hasher.Write(protowire.AppendString(nil, t.Rule))

			case *v11.Trace_Component_Scope:
				_, _ = hasher.Write(protowire.AppendString(nil, t.Scope))

			case *v11.Trace_Component_Variable_:
				if t.Variable != nil {
					cerbos_engine_v1_Trace_Component_Variable_hashpb_sum(t.Variable, hasher, ignore)
				}

			case *v11.Trace_Component_Output:
				_, _ = hasher.Write(protowire.AppendString(nil, t.Output))

			}
		}
	}
}

func cerbos_engine_v1_Trace_Event_hashpb_sum(m *v11.Trace_Event, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.engine.v1.Trace.Event.status"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(m.GetStatus())))

	}
	if _, ok := ignore["cerbos.engine.v1.Trace.Event.effect"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(m.GetEffect())))

	}
	if _, ok := ignore["cerbos.engine.v1.Trace.Event.error"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetError()))

	}
	if _, ok := ignore["cerbos.engine.v1.Trace.Event.message"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetMessage()))

	}
	if _, ok := ignore["cerbos.engine.v1.Trace.Event.result"]; !ok {
		if m.GetResult() != nil {
			google_protobuf_Value_hashpb_sum(m.GetResult(), hasher, ignore)
		}

	}
}

func cerbos_engine_v1_Trace_hashpb_sum(m *v11.Trace, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.engine.v1.Trace.components"]; !ok {
		if len(m.Components) > 0 {
			for _, v := range m.Components {
				if v != nil {
					cerbos_engine_v1_Trace_Component_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
	if _, ok := ignore["cerbos.engine.v1.Trace.event"]; !ok {
		if m.GetEvent() != nil {
			cerbos_engine_v1_Trace_Event_hashpb_sum(m.GetEvent(), hasher, ignore)
		}

	}
}

func cerbos_policy_v1_Condition_hashpb_sum(m *v12.Condition, hasher hash.Hash, ignore map[string]struct{}) {
	if m.Condition != nil {
		if _, ok := ignore["cerbos.policy.v1.Condition.condition"]; !ok {
			switch t := m.Condition.(type) {
			case *v12.Condition_Match:
				if t.Match != nil {
					cerbos_policy_v1_Match_hashpb_sum(t.Match, hasher, ignore)
				}

			case *v12.Condition_Script:
				_, _ = hasher.Write(protowire.AppendString(nil, t.Script))

			}
		}
	}
}

func cerbos_policy_v1_DerivedRoles_hashpb_sum(m *v12.DerivedRoles, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.policy.v1.DerivedRoles.name"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetName()))

	}
	if _, ok := ignore["cerbos.policy.v1.DerivedRoles.definitions"]; !ok {
		if len(m.Definitions) > 0 {
			for _, v := range m.Definitions {
				if v != nil {
					cerbos_policy_v1_RoleDef_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
	if _, ok := ignore["cerbos.policy.v1.DerivedRoles.variables"]; !ok {
		if m.GetVariables() != nil {
			cerbos_policy_v1_Variables_hashpb_sum(m.GetVariables(), hasher, ignore)
		}

	}
}

func cerbos_policy_v1_ExportVariables_hashpb_sum(m *v12.ExportVariables, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.policy.v1.ExportVariables.name"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetName()))

	}
	if _, ok := ignore["cerbos.policy.v1.ExportVariables.definitions"]; !ok {
		if len(m.Definitions) > 0 {
			keys := make([]string, len(m.Definitions))
			i := 0
			for k := range m.Definitions {
				keys[i] = k
				i++
			}

			sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

			for _, k := range keys {
				_, _ = hasher.Write(protowire.AppendString(nil, m.Definitions[k]))

			}
		}
	}
}

func cerbos_policy_v1_Match_ExprList_hashpb_sum(m *v12.Match_ExprList, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.policy.v1.Match.ExprList.of"]; !ok {
		if len(m.Of) > 0 {
			for _, v := range m.Of {
				if v != nil {
					cerbos_policy_v1_Match_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
}

func cerbos_policy_v1_Match_hashpb_sum(m *v12.Match, hasher hash.Hash, ignore map[string]struct{}) {
	if m.Op != nil {
		if _, ok := ignore["cerbos.policy.v1.Match.op"]; !ok {
			switch t := m.Op.(type) {
			case *v12.Match_All:
				if t.All != nil {
					cerbos_policy_v1_Match_ExprList_hashpb_sum(t.All, hasher, ignore)
				}

			case *v12.Match_Any:
				if t.Any != nil {
					cerbos_policy_v1_Match_ExprList_hashpb_sum(t.Any, hasher, ignore)
				}

			case *v12.Match_None:
				if t.None != nil {
					cerbos_policy_v1_Match_ExprList_hashpb_sum(t.None, hasher, ignore)
				}

			case *v12.Match_Expr:
				_, _ = hasher.Write(protowire.AppendString(nil, t.Expr))

			}
		}
	}
}

func cerbos_policy_v1_Metadata_hashpb_sum(m *v12.Metadata, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.policy.v1.Metadata.source_file"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetSourceFile()))

	}
	if _, ok := ignore["cerbos.policy.v1.Metadata.annotations"]; !ok {
		if len(m.Annotations) > 0 {
			keys := make([]string, len(m.Annotations))
			i := 0
			for k := range m.Annotations {
				keys[i] = k
				i++
			}

			sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

			for _, k := range keys {
				_, _ = hasher.Write(protowire.AppendString(nil, m.Annotations[k]))

			}
		}
	}
	if _, ok := ignore["cerbos.policy.v1.Metadata.hash"]; !ok {
		if m.GetHash() != nil {
			google_protobuf_UInt64Value_hashpb_sum(m.GetHash(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.policy.v1.Metadata.store_identifer"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetStoreIdentifer()))

	}
	if _, ok := ignore["cerbos.policy.v1.Metadata.store_identifier"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetStoreIdentifier()))

	}
	if _, ok := ignore["cerbos.policy.v1.Metadata.source_attributes"]; !ok {
		if m.GetSourceAttributes() != nil {
			cerbos_policy_v1_SourceAttributes_hashpb_sum(m.GetSourceAttributes(), hasher, ignore)
		}

	}
}

func cerbos_policy_v1_Output_When_hashpb_sum(m *v12.Output_When, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.policy.v1.Output.When.rule_activated"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetRuleActivated()))

	}
	if _, ok := ignore["cerbos.policy.v1.Output.When.condition_not_met"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetConditionNotMet()))

	}
}

func cerbos_policy_v1_Output_hashpb_sum(m *v12.Output, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.policy.v1.Output.expr"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetExpr()))

	}
	if _, ok := ignore["cerbos.policy.v1.Output.when"]; !ok {
		if m.GetWhen() != nil {
			cerbos_policy_v1_Output_When_hashpb_sum(m.GetWhen(), hasher, ignore)
		}

	}
}

func cerbos_policy_v1_Policy_hashpb_sum(m *v12.Policy, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.policy.v1.Policy.api_version"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetApiVersion()))

	}
	if _, ok := ignore["cerbos.policy.v1.Policy.disabled"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, protowire.EncodeBool(m.GetDisabled())))

	}
	if _, ok := ignore["cerbos.policy.v1.Policy.description"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetDescription()))

	}
	if _, ok := ignore["cerbos.policy.v1.Policy.metadata"]; !ok {
		if m.GetMetadata() != nil {
			cerbos_policy_v1_Metadata_hashpb_sum(m.GetMetadata(), hasher, ignore)
		}

	}
	if m.PolicyType != nil {
		if _, ok := ignore["cerbos.policy.v1.Policy.policy_type"]; !ok {
			switch t := m.PolicyType.(type) {
			case *v12.Policy_ResourcePolicy:
				if t.ResourcePolicy != nil {
					cerbos_policy_v1_ResourcePolicy_hashpb_sum(t.ResourcePolicy, hasher, ignore)
				}

			case *v12.Policy_PrincipalPolicy:
				if t.PrincipalPolicy != nil {
					cerbos_policy_v1_PrincipalPolicy_hashpb_sum(t.PrincipalPolicy, hasher, ignore)
				}

			case *v12.Policy_DerivedRoles:
				if t.DerivedRoles != nil {
					cerbos_policy_v1_DerivedRoles_hashpb_sum(t.DerivedRoles, hasher, ignore)
				}

			case *v12.Policy_ExportVariables:
				if t.ExportVariables != nil {
					cerbos_policy_v1_ExportVariables_hashpb_sum(t.ExportVariables, hasher, ignore)
				}

			}
		}
	}
	if _, ok := ignore["cerbos.policy.v1.Policy.variables"]; !ok {
		if len(m.Variables) > 0 {
			keys := make([]string, len(m.Variables))
			i := 0
			for k := range m.Variables {
				keys[i] = k
				i++
			}

			sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

			for _, k := range keys {
				_, _ = hasher.Write(protowire.AppendString(nil, m.Variables[k]))

			}
		}
	}
	if _, ok := ignore["cerbos.policy.v1.Policy.json_schema"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetJsonSchema()))

	}
}

func cerbos_policy_v1_PrincipalPolicy_hashpb_sum(m *v12.PrincipalPolicy, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.policy.v1.PrincipalPolicy.principal"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetPrincipal()))

	}
	if _, ok := ignore["cerbos.policy.v1.PrincipalPolicy.version"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetVersion()))

	}
	if _, ok := ignore["cerbos.policy.v1.PrincipalPolicy.rules"]; !ok {
		if len(m.Rules) > 0 {
			for _, v := range m.Rules {
				if v != nil {
					cerbos_policy_v1_PrincipalRule_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
	if _, ok := ignore["cerbos.policy.v1.PrincipalPolicy.scope"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetScope()))

	}
	if _, ok := ignore["cerbos.policy.v1.PrincipalPolicy.variables"]; !ok {
		if m.GetVariables() != nil {
			cerbos_policy_v1_Variables_hashpb_sum(m.GetVariables(), hasher, ignore)
		}

	}
}

func cerbos_policy_v1_PrincipalRule_Action_hashpb_sum(m *v12.PrincipalRule_Action, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.policy.v1.PrincipalRule.Action.action"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetAction()))

	}
	if _, ok := ignore["cerbos.policy.v1.PrincipalRule.Action.condition"]; !ok {
		if m.GetCondition() != nil {
			cerbos_policy_v1_Condition_hashpb_sum(m.GetCondition(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.policy.v1.PrincipalRule.Action.effect"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(m.GetEffect())))

	}
	if _, ok := ignore["cerbos.policy.v1.PrincipalRule.Action.name"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetName()))

	}
	if _, ok := ignore["cerbos.policy.v1.PrincipalRule.Action.output"]; !ok {
		if m.GetOutput() != nil {
			cerbos_policy_v1_Output_hashpb_sum(m.GetOutput(), hasher, ignore)
		}

	}
}

func cerbos_policy_v1_PrincipalRule_hashpb_sum(m *v12.PrincipalRule, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.policy.v1.PrincipalRule.resource"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetResource()))

	}
	if _, ok := ignore["cerbos.policy.v1.PrincipalRule.actions"]; !ok {
		if len(m.Actions) > 0 {
			for _, v := range m.Actions {
				if v != nil {
					cerbos_policy_v1_PrincipalRule_Action_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
}

func cerbos_policy_v1_ResourcePolicy_hashpb_sum(m *v12.ResourcePolicy, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.policy.v1.ResourcePolicy.resource"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetResource()))

	}
	if _, ok := ignore["cerbos.policy.v1.ResourcePolicy.version"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetVersion()))

	}
	if _, ok := ignore["cerbos.policy.v1.ResourcePolicy.import_derived_roles"]; !ok {
		if len(m.ImportDerivedRoles) > 0 {
			for _, v := range m.ImportDerivedRoles {
				_, _ = hasher.Write(protowire.AppendString(nil, v))

			}
		}
	}
	if _, ok := ignore["cerbos.policy.v1.ResourcePolicy.rules"]; !ok {
		if len(m.Rules) > 0 {
			for _, v := range m.Rules {
				if v != nil {
					cerbos_policy_v1_ResourceRule_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
	if _, ok := ignore["cerbos.policy.v1.ResourcePolicy.scope"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetScope()))

	}
	if _, ok := ignore["cerbos.policy.v1.ResourcePolicy.schemas"]; !ok {
		if m.GetSchemas() != nil {
			cerbos_policy_v1_Schemas_hashpb_sum(m.GetSchemas(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.policy.v1.ResourcePolicy.variables"]; !ok {
		if m.GetVariables() != nil {
			cerbos_policy_v1_Variables_hashpb_sum(m.GetVariables(), hasher, ignore)
		}

	}
}

func cerbos_policy_v1_ResourceRule_hashpb_sum(m *v12.ResourceRule, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.policy.v1.ResourceRule.actions"]; !ok {
		if len(m.Actions) > 0 {
			for _, v := range m.Actions {
				_, _ = hasher.Write(protowire.AppendString(nil, v))

			}
		}
	}
	if _, ok := ignore["cerbos.policy.v1.ResourceRule.derived_roles"]; !ok {
		if len(m.DerivedRoles) > 0 {
			for _, v := range m.DerivedRoles {
				_, _ = hasher.Write(protowire.AppendString(nil, v))

			}
		}
	}
	if _, ok := ignore["cerbos.policy.v1.ResourceRule.roles"]; !ok {
		if len(m.Roles) > 0 {
			for _, v := range m.Roles {
				_, _ = hasher.Write(protowire.AppendString(nil, v))

			}
		}
	}
	if _, ok := ignore["cerbos.policy.v1.ResourceRule.condition"]; !ok {
		if m.GetCondition() != nil {
			cerbos_policy_v1_Condition_hashpb_sum(m.GetCondition(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.policy.v1.ResourceRule.effect"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(m.GetEffect())))

	}
	if _, ok := ignore["cerbos.policy.v1.ResourceRule.name"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetName()))

	}
	if _, ok := ignore["cerbos.policy.v1.ResourceRule.output"]; !ok {
		if m.GetOutput() != nil {
			cerbos_policy_v1_Output_hashpb_sum(m.GetOutput(), hasher, ignore)
		}

	}
}

func cerbos_policy_v1_RoleDef_hashpb_sum(m *v12.RoleDef, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.policy.v1.RoleDef.name"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetName()))

	}
	if _, ok := ignore["cerbos.policy.v1.RoleDef.parent_roles"]; !ok {
		if len(m.ParentRoles) > 0 {
			for _, v := range m.ParentRoles {
				_, _ = hasher.Write(protowire.AppendString(nil, v))

			}
		}
	}
	if _, ok := ignore["cerbos.policy.v1.RoleDef.condition"]; !ok {
		if m.GetCondition() != nil {
			cerbos_policy_v1_Condition_hashpb_sum(m.GetCondition(), hasher, ignore)
		}

	}
}

func cerbos_policy_v1_Schemas_IgnoreWhen_hashpb_sum(m *v12.Schemas_IgnoreWhen, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.policy.v1.Schemas.IgnoreWhen.actions"]; !ok {
		if len(m.Actions) > 0 {
			for _, v := range m.Actions {
				_, _ = hasher.Write(protowire.AppendString(nil, v))

			}
		}
	}
}

func cerbos_policy_v1_Schemas_Schema_hashpb_sum(m *v12.Schemas_Schema, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.policy.v1.Schemas.Schema.ref"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetRef()))

	}
	if _, ok := ignore["cerbos.policy.v1.Schemas.Schema.ignore_when"]; !ok {
		if m.GetIgnoreWhen() != nil {
			cerbos_policy_v1_Schemas_IgnoreWhen_hashpb_sum(m.GetIgnoreWhen(), hasher, ignore)
		}

	}
}

func cerbos_policy_v1_Schemas_hashpb_sum(m *v12.Schemas, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.policy.v1.Schemas.principal_schema"]; !ok {
		if m.GetPrincipalSchema() != nil {
			cerbos_policy_v1_Schemas_Schema_hashpb_sum(m.GetPrincipalSchema(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.policy.v1.Schemas.resource_schema"]; !ok {
		if m.GetResourceSchema() != nil {
			cerbos_policy_v1_Schemas_Schema_hashpb_sum(m.GetResourceSchema(), hasher, ignore)
		}

	}
}

func cerbos_policy_v1_SourceAttributes_hashpb_sum(m *v12.SourceAttributes, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.policy.v1.SourceAttributes.attributes"]; !ok {
		if len(m.Attributes) > 0 {
			keys := make([]string, len(m.Attributes))
			i := 0
			for k := range m.Attributes {
				keys[i] = k
				i++
			}

			sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

			for _, k := range keys {
				if m.Attributes[k] != nil {
					google_protobuf_Value_hashpb_sum(m.Attributes[k], hasher, ignore)
				}

			}
		}
	}
}

func cerbos_policy_v1_TestOptions_hashpb_sum(m *v12.TestOptions, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.policy.v1.TestOptions.now"]; !ok {
		if m.GetNow() != nil {
			google_protobuf_Timestamp_hashpb_sum(m.GetNow(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.policy.v1.TestOptions.lenient_scope_search"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, protowire.EncodeBool(m.GetLenientScopeSearch())))

	}
	if _, ok := ignore["cerbos.policy.v1.TestOptions.globals"]; !ok {
		if len(m.Globals) > 0 {
			keys := make([]string, len(m.Globals))
			i := 0
			for k := range m.Globals {
				keys[i] = k
				i++
			}

			sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

			for _, k := range keys {
				if m.Globals[k] != nil {
					google_protobuf_Value_hashpb_sum(m.Globals[k], hasher, ignore)
				}

			}
		}
	}
}

func cerbos_policy_v1_TestResults_Action_hashpb_sum(m *v12.TestResults_Action, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.policy.v1.TestResults.Action.name"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetName()))

	}
	if _, ok := ignore["cerbos.policy.v1.TestResults.Action.details"]; !ok {
		if m.GetDetails() != nil {
			cerbos_policy_v1_TestResults_Details_hashpb_sum(m.GetDetails(), hasher, ignore)
		}

	}
}

func cerbos_policy_v1_TestResults_Details_hashpb_sum(m *v12.TestResults_Details, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.policy.v1.TestResults.Details.result"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(m.GetResult())))

	}
	if m.Outcome != nil {
		if _, ok := ignore["cerbos.policy.v1.TestResults.Details.outcome"]; !ok {
			switch t := m.Outcome.(type) {
			case *v12.TestResults_Details_Failure:
				if t.Failure != nil {
					cerbos_policy_v1_TestResults_Failure_hashpb_sum(t.Failure, hasher, ignore)
				}

			case *v12.TestResults_Details_Error:
				_, _ = hasher.Write(protowire.AppendString(nil, t.Error))

			case *v12.TestResults_Details_Success:
				if t.Success != nil {
					cerbos_policy_v1_TestResults_Success_hashpb_sum(t.Success, hasher, ignore)
				}

			}
		}
	}
	if _, ok := ignore["cerbos.policy.v1.TestResults.Details.engine_trace"]; !ok {
		if len(m.EngineTrace) > 0 {
			for _, v := range m.EngineTrace {
				if v != nil {
					cerbos_engine_v1_Trace_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
}

func cerbos_policy_v1_TestResults_Failure_hashpb_sum(m *v12.TestResults_Failure, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.policy.v1.TestResults.Failure.expected"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(m.GetExpected())))

	}
	if _, ok := ignore["cerbos.policy.v1.TestResults.Failure.actual"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(m.GetActual())))

	}
	if _, ok := ignore["cerbos.policy.v1.TestResults.Failure.outputs"]; !ok {
		if len(m.Outputs) > 0 {
			for _, v := range m.Outputs {
				if v != nil {
					cerbos_policy_v1_TestResults_OutputFailure_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
}

func cerbos_policy_v1_TestResults_OutputFailure_MismatchedValue_hashpb_sum(m *v12.TestResults_OutputFailure_MismatchedValue, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.policy.v1.TestResults.OutputFailure.MismatchedValue.expected"]; !ok {
		if m.GetExpected() != nil {
			google_protobuf_Value_hashpb_sum(m.GetExpected(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.policy.v1.TestResults.OutputFailure.MismatchedValue.actual"]; !ok {
		if m.GetActual() != nil {
			google_protobuf_Value_hashpb_sum(m.GetActual(), hasher, ignore)
		}

	}
}

func cerbos_policy_v1_TestResults_OutputFailure_MissingValue_hashpb_sum(m *v12.TestResults_OutputFailure_MissingValue, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.policy.v1.TestResults.OutputFailure.MissingValue.expected"]; !ok {
		if m.GetExpected() != nil {
			google_protobuf_Value_hashpb_sum(m.GetExpected(), hasher, ignore)
		}

	}
}

func cerbos_policy_v1_TestResults_OutputFailure_hashpb_sum(m *v12.TestResults_OutputFailure, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.policy.v1.TestResults.OutputFailure.src"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetSrc()))

	}
	if m.Outcome != nil {
		if _, ok := ignore["cerbos.policy.v1.TestResults.OutputFailure.outcome"]; !ok {
			switch t := m.Outcome.(type) {
			case *v12.TestResults_OutputFailure_Mismatched:
				if t.Mismatched != nil {
					cerbos_policy_v1_TestResults_OutputFailure_MismatchedValue_hashpb_sum(t.Mismatched, hasher, ignore)
				}

			case *v12.TestResults_OutputFailure_Missing:
				if t.Missing != nil {
					cerbos_policy_v1_TestResults_OutputFailure_MissingValue_hashpb_sum(t.Missing, hasher, ignore)
				}

			}
		}
	}
}

func cerbos_policy_v1_TestResults_Principal_hashpb_sum(m *v12.TestResults_Principal, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.policy.v1.TestResults.Principal.name"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetName()))

	}
	if _, ok := ignore["cerbos.policy.v1.TestResults.Principal.resources"]; !ok {
		if len(m.Resources) > 0 {
			for _, v := range m.Resources {
				if v != nil {
					cerbos_policy_v1_TestResults_Resource_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
}

func cerbos_policy_v1_TestResults_Resource_hashpb_sum(m *v12.TestResults_Resource, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.policy.v1.TestResults.Resource.name"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetName()))

	}
	if _, ok := ignore["cerbos.policy.v1.TestResults.Resource.actions"]; !ok {
		if len(m.Actions) > 0 {
			for _, v := range m.Actions {
				if v != nil {
					cerbos_policy_v1_TestResults_Action_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
}

func cerbos_policy_v1_TestResults_Success_hashpb_sum(m *v12.TestResults_Success, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.policy.v1.TestResults.Success.effect"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(m.GetEffect())))

	}
	if _, ok := ignore["cerbos.policy.v1.TestResults.Success.outputs"]; !ok {
		if len(m.Outputs) > 0 {
			for _, v := range m.Outputs {
				if v != nil {
					cerbos_engine_v1_OutputEntry_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
}

func cerbos_policy_v1_TestResults_Suite_hashpb_sum(m *v12.TestResults_Suite, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.policy.v1.TestResults.Suite.file"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetFile()))

	}
	if _, ok := ignore["cerbos.policy.v1.TestResults.Suite.name"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetName()))

	}
	if _, ok := ignore["cerbos.policy.v1.TestResults.Suite.principals"]; !ok {
		if len(m.Principals) > 0 {
			for _, v := range m.Principals {
				if v != nil {
					cerbos_policy_v1_TestResults_Principal_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
	if _, ok := ignore["cerbos.policy.v1.TestResults.Suite.summary"]; !ok {
		if m.GetSummary() != nil {
			cerbos_policy_v1_TestResults_Summary_hashpb_sum(m.GetSummary(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.policy.v1.TestResults.Suite.error"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetError()))

	}
	if _, ok := ignore["cerbos.policy.v1.TestResults.Suite.test_cases"]; !ok {
		if len(m.TestCases) > 0 {
			for _, v := range m.TestCases {
				if v != nil {
					cerbos_policy_v1_TestResults_TestCase_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
	if _, ok := ignore["cerbos.policy.v1.TestResults.Suite.description"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetDescription()))

	}
}

func cerbos_policy_v1_TestResults_Summary_hashpb_sum(m *v12.TestResults_Summary, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.policy.v1.TestResults.Summary.overall_result"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(m.GetOverallResult())))

	}
	if _, ok := ignore["cerbos.policy.v1.TestResults.Summary.tests_count"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(m.GetTestsCount())))

	}
	if _, ok := ignore["cerbos.policy.v1.TestResults.Summary.result_counts"]; !ok {
		if len(m.ResultCounts) > 0 {
			for _, v := range m.ResultCounts {
				if v != nil {
					cerbos_policy_v1_TestResults_Tally_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
}

func cerbos_policy_v1_TestResults_Tally_hashpb_sum(m *v12.TestResults_Tally, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.policy.v1.TestResults.Tally.result"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(m.GetResult())))

	}
	if _, ok := ignore["cerbos.policy.v1.TestResults.Tally.count"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(m.GetCount())))

	}
}

func cerbos_policy_v1_TestResults_TestCase_hashpb_sum(m *v12.TestResults_TestCase, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.policy.v1.TestResults.TestCase.name"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetName()))

	}
	if _, ok := ignore["cerbos.policy.v1.TestResults.TestCase.principals"]; !ok {
		if len(m.Principals) > 0 {
			for _, v := range m.Principals {
				if v != nil {
					cerbos_policy_v1_TestResults_Principal_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
}

func cerbos_policy_v1_TestResults_hashpb_sum(m *v12.TestResults, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.policy.v1.TestResults.suites"]; !ok {
		if len(m.Suites) > 0 {
			for _, v := range m.Suites {
				if v != nil {
					cerbos_policy_v1_TestResults_Suite_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
	if _, ok := ignore["cerbos.policy.v1.TestResults.summary"]; !ok {
		if m.GetSummary() != nil {
			cerbos_policy_v1_TestResults_Summary_hashpb_sum(m.GetSummary(), hasher, ignore)
		}

	}
}

func cerbos_policy_v1_TestTable_Expectation_hashpb_sum(m *v12.TestTable_Expectation, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.policy.v1.TestTable.Expectation.principal"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetPrincipal()))

	}
	if _, ok := ignore["cerbos.policy.v1.TestTable.Expectation.resource"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetResource()))

	}
	if _, ok := ignore["cerbos.policy.v1.TestTable.Expectation.actions"]; !ok {
		if len(m.Actions) > 0 {
			keys := make([]string, len(m.Actions))
			i := 0
			for k := range m.Actions {
				keys[i] = k
				i++
			}

			sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

			for _, k := range keys {
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(m.Actions[k])))

			}
		}
	}
	if _, ok := ignore["cerbos.policy.v1.TestTable.Expectation.outputs"]; !ok {
		if len(m.Outputs) > 0 {
			for _, v := range m.Outputs {
				if v != nil {
					cerbos_policy_v1_TestTable_OutputExpectations_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
}

func cerbos_policy_v1_TestTable_Input_hashpb_sum(m *v12.TestTable_Input, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.policy.v1.TestTable.Input.principals"]; !ok {
		if len(m.Principals) > 0 {
			for _, v := range m.Principals {
				_, _ = hasher.Write(protowire.AppendString(nil, v))

			}
		}
	}
	if _, ok := ignore["cerbos.policy.v1.TestTable.Input.resources"]; !ok {
		if len(m.Resources) > 0 {
			for _, v := range m.Resources {
				_, _ = hasher.Write(protowire.AppendString(nil, v))

			}
		}
	}
	if _, ok := ignore["cerbos.policy.v1.TestTable.Input.actions"]; !ok {
		if len(m.Actions) > 0 {
			for _, v := range m.Actions {
				_, _ = hasher.Write(protowire.AppendString(nil, v))

			}
		}
	}
	if _, ok := ignore["cerbos.policy.v1.TestTable.Input.aux_data"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetAuxData()))

	}
}

func cerbos_policy_v1_TestTable_OutputExpectations_hashpb_sum(m *v12.TestTable_OutputExpectations, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.policy.v1.TestTable.OutputExpectations.action"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetAction()))

	}
	if _, ok := ignore["cerbos.policy.v1.TestTable.OutputExpectations.expected"]; !ok {
		if len(m.Expected) > 0 {
			for _, v := range m.Expected {
				if v != nil {
					cerbos_engine_v1_OutputEntry_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
}

func cerbos_policy_v1_TestTable_hashpb_sum(m *v12.TestTable, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.policy.v1.TestTable.name"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetName()))

	}
	if _, ok := ignore["cerbos.policy.v1.TestTable.description"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetDescription()))

	}
	if _, ok := ignore["cerbos.policy.v1.TestTable.skip"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, protowire.EncodeBool(m.GetSkip())))

	}
	if _, ok := ignore["cerbos.policy.v1.TestTable.skip_reason"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetSkipReason()))

	}
	if _, ok := ignore["cerbos.policy.v1.TestTable.input"]; !ok {
		if m.GetInput() != nil {
			cerbos_policy_v1_TestTable_Input_hashpb_sum(m.GetInput(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.policy.v1.TestTable.expected"]; !ok {
		if len(m.Expected) > 0 {
			for _, v := range m.Expected {
				if v != nil {
					cerbos_policy_v1_TestTable_Expectation_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
	if _, ok := ignore["cerbos.policy.v1.TestTable.options"]; !ok {
		if m.GetOptions() != nil {
			cerbos_policy_v1_TestOptions_hashpb_sum(m.GetOptions(), hasher, ignore)
		}

	}
}

func cerbos_policy_v1_Test_OutputEntries_hashpb_sum(m *v12.Test_OutputEntries, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.policy.v1.Test.OutputEntries.entries"]; !ok {
		if len(m.Entries) > 0 {
			keys := make([]string, len(m.Entries))
			i := 0
			for k := range m.Entries {
				keys[i] = k
				i++
			}

			sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

			for _, k := range keys {
				if m.Entries[k] != nil {
					google_protobuf_Value_hashpb_sum(m.Entries[k], hasher, ignore)
				}

			}
		}
	}
}

func cerbos_policy_v1_Test_TestName_hashpb_sum(m *v12.Test_TestName, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.policy.v1.Test.TestName.test_table_name"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetTestTableName()))

	}
	if _, ok := ignore["cerbos.policy.v1.Test.TestName.principal_key"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetPrincipalKey()))

	}
	if _, ok := ignore["cerbos.policy.v1.Test.TestName.resource_key"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetResourceKey()))

	}
}

func cerbos_policy_v1_Test_hashpb_sum(m *v12.Test, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.policy.v1.Test.name"]; !ok {
		if m.GetName() != nil {
			cerbos_policy_v1_Test_TestName_hashpb_sum(m.GetName(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.policy.v1.Test.description"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetDescription()))

	}
	if _, ok := ignore["cerbos.policy.v1.Test.skip"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, protowire.EncodeBool(m.GetSkip())))

	}
	if _, ok := ignore["cerbos.policy.v1.Test.skip_reason"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetSkipReason()))

	}
	if _, ok := ignore["cerbos.policy.v1.Test.input"]; !ok {
		if m.GetInput() != nil {
			cerbos_engine_v1_CheckInput_hashpb_sum(m.GetInput(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.policy.v1.Test.expected"]; !ok {
		if len(m.Expected) > 0 {
			keys := make([]string, len(m.Expected))
			i := 0
			for k := range m.Expected {
				keys[i] = k
				i++
			}

			sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

			for _, k := range keys {
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(m.Expected[k])))

			}
		}
	}
	if _, ok := ignore["cerbos.policy.v1.Test.options"]; !ok {
		if m.GetOptions() != nil {
			cerbos_policy_v1_TestOptions_hashpb_sum(m.GetOptions(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.policy.v1.Test.expected_outputs"]; !ok {
		if len(m.ExpectedOutputs) > 0 {
			keys := make([]string, len(m.ExpectedOutputs))
			i := 0
			for k := range m.ExpectedOutputs {
				keys[i] = k
				i++
			}

			sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

			for _, k := range keys {
				if m.ExpectedOutputs[k] != nil {
					cerbos_policy_v1_Test_OutputEntries_hashpb_sum(m.ExpectedOutputs[k], hasher, ignore)
				}

			}
		}
	}
}

func cerbos_policy_v1_Variables_hashpb_sum(m *v12.Variables, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.policy.v1.Variables.import"]; !ok {
		if len(m.Import) > 0 {
			for _, v := range m.Import {
				_, _ = hasher.Write(protowire.AppendString(nil, v))

			}
		}
	}
	if _, ok := ignore["cerbos.policy.v1.Variables.local"]; !ok {
		if len(m.Local) > 0 {
			keys := make([]string, len(m.Local))
			i := 0
			for k := range m.Local {
				keys[i] = k
				i++
			}

			sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

			for _, k := range keys {
				_, _ = hasher.Write(protowire.AppendString(nil, m.Local[k]))

			}
		}
	}
}

func cerbos_private_v1_AttrWrapper_hashpb_sum(m *AttrWrapper, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.private.v1.AttrWrapper.attr"]; !ok {
		if len(m.Attr) > 0 {
			keys := make([]string, len(m.Attr))
			i := 0
			for k := range m.Attr {
				keys[i] = k
				i++
			}

			sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

			for _, k := range keys {
				if m.Attr[k] != nil {
					google_protobuf_Value_hashpb_sum(m.Attr[k], hasher, ignore)
				}

			}
		}
	}
}

func cerbos_private_v1_CelTestCase_hashpb_sum(m *CelTestCase, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.private.v1.CelTestCase.condition"]; !ok {
		if m.GetCondition() != nil {
			cerbos_policy_v1_Match_hashpb_sum(m.GetCondition(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.private.v1.CelTestCase.request"]; !ok {
		if m.GetRequest() != nil {
			cerbos_engine_v1_Request_hashpb_sum(m.GetRequest(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.private.v1.CelTestCase.want"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, protowire.EncodeBool(m.GetWant())))

	}
	if _, ok := ignore["cerbos.private.v1.CelTestCase.want_error"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, protowire.EncodeBool(m.GetWantError())))

	}
}

func cerbos_private_v1_CompileTestCase_Variables_DerivedRole_hashpb_sum(m *CompileTestCase_Variables_DerivedRole, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.private.v1.CompileTestCase.Variables.DerivedRole.name"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetName()))

	}
	if _, ok := ignore["cerbos.private.v1.CompileTestCase.Variables.DerivedRole.variables"]; !ok {
		if len(m.Variables) > 0 {
			for _, v := range m.Variables {
				_, _ = hasher.Write(protowire.AppendString(nil, v))

			}
		}
	}
}

func cerbos_private_v1_CompileTestCase_Variables_hashpb_sum(m *CompileTestCase_Variables, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.private.v1.CompileTestCase.Variables.scope"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetScope()))

	}
	if _, ok := ignore["cerbos.private.v1.CompileTestCase.Variables.variables"]; !ok {
		if len(m.Variables) > 0 {
			for _, v := range m.Variables {
				_, _ = hasher.Write(protowire.AppendString(nil, v))

			}
		}
	}
	if _, ok := ignore["cerbos.private.v1.CompileTestCase.Variables.derived_roles"]; !ok {
		if len(m.DerivedRoles) > 0 {
			for _, v := range m.DerivedRoles {
				if v != nil {
					cerbos_private_v1_CompileTestCase_Variables_DerivedRole_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
}

func cerbos_private_v1_CompileTestCase_hashpb_sum(m *CompileTestCase, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.private.v1.CompileTestCase.main_def"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetMainDef()))

	}
	if _, ok := ignore["cerbos.private.v1.CompileTestCase.want_errors"]; !ok {
		if len(m.WantErrors) > 0 {
			for _, v := range m.WantErrors {
				if v != nil {
					cerbos_runtime_v1_CompileErrors_Err_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
	if _, ok := ignore["cerbos.private.v1.CompileTestCase.want_variables"]; !ok {
		if len(m.WantVariables) > 0 {
			for _, v := range m.WantVariables {
				if v != nil {
					cerbos_private_v1_CompileTestCase_Variables_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
}

func cerbos_private_v1_EngineTestCase_hashpb_sum(m *EngineTestCase, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.private.v1.EngineTestCase.description"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetDescription()))

	}
	if _, ok := ignore["cerbos.private.v1.EngineTestCase.inputs"]; !ok {
		if len(m.Inputs) > 0 {
			for _, v := range m.Inputs {
				if v != nil {
					cerbos_engine_v1_CheckInput_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
	if _, ok := ignore["cerbos.private.v1.EngineTestCase.want_outputs"]; !ok {
		if len(m.WantOutputs) > 0 {
			for _, v := range m.WantOutputs {
				if v != nil {
					cerbos_engine_v1_CheckOutput_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
	if _, ok := ignore["cerbos.private.v1.EngineTestCase.want_error"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, protowire.EncodeBool(m.GetWantError())))

	}
	if _, ok := ignore["cerbos.private.v1.EngineTestCase.want_decision_logs"]; !ok {
		if len(m.WantDecisionLogs) > 0 {
			for _, v := range m.WantDecisionLogs {
				if v != nil {
					cerbos_audit_v1_DecisionLogEntry_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
}

func cerbos_private_v1_IndexBuilderTestCase_CompilationUnit_hashpb_sum(m *IndexBuilderTestCase_CompilationUnit, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.private.v1.IndexBuilderTestCase.CompilationUnit.main_fqn"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetMainFqn()))

	}
	if _, ok := ignore["cerbos.private.v1.IndexBuilderTestCase.CompilationUnit.definition_fqns"]; !ok {
		if len(m.DefinitionFqns) > 0 {
			for _, v := range m.DefinitionFqns {
				_, _ = hasher.Write(protowire.AppendString(nil, v))

			}
		}
	}
	if _, ok := ignore["cerbos.private.v1.IndexBuilderTestCase.CompilationUnit.ancestor_fqns"]; !ok {
		if len(m.AncestorFqns) > 0 {
			for _, v := range m.AncestorFqns {
				_, _ = hasher.Write(protowire.AppendString(nil, v))

			}
		}
	}
}

func cerbos_private_v1_IndexBuilderTestCase_hashpb_sum(m *IndexBuilderTestCase, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.private.v1.IndexBuilderTestCase.files"]; !ok {
		if len(m.Files) > 0 {
			keys := make([]string, len(m.Files))
			i := 0
			for k := range m.Files {
				keys[i] = k
				i++
			}

			sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

			for _, k := range keys {
				_, _ = hasher.Write(protowire.AppendString(nil, m.Files[k]))

			}
		}
	}
	if _, ok := ignore["cerbos.private.v1.IndexBuilderTestCase.want_err_list"]; !ok {
		if m.GetWantErrList() != nil {
			cerbos_runtime_v1_IndexBuildErrors_hashpb_sum(m.GetWantErrList(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.private.v1.IndexBuilderTestCase.want_err"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetWantErr()))

	}
	if _, ok := ignore["cerbos.private.v1.IndexBuilderTestCase.want_compilation_units"]; !ok {
		if len(m.WantCompilationUnits) > 0 {
			for _, v := range m.WantCompilationUnits {
				if v != nil {
					cerbos_private_v1_IndexBuilderTestCase_CompilationUnit_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
}

func cerbos_private_v1_ProtoYamlTestCase_Want_hashpb_sum(m *ProtoYamlTestCase_Want, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.private.v1.ProtoYamlTestCase.Want.message"]; !ok {
		if m.GetMessage() != nil {
			cerbos_policy_v1_Policy_hashpb_sum(m.GetMessage(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.private.v1.ProtoYamlTestCase.Want.errors"]; !ok {
		if len(m.Errors) > 0 {
			for _, v := range m.Errors {
				if v != nil {
					cerbos_source_v1_Error_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
}

func cerbos_private_v1_ProtoYamlTestCase_hashpb_sum(m *ProtoYamlTestCase, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.private.v1.ProtoYamlTestCase.description"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetDescription()))

	}
	if _, ok := ignore["cerbos.private.v1.ProtoYamlTestCase.want"]; !ok {
		if len(m.Want) > 0 {
			for _, v := range m.Want {
				if v != nil {
					cerbos_private_v1_ProtoYamlTestCase_Want_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
	if _, ok := ignore["cerbos.private.v1.ProtoYamlTestCase.want_errors"]; !ok {
		if len(m.WantErrors) > 0 {
			for _, v := range m.WantErrors {
				if v != nil {
					cerbos_source_v1_Error_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
}

func cerbos_private_v1_QueryPlannerFilterTestCase_hashpb_sum(m *QueryPlannerFilterTestCase, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.private.v1.QueryPlannerFilterTestCase.description"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetDescription()))

	}
	if _, ok := ignore["cerbos.private.v1.QueryPlannerFilterTestCase.input"]; !ok {
		if m.GetInput() != nil {
			cerbos_engine_v1_PlanResourcesFilter_hashpb_sum(m.GetInput(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.private.v1.QueryPlannerFilterTestCase.want_filter"]; !ok {
		if m.GetWantFilter() != nil {
			cerbos_engine_v1_PlanResourcesFilter_hashpb_sum(m.GetWantFilter(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.private.v1.QueryPlannerFilterTestCase.want_string"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetWantString()))

	}
}

func cerbos_private_v1_QueryPlannerTestSuite_Test_hashpb_sum(m *QueryPlannerTestSuite_Test, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.private.v1.QueryPlannerTestSuite.Test.action"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetAction()))

	}
	if _, ok := ignore["cerbos.private.v1.QueryPlannerTestSuite.Test.want"]; !ok {
		if m.GetWant() != nil {
			cerbos_engine_v1_PlanResourcesFilter_hashpb_sum(m.GetWant(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.private.v1.QueryPlannerTestSuite.Test.resource"]; !ok {
		if m.GetResource() != nil {
			cerbos_engine_v1_PlanResourcesInput_Resource_hashpb_sum(m.GetResource(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.private.v1.QueryPlannerTestSuite.Test.want_err"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, protowire.EncodeBool(m.GetWantErr())))

	}
}

func cerbos_private_v1_QueryPlannerTestSuite_hashpb_sum(m *QueryPlannerTestSuite, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.private.v1.QueryPlannerTestSuite.description"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetDescription()))

	}
	if _, ok := ignore["cerbos.private.v1.QueryPlannerTestSuite.principal"]; !ok {
		if m.GetPrincipal() != nil {
			cerbos_engine_v1_Principal_hashpb_sum(m.GetPrincipal(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.private.v1.QueryPlannerTestSuite.tests"]; !ok {
		if len(m.Tests) > 0 {
			for _, v := range m.Tests {
				if v != nil {
					cerbos_private_v1_QueryPlannerTestSuite_Test_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
}

func cerbos_private_v1_SchemaTestCase_hashpb_sum(m *SchemaTestCase, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.private.v1.SchemaTestCase.description"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetDescription()))

	}
	if _, ok := ignore["cerbos.private.v1.SchemaTestCase.schema_refs"]; !ok {
		if m.GetSchemaRefs() != nil {
			cerbos_policy_v1_Schemas_hashpb_sum(m.GetSchemaRefs(), hasher, ignore)
		}

	}
	if m.Input != nil {
		if _, ok := ignore["cerbos.private.v1.SchemaTestCase.input"]; !ok {
			switch t := m.Input.(type) {
			case *SchemaTestCase_CheckInput:
				if t.CheckInput != nil {
					cerbos_engine_v1_CheckInput_hashpb_sum(t.CheckInput, hasher, ignore)
				}

			case *SchemaTestCase_PlanResourcesInput:
				if t.PlanResourcesInput != nil {
					cerbos_engine_v1_PlanResourcesInput_hashpb_sum(t.PlanResourcesInput, hasher, ignore)
				}

			}
		}
	}
	if _, ok := ignore["cerbos.private.v1.SchemaTestCase.want_error"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, protowire.EncodeBool(m.GetWantError())))

	}
	if _, ok := ignore["cerbos.private.v1.SchemaTestCase.want_validation_errors"]; !ok {
		if len(m.WantValidationErrors) > 0 {
			for _, v := range m.WantValidationErrors {
				if v != nil {
					cerbos_schema_v1_ValidationError_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
}

func cerbos_private_v1_ServerTestCase_AdminAddOrUpdatePolicyCall_hashpb_sum(m *ServerTestCase_AdminAddOrUpdatePolicyCall, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.private.v1.ServerTestCase.AdminAddOrUpdatePolicyCall.input"]; !ok {
		if m.GetInput() != nil {
			cerbos_request_v1_AddOrUpdatePolicyRequest_hashpb_sum(m.GetInput(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.private.v1.ServerTestCase.AdminAddOrUpdatePolicyCall.want_response"]; !ok {
		if m.GetWantResponse() != nil {
			cerbos_response_v1_AddOrUpdatePolicyResponse_hashpb_sum(m.GetWantResponse(), hasher, ignore)
		}

	}
}

func cerbos_private_v1_ServerTestCase_AdminAddOrUpdateSchemaCall_hashpb_sum(m *ServerTestCase_AdminAddOrUpdateSchemaCall, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.private.v1.ServerTestCase.AdminAddOrUpdateSchemaCall.input"]; !ok {
		if m.GetInput() != nil {
			cerbos_request_v1_AddOrUpdateSchemaRequest_hashpb_sum(m.GetInput(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.private.v1.ServerTestCase.AdminAddOrUpdateSchemaCall.want_response"]; !ok {
		if m.GetWantResponse() != nil {
			cerbos_response_v1_AddOrUpdateSchemaResponse_hashpb_sum(m.GetWantResponse(), hasher, ignore)
		}

	}
}

func cerbos_private_v1_ServerTestCase_CheckResourceBatchCall_hashpb_sum(m *ServerTestCase_CheckResourceBatchCall, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.private.v1.ServerTestCase.CheckResourceBatchCall.input"]; !ok {
		if m.GetInput() != nil {
			cerbos_request_v1_CheckResourceBatchRequest_hashpb_sum(m.GetInput(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.private.v1.ServerTestCase.CheckResourceBatchCall.want_response"]; !ok {
		if m.GetWantResponse() != nil {
			cerbos_response_v1_CheckResourceBatchResponse_hashpb_sum(m.GetWantResponse(), hasher, ignore)
		}

	}
}

func cerbos_private_v1_ServerTestCase_CheckResourceSetCall_hashpb_sum(m *ServerTestCase_CheckResourceSetCall, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.private.v1.ServerTestCase.CheckResourceSetCall.input"]; !ok {
		if m.GetInput() != nil {
			cerbos_request_v1_CheckResourceSetRequest_hashpb_sum(m.GetInput(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.private.v1.ServerTestCase.CheckResourceSetCall.want_response"]; !ok {
		if m.GetWantResponse() != nil {
			cerbos_response_v1_CheckResourceSetResponse_hashpb_sum(m.GetWantResponse(), hasher, ignore)
		}

	}
}

func cerbos_private_v1_ServerTestCase_CheckResourcesCall_hashpb_sum(m *ServerTestCase_CheckResourcesCall, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.private.v1.ServerTestCase.CheckResourcesCall.input"]; !ok {
		if m.GetInput() != nil {
			cerbos_request_v1_CheckResourcesRequest_hashpb_sum(m.GetInput(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.private.v1.ServerTestCase.CheckResourcesCall.want_response"]; !ok {
		if m.GetWantResponse() != nil {
			cerbos_response_v1_CheckResourcesResponse_hashpb_sum(m.GetWantResponse(), hasher, ignore)
		}

	}
}

func cerbos_private_v1_ServerTestCase_PlanResourcesCall_hashpb_sum(m *ServerTestCase_PlanResourcesCall, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.private.v1.ServerTestCase.PlanResourcesCall.input"]; !ok {
		if m.GetInput() != nil {
			cerbos_request_v1_PlanResourcesRequest_hashpb_sum(m.GetInput(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.private.v1.ServerTestCase.PlanResourcesCall.want_response"]; !ok {
		if m.GetWantResponse() != nil {
			cerbos_response_v1_PlanResourcesResponse_hashpb_sum(m.GetWantResponse(), hasher, ignore)
		}

	}
}

func cerbos_private_v1_ServerTestCase_PlaygroundEvaluateCall_hashpb_sum(m *ServerTestCase_PlaygroundEvaluateCall, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.private.v1.ServerTestCase.PlaygroundEvaluateCall.input"]; !ok {
		if m.GetInput() != nil {
			cerbos_request_v1_PlaygroundEvaluateRequest_hashpb_sum(m.GetInput(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.private.v1.ServerTestCase.PlaygroundEvaluateCall.want_response"]; !ok {
		if m.GetWantResponse() != nil {
			cerbos_response_v1_PlaygroundEvaluateResponse_hashpb_sum(m.GetWantResponse(), hasher, ignore)
		}

	}
}

func cerbos_private_v1_ServerTestCase_PlaygroundProxyCall_hashpb_sum(m *ServerTestCase_PlaygroundProxyCall, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.private.v1.ServerTestCase.PlaygroundProxyCall.input"]; !ok {
		if m.GetInput() != nil {
			cerbos_request_v1_PlaygroundProxyRequest_hashpb_sum(m.GetInput(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.private.v1.ServerTestCase.PlaygroundProxyCall.want_response"]; !ok {
		if m.GetWantResponse() != nil {
			cerbos_response_v1_PlaygroundProxyResponse_hashpb_sum(m.GetWantResponse(), hasher, ignore)
		}

	}
}

func cerbos_private_v1_ServerTestCase_PlaygroundTestCall_hashpb_sum(m *ServerTestCase_PlaygroundTestCall, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.private.v1.ServerTestCase.PlaygroundTestCall.input"]; !ok {
		if m.GetInput() != nil {
			cerbos_request_v1_PlaygroundTestRequest_hashpb_sum(m.GetInput(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.private.v1.ServerTestCase.PlaygroundTestCall.want_response"]; !ok {
		if m.GetWantResponse() != nil {
			cerbos_response_v1_PlaygroundTestResponse_hashpb_sum(m.GetWantResponse(), hasher, ignore)
		}

	}
}

func cerbos_private_v1_ServerTestCase_PlaygroundValidateCall_hashpb_sum(m *ServerTestCase_PlaygroundValidateCall, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.private.v1.ServerTestCase.PlaygroundValidateCall.input"]; !ok {
		if m.GetInput() != nil {
			cerbos_request_v1_PlaygroundValidateRequest_hashpb_sum(m.GetInput(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.private.v1.ServerTestCase.PlaygroundValidateCall.want_response"]; !ok {
		if m.GetWantResponse() != nil {
			cerbos_response_v1_PlaygroundValidateResponse_hashpb_sum(m.GetWantResponse(), hasher, ignore)
		}

	}
}

func cerbos_private_v1_ServerTestCase_Status_hashpb_sum(m *ServerTestCase_Status, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.private.v1.ServerTestCase.Status.http_status_code"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(m.GetHttpStatusCode())))

	}
	if _, ok := ignore["cerbos.private.v1.ServerTestCase.Status.grpc_status_code"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(m.GetGrpcStatusCode())))

	}
}

func cerbos_private_v1_ServerTestCase_hashpb_sum(m *ServerTestCase, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.private.v1.ServerTestCase.name"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetName()))

	}
	if _, ok := ignore["cerbos.private.v1.ServerTestCase.description"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetDescription()))

	}
	if _, ok := ignore["cerbos.private.v1.ServerTestCase.want_error"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, protowire.EncodeBool(m.GetWantError())))

	}
	if _, ok := ignore["cerbos.private.v1.ServerTestCase.want_status"]; !ok {
		if m.GetWantStatus() != nil {
			cerbos_private_v1_ServerTestCase_Status_hashpb_sum(m.GetWantStatus(), hasher, ignore)
		}

	}
	if m.CallKind != nil {
		if _, ok := ignore["cerbos.private.v1.ServerTestCase.call_kind"]; !ok {
			switch t := m.CallKind.(type) {
			case *ServerTestCase_CheckResourceSet:
				if t.CheckResourceSet != nil {
					cerbos_private_v1_ServerTestCase_CheckResourceSetCall_hashpb_sum(t.CheckResourceSet, hasher, ignore)
				}

			case *ServerTestCase_CheckResourceBatch:
				if t.CheckResourceBatch != nil {
					cerbos_private_v1_ServerTestCase_CheckResourceBatchCall_hashpb_sum(t.CheckResourceBatch, hasher, ignore)
				}

			case *ServerTestCase_PlaygroundValidate:
				if t.PlaygroundValidate != nil {
					cerbos_private_v1_ServerTestCase_PlaygroundValidateCall_hashpb_sum(t.PlaygroundValidate, hasher, ignore)
				}

			case *ServerTestCase_PlaygroundEvaluate:
				if t.PlaygroundEvaluate != nil {
					cerbos_private_v1_ServerTestCase_PlaygroundEvaluateCall_hashpb_sum(t.PlaygroundEvaluate, hasher, ignore)
				}

			case *ServerTestCase_AdminAddOrUpdatePolicy:
				if t.AdminAddOrUpdatePolicy != nil {
					cerbos_private_v1_ServerTestCase_AdminAddOrUpdatePolicyCall_hashpb_sum(t.AdminAddOrUpdatePolicy, hasher, ignore)
				}

			case *ServerTestCase_PlaygroundProxy:
				if t.PlaygroundProxy != nil {
					cerbos_private_v1_ServerTestCase_PlaygroundProxyCall_hashpb_sum(t.PlaygroundProxy, hasher, ignore)
				}

			case *ServerTestCase_PlanResources:
				if t.PlanResources != nil {
					cerbos_private_v1_ServerTestCase_PlanResourcesCall_hashpb_sum(t.PlanResources, hasher, ignore)
				}

			case *ServerTestCase_AdminAddOrUpdateSchema:
				if t.AdminAddOrUpdateSchema != nil {
					cerbos_private_v1_ServerTestCase_AdminAddOrUpdateSchemaCall_hashpb_sum(t.AdminAddOrUpdateSchema, hasher, ignore)
				}

			case *ServerTestCase_PlaygroundTest:
				if t.PlaygroundTest != nil {
					cerbos_private_v1_ServerTestCase_PlaygroundTestCall_hashpb_sum(t.PlaygroundTest, hasher, ignore)
				}

			case *ServerTestCase_CheckResources:
				if t.CheckResources != nil {
					cerbos_private_v1_ServerTestCase_CheckResourcesCall_hashpb_sum(t.CheckResources, hasher, ignore)
				}

			}
		}
	}
}

func cerbos_private_v1_ValidationErrContainer_hashpb_sum(m *ValidationErrContainer, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.private.v1.ValidationErrContainer.errors"]; !ok {
		if len(m.Errors) > 0 {
			for _, v := range m.Errors {
				if v != nil {
					cerbos_schema_v1_ValidationError_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
}

func cerbos_private_v1_VerifyTestCase_hashpb_sum(m *VerifyTestCase, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.private.v1.VerifyTestCase.description"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetDescription()))

	}
	if _, ok := ignore["cerbos.private.v1.VerifyTestCase.want_err"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, protowire.EncodeBool(m.GetWantErr())))

	}
	if _, ok := ignore["cerbos.private.v1.VerifyTestCase.want"]; !ok {
		if m.GetWant() != nil {
			cerbos_policy_v1_TestResults_hashpb_sum(m.GetWant(), hasher, ignore)
		}

	}
}

func cerbos_private_v1_VerifyTestFixtureGetTestsTestCase_hashpb_sum(m *VerifyTestFixtureGetTestsTestCase, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.private.v1.VerifyTestFixtureGetTestsTestCase.table"]; !ok {
		if m.GetTable() != nil {
			cerbos_policy_v1_TestTable_hashpb_sum(m.GetTable(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.private.v1.VerifyTestFixtureGetTestsTestCase.want_tests"]; !ok {
		if len(m.WantTests) > 0 {
			for _, v := range m.WantTests {
				if v != nil {
					cerbos_policy_v1_Test_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
	if _, ok := ignore["cerbos.private.v1.VerifyTestFixtureGetTestsTestCase.want_err"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetWantErr()))

	}
}

func cerbos_private_v1_WellKnownTypes_Nested_hashpb_sum(m *WellKnownTypes_Nested, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.private.v1.WellKnownTypes.Nested.string_field"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetStringField()))

	}
	if _, ok := ignore["cerbos.private.v1.WellKnownTypes.Nested.value_field"]; !ok {
		if m.GetValueField() != nil {
			google_protobuf_Value_hashpb_sum(m.GetValueField(), hasher, ignore)
		}

	}
}

func cerbos_private_v1_WellKnownTypes_hashpb_sum(m *WellKnownTypes, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.private.v1.WellKnownTypes.bool_wrapper"]; !ok {
		if m.GetBoolWrapper() != nil {
			google_protobuf_BoolValue_hashpb_sum(m.GetBoolWrapper(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.private.v1.WellKnownTypes.int32_wrapper"]; !ok {
		if m.GetInt32Wrapper() != nil {
			google_protobuf_Int32Value_hashpb_sum(m.GetInt32Wrapper(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.private.v1.WellKnownTypes.int64_wrapper"]; !ok {
		if m.GetInt64Wrapper() != nil {
			google_protobuf_Int64Value_hashpb_sum(m.GetInt64Wrapper(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.private.v1.WellKnownTypes.uint32_wrapper"]; !ok {
		if m.GetUint32Wrapper() != nil {
			google_protobuf_UInt32Value_hashpb_sum(m.GetUint32Wrapper(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.private.v1.WellKnownTypes.uint64_wrapper"]; !ok {
		if m.GetUint64Wrapper() != nil {
			google_protobuf_UInt64Value_hashpb_sum(m.GetUint64Wrapper(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.private.v1.WellKnownTypes.float_wrapper"]; !ok {
		if m.GetFloatWrapper() != nil {
			google_protobuf_FloatValue_hashpb_sum(m.GetFloatWrapper(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.private.v1.WellKnownTypes.double_wrapper"]; !ok {
		if m.GetDoubleWrapper() != nil {
			google_protobuf_DoubleValue_hashpb_sum(m.GetDoubleWrapper(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.private.v1.WellKnownTypes.string_wrapper"]; !ok {
		if m.GetStringWrapper() != nil {
			google_protobuf_StringValue_hashpb_sum(m.GetStringWrapper(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.private.v1.WellKnownTypes.bytes_wrapper"]; !ok {
		if m.GetBytesWrapper() != nil {
			google_protobuf_BytesValue_hashpb_sum(m.GetBytesWrapper(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.private.v1.WellKnownTypes.repeated_bool_wrapper"]; !ok {
		if len(m.RepeatedBoolWrapper) > 0 {
			for _, v := range m.RepeatedBoolWrapper {
				if v != nil {
					google_protobuf_BoolValue_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
	if _, ok := ignore["cerbos.private.v1.WellKnownTypes.repeated_int32_wrapper"]; !ok {
		if len(m.RepeatedInt32Wrapper) > 0 {
			for _, v := range m.RepeatedInt32Wrapper {
				if v != nil {
					google_protobuf_Int32Value_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
	if _, ok := ignore["cerbos.private.v1.WellKnownTypes.repeated_int64_wrapper"]; !ok {
		if len(m.RepeatedInt64Wrapper) > 0 {
			for _, v := range m.RepeatedInt64Wrapper {
				if v != nil {
					google_protobuf_Int64Value_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
	if _, ok := ignore["cerbos.private.v1.WellKnownTypes.repeated_uint32_wrapper"]; !ok {
		if len(m.RepeatedUint32Wrapper) > 0 {
			for _, v := range m.RepeatedUint32Wrapper {
				if v != nil {
					google_protobuf_UInt32Value_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
	if _, ok := ignore["cerbos.private.v1.WellKnownTypes.repeated_uint64_wrapper"]; !ok {
		if len(m.RepeatedUint64Wrapper) > 0 {
			for _, v := range m.RepeatedUint64Wrapper {
				if v != nil {
					google_protobuf_UInt64Value_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
	if _, ok := ignore["cerbos.private.v1.WellKnownTypes.repeated_float_wrapper"]; !ok {
		if len(m.RepeatedFloatWrapper) > 0 {
			for _, v := range m.RepeatedFloatWrapper {
				if v != nil {
					google_protobuf_FloatValue_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
	if _, ok := ignore["cerbos.private.v1.WellKnownTypes.repeated_double_wrapper"]; !ok {
		if len(m.RepeatedDoubleWrapper) > 0 {
			for _, v := range m.RepeatedDoubleWrapper {
				if v != nil {
					google_protobuf_DoubleValue_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
	if _, ok := ignore["cerbos.private.v1.WellKnownTypes.repeated_string_wrapper"]; !ok {
		if len(m.RepeatedStringWrapper) > 0 {
			for _, v := range m.RepeatedStringWrapper {
				if v != nil {
					google_protobuf_StringValue_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
	if _, ok := ignore["cerbos.private.v1.WellKnownTypes.repeated_bytes_wrapper"]; !ok {
		if len(m.RepeatedBytesWrapper) > 0 {
			for _, v := range m.RepeatedBytesWrapper {
				if v != nil {
					google_protobuf_BytesValue_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
	if _, ok := ignore["cerbos.private.v1.WellKnownTypes.duration"]; !ok {
		if m.GetDuration() != nil {
			google_protobuf_Duration_hashpb_sum(m.GetDuration(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.private.v1.WellKnownTypes.timestamp"]; !ok {
		if m.GetTimestamp() != nil {
			google_protobuf_Timestamp_hashpb_sum(m.GetTimestamp(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.private.v1.WellKnownTypes.struct"]; !ok {
		if m.GetStruct() != nil {
			google_protobuf_Struct_hashpb_sum(m.GetStruct(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.private.v1.WellKnownTypes.any"]; !ok {
		if m.GetAny() != nil {
			google_protobuf_Any_hashpb_sum(m.GetAny(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.private.v1.WellKnownTypes.value"]; !ok {
		if m.GetValue() != nil {
			google_protobuf_Value_hashpb_sum(m.GetValue(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.private.v1.WellKnownTypes.null_value"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(m.GetNullValue())))

	}
	if _, ok := ignore["cerbos.private.v1.WellKnownTypes.repeated_duration"]; !ok {
		if len(m.RepeatedDuration) > 0 {
			for _, v := range m.RepeatedDuration {
				if v != nil {
					google_protobuf_Duration_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
	if _, ok := ignore["cerbos.private.v1.WellKnownTypes.repeated_timestamp"]; !ok {
		if len(m.RepeatedTimestamp) > 0 {
			for _, v := range m.RepeatedTimestamp {
				if v != nil {
					google_protobuf_Timestamp_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
	if _, ok := ignore["cerbos.private.v1.WellKnownTypes.repeated_struct"]; !ok {
		if len(m.RepeatedStruct) > 0 {
			for _, v := range m.RepeatedStruct {
				if v != nil {
					google_protobuf_Struct_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
	if _, ok := ignore["cerbos.private.v1.WellKnownTypes.repeated_any"]; !ok {
		if len(m.RepeatedAny) > 0 {
			for _, v := range m.RepeatedAny {
				if v != nil {
					google_protobuf_Any_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
	if _, ok := ignore["cerbos.private.v1.WellKnownTypes.repeated_value"]; !ok {
		if len(m.RepeatedValue) > 0 {
			for _, v := range m.RepeatedValue {
				if v != nil {
					google_protobuf_Value_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
	if _, ok := ignore["cerbos.private.v1.WellKnownTypes.repeated_list_value"]; !ok {
		if len(m.RepeatedListValue) > 0 {
			for _, v := range m.RepeatedListValue {
				if v != nil {
					google_protobuf_ListValue_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
	if _, ok := ignore["cerbos.private.v1.WellKnownTypes.optional_nested_msg"]; !ok {
		if m.GetOptionalNestedMsg() != nil {
			cerbos_private_v1_WellKnownTypes_Nested_hashpb_sum(m.GetOptionalNestedMsg(), hasher, ignore)
		}

	}
}

func cerbos_request_v1_AddOrUpdatePolicyRequest_hashpb_sum(m *v13.AddOrUpdatePolicyRequest, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.request.v1.AddOrUpdatePolicyRequest.policies"]; !ok {
		if len(m.Policies) > 0 {
			for _, v := range m.Policies {
				if v != nil {
					cerbos_policy_v1_Policy_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
}

func cerbos_request_v1_AddOrUpdateSchemaRequest_hashpb_sum(m *v13.AddOrUpdateSchemaRequest, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.request.v1.AddOrUpdateSchemaRequest.schemas"]; !ok {
		if len(m.Schemas) > 0 {
			for _, v := range m.Schemas {
				if v != nil {
					cerbos_schema_v1_Schema_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
}

func cerbos_request_v1_AttributesMap_hashpb_sum(m *v13.AttributesMap, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.request.v1.AttributesMap.attr"]; !ok {
		if len(m.Attr) > 0 {
			keys := make([]string, len(m.Attr))
			i := 0
			for k := range m.Attr {
				keys[i] = k
				i++
			}

			sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

			for _, k := range keys {
				if m.Attr[k] != nil {
					google_protobuf_Value_hashpb_sum(m.Attr[k], hasher, ignore)
				}

			}
		}
	}
}

func cerbos_request_v1_AuxData_JWT_hashpb_sum(m *v13.AuxData_JWT, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.request.v1.AuxData.JWT.token"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetToken()))

	}
	if _, ok := ignore["cerbos.request.v1.AuxData.JWT.key_set_id"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetKeySetId()))

	}
}

func cerbos_request_v1_AuxData_hashpb_sum(m *v13.AuxData, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.request.v1.AuxData.jwt"]; !ok {
		if m.GetJwt() != nil {
			cerbos_request_v1_AuxData_JWT_hashpb_sum(m.GetJwt(), hasher, ignore)
		}

	}
}

func cerbos_request_v1_CheckResourceBatchRequest_BatchEntry_hashpb_sum(m *v13.CheckResourceBatchRequest_BatchEntry, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.request.v1.CheckResourceBatchRequest.BatchEntry.actions"]; !ok {
		if len(m.Actions) > 0 {
			for _, v := range m.Actions {
				_, _ = hasher.Write(protowire.AppendString(nil, v))

			}
		}
	}
	if _, ok := ignore["cerbos.request.v1.CheckResourceBatchRequest.BatchEntry.resource"]; !ok {
		if m.GetResource() != nil {
			cerbos_engine_v1_Resource_hashpb_sum(m.GetResource(), hasher, ignore)
		}

	}
}

func cerbos_request_v1_CheckResourceBatchRequest_hashpb_sum(m *v13.CheckResourceBatchRequest, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.request.v1.CheckResourceBatchRequest.request_id"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetRequestId()))

	}
	if _, ok := ignore["cerbos.request.v1.CheckResourceBatchRequest.principal"]; !ok {
		if m.GetPrincipal() != nil {
			cerbos_engine_v1_Principal_hashpb_sum(m.GetPrincipal(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.request.v1.CheckResourceBatchRequest.resources"]; !ok {
		if len(m.Resources) > 0 {
			for _, v := range m.Resources {
				if v != nil {
					cerbos_request_v1_CheckResourceBatchRequest_BatchEntry_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
	if _, ok := ignore["cerbos.request.v1.CheckResourceBatchRequest.aux_data"]; !ok {
		if m.GetAuxData() != nil {
			cerbos_request_v1_AuxData_hashpb_sum(m.GetAuxData(), hasher, ignore)
		}

	}
}

func cerbos_request_v1_CheckResourceSetRequest_hashpb_sum(m *v13.CheckResourceSetRequest, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.request.v1.CheckResourceSetRequest.request_id"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetRequestId()))

	}
	if _, ok := ignore["cerbos.request.v1.CheckResourceSetRequest.actions"]; !ok {
		if len(m.Actions) > 0 {
			for _, v := range m.Actions {
				_, _ = hasher.Write(protowire.AppendString(nil, v))

			}
		}
	}
	if _, ok := ignore["cerbos.request.v1.CheckResourceSetRequest.principal"]; !ok {
		if m.GetPrincipal() != nil {
			cerbos_engine_v1_Principal_hashpb_sum(m.GetPrincipal(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.request.v1.CheckResourceSetRequest.resource"]; !ok {
		if m.GetResource() != nil {
			cerbos_request_v1_ResourceSet_hashpb_sum(m.GetResource(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.request.v1.CheckResourceSetRequest.include_meta"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, protowire.EncodeBool(m.GetIncludeMeta())))

	}
	if _, ok := ignore["cerbos.request.v1.CheckResourceSetRequest.aux_data"]; !ok {
		if m.GetAuxData() != nil {
			cerbos_request_v1_AuxData_hashpb_sum(m.GetAuxData(), hasher, ignore)
		}

	}
}

func cerbos_request_v1_CheckResourcesRequest_ResourceEntry_hashpb_sum(m *v13.CheckResourcesRequest_ResourceEntry, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.request.v1.CheckResourcesRequest.ResourceEntry.actions"]; !ok {
		if len(m.Actions) > 0 {
			for _, v := range m.Actions {
				_, _ = hasher.Write(protowire.AppendString(nil, v))

			}
		}
	}
	if _, ok := ignore["cerbos.request.v1.CheckResourcesRequest.ResourceEntry.resource"]; !ok {
		if m.GetResource() != nil {
			cerbos_engine_v1_Resource_hashpb_sum(m.GetResource(), hasher, ignore)
		}

	}
}

func cerbos_request_v1_CheckResourcesRequest_hashpb_sum(m *v13.CheckResourcesRequest, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.request.v1.CheckResourcesRequest.request_id"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetRequestId()))

	}
	if _, ok := ignore["cerbos.request.v1.CheckResourcesRequest.include_meta"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, protowire.EncodeBool(m.GetIncludeMeta())))

	}
	if _, ok := ignore["cerbos.request.v1.CheckResourcesRequest.principal"]; !ok {
		if m.GetPrincipal() != nil {
			cerbos_engine_v1_Principal_hashpb_sum(m.GetPrincipal(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.request.v1.CheckResourcesRequest.resources"]; !ok {
		if len(m.Resources) > 0 {
			for _, v := range m.Resources {
				if v != nil {
					cerbos_request_v1_CheckResourcesRequest_ResourceEntry_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
	if _, ok := ignore["cerbos.request.v1.CheckResourcesRequest.aux_data"]; !ok {
		if m.GetAuxData() != nil {
			cerbos_request_v1_AuxData_hashpb_sum(m.GetAuxData(), hasher, ignore)
		}

	}
}

func cerbos_request_v1_File_hashpb_sum(m *v13.File, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.request.v1.File.file_name"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetFileName()))

	}
	if _, ok := ignore["cerbos.request.v1.File.contents"]; !ok {
		_, _ = hasher.Write(protowire.AppendBytes(nil, m.GetContents()))

	}
}

func cerbos_request_v1_PlanResourcesRequest_hashpb_sum(m *v13.PlanResourcesRequest, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.request.v1.PlanResourcesRequest.request_id"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetRequestId()))

	}
	if _, ok := ignore["cerbos.request.v1.PlanResourcesRequest.action"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetAction()))

	}
	if _, ok := ignore["cerbos.request.v1.PlanResourcesRequest.principal"]; !ok {
		if m.GetPrincipal() != nil {
			cerbos_engine_v1_Principal_hashpb_sum(m.GetPrincipal(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.request.v1.PlanResourcesRequest.resource"]; !ok {
		if m.GetResource() != nil {
			cerbos_engine_v1_PlanResourcesInput_Resource_hashpb_sum(m.GetResource(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.request.v1.PlanResourcesRequest.aux_data"]; !ok {
		if m.GetAuxData() != nil {
			cerbos_request_v1_AuxData_hashpb_sum(m.GetAuxData(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.request.v1.PlanResourcesRequest.include_meta"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, protowire.EncodeBool(m.GetIncludeMeta())))

	}
}

func cerbos_request_v1_PlaygroundEvaluateRequest_hashpb_sum(m *v13.PlaygroundEvaluateRequest, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.request.v1.PlaygroundEvaluateRequest.playground_id"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetPlaygroundId()))

	}
	if _, ok := ignore["cerbos.request.v1.PlaygroundEvaluateRequest.files"]; !ok {
		if len(m.Files) > 0 {
			for _, v := range m.Files {
				if v != nil {
					cerbos_request_v1_File_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
	if _, ok := ignore["cerbos.request.v1.PlaygroundEvaluateRequest.principal"]; !ok {
		if m.GetPrincipal() != nil {
			cerbos_engine_v1_Principal_hashpb_sum(m.GetPrincipal(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.request.v1.PlaygroundEvaluateRequest.resource"]; !ok {
		if m.GetResource() != nil {
			cerbos_engine_v1_Resource_hashpb_sum(m.GetResource(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.request.v1.PlaygroundEvaluateRequest.actions"]; !ok {
		if len(m.Actions) > 0 {
			for _, v := range m.Actions {
				_, _ = hasher.Write(protowire.AppendString(nil, v))

			}
		}
	}
	if _, ok := ignore["cerbos.request.v1.PlaygroundEvaluateRequest.aux_data"]; !ok {
		if m.GetAuxData() != nil {
			cerbos_request_v1_AuxData_hashpb_sum(m.GetAuxData(), hasher, ignore)
		}

	}
}

func cerbos_request_v1_PlaygroundProxyRequest_hashpb_sum(m *v13.PlaygroundProxyRequest, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.request.v1.PlaygroundProxyRequest.playground_id"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetPlaygroundId()))

	}
	if _, ok := ignore["cerbos.request.v1.PlaygroundProxyRequest.files"]; !ok {
		if len(m.Files) > 0 {
			for _, v := range m.Files {
				if v != nil {
					cerbos_request_v1_File_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
	if m.ProxyRequest != nil {
		if _, ok := ignore["cerbos.request.v1.PlaygroundProxyRequest.proxy_request"]; !ok {
			switch t := m.ProxyRequest.(type) {
			case *v13.PlaygroundProxyRequest_CheckResourceSet:
				if t.CheckResourceSet != nil {
					cerbos_request_v1_CheckResourceSetRequest_hashpb_sum(t.CheckResourceSet, hasher, ignore)
				}

			case *v13.PlaygroundProxyRequest_CheckResourceBatch:
				if t.CheckResourceBatch != nil {
					cerbos_request_v1_CheckResourceBatchRequest_hashpb_sum(t.CheckResourceBatch, hasher, ignore)
				}

			case *v13.PlaygroundProxyRequest_PlanResources:
				if t.PlanResources != nil {
					cerbos_request_v1_PlanResourcesRequest_hashpb_sum(t.PlanResources, hasher, ignore)
				}

			case *v13.PlaygroundProxyRequest_CheckResources:
				if t.CheckResources != nil {
					cerbos_request_v1_CheckResourcesRequest_hashpb_sum(t.CheckResources, hasher, ignore)
				}

			}
		}
	}
}

func cerbos_request_v1_PlaygroundTestRequest_hashpb_sum(m *v13.PlaygroundTestRequest, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.request.v1.PlaygroundTestRequest.playground_id"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetPlaygroundId()))

	}
	if _, ok := ignore["cerbos.request.v1.PlaygroundTestRequest.files"]; !ok {
		if len(m.Files) > 0 {
			for _, v := range m.Files {
				if v != nil {
					cerbos_request_v1_File_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
}

func cerbos_request_v1_PlaygroundValidateRequest_hashpb_sum(m *v13.PlaygroundValidateRequest, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.request.v1.PlaygroundValidateRequest.playground_id"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetPlaygroundId()))

	}
	if _, ok := ignore["cerbos.request.v1.PlaygroundValidateRequest.files"]; !ok {
		if len(m.Files) > 0 {
			for _, v := range m.Files {
				if v != nil {
					cerbos_request_v1_File_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
}

func cerbos_request_v1_ResourceSet_hashpb_sum(m *v13.ResourceSet, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.request.v1.ResourceSet.kind"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetKind()))

	}
	if _, ok := ignore["cerbos.request.v1.ResourceSet.policy_version"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetPolicyVersion()))

	}
	if _, ok := ignore["cerbos.request.v1.ResourceSet.instances"]; !ok {
		if len(m.Instances) > 0 {
			keys := make([]string, len(m.Instances))
			i := 0
			for k := range m.Instances {
				keys[i] = k
				i++
			}

			sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

			for _, k := range keys {
				if m.Instances[k] != nil {
					cerbos_request_v1_AttributesMap_hashpb_sum(m.Instances[k], hasher, ignore)
				}

			}
		}
	}
	if _, ok := ignore["cerbos.request.v1.ResourceSet.scope"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetScope()))

	}
}

func cerbos_response_v1_AddOrUpdatePolicyResponse_hashpb_sum(m *v14.AddOrUpdatePolicyResponse, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.response.v1.AddOrUpdatePolicyResponse.success"]; !ok {
		if m.GetSuccess() != nil {
			google_protobuf_Empty_hashpb_sum(m.GetSuccess(), hasher, ignore)
		}

	}
}

func cerbos_response_v1_AddOrUpdateSchemaResponse_hashpb_sum(m *v14.AddOrUpdateSchemaResponse, hasher hash.Hash, ignore map[string]struct{}) {
}

func cerbos_response_v1_CheckResourceBatchResponse_ActionEffectMap_hashpb_sum(m *v14.CheckResourceBatchResponse_ActionEffectMap, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.response.v1.CheckResourceBatchResponse.ActionEffectMap.resource_id"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetResourceId()))

	}
	if _, ok := ignore["cerbos.response.v1.CheckResourceBatchResponse.ActionEffectMap.actions"]; !ok {
		if len(m.Actions) > 0 {
			keys := make([]string, len(m.Actions))
			i := 0
			for k := range m.Actions {
				keys[i] = k
				i++
			}

			sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

			for _, k := range keys {
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(m.Actions[k])))

			}
		}
	}
	if _, ok := ignore["cerbos.response.v1.CheckResourceBatchResponse.ActionEffectMap.validation_errors"]; !ok {
		if len(m.ValidationErrors) > 0 {
			for _, v := range m.ValidationErrors {
				if v != nil {
					cerbos_schema_v1_ValidationError_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
}

func cerbos_response_v1_CheckResourceBatchResponse_hashpb_sum(m *v14.CheckResourceBatchResponse, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.response.v1.CheckResourceBatchResponse.request_id"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetRequestId()))

	}
	if _, ok := ignore["cerbos.response.v1.CheckResourceBatchResponse.results"]; !ok {
		if len(m.Results) > 0 {
			for _, v := range m.Results {
				if v != nil {
					cerbos_response_v1_CheckResourceBatchResponse_ActionEffectMap_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
}

func cerbos_response_v1_CheckResourceSetResponse_ActionEffectMap_hashpb_sum(m *v14.CheckResourceSetResponse_ActionEffectMap, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.response.v1.CheckResourceSetResponse.ActionEffectMap.actions"]; !ok {
		if len(m.Actions) > 0 {
			keys := make([]string, len(m.Actions))
			i := 0
			for k := range m.Actions {
				keys[i] = k
				i++
			}

			sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

			for _, k := range keys {
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(m.Actions[k])))

			}
		}
	}
	if _, ok := ignore["cerbos.response.v1.CheckResourceSetResponse.ActionEffectMap.validation_errors"]; !ok {
		if len(m.ValidationErrors) > 0 {
			for _, v := range m.ValidationErrors {
				if v != nil {
					cerbos_schema_v1_ValidationError_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
}

func cerbos_response_v1_CheckResourceSetResponse_Meta_ActionMeta_hashpb_sum(m *v14.CheckResourceSetResponse_Meta_ActionMeta, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.response.v1.CheckResourceSetResponse.Meta.ActionMeta.actions"]; !ok {
		if len(m.Actions) > 0 {
			keys := make([]string, len(m.Actions))
			i := 0
			for k := range m.Actions {
				keys[i] = k
				i++
			}

			sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

			for _, k := range keys {
				if m.Actions[k] != nil {
					cerbos_response_v1_CheckResourceSetResponse_Meta_EffectMeta_hashpb_sum(m.Actions[k], hasher, ignore)
				}

			}
		}
	}
	if _, ok := ignore["cerbos.response.v1.CheckResourceSetResponse.Meta.ActionMeta.effective_derived_roles"]; !ok {
		if len(m.EffectiveDerivedRoles) > 0 {
			for _, v := range m.EffectiveDerivedRoles {
				_, _ = hasher.Write(protowire.AppendString(nil, v))

			}
		}
	}
}

func cerbos_response_v1_CheckResourceSetResponse_Meta_EffectMeta_hashpb_sum(m *v14.CheckResourceSetResponse_Meta_EffectMeta, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.response.v1.CheckResourceSetResponse.Meta.EffectMeta.matched_policy"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetMatchedPolicy()))

	}
	if _, ok := ignore["cerbos.response.v1.CheckResourceSetResponse.Meta.EffectMeta.matched_scope"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetMatchedScope()))

	}
}

func cerbos_response_v1_CheckResourceSetResponse_Meta_hashpb_sum(m *v14.CheckResourceSetResponse_Meta, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.response.v1.CheckResourceSetResponse.Meta.resource_instances"]; !ok {
		if len(m.ResourceInstances) > 0 {
			keys := make([]string, len(m.ResourceInstances))
			i := 0
			for k := range m.ResourceInstances {
				keys[i] = k
				i++
			}

			sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

			for _, k := range keys {
				if m.ResourceInstances[k] != nil {
					cerbos_response_v1_CheckResourceSetResponse_Meta_ActionMeta_hashpb_sum(m.ResourceInstances[k], hasher, ignore)
				}

			}
		}
	}
}

func cerbos_response_v1_CheckResourceSetResponse_hashpb_sum(m *v14.CheckResourceSetResponse, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.response.v1.CheckResourceSetResponse.request_id"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetRequestId()))

	}
	if _, ok := ignore["cerbos.response.v1.CheckResourceSetResponse.resource_instances"]; !ok {
		if len(m.ResourceInstances) > 0 {
			keys := make([]string, len(m.ResourceInstances))
			i := 0
			for k := range m.ResourceInstances {
				keys[i] = k
				i++
			}

			sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

			for _, k := range keys {
				if m.ResourceInstances[k] != nil {
					cerbos_response_v1_CheckResourceSetResponse_ActionEffectMap_hashpb_sum(m.ResourceInstances[k], hasher, ignore)
				}

			}
		}
	}
	if _, ok := ignore["cerbos.response.v1.CheckResourceSetResponse.meta"]; !ok {
		if m.GetMeta() != nil {
			cerbos_response_v1_CheckResourceSetResponse_Meta_hashpb_sum(m.GetMeta(), hasher, ignore)
		}

	}
}

func cerbos_response_v1_CheckResourcesResponse_ResultEntry_Meta_EffectMeta_hashpb_sum(m *v14.CheckResourcesResponse_ResultEntry_Meta_EffectMeta, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.response.v1.CheckResourcesResponse.ResultEntry.Meta.EffectMeta.matched_policy"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetMatchedPolicy()))

	}
	if _, ok := ignore["cerbos.response.v1.CheckResourcesResponse.ResultEntry.Meta.EffectMeta.matched_scope"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetMatchedScope()))

	}
}

func cerbos_response_v1_CheckResourcesResponse_ResultEntry_Meta_hashpb_sum(m *v14.CheckResourcesResponse_ResultEntry_Meta, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.response.v1.CheckResourcesResponse.ResultEntry.Meta.actions"]; !ok {
		if len(m.Actions) > 0 {
			keys := make([]string, len(m.Actions))
			i := 0
			for k := range m.Actions {
				keys[i] = k
				i++
			}

			sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

			for _, k := range keys {
				if m.Actions[k] != nil {
					cerbos_response_v1_CheckResourcesResponse_ResultEntry_Meta_EffectMeta_hashpb_sum(m.Actions[k], hasher, ignore)
				}

			}
		}
	}
	if _, ok := ignore["cerbos.response.v1.CheckResourcesResponse.ResultEntry.Meta.effective_derived_roles"]; !ok {
		if len(m.EffectiveDerivedRoles) > 0 {
			for _, v := range m.EffectiveDerivedRoles {
				_, _ = hasher.Write(protowire.AppendString(nil, v))

			}
		}
	}
}

func cerbos_response_v1_CheckResourcesResponse_ResultEntry_Resource_hashpb_sum(m *v14.CheckResourcesResponse_ResultEntry_Resource, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.response.v1.CheckResourcesResponse.ResultEntry.Resource.id"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetId()))

	}
	if _, ok := ignore["cerbos.response.v1.CheckResourcesResponse.ResultEntry.Resource.kind"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetKind()))

	}
	if _, ok := ignore["cerbos.response.v1.CheckResourcesResponse.ResultEntry.Resource.policy_version"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetPolicyVersion()))

	}
	if _, ok := ignore["cerbos.response.v1.CheckResourcesResponse.ResultEntry.Resource.scope"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetScope()))

	}
}

func cerbos_response_v1_CheckResourcesResponse_ResultEntry_hashpb_sum(m *v14.CheckResourcesResponse_ResultEntry, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.response.v1.CheckResourcesResponse.ResultEntry.resource"]; !ok {
		if m.GetResource() != nil {
			cerbos_response_v1_CheckResourcesResponse_ResultEntry_Resource_hashpb_sum(m.GetResource(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.response.v1.CheckResourcesResponse.ResultEntry.actions"]; !ok {
		if len(m.Actions) > 0 {
			keys := make([]string, len(m.Actions))
			i := 0
			for k := range m.Actions {
				keys[i] = k
				i++
			}

			sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

			for _, k := range keys {
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(m.Actions[k])))

			}
		}
	}
	if _, ok := ignore["cerbos.response.v1.CheckResourcesResponse.ResultEntry.validation_errors"]; !ok {
		if len(m.ValidationErrors) > 0 {
			for _, v := range m.ValidationErrors {
				if v != nil {
					cerbos_schema_v1_ValidationError_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
	if _, ok := ignore["cerbos.response.v1.CheckResourcesResponse.ResultEntry.meta"]; !ok {
		if m.GetMeta() != nil {
			cerbos_response_v1_CheckResourcesResponse_ResultEntry_Meta_hashpb_sum(m.GetMeta(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.response.v1.CheckResourcesResponse.ResultEntry.outputs"]; !ok {
		if len(m.Outputs) > 0 {
			for _, v := range m.Outputs {
				if v != nil {
					cerbos_engine_v1_OutputEntry_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
}

func cerbos_response_v1_CheckResourcesResponse_hashpb_sum(m *v14.CheckResourcesResponse, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.response.v1.CheckResourcesResponse.request_id"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetRequestId()))

	}
	if _, ok := ignore["cerbos.response.v1.CheckResourcesResponse.results"]; !ok {
		if len(m.Results) > 0 {
			for _, v := range m.Results {
				if v != nil {
					cerbos_response_v1_CheckResourcesResponse_ResultEntry_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
	if _, ok := ignore["cerbos.response.v1.CheckResourcesResponse.cerbos_call_id"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetCerbosCallId()))

	}
}

func cerbos_response_v1_PlanResourcesResponse_Meta_hashpb_sum(m *v14.PlanResourcesResponse_Meta, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.response.v1.PlanResourcesResponse.Meta.filter_debug"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetFilterDebug()))

	}
	if _, ok := ignore["cerbos.response.v1.PlanResourcesResponse.Meta.matched_scope"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetMatchedScope()))

	}
}

func cerbos_response_v1_PlanResourcesResponse_hashpb_sum(m *v14.PlanResourcesResponse, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.response.v1.PlanResourcesResponse.request_id"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetRequestId()))

	}
	if _, ok := ignore["cerbos.response.v1.PlanResourcesResponse.action"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetAction()))

	}
	if _, ok := ignore["cerbos.response.v1.PlanResourcesResponse.resource_kind"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetResourceKind()))

	}
	if _, ok := ignore["cerbos.response.v1.PlanResourcesResponse.policy_version"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetPolicyVersion()))

	}
	if _, ok := ignore["cerbos.response.v1.PlanResourcesResponse.filter"]; !ok {
		if m.GetFilter() != nil {
			cerbos_engine_v1_PlanResourcesFilter_hashpb_sum(m.GetFilter(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.response.v1.PlanResourcesResponse.meta"]; !ok {
		if m.GetMeta() != nil {
			cerbos_response_v1_PlanResourcesResponse_Meta_hashpb_sum(m.GetMeta(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.response.v1.PlanResourcesResponse.validation_errors"]; !ok {
		if len(m.ValidationErrors) > 0 {
			for _, v := range m.ValidationErrors {
				if v != nil {
					cerbos_schema_v1_ValidationError_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
	if _, ok := ignore["cerbos.response.v1.PlanResourcesResponse.cerbos_call_id"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetCerbosCallId()))

	}
}

func cerbos_response_v1_PlaygroundEvaluateResponse_EvalResultList_hashpb_sum(m *v14.PlaygroundEvaluateResponse_EvalResultList, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.response.v1.PlaygroundEvaluateResponse.EvalResultList.results"]; !ok {
		if len(m.Results) > 0 {
			for _, v := range m.Results {
				if v != nil {
					cerbos_response_v1_PlaygroundEvaluateResponse_EvalResult_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
	if _, ok := ignore["cerbos.response.v1.PlaygroundEvaluateResponse.EvalResultList.effective_derived_roles"]; !ok {
		if len(m.EffectiveDerivedRoles) > 0 {
			for _, v := range m.EffectiveDerivedRoles {
				_, _ = hasher.Write(protowire.AppendString(nil, v))

			}
		}
	}
	if _, ok := ignore["cerbos.response.v1.PlaygroundEvaluateResponse.EvalResultList.validation_errors"]; !ok {
		if len(m.ValidationErrors) > 0 {
			for _, v := range m.ValidationErrors {
				if v != nil {
					cerbos_schema_v1_ValidationError_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
	if _, ok := ignore["cerbos.response.v1.PlaygroundEvaluateResponse.EvalResultList.outputs"]; !ok {
		if len(m.Outputs) > 0 {
			for _, v := range m.Outputs {
				if v != nil {
					cerbos_engine_v1_OutputEntry_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
}

func cerbos_response_v1_PlaygroundEvaluateResponse_EvalResult_hashpb_sum(m *v14.PlaygroundEvaluateResponse_EvalResult, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.response.v1.PlaygroundEvaluateResponse.EvalResult.action"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetAction()))

	}
	if _, ok := ignore["cerbos.response.v1.PlaygroundEvaluateResponse.EvalResult.effect"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(m.GetEffect())))

	}
	if _, ok := ignore["cerbos.response.v1.PlaygroundEvaluateResponse.EvalResult.policy"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetPolicy()))

	}
	if _, ok := ignore["cerbos.response.v1.PlaygroundEvaluateResponse.EvalResult.effective_derived_roles"]; !ok {
		if len(m.EffectiveDerivedRoles) > 0 {
			for _, v := range m.EffectiveDerivedRoles {
				_, _ = hasher.Write(protowire.AppendString(nil, v))

			}
		}
	}
	if _, ok := ignore["cerbos.response.v1.PlaygroundEvaluateResponse.EvalResult.validation_errors"]; !ok {
		if len(m.ValidationErrors) > 0 {
			for _, v := range m.ValidationErrors {
				if v != nil {
					cerbos_schema_v1_ValidationError_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
}

func cerbos_response_v1_PlaygroundEvaluateResponse_hashpb_sum(m *v14.PlaygroundEvaluateResponse, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.response.v1.PlaygroundEvaluateResponse.playground_id"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetPlaygroundId()))

	}
	if m.Outcome != nil {
		if _, ok := ignore["cerbos.response.v1.PlaygroundEvaluateResponse.outcome"]; !ok {
			switch t := m.Outcome.(type) {
			case *v14.PlaygroundEvaluateResponse_Failure:
				if t.Failure != nil {
					cerbos_response_v1_PlaygroundFailure_hashpb_sum(t.Failure, hasher, ignore)
				}

			case *v14.PlaygroundEvaluateResponse_Success:
				if t.Success != nil {
					cerbos_response_v1_PlaygroundEvaluateResponse_EvalResultList_hashpb_sum(t.Success, hasher, ignore)
				}

			}
		}
	}
}

func cerbos_response_v1_PlaygroundFailure_ErrorDetails_hashpb_sum(m *v14.PlaygroundFailure_ErrorDetails, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.response.v1.PlaygroundFailure.ErrorDetails.line"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(m.GetLine())))

	}
	if _, ok := ignore["cerbos.response.v1.PlaygroundFailure.ErrorDetails.column"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(m.GetColumn())))

	}
	if _, ok := ignore["cerbos.response.v1.PlaygroundFailure.ErrorDetails.context"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetContext()))

	}
}

func cerbos_response_v1_PlaygroundFailure_Error_hashpb_sum(m *v14.PlaygroundFailure_Error, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.response.v1.PlaygroundFailure.Error.file"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetFile()))

	}
	if _, ok := ignore["cerbos.response.v1.PlaygroundFailure.Error.error"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetError()))

	}
	if _, ok := ignore["cerbos.response.v1.PlaygroundFailure.Error.details"]; !ok {
		if m.GetDetails() != nil {
			cerbos_response_v1_PlaygroundFailure_ErrorDetails_hashpb_sum(m.GetDetails(), hasher, ignore)
		}

	}
}

func cerbos_response_v1_PlaygroundFailure_hashpb_sum(m *v14.PlaygroundFailure, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.response.v1.PlaygroundFailure.errors"]; !ok {
		if len(m.Errors) > 0 {
			for _, v := range m.Errors {
				if v != nil {
					cerbos_response_v1_PlaygroundFailure_Error_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
}

func cerbos_response_v1_PlaygroundProxyResponse_hashpb_sum(m *v14.PlaygroundProxyResponse, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.response.v1.PlaygroundProxyResponse.playground_id"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetPlaygroundId()))

	}
	if m.Outcome != nil {
		if _, ok := ignore["cerbos.response.v1.PlaygroundProxyResponse.outcome"]; !ok {
			switch t := m.Outcome.(type) {
			case *v14.PlaygroundProxyResponse_Failure:
				if t.Failure != nil {
					cerbos_response_v1_PlaygroundFailure_hashpb_sum(t.Failure, hasher, ignore)
				}

			case *v14.PlaygroundProxyResponse_CheckResourceSet:
				if t.CheckResourceSet != nil {
					cerbos_response_v1_CheckResourceSetResponse_hashpb_sum(t.CheckResourceSet, hasher, ignore)
				}

			case *v14.PlaygroundProxyResponse_CheckResourceBatch:
				if t.CheckResourceBatch != nil {
					cerbos_response_v1_CheckResourceBatchResponse_hashpb_sum(t.CheckResourceBatch, hasher, ignore)
				}

			case *v14.PlaygroundProxyResponse_PlanResources:
				if t.PlanResources != nil {
					cerbos_response_v1_PlanResourcesResponse_hashpb_sum(t.PlanResources, hasher, ignore)
				}

			case *v14.PlaygroundProxyResponse_CheckResources:
				if t.CheckResources != nil {
					cerbos_response_v1_CheckResourcesResponse_hashpb_sum(t.CheckResources, hasher, ignore)
				}

			}
		}
	}
}

func cerbos_response_v1_PlaygroundTestResponse_TestResults_hashpb_sum(m *v14.PlaygroundTestResponse_TestResults, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.response.v1.PlaygroundTestResponse.TestResults.results"]; !ok {
		if m.GetResults() != nil {
			cerbos_policy_v1_TestResults_hashpb_sum(m.GetResults(), hasher, ignore)
		}

	}
}

func cerbos_response_v1_PlaygroundTestResponse_hashpb_sum(m *v14.PlaygroundTestResponse, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.response.v1.PlaygroundTestResponse.playground_id"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetPlaygroundId()))

	}
	if m.Outcome != nil {
		if _, ok := ignore["cerbos.response.v1.PlaygroundTestResponse.outcome"]; !ok {
			switch t := m.Outcome.(type) {
			case *v14.PlaygroundTestResponse_Failure:
				if t.Failure != nil {
					cerbos_response_v1_PlaygroundFailure_hashpb_sum(t.Failure, hasher, ignore)
				}

			case *v14.PlaygroundTestResponse_Success:
				if t.Success != nil {
					cerbos_response_v1_PlaygroundTestResponse_TestResults_hashpb_sum(t.Success, hasher, ignore)
				}

			}
		}
	}
}

func cerbos_response_v1_PlaygroundValidateResponse_hashpb_sum(m *v14.PlaygroundValidateResponse, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.response.v1.PlaygroundValidateResponse.playground_id"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetPlaygroundId()))

	}
	if m.Outcome != nil {
		if _, ok := ignore["cerbos.response.v1.PlaygroundValidateResponse.outcome"]; !ok {
			switch t := m.Outcome.(type) {
			case *v14.PlaygroundValidateResponse_Failure:
				if t.Failure != nil {
					cerbos_response_v1_PlaygroundFailure_hashpb_sum(t.Failure, hasher, ignore)
				}

			case *v14.PlaygroundValidateResponse_Success:
				if t.Success != nil {
					google_protobuf_Empty_hashpb_sum(t.Success, hasher, ignore)
				}

			}
		}
	}
}

func cerbos_runtime_v1_CompileErrors_Err_hashpb_sum(m *v15.CompileErrors_Err, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.runtime.v1.CompileErrors.Err.file"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetFile()))

	}
	if _, ok := ignore["cerbos.runtime.v1.CompileErrors.Err.error"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetError()))

	}
	if _, ok := ignore["cerbos.runtime.v1.CompileErrors.Err.description"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetDescription()))

	}
	if _, ok := ignore["cerbos.runtime.v1.CompileErrors.Err.position"]; !ok {
		if m.GetPosition() != nil {
			cerbos_source_v1_Position_hashpb_sum(m.GetPosition(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.runtime.v1.CompileErrors.Err.context"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetContext()))

	}
}

func cerbos_runtime_v1_IndexBuildErrors_Disabled_hashpb_sum(m *v15.IndexBuildErrors_Disabled, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.runtime.v1.IndexBuildErrors.Disabled.file"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetFile()))

	}
	if _, ok := ignore["cerbos.runtime.v1.IndexBuildErrors.Disabled.policy"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetPolicy()))

	}
	if _, ok := ignore["cerbos.runtime.v1.IndexBuildErrors.Disabled.position"]; !ok {
		if m.GetPosition() != nil {
			cerbos_source_v1_Position_hashpb_sum(m.GetPosition(), hasher, ignore)
		}

	}
}

func cerbos_runtime_v1_IndexBuildErrors_DuplicateDef_hashpb_sum(m *v15.IndexBuildErrors_DuplicateDef, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.runtime.v1.IndexBuildErrors.DuplicateDef.file"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetFile()))

	}
	if _, ok := ignore["cerbos.runtime.v1.IndexBuildErrors.DuplicateDef.other_file"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetOtherFile()))

	}
	if _, ok := ignore["cerbos.runtime.v1.IndexBuildErrors.DuplicateDef.policy"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetPolicy()))

	}
	if _, ok := ignore["cerbos.runtime.v1.IndexBuildErrors.DuplicateDef.position"]; !ok {
		if m.GetPosition() != nil {
			cerbos_source_v1_Position_hashpb_sum(m.GetPosition(), hasher, ignore)
		}

	}
}

func cerbos_runtime_v1_IndexBuildErrors_LoadFailure_hashpb_sum(m *v15.IndexBuildErrors_LoadFailure, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.runtime.v1.IndexBuildErrors.LoadFailure.file"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetFile()))

	}
	if _, ok := ignore["cerbos.runtime.v1.IndexBuildErrors.LoadFailure.error"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetError()))

	}
	if _, ok := ignore["cerbos.runtime.v1.IndexBuildErrors.LoadFailure.error_details"]; !ok {
		if m.GetErrorDetails() != nil {
			cerbos_source_v1_Error_hashpb_sum(m.GetErrorDetails(), hasher, ignore)
		}

	}
}

func cerbos_runtime_v1_IndexBuildErrors_MissingImport_hashpb_sum(m *v15.IndexBuildErrors_MissingImport, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.runtime.v1.IndexBuildErrors.MissingImport.importing_file"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetImportingFile()))

	}
	if _, ok := ignore["cerbos.runtime.v1.IndexBuildErrors.MissingImport.desc"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetDesc()))

	}
	if _, ok := ignore["cerbos.runtime.v1.IndexBuildErrors.MissingImport.importing_policy"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetImportingPolicy()))

	}
	if _, ok := ignore["cerbos.runtime.v1.IndexBuildErrors.MissingImport.import_kind"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetImportKind()))

	}
	if _, ok := ignore["cerbos.runtime.v1.IndexBuildErrors.MissingImport.import_name"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetImportName()))

	}
	if _, ok := ignore["cerbos.runtime.v1.IndexBuildErrors.MissingImport.position"]; !ok {
		if m.GetPosition() != nil {
			cerbos_source_v1_Position_hashpb_sum(m.GetPosition(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.runtime.v1.IndexBuildErrors.MissingImport.context"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetContext()))

	}
}

func cerbos_runtime_v1_IndexBuildErrors_hashpb_sum(m *v15.IndexBuildErrors, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.runtime.v1.IndexBuildErrors.disabled"]; !ok {
		if len(m.Disabled) > 0 {
			for _, v := range m.Disabled {
				_, _ = hasher.Write(protowire.AppendString(nil, v))

			}
		}
	}
	if _, ok := ignore["cerbos.runtime.v1.IndexBuildErrors.duplicate_defs"]; !ok {
		if len(m.DuplicateDefs) > 0 {
			for _, v := range m.DuplicateDefs {
				if v != nil {
					cerbos_runtime_v1_IndexBuildErrors_DuplicateDef_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
	if _, ok := ignore["cerbos.runtime.v1.IndexBuildErrors.load_failures"]; !ok {
		if len(m.LoadFailures) > 0 {
			for _, v := range m.LoadFailures {
				if v != nil {
					cerbos_runtime_v1_IndexBuildErrors_LoadFailure_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
	if _, ok := ignore["cerbos.runtime.v1.IndexBuildErrors.missing_imports"]; !ok {
		if len(m.MissingImports) > 0 {
			for _, v := range m.MissingImports {
				if v != nil {
					cerbos_runtime_v1_IndexBuildErrors_MissingImport_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
	if _, ok := ignore["cerbos.runtime.v1.IndexBuildErrors.missing_scopes"]; !ok {
		if len(m.MissingScopes) > 0 {
			for _, v := range m.MissingScopes {
				_, _ = hasher.Write(protowire.AppendString(nil, v))

			}
		}
	}
	if _, ok := ignore["cerbos.runtime.v1.IndexBuildErrors.disabled_defs"]; !ok {
		if len(m.DisabledDefs) > 0 {
			for _, v := range m.DisabledDefs {
				if v != nil {
					cerbos_runtime_v1_IndexBuildErrors_Disabled_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
}

func cerbos_schema_v1_Schema_hashpb_sum(m *v16.Schema, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.schema.v1.Schema.id"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetId()))

	}
	if _, ok := ignore["cerbos.schema.v1.Schema.definition"]; !ok {
		_, _ = hasher.Write(protowire.AppendBytes(nil, m.GetDefinition()))

	}
}

func cerbos_schema_v1_ValidationError_hashpb_sum(m *v16.ValidationError, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.schema.v1.ValidationError.path"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetPath()))

	}
	if _, ok := ignore["cerbos.schema.v1.ValidationError.message"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetMessage()))

	}
	if _, ok := ignore["cerbos.schema.v1.ValidationError.source"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(m.GetSource())))

	}
}

func cerbos_source_v1_Error_hashpb_sum(m *v17.Error, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.source.v1.Error.kind"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(m.GetKind())))

	}
	if _, ok := ignore["cerbos.source.v1.Error.position"]; !ok {
		if m.GetPosition() != nil {
			cerbos_source_v1_Position_hashpb_sum(m.GetPosition(), hasher, ignore)
		}

	}
	if _, ok := ignore["cerbos.source.v1.Error.message"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetMessage()))

	}
	if _, ok := ignore["cerbos.source.v1.Error.context"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetContext()))

	}
}

func cerbos_source_v1_Position_hashpb_sum(m *v17.Position, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.source.v1.Position.line"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(m.GetLine())))

	}
	if _, ok := ignore["cerbos.source.v1.Position.column"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(m.GetColumn())))

	}
	if _, ok := ignore["cerbos.source.v1.Position.path"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetPath()))

	}
}

func google_protobuf_Any_hashpb_sum(m *anypb.Any, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["google.protobuf.Any.type_url"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetTypeUrl()))

	}
	if _, ok := ignore["google.protobuf.Any.value"]; !ok {
		_, _ = hasher.Write(protowire.AppendBytes(nil, m.GetValue()))

	}
}

func google_protobuf_BoolValue_hashpb_sum(m *wrapperspb.BoolValue, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["google.protobuf.BoolValue.value"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, protowire.EncodeBool(m.GetValue())))

	}
}

func google_protobuf_BytesValue_hashpb_sum(m *wrapperspb.BytesValue, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["google.protobuf.BytesValue.value"]; !ok {
		_, _ = hasher.Write(protowire.AppendBytes(nil, m.GetValue()))

	}
}

func google_protobuf_DoubleValue_hashpb_sum(m *wrapperspb.DoubleValue, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["google.protobuf.DoubleValue.value"]; !ok {
		_, _ = hasher.Write(protowire.AppendFixed64(nil, math.Float64bits(m.GetValue())))

	}
}

func google_protobuf_Duration_hashpb_sum(m *durationpb.Duration, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["google.protobuf.Duration.seconds"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(m.GetSeconds())))

	}
	if _, ok := ignore["google.protobuf.Duration.nanos"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(m.GetNanos())))

	}
}

func google_protobuf_Empty_hashpb_sum(m *emptypb.Empty, hasher hash.Hash, ignore map[string]struct{}) {
}

func google_protobuf_FloatValue_hashpb_sum(m *wrapperspb.FloatValue, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["google.protobuf.FloatValue.value"]; !ok {
		_, _ = hasher.Write(protowire.AppendFixed32(nil, math.Float32bits(m.GetValue())))

	}
}

func google_protobuf_Int32Value_hashpb_sum(m *wrapperspb.Int32Value, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["google.protobuf.Int32Value.value"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(m.GetValue())))

	}
}

func google_protobuf_Int64Value_hashpb_sum(m *wrapperspb.Int64Value, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["google.protobuf.Int64Value.value"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(m.GetValue())))

	}
}

func google_protobuf_ListValue_hashpb_sum(m *structpb.ListValue, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["google.protobuf.ListValue.values"]; !ok {
		if len(m.Values) > 0 {
			for _, v := range m.Values {
				if v != nil {
					google_protobuf_Value_hashpb_sum(v, hasher, ignore)
				}

			}
		}
	}
}

func google_protobuf_StringValue_hashpb_sum(m *wrapperspb.StringValue, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["google.protobuf.StringValue.value"]; !ok {
		_, _ = hasher.Write(protowire.AppendString(nil, m.GetValue()))

	}
}

func google_protobuf_Struct_hashpb_sum(m *structpb.Struct, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["google.protobuf.Struct.fields"]; !ok {
		if len(m.Fields) > 0 {
			keys := make([]string, len(m.Fields))
			i := 0
			for k := range m.Fields {
				keys[i] = k
				i++
			}

			sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

			for _, k := range keys {
				if m.Fields[k] != nil {
					google_protobuf_Value_hashpb_sum(m.Fields[k], hasher, ignore)
				}

			}
		}
	}
}

func google_protobuf_Timestamp_hashpb_sum(m *timestamppb.Timestamp, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["google.protobuf.Timestamp.seconds"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(m.GetSeconds())))

	}
	if _, ok := ignore["google.protobuf.Timestamp.nanos"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(m.GetNanos())))

	}
}

func google_protobuf_UInt32Value_hashpb_sum(m *wrapperspb.UInt32Value, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["google.protobuf.UInt32Value.value"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(m.GetValue())))

	}
}

func google_protobuf_UInt64Value_hashpb_sum(m *wrapperspb.UInt64Value, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["google.protobuf.UInt64Value.value"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, m.GetValue()))

	}
}

func google_protobuf_Value_hashpb_sum(m *structpb.Value, hasher hash.Hash, ignore map[string]struct{}) {
	if m.Kind != nil {
		if _, ok := ignore["google.protobuf.Value.kind"]; !ok {
			switch t := m.Kind.(type) {
			case *structpb.Value_NullValue:
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(t.NullValue)))

			case *structpb.Value_NumberValue:
				_, _ = hasher.Write(protowire.AppendFixed64(nil, math.Float64bits(t.NumberValue)))

			case *structpb.Value_StringValue:
				_, _ = hasher.Write(protowire.AppendString(nil, t.StringValue))

			case *structpb.Value_BoolValue:
				_, _ = hasher.Write(protowire.AppendVarint(nil, protowire.EncodeBool(t.BoolValue)))

			case *structpb.Value_StructValue:
				if t.StructValue != nil {
					google_protobuf_Struct_hashpb_sum(t.StructValue, hasher, ignore)
				}

			case *structpb.Value_ListValue:
				if t.ListValue != nil {
					google_protobuf_ListValue_hashpb_sum(t.ListValue, hasher, ignore)
				}

			}
		}
	}
}