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

package responsev1

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/schema/v1"
	protowire "google.golang.org/protobuf/encoding/protowire"
	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"
	maps "maps"
	math "math"
	slices "slices"
	unsafe "unsafe"
)

func cerbos_audit_v1_AccessLogEntry_hashpb_sum(m *v1.AccessLogEntry, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.audit.v1.AccessLogEntry.call_id"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetCallId()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetCallId()), len(m.GetCallId())))
	}
	if _, ok := ignore["cerbos.audit.v1.AccessLogEntry.timestamp"]; !ok {
		if m.GetTimestamp() != nil {
			google_protobuf_Timestamp_hashpb_sum(m.GetTimestamp(), hasher, ignore)
		}
	}
	if _, ok := ignore["cerbos.audit.v1.AccessLogEntry.peer"]; !ok {
		if m.GetPeer() != nil {
			cerbos_audit_v1_Peer_hashpb_sum(m.GetPeer(), hasher, ignore)
		}
	}
	if _, ok := ignore["cerbos.audit.v1.AccessLogEntry.metadata"]; !ok {
		if len(m.Metadata) > 0 {
			for _, k := range slices.Sorted(maps.Keys(m.Metadata)) {
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(k))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(k), len(k)))
				if m.Metadata[k] != nil {
					cerbos_audit_v1_MetaValues_hashpb_sum(m.Metadata[k], hasher, ignore)
				}
			}
		}
	}
	if _, ok := ignore["cerbos.audit.v1.AccessLogEntry.method"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetMethod()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetMethod()), len(m.GetMethod())))
	}
	if _, ok := ignore["cerbos.audit.v1.AccessLogEntry.status_code"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(m.GetStatusCode())))
	}
	if _, ok := ignore["cerbos.audit.v1.AccessLogEntry.oversized"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, protowire.EncodeBool(m.GetOversized())))
	}
	if _, ok := ignore["cerbos.audit.v1.AccessLogEntry.policy_source"]; !ok {
		if m.GetPolicySource() != nil {
			cerbos_audit_v1_PolicySource_hashpb_sum(m.GetPolicySource(), hasher, ignore)
		}
	}
}

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 {
			for _, k := range slices.Sorted(maps.Keys(m.EffectivePolicies)) {
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(k))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(k), len(k)))
				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.AppendVarint(nil, uint64(len(m.GetError()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetError()), len(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.AppendVarint(nil, uint64(len(m.GetError()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetError()), len(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.AppendVarint(nil, uint64(len(m.GetCallId()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetCallId()), len(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.AppendVarint(nil, uint64(len(m.GetError()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetError()), len(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 {
			for _, k := range slices.Sorted(maps.Keys(m.Metadata)) {
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(k))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(k), len(k)))
				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)
		}
	}
	if _, ok := ignore["cerbos.audit.v1.DecisionLogEntry.oversized"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, protowire.EncodeBool(m.GetOversized())))
	}
	if _, ok := ignore["cerbos.audit.v1.DecisionLogEntry.policy_source"]; !ok {
		if m.GetPolicySource() != nil {
			cerbos_audit_v1_PolicySource_hashpb_sum(m.GetPolicySource(), 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.AppendVarint(nil, uint64(len(v))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(v), len(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.AppendVarint(nil, uint64(len(m.GetAddress()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetAddress()), len(m.GetAddress())))
	}
	if _, ok := ignore["cerbos.audit.v1.Peer.auth_info"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetAuthInfo()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetAuthInfo()), len(m.GetAuthInfo())))
	}
	if _, ok := ignore["cerbos.audit.v1.Peer.user_agent"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetUserAgent()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetUserAgent()), len(m.GetUserAgent())))
	}
	if _, ok := ignore["cerbos.audit.v1.Peer.forwarded_for"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetForwardedFor()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetForwardedFor()), len(m.GetForwardedFor())))
	}
}

func cerbos_audit_v1_PolicySource_Blob_hashpb_sum(m *v1.PolicySource_Blob, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.audit.v1.PolicySource.Blob.bucket_url"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetBucketUrl()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetBucketUrl()), len(m.GetBucketUrl())))
	}
	if _, ok := ignore["cerbos.audit.v1.PolicySource.Blob.prefix"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetPrefix()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetPrefix()), len(m.GetPrefix())))
	}
}

func cerbos_audit_v1_PolicySource_Database_hashpb_sum(m *v1.PolicySource_Database, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.audit.v1.PolicySource.Database.driver"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(m.GetDriver())))
	}
}

func cerbos_audit_v1_PolicySource_Disk_hashpb_sum(m *v1.PolicySource_Disk, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.audit.v1.PolicySource.Disk.directory"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetDirectory()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetDirectory()), len(m.GetDirectory())))
	}
}

func cerbos_audit_v1_PolicySource_EmbeddedPDP_hashpb_sum(m *v1.PolicySource_EmbeddedPDP, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.audit.v1.PolicySource.EmbeddedPDP.url"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetUrl()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetUrl()), len(m.GetUrl())))
	}
	if _, ok := ignore["cerbos.audit.v1.PolicySource.EmbeddedPDP.commit_hash"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetCommitHash()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetCommitHash()), len(m.GetCommitHash())))
	}
	if _, ok := ignore["cerbos.audit.v1.PolicySource.EmbeddedPDP.built_at"]; !ok {
		if m.GetBuiltAt() != nil {
			google_protobuf_Timestamp_hashpb_sum(m.GetBuiltAt(), hasher, ignore)
		}
	}
}

func cerbos_audit_v1_PolicySource_Git_hashpb_sum(m *v1.PolicySource_Git, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.audit.v1.PolicySource.Git.repository_url"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetRepositoryUrl()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetRepositoryUrl()), len(m.GetRepositoryUrl())))
	}
	if _, ok := ignore["cerbos.audit.v1.PolicySource.Git.branch"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetBranch()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetBranch()), len(m.GetBranch())))
	}
	if _, ok := ignore["cerbos.audit.v1.PolicySource.Git.subdirectory"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetSubdirectory()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetSubdirectory()), len(m.GetSubdirectory())))
	}
}

func cerbos_audit_v1_PolicySource_Hub_LocalBundle_hashpb_sum(m *v1.PolicySource_Hub_LocalBundle, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.audit.v1.PolicySource.Hub.LocalBundle.path"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetPath()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetPath()), len(m.GetPath())))
	}
}

func cerbos_audit_v1_PolicySource_Hub_hashpb_sum(m *v1.PolicySource_Hub, hasher hash.Hash, ignore map[string]struct{}) {
	if m.Source != nil {
		if _, ok := ignore["cerbos.audit.v1.PolicySource.Hub.source"]; !ok {
			switch t := m.Source.(type) {
			case *v1.PolicySource_Hub_Label:
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(t.Label))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(t.Label), len(t.Label)))
			case *v1.PolicySource_Hub_DeploymentId:
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(t.DeploymentId))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(t.DeploymentId), len(t.DeploymentId)))
			case *v1.PolicySource_Hub_PlaygroundId:
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(t.PlaygroundId))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(t.PlaygroundId), len(t.PlaygroundId)))
			case *v1.PolicySource_Hub_LocalBundle_:
				if t.LocalBundle != nil {
					cerbos_audit_v1_PolicySource_Hub_LocalBundle_hashpb_sum(t.LocalBundle, hasher, ignore)
				}
			}
		}
	}
}

func cerbos_audit_v1_PolicySource_hashpb_sum(m *v1.PolicySource, hasher hash.Hash, ignore map[string]struct{}) {
	if m.Source != nil {
		if _, ok := ignore["cerbos.audit.v1.PolicySource.source"]; !ok {
			switch t := m.Source.(type) {
			case *v1.PolicySource_Blob_:
				if t.Blob != nil {
					cerbos_audit_v1_PolicySource_Blob_hashpb_sum(t.Blob, hasher, ignore)
				}
			case *v1.PolicySource_Database_:
				if t.Database != nil {
					cerbos_audit_v1_PolicySource_Database_hashpb_sum(t.Database, hasher, ignore)
				}
			case *v1.PolicySource_Disk_:
				if t.Disk != nil {
					cerbos_audit_v1_PolicySource_Disk_hashpb_sum(t.Disk, hasher, ignore)
				}
			case *v1.PolicySource_Git_:
				if t.Git != nil {
					cerbos_audit_v1_PolicySource_Git_hashpb_sum(t.Git, hasher, ignore)
				}
			case *v1.PolicySource_Hub_:
				if t.Hub != nil {
					cerbos_audit_v1_PolicySource_Hub_hashpb_sum(t.Hub, hasher, ignore)
				}
			case *v1.PolicySource_EmbeddedPdp:
				if t.EmbeddedPdp != nil {
					cerbos_audit_v1_PolicySource_EmbeddedPDP_hashpb_sum(t.EmbeddedPdp, hasher, ignore)
				}
			}
		}
	}
}

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 {
			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 *v11.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_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.AppendVarint(nil, uint64(len(m.GetPolicy()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetPolicy()), len(m.GetPolicy())))
	}
	if _, ok := ignore["cerbos.engine.v1.CheckOutput.ActionEffect.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_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.AppendVarint(nil, uint64(len(m.GetRequestId()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetRequestId()), len(m.GetRequestId())))
	}
	if _, ok := ignore["cerbos.engine.v1.CheckOutput.resource_id"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetResourceId()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetResourceId()), len(m.GetResourceId())))
	}
	if _, ok := ignore["cerbos.engine.v1.CheckOutput.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)))
				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.AppendVarint(nil, uint64(len(v))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(v), len(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.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_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.AppendVarint(nil, uint64(len(t.Variable))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(t.Variable), len(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.AppendVarint(nil, uint64(len(m.GetOperator()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetOperator()), len(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.AppendVarint(nil, uint64(len(m.GetKind()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetKind()), len(m.GetKind())))
	}
	if _, ok := ignore["cerbos.engine.v1.PlanResourcesInput.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.PlanResourcesInput.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.PlanResourcesInput.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_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.AppendVarint(nil, uint64(len(m.GetRequestId()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetRequestId()), len(m.GetRequestId())))
	}
	if _, ok := ignore["cerbos.engine.v1.PlanResourcesInput.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.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())))
	}
	if _, ok := ignore["cerbos.engine.v1.PlanResourcesInput.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_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.AppendVarint(nil, uint64(len(m.GetRequestId()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetRequestId()), len(m.GetRequestId())))
	}
	if _, ok := ignore["cerbos.engine.v1.PlanResourcesOutput.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.engine.v1.PlanResourcesOutput.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.PlanResourcesOutput.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.PlanResourcesOutput.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.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.AppendVarint(nil, uint64(len(m.GetFilterDebug()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetFilterDebug()), len(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)
				}
			}
		}
	}
	if _, ok := ignore["cerbos.engine.v1.PlanResourcesOutput.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.PlanResourcesOutput.matched_scopes"]; !ok {
		if len(m.MatchedScopes) > 0 {
			for _, k := range slices.Sorted(maps.Keys(m.MatchedScopes)) {
				_, _ = 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.MatchedScopes[k]))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.MatchedScopes[k]), len(m.MatchedScopes[k])))
			}
		}
	}
}

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.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 *v11.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 *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.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 *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.AppendVarint(nil, uint64(len(t.Action))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(t.Action), len(t.Action)))
			case *v11.Trace_Component_DerivedRole:
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(t.DerivedRole))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(t.DerivedRole), len(t.DerivedRole)))
			case *v11.Trace_Component_Expr:
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(t.Expr))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(t.Expr), len(t.Expr)))
			case *v11.Trace_Component_Index:
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(t.Index)))
			case *v11.Trace_Component_Policy:
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(t.Policy))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(t.Policy), len(t.Policy)))
			case *v11.Trace_Component_Resource:
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(t.Resource))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(t.Resource), len(t.Resource)))
			case *v11.Trace_Component_Rule:
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(t.Rule))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(t.Rule), len(t.Rule)))
			case *v11.Trace_Component_Scope:
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(t.Scope))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(t.Scope), len(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.AppendVarint(nil, uint64(len(t.Output))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(t.Output), len(t.Output)))
			case *v11.Trace_Component_RolePolicyScope:
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(t.RolePolicyScope))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(t.RolePolicyScope), len(t.RolePolicyScope)))
			case *v11.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 *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.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 *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.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 *v12.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 *v12.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 *v12.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 *v12.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 *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.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 *v12.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 *v12.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 *v12.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 *v12.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 *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)
				}
			case *v12.Policy_RolePolicy:
				if t.RolePolicy != nil {
					cerbos_policy_v1_RolePolicy_hashpb_sum(t.RolePolicy, hasher, ignore)
				}
			case *v12.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 *v12.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 *v12.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 *v12.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 *v12.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 *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.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 *v12.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 *v12.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 *v12.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 *v12.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 *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.AppendVarint(nil, uint64(len(v))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(v), len(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.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 *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 {
			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_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.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 *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.AppendVarint(nil, uint64(len(t.Error))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(t.Error), len(t.Error)))
			case *v12.TestResults_Details_Success:
				if t.Success != nil {
					cerbos_policy_v1_TestResults_Success_hashpb_sum(t.Success, hasher, ignore)
				}
			case *v12.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 *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.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 *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.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 *v12.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 *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.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 *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.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 *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_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.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 cerbos_response_v1_AddOrUpdatePolicyResponse_hashpb_sum(m *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 *AddOrUpdateSchemaResponse, hasher hash.Hash, ignore map[string]struct{}) {
}

func cerbos_response_v1_CheckResourceBatchResponse_ActionEffectMap_hashpb_sum(m *CheckResourceBatchResponse_ActionEffectMap, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.response.v1.CheckResourceBatchResponse.ActionEffectMap.resource_id"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetResourceId()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetResourceId()), len(m.GetResourceId())))
	}
	if _, ok := ignore["cerbos.response.v1.CheckResourceBatchResponse.ActionEffectMap.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.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 *CheckResourceBatchResponse, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.response.v1.CheckResourceBatchResponse.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.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 *CheckResourceSetResponse_ActionEffectMap, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.response.v1.CheckResourceSetResponse.ActionEffectMap.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.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 *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 {
			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)))
				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.AppendVarint(nil, uint64(len(v))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(v), len(v)))
			}
		}
	}
}

func cerbos_response_v1_CheckResourceSetResponse_Meta_EffectMeta_hashpb_sum(m *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.AppendVarint(nil, uint64(len(m.GetMatchedPolicy()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetMatchedPolicy()), len(m.GetMatchedPolicy())))
	}
	if _, ok := ignore["cerbos.response.v1.CheckResourceSetResponse.Meta.EffectMeta.matched_scope"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetMatchedScope()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetMatchedScope()), len(m.GetMatchedScope())))
	}
}

func cerbos_response_v1_CheckResourceSetResponse_Meta_hashpb_sum(m *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 {
			for _, k := range slices.Sorted(maps.Keys(m.ResourceInstances)) {
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(k))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(k), len(k)))
				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 *CheckResourceSetResponse, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.response.v1.CheckResourceSetResponse.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.response.v1.CheckResourceSetResponse.resource_instances"]; !ok {
		if len(m.ResourceInstances) > 0 {
			for _, k := range slices.Sorted(maps.Keys(m.ResourceInstances)) {
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(k))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(k), len(k)))
				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 *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.AppendVarint(nil, uint64(len(m.GetMatchedPolicy()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetMatchedPolicy()), len(m.GetMatchedPolicy())))
	}
	if _, ok := ignore["cerbos.response.v1.CheckResourcesResponse.ResultEntry.Meta.EffectMeta.matched_scope"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetMatchedScope()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetMatchedScope()), len(m.GetMatchedScope())))
	}
}

func cerbos_response_v1_CheckResourcesResponse_ResultEntry_Meta_hashpb_sum(m *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 {
			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)))
				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.AppendVarint(nil, uint64(len(v))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(v), len(v)))
			}
		}
	}
}

func cerbos_response_v1_CheckResourcesResponse_ResultEntry_Resource_hashpb_sum(m *CheckResourcesResponse_ResultEntry_Resource, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.response.v1.CheckResourcesResponse.ResultEntry.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.response.v1.CheckResourcesResponse.ResultEntry.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.response.v1.CheckResourcesResponse.ResultEntry.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.response.v1.CheckResourcesResponse.ResultEntry.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_response_v1_CheckResourcesResponse_ResultEntry_hashpb_sum(m *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 {
			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.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 *CheckResourcesResponse, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.response.v1.CheckResourcesResponse.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.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.AppendVarint(nil, uint64(len(m.GetCerbosCallId()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetCerbosCallId()), len(m.GetCerbosCallId())))
	}
}

func cerbos_response_v1_DeleteSchemaResponse_hashpb_sum(m *DeleteSchemaResponse, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.response.v1.DeleteSchemaResponse.deleted_schemas"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(m.GetDeletedSchemas())))
	}
}

func cerbos_response_v1_DisablePolicyResponse_hashpb_sum(m *DisablePolicyResponse, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.response.v1.DisablePolicyResponse.disabled_policies"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(m.GetDisabledPolicies())))
	}
}

func cerbos_response_v1_EnablePolicyResponse_hashpb_sum(m *EnablePolicyResponse, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.response.v1.EnablePolicyResponse.enabled_policies"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(m.GetEnabledPolicies())))
	}
}

func cerbos_response_v1_GetPolicyResponse_hashpb_sum(m *GetPolicyResponse, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.response.v1.GetPolicyResponse.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_response_v1_GetSchemaResponse_hashpb_sum(m *GetSchemaResponse, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.response.v1.GetSchemaResponse.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_response_v1_InspectPoliciesResponse_Attribute_hashpb_sum(m *InspectPoliciesResponse_Attribute, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.response.v1.InspectPoliciesResponse.Attribute.kind"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(m.GetKind())))
	}
	if _, ok := ignore["cerbos.response.v1.InspectPoliciesResponse.Attribute.name"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetName()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetName()), len(m.GetName())))
	}
}

func cerbos_response_v1_InspectPoliciesResponse_Constant_hashpb_sum(m *InspectPoliciesResponse_Constant, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.response.v1.InspectPoliciesResponse.Constant.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.response.v1.InspectPoliciesResponse.Constant.value"]; !ok {
		if m.GetValue() != nil {
			google_protobuf_Value_hashpb_sum(m.GetValue(), hasher, ignore)
		}
	}
	if _, ok := ignore["cerbos.response.v1.InspectPoliciesResponse.Constant.kind"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(m.GetKind())))
	}
	if _, ok := ignore["cerbos.response.v1.InspectPoliciesResponse.Constant.source"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetSource()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetSource()), len(m.GetSource())))
	}
	if _, ok := ignore["cerbos.response.v1.InspectPoliciesResponse.Constant.used"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, protowire.EncodeBool(m.GetUsed())))
	}
}

func cerbos_response_v1_InspectPoliciesResponse_DerivedRole_hashpb_sum(m *InspectPoliciesResponse_DerivedRole, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.response.v1.InspectPoliciesResponse.DerivedRole.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.response.v1.InspectPoliciesResponse.DerivedRole.kind"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(m.GetKind())))
	}
	if _, ok := ignore["cerbos.response.v1.InspectPoliciesResponse.DerivedRole.source"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetSource()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetSource()), len(m.GetSource())))
	}
}

func cerbos_response_v1_InspectPoliciesResponse_Result_hashpb_sum(m *InspectPoliciesResponse_Result, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.response.v1.InspectPoliciesResponse.Result.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.response.v1.InspectPoliciesResponse.Result.variables"]; !ok {
		if len(m.Variables) > 0 {
			for _, v := range m.Variables {
				if v != nil {
					cerbos_response_v1_InspectPoliciesResponse_Variable_hashpb_sum(v, hasher, ignore)
				}
			}
		}
	}
	if _, ok := ignore["cerbos.response.v1.InspectPoliciesResponse.Result.policy_id"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetPolicyId()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetPolicyId()), len(m.GetPolicyId())))
	}
	if _, ok := ignore["cerbos.response.v1.InspectPoliciesResponse.Result.derived_roles"]; !ok {
		if len(m.DerivedRoles) > 0 {
			for _, v := range m.DerivedRoles {
				if v != nil {
					cerbos_response_v1_InspectPoliciesResponse_DerivedRole_hashpb_sum(v, hasher, ignore)
				}
			}
		}
	}
	if _, ok := ignore["cerbos.response.v1.InspectPoliciesResponse.Result.attributes"]; !ok {
		if len(m.Attributes) > 0 {
			for _, v := range m.Attributes {
				if v != nil {
					cerbos_response_v1_InspectPoliciesResponse_Attribute_hashpb_sum(v, hasher, ignore)
				}
			}
		}
	}
	if _, ok := ignore["cerbos.response.v1.InspectPoliciesResponse.Result.constants"]; !ok {
		if len(m.Constants) > 0 {
			for _, v := range m.Constants {
				if v != nil {
					cerbos_response_v1_InspectPoliciesResponse_Constant_hashpb_sum(v, hasher, ignore)
				}
			}
		}
	}
}

func cerbos_response_v1_InspectPoliciesResponse_Variable_hashpb_sum(m *InspectPoliciesResponse_Variable, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.response.v1.InspectPoliciesResponse.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.response.v1.InspectPoliciesResponse.Variable.value"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetValue()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetValue()), len(m.GetValue())))
	}
	if _, ok := ignore["cerbos.response.v1.InspectPoliciesResponse.Variable.kind"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(m.GetKind())))
	}
	if _, ok := ignore["cerbos.response.v1.InspectPoliciesResponse.Variable.source"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetSource()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetSource()), len(m.GetSource())))
	}
	if _, ok := ignore["cerbos.response.v1.InspectPoliciesResponse.Variable.used"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, protowire.EncodeBool(m.GetUsed())))
	}
}

func cerbos_response_v1_InspectPoliciesResponse_hashpb_sum(m *InspectPoliciesResponse, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.response.v1.InspectPoliciesResponse.results"]; !ok {
		if len(m.Results) > 0 {
			for _, k := range slices.Sorted(maps.Keys(m.Results)) {
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(k))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(k), len(k)))
				if m.Results[k] != nil {
					cerbos_response_v1_InspectPoliciesResponse_Result_hashpb_sum(m.Results[k], hasher, ignore)
				}
			}
		}
	}
}

func cerbos_response_v1_ListAuditLogEntriesResponse_hashpb_sum(m *ListAuditLogEntriesResponse, hasher hash.Hash, ignore map[string]struct{}) {
	if m.Entry != nil {
		if _, ok := ignore["cerbos.response.v1.ListAuditLogEntriesResponse.entry"]; !ok {
			switch t := m.Entry.(type) {
			case *ListAuditLogEntriesResponse_AccessLogEntry:
				if t.AccessLogEntry != nil {
					cerbos_audit_v1_AccessLogEntry_hashpb_sum(t.AccessLogEntry, hasher, ignore)
				}
			case *ListAuditLogEntriesResponse_DecisionLogEntry:
				if t.DecisionLogEntry != nil {
					cerbos_audit_v1_DecisionLogEntry_hashpb_sum(t.DecisionLogEntry, hasher, ignore)
				}
			}
		}
	}
}

func cerbos_response_v1_ListPoliciesResponse_hashpb_sum(m *ListPoliciesResponse, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.response.v1.ListPoliciesResponse.policy_ids"]; !ok {
		if len(m.PolicyIds) > 0 {
			for _, v := range m.PolicyIds {
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(v))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(v), len(v)))
			}
		}
	}
}

func cerbos_response_v1_ListSchemasResponse_hashpb_sum(m *ListSchemasResponse, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.response.v1.ListSchemasResponse.schema_ids"]; !ok {
		if len(m.SchemaIds) > 0 {
			for _, v := range m.SchemaIds {
				_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(v))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(v), len(v)))
			}
		}
	}
}

func cerbos_response_v1_PlanResourcesResponse_Meta_hashpb_sum(m *PlanResourcesResponse_Meta, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.response.v1.PlanResourcesResponse.Meta.filter_debug"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetFilterDebug()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetFilterDebug()), len(m.GetFilterDebug())))
	}
	if _, ok := ignore["cerbos.response.v1.PlanResourcesResponse.Meta.matched_scope"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetMatchedScope()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetMatchedScope()), len(m.GetMatchedScope())))
	}
	if _, ok := ignore["cerbos.response.v1.PlanResourcesResponse.Meta.matched_scopes"]; !ok {
		if len(m.MatchedScopes) > 0 {
			for _, k := range slices.Sorted(maps.Keys(m.MatchedScopes)) {
				_, _ = 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.MatchedScopes[k]))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.MatchedScopes[k]), len(m.MatchedScopes[k])))
			}
		}
	}
}

func cerbos_response_v1_PlanResourcesResponse_hashpb_sum(m *PlanResourcesResponse, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.response.v1.PlanResourcesResponse.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.response.v1.PlanResourcesResponse.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.response.v1.PlanResourcesResponse.resource_kind"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetResourceKind()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetResourceKind()), len(m.GetResourceKind())))
	}
	if _, ok := ignore["cerbos.response.v1.PlanResourcesResponse.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.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.AppendVarint(nil, uint64(len(m.GetCerbosCallId()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetCerbosCallId()), len(m.GetCerbosCallId())))
	}
	if _, ok := ignore["cerbos.response.v1.PlanResourcesResponse.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_response_v1_PlaygroundEvaluateResponse_EvalResultList_hashpb_sum(m *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.AppendVarint(nil, uint64(len(v))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(v), len(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 *PlaygroundEvaluateResponse_EvalResult, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.response.v1.PlaygroundEvaluateResponse.EvalResult.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.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.AppendVarint(nil, uint64(len(m.GetPolicy()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetPolicy()), len(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.AppendVarint(nil, uint64(len(v))))
				_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(v), len(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 *PlaygroundEvaluateResponse, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.response.v1.PlaygroundEvaluateResponse.playground_id"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetPlaygroundId()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetPlaygroundId()), len(m.GetPlaygroundId())))
	}
	if m.Outcome != nil {
		if _, ok := ignore["cerbos.response.v1.PlaygroundEvaluateResponse.outcome"]; !ok {
			switch t := m.Outcome.(type) {
			case *PlaygroundEvaluateResponse_Failure:
				if t.Failure != nil {
					cerbos_response_v1_PlaygroundFailure_hashpb_sum(t.Failure, hasher, ignore)
				}
			case *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 *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.AppendVarint(nil, uint64(len(m.GetContext()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetContext()), len(m.GetContext())))
	}
}

func cerbos_response_v1_PlaygroundFailure_Error_hashpb_sum(m *PlaygroundFailure_Error, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.response.v1.PlaygroundFailure.Error.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.response.v1.PlaygroundFailure.Error.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.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 *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 *PlaygroundProxyResponse, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.response.v1.PlaygroundProxyResponse.playground_id"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetPlaygroundId()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetPlaygroundId()), len(m.GetPlaygroundId())))
	}
	if m.Outcome != nil {
		if _, ok := ignore["cerbos.response.v1.PlaygroundProxyResponse.outcome"]; !ok {
			switch t := m.Outcome.(type) {
			case *PlaygroundProxyResponse_Failure:
				if t.Failure != nil {
					cerbos_response_v1_PlaygroundFailure_hashpb_sum(t.Failure, hasher, ignore)
				}
			case *PlaygroundProxyResponse_CheckResourceSet:
				if t.CheckResourceSet != nil {
					cerbos_response_v1_CheckResourceSetResponse_hashpb_sum(t.CheckResourceSet, hasher, ignore)
				}
			case *PlaygroundProxyResponse_CheckResourceBatch:
				if t.CheckResourceBatch != nil {
					cerbos_response_v1_CheckResourceBatchResponse_hashpb_sum(t.CheckResourceBatch, hasher, ignore)
				}
			case *PlaygroundProxyResponse_PlanResources:
				if t.PlanResources != nil {
					cerbos_response_v1_PlanResourcesResponse_hashpb_sum(t.PlanResources, hasher, ignore)
				}
			case *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 *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 *PlaygroundTestResponse, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.response.v1.PlaygroundTestResponse.playground_id"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetPlaygroundId()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetPlaygroundId()), len(m.GetPlaygroundId())))
	}
	if m.Outcome != nil {
		if _, ok := ignore["cerbos.response.v1.PlaygroundTestResponse.outcome"]; !ok {
			switch t := m.Outcome.(type) {
			case *PlaygroundTestResponse_Failure:
				if t.Failure != nil {
					cerbos_response_v1_PlaygroundFailure_hashpb_sum(t.Failure, hasher, ignore)
				}
			case *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 *PlaygroundValidateResponse, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.response.v1.PlaygroundValidateResponse.playground_id"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetPlaygroundId()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetPlaygroundId()), len(m.GetPlaygroundId())))
	}
	if m.Outcome != nil {
		if _, ok := ignore["cerbos.response.v1.PlaygroundValidateResponse.outcome"]; !ok {
			switch t := m.Outcome.(type) {
			case *PlaygroundValidateResponse_Failure:
				if t.Failure != nil {
					cerbos_response_v1_PlaygroundFailure_hashpb_sum(t.Failure, hasher, ignore)
				}
			case *PlaygroundValidateResponse_Success:
				if t.Success != nil {
					google_protobuf_Empty_hashpb_sum(t.Success, hasher, ignore)
				}
			}
		}
	}
}

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

func cerbos_response_v1_ServerInfoResponse_hashpb_sum(m *ServerInfoResponse, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.response.v1.ServerInfoResponse.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.response.v1.ServerInfoResponse.commit"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetCommit()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetCommit()), len(m.GetCommit())))
	}
	if _, ok := ignore["cerbos.response.v1.ServerInfoResponse.build_date"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetBuildDate()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetBuildDate()), len(m.GetBuildDate())))
	}
}

func cerbos_schema_v1_Schema_hashpb_sum(m *v13.Schema, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.schema.v1.Schema.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.schema.v1.Schema.definition"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetDefinition()))))
		_, _ = hasher.Write(m.GetDefinition())
	}
}

func cerbos_schema_v1_ValidationError_hashpb_sum(m *v13.ValidationError, hasher hash.Hash, ignore map[string]struct{}) {
	if _, ok := ignore["cerbos.schema.v1.ValidationError.path"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(len(m.GetPath()))))
		_, _ = hasher.Write(unsafe.Slice(unsafe.StringData(m.GetPath()), len(m.GetPath())))
	}
	if _, ok := ignore["cerbos.schema.v1.ValidationError.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.schema.v1.ValidationError.source"]; !ok {
		_, _ = hasher.Write(protowire.AppendVarint(nil, uint64(m.GetSource())))
	}
}

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

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)
				}
			}
		}
	}
}
