// Code generated by protoc-gen-go-hashpb. DO NOT EDIT.
// protoc-gen-go-hashpb v0.4.2

package policyv1

import (
	v1 "github.com/cerbos/cerbos/api/genpb/cerbos/engine/v1"
	protowire "google.golang.org/protobuf/encoding/protowire"
	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"
	maps "maps"
	math "math"
	slices "slices"
	unsafe "unsafe"
)

func cerbos_engine_v1_AuxData_hashpb_sum(m *v1.AuxData, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.engine.v1.AuxData.jwt"]; !ok {
		if len(m.Jwt) > 0 {
			for _, k := range slices.Sorted(maps.Keys(m.Jwt)) {
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(k))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(k), len(k)))
				if m.Jwt[k] != nil {
					google_protobuf_Value_hashpb_sum(m.Jwt[k], hasher, ignore)
				}
			}
		}
	}
}

func cerbos_engine_v1_CheckInput_hashpb_sum(m *v1.CheckInput, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.engine.v1.CheckInput.request_id"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetRequestId()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetRequestId()), len(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.AppendVarint(nil, uint64(len(v))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(v), len(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_OutputEntry_hashpb_sum(m *v1.OutputEntry, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.engine.v1.OutputEntry.src"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetSrc()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetSrc()), len(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_Principal_hashpb_sum(m *v1.Principal, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.engine.v1.Principal.id"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetId()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetId()), len(m.GetId())))
	}
	if _, ok := ignore["cerbos.engine.v1.Principal.policy_version"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetPolicyVersion()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetPolicyVersion()), len(m.GetPolicyVersion())))
	}
	if _, ok := ignore["cerbos.engine.v1.Principal.roles"]; !ok {
		if len(m.Roles) > 0 {
			for _, v := range m.Roles {
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(v))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(v), len(v)))
			}
		}
	}
	if _, ok := ignore["cerbos.engine.v1.Principal.attr"]; !ok {
		if len(m.Attr) > 0 {
			for _, k := range slices.Sorted(maps.Keys(m.Attr)) {
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(k))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(k), len(k)))
				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.AppendVarint(nil, uint64(len(m.GetScope()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetScope()), len(m.GetScope())))
	}
}

func cerbos_engine_v1_Resource_hashpb_sum(m *v1.Resource, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.engine.v1.Resource.kind"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetKind()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetKind()), len(m.GetKind())))
	}
	if _, ok := ignore["cerbos.engine.v1.Resource.policy_version"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetPolicyVersion()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetPolicyVersion()), len(m.GetPolicyVersion())))
	}
	if _, ok := ignore["cerbos.engine.v1.Resource.id"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetId()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetId()), len(m.GetId())))
	}
	if _, ok := ignore["cerbos.engine.v1.Resource.attr"]; !ok {
		if len(m.Attr) > 0 {
			for _, k := range slices.Sorted(maps.Keys(m.Attr)) {
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(k))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(k), len(k)))
				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.AppendVarint(nil, uint64(len(m.GetScope()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetScope()), len(m.GetScope())))
	}
}

func cerbos_engine_v1_Trace_Component_Variable_hashpb_sum(m *v1.Trace_Component_Variable, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.engine.v1.Trace.Component.Variable.name"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetName()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetName()), len(m.GetName())))
	}
	if _, ok := ignore["cerbos.engine.v1.Trace.Component.Variable.expr"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetExpr()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetExpr()), len(m.GetExpr())))
	}
}

func cerbos_engine_v1_Trace_Component_hashpb_sum(m *v1.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 *v1.Trace_Component_Action:
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(t.Action))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(t.Action), len(t.Action)))
			case *v1.Trace_Component_DerivedRole:
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(t.DerivedRole))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(t.DerivedRole), len(t.DerivedRole)))
			case *v1.Trace_Component_Expr:
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(t.Expr))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(t.Expr), len(t.Expr)))
			case *v1.Trace_Component_Index:
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(t.Index)))
			case *v1.Trace_Component_Policy:
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(t.Policy))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(t.Policy), len(t.Policy)))
			case *v1.Trace_Component_Resource:
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(t.Resource))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(t.Resource), len(t.Resource)))
			case *v1.Trace_Component_Rule:
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(t.Rule))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(t.Rule), len(t.Rule)))
			case *v1.Trace_Component_Scope:
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(t.Scope))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(t.Scope), len(t.Scope)))
			case *v1.Trace_Component_Variable_:
				if t.Variable != nil {
					cerbos_engine_v1_Trace_Component_Variable_hashpb_sum(t.Variable, hasher, ignore)
				}
			case *v1.Trace_Component_Output:
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(t.Output))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(t.Output), len(t.Output)))
			case *v1.Trace_Component_RolePolicyScope:
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(t.RolePolicyScope))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(t.RolePolicyScope), len(t.RolePolicyScope)))
			case *v1.Trace_Component_Role:
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(t.Role))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(t.Role), len(t.Role)))
			}
		}
	}
}

func cerbos_engine_v1_Trace_Event_hashpb_sum(m *v1.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.AppendVarint(nil, uint64(len(m.GetError()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetError()), len(m.GetError())))
	}
	if _, ok := ignore["cerbos.engine.v1.Trace.Event.message"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetMessage()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetMessage()), len(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 *v1.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 *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 *Condition_Match:
				if t.Match != nil {
					cerbos_policy_v1_Match_hashpb_sum(t.Match, hasher, ignore)
				}
			case *Condition_Script:
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(t.Script))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(t.Script), len(t.Script)))
			}
		}
	}
}

func cerbos_policy_v1_Constants_hashpb_sum(m *Constants, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.policy.v1.Constants.import"]; !ok {
		if len(m.Import) > 0 {
			for _, v := range m.Import {
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(v))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(v), len(v)))
			}
		}
	}
	if _, ok := ignore["cerbos.policy.v1.Constants.local"]; !ok {
		if len(m.Local) > 0 {
			for _, k := range slices.Sorted(maps.Keys(m.Local)) {
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(k))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(k), len(k)))
				if m.Local[k] != nil {
					google_protobuf_Value_hashpb_sum(m.Local[k], hasher, ignore)
				}
			}
		}
	}
}

func cerbos_policy_v1_DerivedRoles_hashpb_sum(m *DerivedRoles, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.policy.v1.DerivedRoles.name"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetName()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetName()), len(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)
		}
	}
	if _, ok := ignore["cerbos.policy.v1.DerivedRoles.constants"]; !ok {
		if m.GetConstants() != nil {
			cerbos_policy_v1_Constants_hashpb_sum(m.GetConstants(), hasher, ignore)
		}
	}
}

func cerbos_policy_v1_ExportConstants_hashpb_sum(m *ExportConstants, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.policy.v1.ExportConstants.name"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetName()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetName()), len(m.GetName())))
	}
	if _, ok := ignore["cerbos.policy.v1.ExportConstants.definitions"]; !ok {
		if len(m.Definitions) > 0 {
			for _, k := range slices.Sorted(maps.Keys(m.Definitions)) {
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(k))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(k), len(k)))
				if m.Definitions[k] != nil {
					google_protobuf_Value_hashpb_sum(m.Definitions[k], hasher, ignore)
				}
			}
		}
	}
}

func cerbos_policy_v1_ExportVariables_hashpb_sum(m *ExportVariables, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.policy.v1.ExportVariables.name"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetName()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetName()), len(m.GetName())))
	}
	if _, ok := ignore["cerbos.policy.v1.ExportVariables.definitions"]; !ok {
		if len(m.Definitions) > 0 {
			for _, k := range slices.Sorted(maps.Keys(m.Definitions)) {
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(k))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(k), len(k)))
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.Definitions[k]))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.Definitions[k]), len(m.Definitions[k])))
			}
		}
	}
}

func cerbos_policy_v1_Match_ExprList_hashpb_sum(m *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 *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 *Match_All:
				if t.All != nil {
					cerbos_policy_v1_Match_ExprList_hashpb_sum(t.All, hasher, ignore)
				}
			case *Match_Any:
				if t.Any != nil {
					cerbos_policy_v1_Match_ExprList_hashpb_sum(t.Any, hasher, ignore)
				}
			case *Match_None:
				if t.None != nil {
					cerbos_policy_v1_Match_ExprList_hashpb_sum(t.None, hasher, ignore)
				}
			case *Match_Expr:
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(t.Expr))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(t.Expr), len(t.Expr)))
			}
		}
	}
}

func cerbos_policy_v1_Metadata_hashpb_sum(m *Metadata, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.policy.v1.Metadata.source_file"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetSourceFile()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetSourceFile()), len(m.GetSourceFile())))
	}
	if _, ok := ignore["cerbos.policy.v1.Metadata.annotations"]; !ok {
		if len(m.Annotations) > 0 {
			for _, k := range slices.Sorted(maps.Keys(m.Annotations)) {
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(k))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(k), len(k)))
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.Annotations[k]))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.Annotations[k]), len(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.AppendVarint(nil, uint64(len(m.GetStoreIdentifer()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetStoreIdentifer()), len(m.GetStoreIdentifer())))
	}
	if _, ok := ignore["cerbos.policy.v1.Metadata.store_identifier"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetStoreIdentifier()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetStoreIdentifier()), len(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 *Output_When, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.policy.v1.Output.When.rule_activated"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetRuleActivated()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetRuleActivated()), len(m.GetRuleActivated())))
	}
	if _, ok := ignore["cerbos.policy.v1.Output.When.condition_not_met"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetConditionNotMet()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetConditionNotMet()), len(m.GetConditionNotMet())))
	}
}

func cerbos_policy_v1_Output_hashpb_sum(m *Output, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.policy.v1.Output.expr"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetExpr()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetExpr()), len(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 *Policy, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.policy.v1.Policy.api_version"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetApiVersion()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetApiVersion()), len(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.AppendVarint(nil, uint64(len(m.GetDescription()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetDescription()), len(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 *Policy_ResourcePolicy:
				if t.ResourcePolicy != nil {
					cerbos_policy_v1_ResourcePolicy_hashpb_sum(t.ResourcePolicy, hasher, ignore)
				}
			case *Policy_PrincipalPolicy:
				if t.PrincipalPolicy != nil {
					cerbos_policy_v1_PrincipalPolicy_hashpb_sum(t.PrincipalPolicy, hasher, ignore)
				}
			case *Policy_DerivedRoles:
				if t.DerivedRoles != nil {
					cerbos_policy_v1_DerivedRoles_hashpb_sum(t.DerivedRoles, hasher, ignore)
				}
			case *Policy_ExportVariables:
				if t.ExportVariables != nil {
					cerbos_policy_v1_ExportVariables_hashpb_sum(t.ExportVariables, hasher, ignore)
				}
			case *Policy_RolePolicy:
				if t.RolePolicy != nil {
					cerbos_policy_v1_RolePolicy_hashpb_sum(t.RolePolicy, hasher, ignore)
				}
			case *Policy_ExportConstants:
				if t.ExportConstants != nil {
					cerbos_policy_v1_ExportConstants_hashpb_sum(t.ExportConstants, hasher, ignore)
				}
			}
		}
	}
	if _, ok := ignore["cerbos.policy.v1.Policy.variables"]; !ok {
		if len(m.Variables) > 0 {
			for _, k := range slices.Sorted(maps.Keys(m.Variables)) {
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(k))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(k), len(k)))
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.Variables[k]))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.Variables[k]), len(m.Variables[k])))
			}
		}
	}
	if _, ok := ignore["cerbos.policy.v1.Policy.json_schema"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetJsonSchema()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetJsonSchema()), len(m.GetJsonSchema())))
	}
}

func cerbos_policy_v1_PrincipalPolicy_hashpb_sum(m *PrincipalPolicy, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.policy.v1.PrincipalPolicy.principal"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetPrincipal()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetPrincipal()), len(m.GetPrincipal())))
	}
	if _, ok := ignore["cerbos.policy.v1.PrincipalPolicy.version"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetVersion()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetVersion()), len(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.AppendVarint(nil, uint64(len(m.GetScope()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetScope()), len(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)
		}
	}
	if _, ok := ignore["cerbos.policy.v1.PrincipalPolicy.scope_permissions"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(m.GetScopePermissions())))
	}
	if _, ok := ignore["cerbos.policy.v1.PrincipalPolicy.constants"]; !ok {
		if m.GetConstants() != nil {
			cerbos_policy_v1_Constants_hashpb_sum(m.GetConstants(), hasher, ignore)
		}
	}
}

func cerbos_policy_v1_PrincipalRule_Action_hashpb_sum(m *PrincipalRule_Action, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.policy.v1.PrincipalRule.Action.action"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetAction()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetAction()), len(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.AppendVarint(nil, uint64(len(m.GetName()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetName()), len(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 *PrincipalRule, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.policy.v1.PrincipalRule.resource"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetResource()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetResource()), len(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 *ResourcePolicy, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.policy.v1.ResourcePolicy.resource"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetResource()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetResource()), len(m.GetResource())))
	}
	if _, ok := ignore["cerbos.policy.v1.ResourcePolicy.version"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetVersion()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetVersion()), len(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.AppendVarint(nil, uint64(len(v))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(v), len(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.AppendVarint(nil, uint64(len(m.GetScope()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetScope()), len(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)
		}
	}
	if _, ok := ignore["cerbos.policy.v1.ResourcePolicy.scope_permissions"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(m.GetScopePermissions())))
	}
	if _, ok := ignore["cerbos.policy.v1.ResourcePolicy.constants"]; !ok {
		if m.GetConstants() != nil {
			cerbos_policy_v1_Constants_hashpb_sum(m.GetConstants(), hasher, ignore)
		}
	}
}

func cerbos_policy_v1_ResourceRule_hashpb_sum(m *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.AppendVarint(nil, uint64(len(v))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(v), len(v)))
			}
		}
	}
	if _, ok := ignore["cerbos.policy.v1.ResourceRule.derived_roles"]; !ok {
		if len(m.DerivedRoles) > 0 {
			for _, v := range m.DerivedRoles {
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(v))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(v), len(v)))
			}
		}
	}
	if _, ok := ignore["cerbos.policy.v1.ResourceRule.roles"]; !ok {
		if len(m.Roles) > 0 {
			for _, v := range m.Roles {
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(v))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(v), len(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.AppendVarint(nil, uint64(len(m.GetName()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetName()), len(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 *RoleDef, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.policy.v1.RoleDef.name"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetName()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetName()), len(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.AppendVarint(nil, uint64(len(v))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(v), len(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_RolePolicy_hashpb_sum(m *RolePolicy, hasher hash.Hash, ignore map[string]struct{}) {
	if m.PolicyType != nil {
		if _, ok := ignore["cerbos.policy.v1.RolePolicy.policy_type"]; !ok {
			switch t := m.PolicyType.(type) {
			case *RolePolicy_Role:
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(t.Role))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(t.Role), len(t.Role)))
			}
		}
	}
	if _, ok := ignore["cerbos.policy.v1.RolePolicy.scope"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetScope()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetScope()), len(m.GetScope())))
	}
	if _, ok := ignore["cerbos.policy.v1.RolePolicy.rules"]; !ok {
		if len(m.Rules) > 0 {
			for _, v := range m.Rules {
				if v != nil {
					cerbos_policy_v1_RoleRule_hashpb_sum(v, hasher, ignore)
				}
			}
		}
	}
	if _, ok := ignore["cerbos.policy.v1.RolePolicy.scope_permissions"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(m.GetScopePermissions())))
	}
	if _, ok := ignore["cerbos.policy.v1.RolePolicy.parent_roles"]; !ok {
		if len(m.ParentRoles) > 0 {
			for _, v := range m.ParentRoles {
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(v))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(v), len(v)))
			}
		}
	}
}

func cerbos_policy_v1_RoleRule_hashpb_sum(m *RoleRule, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.policy.v1.RoleRule.resource"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetResource()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetResource()), len(m.GetResource())))
	}
	if _, ok := ignore["cerbos.policy.v1.RoleRule.allow_actions"]; !ok {
		if len(m.AllowActions) > 0 {
			for _, v := range m.AllowActions {
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(v))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(v), len(v)))
			}
		}
	}
	if _, ok := ignore["cerbos.policy.v1.RoleRule.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 *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.AppendVarint(nil, uint64(len(v))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(v), len(v)))
			}
		}
	}
}

func cerbos_policy_v1_Schemas_Schema_hashpb_sum(m *Schemas_Schema, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.policy.v1.Schemas.Schema.ref"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetRef()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetRef()), len(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 *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 *SourceAttributes, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.policy.v1.SourceAttributes.attributes"]; !ok {
		if len(m.Attributes) > 0 {
			for _, k := range slices.Sorted(maps.Keys(m.Attributes)) {
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(k))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(k), len(k)))
				if m.Attributes[k] != nil {
					google_protobuf_Value_hashpb_sum(m.Attributes[k], hasher, ignore)
				}
			}
		}
	}
}

func cerbos_policy_v1_TestFixtureGroup_Principals_hashpb_sum(m *TestFixtureGroup_Principals, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.policy.v1.TestFixtureGroup.Principals.principals"]; !ok {
		if len(m.Principals) > 0 {
			for _, v := range m.Principals {
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(v))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(v), len(v)))
			}
		}
	}
}

func cerbos_policy_v1_TestFixtureGroup_Resources_hashpb_sum(m *TestFixtureGroup_Resources, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.policy.v1.TestFixtureGroup.Resources.resources"]; !ok {
		if len(m.Resources) > 0 {
			for _, v := range m.Resources {
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(v))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(v), len(v)))
			}
		}
	}
}

func cerbos_policy_v1_TestFixtureGroup_hashpb_sum(m *TestFixtureGroup, hasher hash.Hash, ignore map[string]struct{}) {
}

func cerbos_policy_v1_TestFixture_hashpb_sum(m *TestFixture, hasher hash.Hash, ignore map[string]struct{}) {
}

func cerbos_policy_v1_TestOptions_hashpb_sum(m *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 {
			for _, k := range slices.Sorted(maps.Keys(m.Globals)) {
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(k))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(k), len(k)))
				if m.Globals[k] != nil {
					google_protobuf_Value_hashpb_sum(m.Globals[k], hasher, ignore)
				}
			}
		}
	}
	if _, ok := ignore["cerbos.policy.v1.TestOptions.default_policy_version"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetDefaultPolicyVersion()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetDefaultPolicyVersion()), len(m.GetDefaultPolicyVersion())))
	}
}

func cerbos_policy_v1_TestResults_Action_hashpb_sum(m *TestResults_Action, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.policy.v1.TestResults.Action.name"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetName()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetName()), len(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 *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 *TestResults_Details_Failure:
				if t.Failure != nil {
					cerbos_policy_v1_TestResults_Failure_hashpb_sum(t.Failure, hasher, ignore)
				}
			case *TestResults_Details_Error:
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(t.Error))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(t.Error), len(t.Error)))
			case *TestResults_Details_Success:
				if t.Success != nil {
					cerbos_policy_v1_TestResults_Success_hashpb_sum(t.Success, hasher, ignore)
				}
			case *TestResults_Details_SkipReason:
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(t.SkipReason))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(t.SkipReason), len(t.SkipReason)))
			}
		}
	}
	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 *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 *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 *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 *TestResults_OutputFailure, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.policy.v1.TestResults.OutputFailure.src"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetSrc()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetSrc()), len(m.GetSrc())))
	}
	if m.Outcome != nil {
		if _, ok := ignore["cerbos.policy.v1.TestResults.OutputFailure.outcome"]; !ok {
			switch t := m.Outcome.(type) {
			case *TestResults_OutputFailure_Mismatched:
				if t.Mismatched != nil {
					cerbos_policy_v1_TestResults_OutputFailure_MismatchedValue_hashpb_sum(t.Mismatched, hasher, ignore)
				}
			case *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 *TestResults_Principal, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.policy.v1.TestResults.Principal.name"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetName()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetName()), len(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 *TestResults_Resource, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.policy.v1.TestResults.Resource.name"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetName()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetName()), len(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 *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 *TestResults_Suite, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.policy.v1.TestResults.Suite.file"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetFile()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetFile()), len(m.GetFile())))
	}
	if _, ok := ignore["cerbos.policy.v1.TestResults.Suite.name"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetName()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetName()), len(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.AppendVarint(nil, uint64(len(m.GetError()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetError()), len(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.AppendVarint(nil, uint64(len(m.GetDescription()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetDescription()), len(m.GetDescription())))
	}
	if _, ok := ignore["cerbos.policy.v1.TestResults.Suite.skip_reason"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetSkipReason()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetSkipReason()), len(m.GetSkipReason())))
	}
}

func cerbos_policy_v1_TestResults_Summary_hashpb_sum(m *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 *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 *TestResults_TestCase, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.policy.v1.TestResults.TestCase.name"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetName()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetName()), len(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 *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_TestSuite_hashpb_sum(m *TestSuite, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.policy.v1.TestSuite.name"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetName()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetName()), len(m.GetName())))
	}
	if _, ok := ignore["cerbos.policy.v1.TestSuite.description"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetDescription()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetDescription()), len(m.GetDescription())))
	}
	if _, ok := ignore["cerbos.policy.v1.TestSuite.skip"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, protowire.EncodeBool(m.GetSkip())))
	}
	if _, ok := ignore["cerbos.policy.v1.TestSuite.skip_reason"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetSkipReason()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetSkipReason()), len(m.GetSkipReason())))
	}
	if _, ok := ignore["cerbos.policy.v1.TestSuite.tests"]; !ok {
		if len(m.Tests) > 0 {
			for _, v := range m.Tests {
				if v != nil {
					cerbos_policy_v1_TestTable_hashpb_sum(v, hasher, ignore)
				}
			}
		}
	}
	if _, ok := ignore["cerbos.policy.v1.TestSuite.principals"]; !ok {
		if len(m.Principals) > 0 {
			for _, k := range slices.Sorted(maps.Keys(m.Principals)) {
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(k))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(k), len(k)))
				if m.Principals[k] != nil {
					cerbos_engine_v1_Principal_hashpb_sum(m.Principals[k], hasher, ignore)
				}
			}
		}
	}
	if _, ok := ignore["cerbos.policy.v1.TestSuite.resources"]; !ok {
		if len(m.Resources) > 0 {
			for _, k := range slices.Sorted(maps.Keys(m.Resources)) {
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(k))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(k), len(k)))
				if m.Resources[k] != nil {
					cerbos_engine_v1_Resource_hashpb_sum(m.Resources[k], hasher, ignore)
				}
			}
		}
	}
	if _, ok := ignore["cerbos.policy.v1.TestSuite.aux_data"]; !ok {
		if len(m.AuxData) > 0 {
			for _, k := range slices.Sorted(maps.Keys(m.AuxData)) {
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(k))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(k), len(k)))
				if m.AuxData[k] != nil {
					cerbos_engine_v1_AuxData_hashpb_sum(m.AuxData[k], hasher, ignore)
				}
			}
		}
	}
	if _, ok := ignore["cerbos.policy.v1.TestSuite.options"]; !ok {
		if m.GetOptions() != nil {
			cerbos_policy_v1_TestOptions_hashpb_sum(m.GetOptions(), hasher, ignore)
		}
	}
	if _, ok := ignore["cerbos.policy.v1.TestSuite.json_schema"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetJsonSchema()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetJsonSchema()), len(m.GetJsonSchema())))
	}
	if _, ok := ignore["cerbos.policy.v1.TestSuite.principal_groups"]; !ok {
		if len(m.PrincipalGroups) > 0 {
			for _, k := range slices.Sorted(maps.Keys(m.PrincipalGroups)) {
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(k))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(k), len(k)))
				if m.PrincipalGroups[k] != nil {
					cerbos_policy_v1_TestFixtureGroup_Principals_hashpb_sum(m.PrincipalGroups[k], hasher, ignore)
				}
			}
		}
	}
	if _, ok := ignore["cerbos.policy.v1.TestSuite.resource_groups"]; !ok {
		if len(m.ResourceGroups) > 0 {
			for _, k := range slices.Sorted(maps.Keys(m.ResourceGroups)) {
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(k))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(k), len(k)))
				if m.ResourceGroups[k] != nil {
					cerbos_policy_v1_TestFixtureGroup_Resources_hashpb_sum(m.ResourceGroups[k], hasher, ignore)
				}
			}
		}
	}
}

func cerbos_policy_v1_TestTable_Expectation_hashpb_sum(m *TestTable_Expectation, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.policy.v1.TestTable.Expectation.principal"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetPrincipal()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetPrincipal()), len(m.GetPrincipal())))
	}
	if _, ok := ignore["cerbos.policy.v1.TestTable.Expectation.resource"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetResource()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetResource()), len(m.GetResource())))
	}
	if _, ok := ignore["cerbos.policy.v1.TestTable.Expectation.actions"]; !ok {
		if len(m.Actions) > 0 {
			for _, k := range slices.Sorted(maps.Keys(m.Actions)) {
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(k))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(k), len(k)))
				_, _ = 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)
				}
			}
		}
	}
	if _, ok := ignore["cerbos.policy.v1.TestTable.Expectation.principals"]; !ok {
		if len(m.Principals) > 0 {
			for _, v := range m.Principals {
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(v))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(v), len(v)))
			}
		}
	}
	if _, ok := ignore["cerbos.policy.v1.TestTable.Expectation.resources"]; !ok {
		if len(m.Resources) > 0 {
			for _, v := range m.Resources {
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(v))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(v), len(v)))
			}
		}
	}
	if _, ok := ignore["cerbos.policy.v1.TestTable.Expectation.principal_groups"]; !ok {
		if len(m.PrincipalGroups) > 0 {
			for _, v := range m.PrincipalGroups {
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(v))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(v), len(v)))
			}
		}
	}
	if _, ok := ignore["cerbos.policy.v1.TestTable.Expectation.resource_groups"]; !ok {
		if len(m.ResourceGroups) > 0 {
			for _, v := range m.ResourceGroups {
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(v))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(v), len(v)))
			}
		}
	}
}

func cerbos_policy_v1_TestTable_Input_hashpb_sum(m *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.AppendVarint(nil, uint64(len(v))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(v), len(v)))
			}
		}
	}
	if _, ok := ignore["cerbos.policy.v1.TestTable.Input.resources"]; !ok {
		if len(m.Resources) > 0 {
			for _, v := range m.Resources {
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(v))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(v), len(v)))
			}
		}
	}
	if _, ok := ignore["cerbos.policy.v1.TestTable.Input.actions"]; !ok {
		if len(m.Actions) > 0 {
			for _, v := range m.Actions {
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(v))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(v), len(v)))
			}
		}
	}
	if _, ok := ignore["cerbos.policy.v1.TestTable.Input.aux_data"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetAuxData()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetAuxData()), len(m.GetAuxData())))
	}
	if _, ok := ignore["cerbos.policy.v1.TestTable.Input.principal_groups"]; !ok {
		if len(m.PrincipalGroups) > 0 {
			for _, v := range m.PrincipalGroups {
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(v))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(v), len(v)))
			}
		}
	}
	if _, ok := ignore["cerbos.policy.v1.TestTable.Input.resource_groups"]; !ok {
		if len(m.ResourceGroups) > 0 {
			for _, v := range m.ResourceGroups {
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(v))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(v), len(v)))
			}
		}
	}
}

func cerbos_policy_v1_TestTable_OutputExpectations_hashpb_sum(m *TestTable_OutputExpectations, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.policy.v1.TestTable.OutputExpectations.action"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetAction()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetAction()), len(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 *TestTable, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.policy.v1.TestTable.name"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetName()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetName()), len(m.GetName())))
	}
	if _, ok := ignore["cerbos.policy.v1.TestTable.description"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetDescription()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetDescription()), len(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.AppendVarint(nil, uint64(len(m.GetSkipReason()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetSkipReason()), len(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 *Test_OutputEntries, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.policy.v1.Test.OutputEntries.entries"]; !ok {
		if len(m.Entries) > 0 {
			for _, k := range slices.Sorted(maps.Keys(m.Entries)) {
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(k))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(k), len(k)))
				if m.Entries[k] != nil {
					google_protobuf_Value_hashpb_sum(m.Entries[k], hasher, ignore)
				}
			}
		}
	}
}

func cerbos_policy_v1_Test_TestName_hashpb_sum(m *Test_TestName, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.policy.v1.Test.TestName.test_table_name"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetTestTableName()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetTestTableName()), len(m.GetTestTableName())))
	}
	if _, ok := ignore["cerbos.policy.v1.Test.TestName.principal_key"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetPrincipalKey()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetPrincipalKey()), len(m.GetPrincipalKey())))
	}
	if _, ok := ignore["cerbos.policy.v1.Test.TestName.resource_key"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetResourceKey()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetResourceKey()), len(m.GetResourceKey())))
	}
}

func cerbos_policy_v1_Test_hashpb_sum(m *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.AppendVarint(nil, uint64(len(m.GetDescription()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetDescription()), len(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.AppendVarint(nil, uint64(len(m.GetSkipReason()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetSkipReason()), len(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 {
			for _, k := range slices.Sorted(maps.Keys(m.Expected)) {
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(k))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(k), len(k)))
				_, _ = 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 {
			for _, k := range slices.Sorted(maps.Keys(m.ExpectedOutputs)) {
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(k))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(k), len(k)))
				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 *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.AppendVarint(nil, uint64(len(v))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(v), len(v)))
			}
		}
	}
	if _, ok := ignore["cerbos.policy.v1.Variables.local"]; !ok {
		if len(m.Local) > 0 {
			for _, k := range slices.Sorted(maps.Keys(m.Local)) {
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(k))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(k), len(k)))
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.Local[k]))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.Local[k]), len(m.Local[k])))
			}
		}
	}
}

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_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 {
			for _, k := range slices.Sorted(maps.Keys(m.Fields)) {
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(k))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(k), len(k)))
				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_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.AppendVarint(nil, uint64(len(t.StringValue))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(t.StringValue), len(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)
				}
			}
		}
	}
}
