entql.go

// Code generated by ent, DO NOT EDIT.

package generated

import (
	"github.com/datumforge/datum/internal/ent/generated/emailverificationtoken"
	"github.com/datumforge/datum/internal/ent/generated/entitlement"
	"github.com/datumforge/datum/internal/ent/generated/group"
	"github.com/datumforge/datum/internal/ent/generated/groupsetting"
	"github.com/datumforge/datum/internal/ent/generated/integration"
	"github.com/datumforge/datum/internal/ent/generated/oauthprovider"
	"github.com/datumforge/datum/internal/ent/generated/ohauthtootoken"
	"github.com/datumforge/datum/internal/ent/generated/organization"
	"github.com/datumforge/datum/internal/ent/generated/organizationsetting"
	"github.com/datumforge/datum/internal/ent/generated/personalaccesstoken"
	"github.com/datumforge/datum/internal/ent/generated/predicate"
	"github.com/datumforge/datum/internal/ent/generated/session"
	"github.com/datumforge/datum/internal/ent/generated/user"
	"github.com/datumforge/datum/internal/ent/generated/usersetting"

	"entgo.io/ent/dialect/sql"
	"entgo.io/ent/dialect/sql/sqlgraph"
	"entgo.io/ent/entql"
	"entgo.io/ent/schema/field"
)

// schemaGraph holds a representation of ent/schema at runtime.
var schemaGraph = func() *sqlgraph.Schema {
	graph := &sqlgraph.Schema{Nodes: make([]*sqlgraph.Node, 13)}
	graph.Nodes[0] = &sqlgraph.Node{
		NodeSpec: sqlgraph.NodeSpec{
			Table:   emailverificationtoken.Table,
			Columns: emailverificationtoken.Columns,
			ID: &sqlgraph.FieldSpec{
				Type:   field.TypeString,
				Column: emailverificationtoken.FieldID,
			},
		},
		Type: "EmailVerificationToken",
		Fields: map[string]*sqlgraph.FieldSpec{
			emailverificationtoken.FieldCreatedAt: {Type: field.TypeTime, Column: emailverificationtoken.FieldCreatedAt},
			emailverificationtoken.FieldUpdatedAt: {Type: field.TypeTime, Column: emailverificationtoken.FieldUpdatedAt},
			emailverificationtoken.FieldCreatedBy: {Type: field.TypeString, Column: emailverificationtoken.FieldCreatedBy},
			emailverificationtoken.FieldUpdatedBy: {Type: field.TypeString, Column: emailverificationtoken.FieldUpdatedBy},
			emailverificationtoken.FieldDeletedAt: {Type: field.TypeTime, Column: emailverificationtoken.FieldDeletedAt},
			emailverificationtoken.FieldDeletedBy: {Type: field.TypeString, Column: emailverificationtoken.FieldDeletedBy},
			emailverificationtoken.FieldToken:     {Type: field.TypeString, Column: emailverificationtoken.FieldToken},
			emailverificationtoken.FieldTTL:       {Type: field.TypeTime, Column: emailverificationtoken.FieldTTL},
			emailverificationtoken.FieldEmail:     {Type: field.TypeString, Column: emailverificationtoken.FieldEmail},
			emailverificationtoken.FieldSecret:    {Type: field.TypeBytes, Column: emailverificationtoken.FieldSecret},
		},
	}
	graph.Nodes[1] = &sqlgraph.Node{
		NodeSpec: sqlgraph.NodeSpec{
			Table:   entitlement.Table,
			Columns: entitlement.Columns,
			ID: &sqlgraph.FieldSpec{
				Type:   field.TypeString,
				Column: entitlement.FieldID,
			},
		},
		Type: "Entitlement",
		Fields: map[string]*sqlgraph.FieldSpec{
			entitlement.FieldCreatedAt:              {Type: field.TypeTime, Column: entitlement.FieldCreatedAt},
			entitlement.FieldUpdatedAt:              {Type: field.TypeTime, Column: entitlement.FieldUpdatedAt},
			entitlement.FieldCreatedBy:              {Type: field.TypeString, Column: entitlement.FieldCreatedBy},
			entitlement.FieldUpdatedBy:              {Type: field.TypeString, Column: entitlement.FieldUpdatedBy},
			entitlement.FieldDeletedAt:              {Type: field.TypeTime, Column: entitlement.FieldDeletedAt},
			entitlement.FieldDeletedBy:              {Type: field.TypeString, Column: entitlement.FieldDeletedBy},
			entitlement.FieldTier:                   {Type: field.TypeEnum, Column: entitlement.FieldTier},
			entitlement.FieldExternalCustomerID:     {Type: field.TypeString, Column: entitlement.FieldExternalCustomerID},
			entitlement.FieldExternalSubscriptionID: {Type: field.TypeString, Column: entitlement.FieldExternalSubscriptionID},
			entitlement.FieldExpires:                {Type: field.TypeBool, Column: entitlement.FieldExpires},
			entitlement.FieldExpiresAt:              {Type: field.TypeTime, Column: entitlement.FieldExpiresAt},
			entitlement.FieldCancelled:              {Type: field.TypeBool, Column: entitlement.FieldCancelled},
		},
	}
	graph.Nodes[2] = &sqlgraph.Node{
		NodeSpec: sqlgraph.NodeSpec{
			Table:   group.Table,
			Columns: group.Columns,
			ID: &sqlgraph.FieldSpec{
				Type:   field.TypeString,
				Column: group.FieldID,
			},
		},
		Type: "Group",
		Fields: map[string]*sqlgraph.FieldSpec{
			group.FieldCreatedAt:       {Type: field.TypeTime, Column: group.FieldCreatedAt},
			group.FieldUpdatedAt:       {Type: field.TypeTime, Column: group.FieldUpdatedAt},
			group.FieldCreatedBy:       {Type: field.TypeString, Column: group.FieldCreatedBy},
			group.FieldUpdatedBy:       {Type: field.TypeString, Column: group.FieldUpdatedBy},
			group.FieldDeletedAt:       {Type: field.TypeTime, Column: group.FieldDeletedAt},
			group.FieldDeletedBy:       {Type: field.TypeString, Column: group.FieldDeletedBy},
			group.FieldName:            {Type: field.TypeString, Column: group.FieldName},
			group.FieldDescription:     {Type: field.TypeString, Column: group.FieldDescription},
			group.FieldGravatarLogoURL: {Type: field.TypeString, Column: group.FieldGravatarLogoURL},
			group.FieldLogoURL:         {Type: field.TypeString, Column: group.FieldLogoURL},
			group.FieldDisplayName:     {Type: field.TypeString, Column: group.FieldDisplayName},
		},
	}
	graph.Nodes[3] = &sqlgraph.Node{
		NodeSpec: sqlgraph.NodeSpec{
			Table:   groupsetting.Table,
			Columns: groupsetting.Columns,
			ID: &sqlgraph.FieldSpec{
				Type:   field.TypeString,
				Column: groupsetting.FieldID,
			},
		},
		Type: "GroupSetting",
		Fields: map[string]*sqlgraph.FieldSpec{
			groupsetting.FieldCreatedAt:    {Type: field.TypeTime, Column: groupsetting.FieldCreatedAt},
			groupsetting.FieldUpdatedAt:    {Type: field.TypeTime, Column: groupsetting.FieldUpdatedAt},
			groupsetting.FieldCreatedBy:    {Type: field.TypeString, Column: groupsetting.FieldCreatedBy},
			groupsetting.FieldUpdatedBy:    {Type: field.TypeString, Column: groupsetting.FieldUpdatedBy},
			groupsetting.FieldDeletedAt:    {Type: field.TypeTime, Column: groupsetting.FieldDeletedAt},
			groupsetting.FieldDeletedBy:    {Type: field.TypeString, Column: groupsetting.FieldDeletedBy},
			groupsetting.FieldVisibility:   {Type: field.TypeEnum, Column: groupsetting.FieldVisibility},
			groupsetting.FieldJoinPolicy:   {Type: field.TypeEnum, Column: groupsetting.FieldJoinPolicy},
			groupsetting.FieldTags:         {Type: field.TypeJSON, Column: groupsetting.FieldTags},
			groupsetting.FieldSyncToSlack:  {Type: field.TypeBool, Column: groupsetting.FieldSyncToSlack},
			groupsetting.FieldSyncToGithub: {Type: field.TypeBool, Column: groupsetting.FieldSyncToGithub},
		},
	}
	graph.Nodes[4] = &sqlgraph.Node{
		NodeSpec: sqlgraph.NodeSpec{
			Table:   integration.Table,
			Columns: integration.Columns,
			ID: &sqlgraph.FieldSpec{
				Type:   field.TypeString,
				Column: integration.FieldID,
			},
		},
		Type: "Integration",
		Fields: map[string]*sqlgraph.FieldSpec{
			integration.FieldCreatedAt:   {Type: field.TypeTime, Column: integration.FieldCreatedAt},
			integration.FieldUpdatedAt:   {Type: field.TypeTime, Column: integration.FieldUpdatedAt},
			integration.FieldCreatedBy:   {Type: field.TypeString, Column: integration.FieldCreatedBy},
			integration.FieldUpdatedBy:   {Type: field.TypeString, Column: integration.FieldUpdatedBy},
			integration.FieldDeletedAt:   {Type: field.TypeTime, Column: integration.FieldDeletedAt},
			integration.FieldDeletedBy:   {Type: field.TypeString, Column: integration.FieldDeletedBy},
			integration.FieldName:        {Type: field.TypeString, Column: integration.FieldName},
			integration.FieldDescription: {Type: field.TypeString, Column: integration.FieldDescription},
			integration.FieldKind:        {Type: field.TypeString, Column: integration.FieldKind},
			integration.FieldSecretName:  {Type: field.TypeString, Column: integration.FieldSecretName},
		},
	}
	graph.Nodes[5] = &sqlgraph.Node{
		NodeSpec: sqlgraph.NodeSpec{
			Table:   oauthprovider.Table,
			Columns: oauthprovider.Columns,
			ID: &sqlgraph.FieldSpec{
				Type:   field.TypeString,
				Column: oauthprovider.FieldID,
			},
		},
		Type: "OauthProvider",
		Fields: map[string]*sqlgraph.FieldSpec{
			oauthprovider.FieldCreatedAt:    {Type: field.TypeTime, Column: oauthprovider.FieldCreatedAt},
			oauthprovider.FieldUpdatedAt:    {Type: field.TypeTime, Column: oauthprovider.FieldUpdatedAt},
			oauthprovider.FieldCreatedBy:    {Type: field.TypeString, Column: oauthprovider.FieldCreatedBy},
			oauthprovider.FieldUpdatedBy:    {Type: field.TypeString, Column: oauthprovider.FieldUpdatedBy},
			oauthprovider.FieldDeletedAt:    {Type: field.TypeTime, Column: oauthprovider.FieldDeletedAt},
			oauthprovider.FieldDeletedBy:    {Type: field.TypeString, Column: oauthprovider.FieldDeletedBy},
			oauthprovider.FieldName:         {Type: field.TypeString, Column: oauthprovider.FieldName},
			oauthprovider.FieldClientID:     {Type: field.TypeString, Column: oauthprovider.FieldClientID},
			oauthprovider.FieldClientSecret: {Type: field.TypeString, Column: oauthprovider.FieldClientSecret},
			oauthprovider.FieldRedirectURL:  {Type: field.TypeString, Column: oauthprovider.FieldRedirectURL},
			oauthprovider.FieldScopes:       {Type: field.TypeString, Column: oauthprovider.FieldScopes},
			oauthprovider.FieldAuthURL:      {Type: field.TypeString, Column: oauthprovider.FieldAuthURL},
			oauthprovider.FieldTokenURL:     {Type: field.TypeString, Column: oauthprovider.FieldTokenURL},
			oauthprovider.FieldAuthStyle:    {Type: field.TypeUint8, Column: oauthprovider.FieldAuthStyle},
			oauthprovider.FieldInfoURL:      {Type: field.TypeString, Column: oauthprovider.FieldInfoURL},
		},
	}
	graph.Nodes[6] = &sqlgraph.Node{
		NodeSpec: sqlgraph.NodeSpec{
			Table:   ohauthtootoken.Table,
			Columns: ohauthtootoken.Columns,
			ID: &sqlgraph.FieldSpec{
				Type:   field.TypeString,
				Column: ohauthtootoken.FieldID,
			},
		},
		Type: "OhAuthTooToken",
		Fields: map[string]*sqlgraph.FieldSpec{
			ohauthtootoken.FieldClientID:                {Type: field.TypeString, Column: ohauthtootoken.FieldClientID},
			ohauthtootoken.FieldScopes:                  {Type: field.TypeJSON, Column: ohauthtootoken.FieldScopes},
			ohauthtootoken.FieldNonce:                   {Type: field.TypeString, Column: ohauthtootoken.FieldNonce},
			ohauthtootoken.FieldClaimsUserID:            {Type: field.TypeString, Column: ohauthtootoken.FieldClaimsUserID},
			ohauthtootoken.FieldClaimsUsername:          {Type: field.TypeString, Column: ohauthtootoken.FieldClaimsUsername},
			ohauthtootoken.FieldClaimsEmail:             {Type: field.TypeString, Column: ohauthtootoken.FieldClaimsEmail},
			ohauthtootoken.FieldClaimsEmailVerified:     {Type: field.TypeBool, Column: ohauthtootoken.FieldClaimsEmailVerified},
			ohauthtootoken.FieldClaimsGroups:            {Type: field.TypeJSON, Column: ohauthtootoken.FieldClaimsGroups},
			ohauthtootoken.FieldClaimsPreferredUsername: {Type: field.TypeString, Column: ohauthtootoken.FieldClaimsPreferredUsername},
			ohauthtootoken.FieldConnectorID:             {Type: field.TypeString, Column: ohauthtootoken.FieldConnectorID},
			ohauthtootoken.FieldConnectorData:           {Type: field.TypeJSON, Column: ohauthtootoken.FieldConnectorData},
			ohauthtootoken.FieldLastUsed:                {Type: field.TypeTime, Column: ohauthtootoken.FieldLastUsed},
		},
	}
	graph.Nodes[7] = &sqlgraph.Node{
		NodeSpec: sqlgraph.NodeSpec{
			Table:   organization.Table,
			Columns: organization.Columns,
			ID: &sqlgraph.FieldSpec{
				Type:   field.TypeString,
				Column: organization.FieldID,
			},
		},
		Type: "Organization",
		Fields: map[string]*sqlgraph.FieldSpec{
			organization.FieldCreatedAt:            {Type: field.TypeTime, Column: organization.FieldCreatedAt},
			organization.FieldUpdatedAt:            {Type: field.TypeTime, Column: organization.FieldUpdatedAt},
			organization.FieldCreatedBy:            {Type: field.TypeString, Column: organization.FieldCreatedBy},
			organization.FieldUpdatedBy:            {Type: field.TypeString, Column: organization.FieldUpdatedBy},
			organization.FieldDeletedAt:            {Type: field.TypeTime, Column: organization.FieldDeletedAt},
			organization.FieldDeletedBy:            {Type: field.TypeString, Column: organization.FieldDeletedBy},
			organization.FieldName:                 {Type: field.TypeString, Column: organization.FieldName},
			organization.FieldDisplayName:          {Type: field.TypeString, Column: organization.FieldDisplayName},
			organization.FieldDescription:          {Type: field.TypeString, Column: organization.FieldDescription},
			organization.FieldParentOrganizationID: {Type: field.TypeString, Column: organization.FieldParentOrganizationID},
			organization.FieldPersonalOrg:          {Type: field.TypeBool, Column: organization.FieldPersonalOrg},
		},
	}
	graph.Nodes[8] = &sqlgraph.Node{
		NodeSpec: sqlgraph.NodeSpec{
			Table:   organizationsetting.Table,
			Columns: organizationsetting.Columns,
			ID: &sqlgraph.FieldSpec{
				Type:   field.TypeString,
				Column: organizationsetting.FieldID,
			},
		},
		Type: "OrganizationSetting",
		Fields: map[string]*sqlgraph.FieldSpec{
			organizationsetting.FieldCreatedAt:      {Type: field.TypeTime, Column: organizationsetting.FieldCreatedAt},
			organizationsetting.FieldUpdatedAt:      {Type: field.TypeTime, Column: organizationsetting.FieldUpdatedAt},
			organizationsetting.FieldCreatedBy:      {Type: field.TypeString, Column: organizationsetting.FieldCreatedBy},
			organizationsetting.FieldUpdatedBy:      {Type: field.TypeString, Column: organizationsetting.FieldUpdatedBy},
			organizationsetting.FieldDeletedAt:      {Type: field.TypeTime, Column: organizationsetting.FieldDeletedAt},
			organizationsetting.FieldDeletedBy:      {Type: field.TypeString, Column: organizationsetting.FieldDeletedBy},
			organizationsetting.FieldDomains:        {Type: field.TypeJSON, Column: organizationsetting.FieldDomains},
			organizationsetting.FieldSSOCert:        {Type: field.TypeString, Column: organizationsetting.FieldSSOCert},
			organizationsetting.FieldSSOEntrypoint:  {Type: field.TypeString, Column: organizationsetting.FieldSSOEntrypoint},
			organizationsetting.FieldSSOIssuer:      {Type: field.TypeString, Column: organizationsetting.FieldSSOIssuer},
			organizationsetting.FieldBillingContact: {Type: field.TypeString, Column: organizationsetting.FieldBillingContact},
			organizationsetting.FieldBillingEmail:   {Type: field.TypeString, Column: organizationsetting.FieldBillingEmail},
			organizationsetting.FieldBillingPhone:   {Type: field.TypeString, Column: organizationsetting.FieldBillingPhone},
			organizationsetting.FieldBillingAddress: {Type: field.TypeString, Column: organizationsetting.FieldBillingAddress},
			organizationsetting.FieldTaxIdentifier:  {Type: field.TypeString, Column: organizationsetting.FieldTaxIdentifier},
			organizationsetting.FieldTags:           {Type: field.TypeJSON, Column: organizationsetting.FieldTags},
		},
	}
	graph.Nodes[9] = &sqlgraph.Node{
		NodeSpec: sqlgraph.NodeSpec{
			Table:   personalaccesstoken.Table,
			Columns: personalaccesstoken.Columns,
			ID: &sqlgraph.FieldSpec{
				Type:   field.TypeString,
				Column: personalaccesstoken.FieldID,
			},
		},
		Type: "PersonalAccessToken",
		Fields: map[string]*sqlgraph.FieldSpec{
			personalaccesstoken.FieldCreatedAt:   {Type: field.TypeTime, Column: personalaccesstoken.FieldCreatedAt},
			personalaccesstoken.FieldUpdatedAt:   {Type: field.TypeTime, Column: personalaccesstoken.FieldUpdatedAt},
			personalaccesstoken.FieldCreatedBy:   {Type: field.TypeString, Column: personalaccesstoken.FieldCreatedBy},
			personalaccesstoken.FieldUpdatedBy:   {Type: field.TypeString, Column: personalaccesstoken.FieldUpdatedBy},
			personalaccesstoken.FieldName:        {Type: field.TypeString, Column: personalaccesstoken.FieldName},
			personalaccesstoken.FieldToken:       {Type: field.TypeString, Column: personalaccesstoken.FieldToken},
			personalaccesstoken.FieldAbilities:   {Type: field.TypeJSON, Column: personalaccesstoken.FieldAbilities},
			personalaccesstoken.FieldExpiresAt:   {Type: field.TypeTime, Column: personalaccesstoken.FieldExpiresAt},
			personalaccesstoken.FieldDescription: {Type: field.TypeString, Column: personalaccesstoken.FieldDescription},
			personalaccesstoken.FieldLastUsedAt:  {Type: field.TypeTime, Column: personalaccesstoken.FieldLastUsedAt},
		},
	}
	graph.Nodes[10] = &sqlgraph.Node{
		NodeSpec: sqlgraph.NodeSpec{
			Table:   session.Table,
			Columns: session.Columns,
			ID: &sqlgraph.FieldSpec{
				Type:   field.TypeString,
				Column: session.FieldID,
			},
		},
		Type: "Session",
		Fields: map[string]*sqlgraph.FieldSpec{
			session.FieldCreatedAt:      {Type: field.TypeTime, Column: session.FieldCreatedAt},
			session.FieldUpdatedAt:      {Type: field.TypeTime, Column: session.FieldUpdatedAt},
			session.FieldCreatedBy:      {Type: field.TypeString, Column: session.FieldCreatedBy},
			session.FieldUpdatedBy:      {Type: field.TypeString, Column: session.FieldUpdatedBy},
			session.FieldSessionToken:   {Type: field.TypeString, Column: session.FieldSessionToken},
			session.FieldIssuedAt:       {Type: field.TypeTime, Column: session.FieldIssuedAt},
			session.FieldExpiresAt:      {Type: field.TypeTime, Column: session.FieldExpiresAt},
			session.FieldOrganizationID: {Type: field.TypeString, Column: session.FieldOrganizationID},
			session.FieldUserID:         {Type: field.TypeString, Column: session.FieldUserID},
		},
	}
	graph.Nodes[11] = &sqlgraph.Node{
		NodeSpec: sqlgraph.NodeSpec{
			Table:   user.Table,
			Columns: user.Columns,
			ID: &sqlgraph.FieldSpec{
				Type:   field.TypeString,
				Column: user.FieldID,
			},
		},
		Type: "User",
		Fields: map[string]*sqlgraph.FieldSpec{
			user.FieldCreatedAt:       {Type: field.TypeTime, Column: user.FieldCreatedAt},
			user.FieldUpdatedAt:       {Type: field.TypeTime, Column: user.FieldUpdatedAt},
			user.FieldCreatedBy:       {Type: field.TypeString, Column: user.FieldCreatedBy},
			user.FieldUpdatedBy:       {Type: field.TypeString, Column: user.FieldUpdatedBy},
			user.FieldDeletedAt:       {Type: field.TypeTime, Column: user.FieldDeletedAt},
			user.FieldDeletedBy:       {Type: field.TypeString, Column: user.FieldDeletedBy},
			user.FieldEmail:           {Type: field.TypeString, Column: user.FieldEmail},
			user.FieldFirstName:       {Type: field.TypeString, Column: user.FieldFirstName},
			user.FieldLastName:        {Type: field.TypeString, Column: user.FieldLastName},
			user.FieldDisplayName:     {Type: field.TypeString, Column: user.FieldDisplayName},
			user.FieldAvatarRemoteURL: {Type: field.TypeString, Column: user.FieldAvatarRemoteURL},
			user.FieldAvatarLocalFile: {Type: field.TypeString, Column: user.FieldAvatarLocalFile},
			user.FieldAvatarUpdatedAt: {Type: field.TypeTime, Column: user.FieldAvatarUpdatedAt},
			user.FieldLastSeen:        {Type: field.TypeTime, Column: user.FieldLastSeen},
			user.FieldPassword:        {Type: field.TypeString, Column: user.FieldPassword},
			user.FieldSub:             {Type: field.TypeString, Column: user.FieldSub},
			user.FieldOauth:           {Type: field.TypeBool, Column: user.FieldOauth},
		},
	}
	graph.Nodes[12] = &sqlgraph.Node{
		NodeSpec: sqlgraph.NodeSpec{
			Table:   usersetting.Table,
			Columns: usersetting.Columns,
			ID: &sqlgraph.FieldSpec{
				Type:   field.TypeString,
				Column: usersetting.FieldID,
			},
		},
		Type: "UserSetting",
		Fields: map[string]*sqlgraph.FieldSpec{
			usersetting.FieldCreatedAt:      {Type: field.TypeTime, Column: usersetting.FieldCreatedAt},
			usersetting.FieldUpdatedAt:      {Type: field.TypeTime, Column: usersetting.FieldUpdatedAt},
			usersetting.FieldCreatedBy:      {Type: field.TypeString, Column: usersetting.FieldCreatedBy},
			usersetting.FieldUpdatedBy:      {Type: field.TypeString, Column: usersetting.FieldUpdatedBy},
			usersetting.FieldDeletedAt:      {Type: field.TypeTime, Column: usersetting.FieldDeletedAt},
			usersetting.FieldDeletedBy:      {Type: field.TypeString, Column: usersetting.FieldDeletedBy},
			usersetting.FieldLocked:         {Type: field.TypeBool, Column: usersetting.FieldLocked},
			usersetting.FieldSilencedAt:     {Type: field.TypeTime, Column: usersetting.FieldSilencedAt},
			usersetting.FieldSuspendedAt:    {Type: field.TypeTime, Column: usersetting.FieldSuspendedAt},
			usersetting.FieldRecoveryCode:   {Type: field.TypeString, Column: usersetting.FieldRecoveryCode},
			usersetting.FieldStatus:         {Type: field.TypeEnum, Column: usersetting.FieldStatus},
			usersetting.FieldRole:           {Type: field.TypeEnum, Column: usersetting.FieldRole},
			usersetting.FieldPermissions:    {Type: field.TypeJSON, Column: usersetting.FieldPermissions},
			usersetting.FieldEmailConfirmed: {Type: field.TypeBool, Column: usersetting.FieldEmailConfirmed},
			usersetting.FieldTags:           {Type: field.TypeJSON, Column: usersetting.FieldTags},
		},
	}
	graph.MustAddE(
		"owner",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: true,
			Table:   emailverificationtoken.OwnerTable,
			Columns: []string{emailverificationtoken.OwnerColumn},
			Bidi:    false,
		},
		"EmailVerificationToken",
		"User",
	)
	graph.MustAddE(
		"owner",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: true,
			Table:   entitlement.OwnerTable,
			Columns: []string{entitlement.OwnerColumn},
			Bidi:    false,
		},
		"Entitlement",
		"Organization",
	)
	graph.MustAddE(
		"setting",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2O,
			Inverse: false,
			Table:   group.SettingTable,
			Columns: []string{group.SettingColumn},
			Bidi:    false,
		},
		"Group",
		"GroupSetting",
	)
	graph.MustAddE(
		"users",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2M,
			Inverse: false,
			Table:   group.UsersTable,
			Columns: group.UsersPrimaryKey,
			Bidi:    false,
		},
		"Group",
		"User",
	)
	graph.MustAddE(
		"owner",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: true,
			Table:   group.OwnerTable,
			Columns: []string{group.OwnerColumn},
			Bidi:    false,
		},
		"Group",
		"Organization",
	)
	graph.MustAddE(
		"group",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2O,
			Inverse: true,
			Table:   groupsetting.GroupTable,
			Columns: []string{groupsetting.GroupColumn},
			Bidi:    false,
		},
		"GroupSetting",
		"Group",
	)
	graph.MustAddE(
		"owner",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: true,
			Table:   integration.OwnerTable,
			Columns: []string{integration.OwnerColumn},
			Bidi:    false,
		},
		"Integration",
		"Organization",
	)
	graph.MustAddE(
		"owner",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: true,
			Table:   oauthprovider.OwnerTable,
			Columns: []string{oauthprovider.OwnerColumn},
			Bidi:    false,
		},
		"OauthProvider",
		"Organization",
	)
	graph.MustAddE(
		"parent",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: true,
			Table:   organization.ParentTable,
			Columns: []string{organization.ParentColumn},
			Bidi:    false,
		},
		"Organization",
		"Organization",
	)
	graph.MustAddE(
		"children",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   organization.ChildrenTable,
			Columns: []string{organization.ChildrenColumn},
			Bidi:    false,
		},
		"Organization",
		"Organization",
	)
	graph.MustAddE(
		"users",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2M,
			Inverse: true,
			Table:   organization.UsersTable,
			Columns: organization.UsersPrimaryKey,
			Bidi:    false,
		},
		"Organization",
		"User",
	)
	graph.MustAddE(
		"groups",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   organization.GroupsTable,
			Columns: []string{organization.GroupsColumn},
			Bidi:    false,
		},
		"Organization",
		"Group",
	)
	graph.MustAddE(
		"integrations",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   organization.IntegrationsTable,
			Columns: []string{organization.IntegrationsColumn},
			Bidi:    false,
		},
		"Organization",
		"Integration",
	)
	graph.MustAddE(
		"setting",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2O,
			Inverse: false,
			Table:   organization.SettingTable,
			Columns: []string{organization.SettingColumn},
			Bidi:    false,
		},
		"Organization",
		"OrganizationSetting",
	)
	graph.MustAddE(
		"entitlements",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   organization.EntitlementsTable,
			Columns: []string{organization.EntitlementsColumn},
			Bidi:    false,
		},
		"Organization",
		"Entitlement",
	)
	graph.MustAddE(
		"oauthprovider",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   organization.OauthproviderTable,
			Columns: []string{organization.OauthproviderColumn},
			Bidi:    false,
		},
		"Organization",
		"OauthProvider",
	)
	graph.MustAddE(
		"organization",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2O,
			Inverse: true,
			Table:   organizationsetting.OrganizationTable,
			Columns: []string{organizationsetting.OrganizationColumn},
			Bidi:    false,
		},
		"OrganizationSetting",
		"Organization",
	)
	graph.MustAddE(
		"owner",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: true,
			Table:   personalaccesstoken.OwnerTable,
			Columns: []string{personalaccesstoken.OwnerColumn},
			Bidi:    false,
		},
		"PersonalAccessToken",
		"User",
	)
	graph.MustAddE(
		"owner",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: true,
			Table:   session.OwnerTable,
			Columns: []string{session.OwnerColumn},
			Bidi:    false,
		},
		"Session",
		"User",
	)
	graph.MustAddE(
		"organizations",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2M,
			Inverse: false,
			Table:   user.OrganizationsTable,
			Columns: user.OrganizationsPrimaryKey,
			Bidi:    false,
		},
		"User",
		"Organization",
	)
	graph.MustAddE(
		"sessions",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   user.SessionsTable,
			Columns: []string{user.SessionsColumn},
			Bidi:    false,
		},
		"User",
		"Session",
	)
	graph.MustAddE(
		"groups",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2M,
			Inverse: true,
			Table:   user.GroupsTable,
			Columns: user.GroupsPrimaryKey,
			Bidi:    false,
		},
		"User",
		"Group",
	)
	graph.MustAddE(
		"personal_access_tokens",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   user.PersonalAccessTokensTable,
			Columns: []string{user.PersonalAccessTokensColumn},
			Bidi:    false,
		},
		"User",
		"PersonalAccessToken",
	)
	graph.MustAddE(
		"setting",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2O,
			Inverse: false,
			Table:   user.SettingTable,
			Columns: []string{user.SettingColumn},
			Bidi:    false,
		},
		"User",
		"UserSetting",
	)
	graph.MustAddE(
		"email_verification_tokens",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   user.EmailVerificationTokensTable,
			Columns: []string{user.EmailVerificationTokensColumn},
			Bidi:    false,
		},
		"User",
		"EmailVerificationToken",
	)
	graph.MustAddE(
		"user",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2O,
			Inverse: true,
			Table:   usersetting.UserTable,
			Columns: []string{usersetting.UserColumn},
			Bidi:    false,
		},
		"UserSetting",
		"User",
	)
	return graph
}()

// predicateAdder wraps the addPredicate method.
// All update, update-one and query builders implement this interface.
type predicateAdder interface {
	addPredicate(func(s *sql.Selector))
}

// addPredicate implements the predicateAdder interface.
func (evtq *EmailVerificationTokenQuery) addPredicate(pred func(s *sql.Selector)) {
	evtq.predicates = append(evtq.predicates, pred)
}

// Filter returns a Filter implementation to apply filters on the EmailVerificationTokenQuery builder.
func (evtq *EmailVerificationTokenQuery) Filter() *EmailVerificationTokenFilter {
	return &EmailVerificationTokenFilter{config: evtq.config, predicateAdder: evtq}
}

// addPredicate implements the predicateAdder interface.
func (m *EmailVerificationTokenMutation) addPredicate(pred func(s *sql.Selector)) {
	m.predicates = append(m.predicates, pred)
}

// Filter returns an entql.Where implementation to apply filters on the EmailVerificationTokenMutation builder.
func (m *EmailVerificationTokenMutation) Filter() *EmailVerificationTokenFilter {
	return &EmailVerificationTokenFilter{config: m.config, predicateAdder: m}
}

// EmailVerificationTokenFilter provides a generic filtering capability at runtime for EmailVerificationTokenQuery.
type EmailVerificationTokenFilter struct {
	predicateAdder
	config
}

// Where applies the entql predicate on the query filter.
func (f *EmailVerificationTokenFilter) Where(p entql.P) {
	f.addPredicate(func(s *sql.Selector) {
		if err := schemaGraph.EvalP(schemaGraph.Nodes[0].Type, p, s); err != nil {
			s.AddError(err)
		}
	})
}

// WhereID applies the entql string predicate on the id field.
func (f *EmailVerificationTokenFilter) WhereID(p entql.StringP) {
	f.Where(p.Field(emailverificationtoken.FieldID))
}

// WhereCreatedAt applies the entql time.Time predicate on the created_at field.
func (f *EmailVerificationTokenFilter) WhereCreatedAt(p entql.TimeP) {
	f.Where(p.Field(emailverificationtoken.FieldCreatedAt))
}

// WhereUpdatedAt applies the entql time.Time predicate on the updated_at field.
func (f *EmailVerificationTokenFilter) WhereUpdatedAt(p entql.TimeP) {
	f.Where(p.Field(emailverificationtoken.FieldUpdatedAt))
}

// WhereCreatedBy applies the entql string predicate on the created_by field.
func (f *EmailVerificationTokenFilter) WhereCreatedBy(p entql.StringP) {
	f.Where(p.Field(emailverificationtoken.FieldCreatedBy))
}

// WhereUpdatedBy applies the entql string predicate on the updated_by field.
func (f *EmailVerificationTokenFilter) WhereUpdatedBy(p entql.StringP) {
	f.Where(p.Field(emailverificationtoken.FieldUpdatedBy))
}

// WhereDeletedAt applies the entql time.Time predicate on the deleted_at field.
func (f *EmailVerificationTokenFilter) WhereDeletedAt(p entql.TimeP) {
	f.Where(p.Field(emailverificationtoken.FieldDeletedAt))
}

// WhereDeletedBy applies the entql string predicate on the deleted_by field.
func (f *EmailVerificationTokenFilter) WhereDeletedBy(p entql.StringP) {
	f.Where(p.Field(emailverificationtoken.FieldDeletedBy))
}

// WhereToken applies the entql string predicate on the token field.
func (f *EmailVerificationTokenFilter) WhereToken(p entql.StringP) {
	f.Where(p.Field(emailverificationtoken.FieldToken))
}

// WhereTTL applies the entql time.Time predicate on the ttl field.
func (f *EmailVerificationTokenFilter) WhereTTL(p entql.TimeP) {
	f.Where(p.Field(emailverificationtoken.FieldTTL))
}

// WhereEmail applies the entql string predicate on the email field.
func (f *EmailVerificationTokenFilter) WhereEmail(p entql.StringP) {
	f.Where(p.Field(emailverificationtoken.FieldEmail))
}

// WhereSecret applies the entql []byte predicate on the secret field.
func (f *EmailVerificationTokenFilter) WhereSecret(p entql.BytesP) {
	f.Where(p.Field(emailverificationtoken.FieldSecret))
}

// WhereHasOwner applies a predicate to check if query has an edge owner.
func (f *EmailVerificationTokenFilter) WhereHasOwner() {
	f.Where(entql.HasEdge("owner"))
}

// WhereHasOwnerWith applies a predicate to check if query has an edge owner with a given conditions (other predicates).
func (f *EmailVerificationTokenFilter) WhereHasOwnerWith(preds ...predicate.User) {
	f.Where(entql.HasEdgeWith("owner", sqlgraph.WrapFunc(func(s *sql.Selector) {
		for _, p := range preds {
			p(s)
		}
	})))
}

// addPredicate implements the predicateAdder interface.
func (eq *EntitlementQuery) addPredicate(pred func(s *sql.Selector)) {
	eq.predicates = append(eq.predicates, pred)
}

// Filter returns a Filter implementation to apply filters on the EntitlementQuery builder.
func (eq *EntitlementQuery) Filter() *EntitlementFilter {
	return &EntitlementFilter{config: eq.config, predicateAdder: eq}
}

// addPredicate implements the predicateAdder interface.
func (m *EntitlementMutation) addPredicate(pred func(s *sql.Selector)) {
	m.predicates = append(m.predicates, pred)
}

// Filter returns an entql.Where implementation to apply filters on the EntitlementMutation builder.
func (m *EntitlementMutation) Filter() *EntitlementFilter {
	return &EntitlementFilter{config: m.config, predicateAdder: m}
}

// EntitlementFilter provides a generic filtering capability at runtime for EntitlementQuery.
type EntitlementFilter struct {
	predicateAdder
	config
}

// Where applies the entql predicate on the query filter.
func (f *EntitlementFilter) Where(p entql.P) {
	f.addPredicate(func(s *sql.Selector) {
		if err := schemaGraph.EvalP(schemaGraph.Nodes[1].Type, p, s); err != nil {
			s.AddError(err)
		}
	})
}

// WhereID applies the entql string predicate on the id field.
func (f *EntitlementFilter) WhereID(p entql.StringP) {
	f.Where(p.Field(entitlement.FieldID))
}

// WhereCreatedAt applies the entql time.Time predicate on the created_at field.
func (f *EntitlementFilter) WhereCreatedAt(p entql.TimeP) {
	f.Where(p.Field(entitlement.FieldCreatedAt))
}

// WhereUpdatedAt applies the entql time.Time predicate on the updated_at field.
func (f *EntitlementFilter) WhereUpdatedAt(p entql.TimeP) {
	f.Where(p.Field(entitlement.FieldUpdatedAt))
}

// WhereCreatedBy applies the entql string predicate on the created_by field.
func (f *EntitlementFilter) WhereCreatedBy(p entql.StringP) {
	f.Where(p.Field(entitlement.FieldCreatedBy))
}

// WhereUpdatedBy applies the entql string predicate on the updated_by field.
func (f *EntitlementFilter) WhereUpdatedBy(p entql.StringP) {
	f.Where(p.Field(entitlement.FieldUpdatedBy))
}

// WhereDeletedAt applies the entql time.Time predicate on the deleted_at field.
func (f *EntitlementFilter) WhereDeletedAt(p entql.TimeP) {
	f.Where(p.Field(entitlement.FieldDeletedAt))
}

// WhereDeletedBy applies the entql string predicate on the deleted_by field.
func (f *EntitlementFilter) WhereDeletedBy(p entql.StringP) {
	f.Where(p.Field(entitlement.FieldDeletedBy))
}

// WhereTier applies the entql string predicate on the tier field.
func (f *EntitlementFilter) WhereTier(p entql.StringP) {
	f.Where(p.Field(entitlement.FieldTier))
}

// WhereExternalCustomerID applies the entql string predicate on the external_customer_id field.
func (f *EntitlementFilter) WhereExternalCustomerID(p entql.StringP) {
	f.Where(p.Field(entitlement.FieldExternalCustomerID))
}

// WhereExternalSubscriptionID applies the entql string predicate on the external_subscription_id field.
func (f *EntitlementFilter) WhereExternalSubscriptionID(p entql.StringP) {
	f.Where(p.Field(entitlement.FieldExternalSubscriptionID))
}

// WhereExpires applies the entql bool predicate on the expires field.
func (f *EntitlementFilter) WhereExpires(p entql.BoolP) {
	f.Where(p.Field(entitlement.FieldExpires))
}

// WhereExpiresAt applies the entql time.Time predicate on the expires_at field.
func (f *EntitlementFilter) WhereExpiresAt(p entql.TimeP) {
	f.Where(p.Field(entitlement.FieldExpiresAt))
}

// WhereCancelled applies the entql bool predicate on the cancelled field.
func (f *EntitlementFilter) WhereCancelled(p entql.BoolP) {
	f.Where(p.Field(entitlement.FieldCancelled))
}

// WhereHasOwner applies a predicate to check if query has an edge owner.
func (f *EntitlementFilter) WhereHasOwner() {
	f.Where(entql.HasEdge("owner"))
}

// WhereHasOwnerWith applies a predicate to check if query has an edge owner with a given conditions (other predicates).
func (f *EntitlementFilter) WhereHasOwnerWith(preds ...predicate.Organization) {
	f.Where(entql.HasEdgeWith("owner", sqlgraph.WrapFunc(func(s *sql.Selector) {
		for _, p := range preds {
			p(s)
		}
	})))
}

// addPredicate implements the predicateAdder interface.
func (gq *GroupQuery) addPredicate(pred func(s *sql.Selector)) {
	gq.predicates = append(gq.predicates, pred)
}

// Filter returns a Filter implementation to apply filters on the GroupQuery builder.
func (gq *GroupQuery) Filter() *GroupFilter {
	return &GroupFilter{config: gq.config, predicateAdder: gq}
}

// addPredicate implements the predicateAdder interface.
func (m *GroupMutation) addPredicate(pred func(s *sql.Selector)) {
	m.predicates = append(m.predicates, pred)
}

// Filter returns an entql.Where implementation to apply filters on the GroupMutation builder.
func (m *GroupMutation) Filter() *GroupFilter {
	return &GroupFilter{config: m.config, predicateAdder: m}
}

// GroupFilter provides a generic filtering capability at runtime for GroupQuery.
type GroupFilter struct {
	predicateAdder
	config
}

// Where applies the entql predicate on the query filter.
func (f *GroupFilter) Where(p entql.P) {
	f.addPredicate(func(s *sql.Selector) {
		if err := schemaGraph.EvalP(schemaGraph.Nodes[2].Type, p, s); err != nil {
			s.AddError(err)
		}
	})
}

// WhereID applies the entql string predicate on the id field.
func (f *GroupFilter) WhereID(p entql.StringP) {
	f.Where(p.Field(group.FieldID))
}

// WhereCreatedAt applies the entql time.Time predicate on the created_at field.
func (f *GroupFilter) WhereCreatedAt(p entql.TimeP) {
	f.Where(p.Field(group.FieldCreatedAt))
}

// WhereUpdatedAt applies the entql time.Time predicate on the updated_at field.
func (f *GroupFilter) WhereUpdatedAt(p entql.TimeP) {
	f.Where(p.Field(group.FieldUpdatedAt))
}

// WhereCreatedBy applies the entql string predicate on the created_by field.
func (f *GroupFilter) WhereCreatedBy(p entql.StringP) {
	f.Where(p.Field(group.FieldCreatedBy))
}

// WhereUpdatedBy applies the entql string predicate on the updated_by field.
func (f *GroupFilter) WhereUpdatedBy(p entql.StringP) {
	f.Where(p.Field(group.FieldUpdatedBy))
}

// WhereDeletedAt applies the entql time.Time predicate on the deleted_at field.
func (f *GroupFilter) WhereDeletedAt(p entql.TimeP) {
	f.Where(p.Field(group.FieldDeletedAt))
}

// WhereDeletedBy applies the entql string predicate on the deleted_by field.
func (f *GroupFilter) WhereDeletedBy(p entql.StringP) {
	f.Where(p.Field(group.FieldDeletedBy))
}

// WhereName applies the entql string predicate on the name field.
func (f *GroupFilter) WhereName(p entql.StringP) {
	f.Where(p.Field(group.FieldName))
}

// WhereDescription applies the entql string predicate on the description field.
func (f *GroupFilter) WhereDescription(p entql.StringP) {
	f.Where(p.Field(group.FieldDescription))
}

// WhereGravatarLogoURL applies the entql string predicate on the gravatar_logo_url field.
func (f *GroupFilter) WhereGravatarLogoURL(p entql.StringP) {
	f.Where(p.Field(group.FieldGravatarLogoURL))
}

// WhereLogoURL applies the entql string predicate on the logo_url field.
func (f *GroupFilter) WhereLogoURL(p entql.StringP) {
	f.Where(p.Field(group.FieldLogoURL))
}

// WhereDisplayName applies the entql string predicate on the display_name field.
func (f *GroupFilter) WhereDisplayName(p entql.StringP) {
	f.Where(p.Field(group.FieldDisplayName))
}

// WhereHasSetting applies a predicate to check if query has an edge setting.
func (f *GroupFilter) WhereHasSetting() {
	f.Where(entql.HasEdge("setting"))
}

// WhereHasSettingWith applies a predicate to check if query has an edge setting with a given conditions (other predicates).
func (f *GroupFilter) WhereHasSettingWith(preds ...predicate.GroupSetting) {
	f.Where(entql.HasEdgeWith("setting", sqlgraph.WrapFunc(func(s *sql.Selector) {
		for _, p := range preds {
			p(s)
		}
	})))
}

// WhereHasUsers applies a predicate to check if query has an edge users.
func (f *GroupFilter) WhereHasUsers() {
	f.Where(entql.HasEdge("users"))
}

// WhereHasUsersWith applies a predicate to check if query has an edge users with a given conditions (other predicates).
func (f *GroupFilter) WhereHasUsersWith(preds ...predicate.User) {
	f.Where(entql.HasEdgeWith("users", sqlgraph.WrapFunc(func(s *sql.Selector) {
		for _, p := range preds {
			p(s)
		}
	})))
}

// WhereHasOwner applies a predicate to check if query has an edge owner.
func (f *GroupFilter) WhereHasOwner() {
	f.Where(entql.HasEdge("owner"))
}

// WhereHasOwnerWith applies a predicate to check if query has an edge owner with a given conditions (other predicates).
func (f *GroupFilter) WhereHasOwnerWith(preds ...predicate.Organization) {
	f.Where(entql.HasEdgeWith("owner", sqlgraph.WrapFunc(func(s *sql.Selector) {
		for _, p := range preds {
			p(s)
		}
	})))
}

// addPredicate implements the predicateAdder interface.
func (gsq *GroupSettingQuery) addPredicate(pred func(s *sql.Selector)) {
	gsq.predicates = append(gsq.predicates, pred)
}

// Filter returns a Filter implementation to apply filters on the GroupSettingQuery builder.
func (gsq *GroupSettingQuery) Filter() *GroupSettingFilter {
	return &GroupSettingFilter{config: gsq.config, predicateAdder: gsq}
}

// addPredicate implements the predicateAdder interface.
func (m *GroupSettingMutation) addPredicate(pred func(s *sql.Selector)) {
	m.predicates = append(m.predicates, pred)
}

// Filter returns an entql.Where implementation to apply filters on the GroupSettingMutation builder.
func (m *GroupSettingMutation) Filter() *GroupSettingFilter {
	return &GroupSettingFilter{config: m.config, predicateAdder: m}
}

// GroupSettingFilter provides a generic filtering capability at runtime for GroupSettingQuery.
type GroupSettingFilter struct {
	predicateAdder
	config
}

// Where applies the entql predicate on the query filter.
func (f *GroupSettingFilter) Where(p entql.P) {
	f.addPredicate(func(s *sql.Selector) {
		if err := schemaGraph.EvalP(schemaGraph.Nodes[3].Type, p, s); err != nil {
			s.AddError(err)
		}
	})
}

// WhereID applies the entql string predicate on the id field.
func (f *GroupSettingFilter) WhereID(p entql.StringP) {
	f.Where(p.Field(groupsetting.FieldID))
}

// WhereCreatedAt applies the entql time.Time predicate on the created_at field.
func (f *GroupSettingFilter) WhereCreatedAt(p entql.TimeP) {
	f.Where(p.Field(groupsetting.FieldCreatedAt))
}

// WhereUpdatedAt applies the entql time.Time predicate on the updated_at field.
func (f *GroupSettingFilter) WhereUpdatedAt(p entql.TimeP) {
	f.Where(p.Field(groupsetting.FieldUpdatedAt))
}

// WhereCreatedBy applies the entql string predicate on the created_by field.
func (f *GroupSettingFilter) WhereCreatedBy(p entql.StringP) {
	f.Where(p.Field(groupsetting.FieldCreatedBy))
}

// WhereUpdatedBy applies the entql string predicate on the updated_by field.
func (f *GroupSettingFilter) WhereUpdatedBy(p entql.StringP) {
	f.Where(p.Field(groupsetting.FieldUpdatedBy))
}

// WhereDeletedAt applies the entql time.Time predicate on the deleted_at field.
func (f *GroupSettingFilter) WhereDeletedAt(p entql.TimeP) {
	f.Where(p.Field(groupsetting.FieldDeletedAt))
}

// WhereDeletedBy applies the entql string predicate on the deleted_by field.
func (f *GroupSettingFilter) WhereDeletedBy(p entql.StringP) {
	f.Where(p.Field(groupsetting.FieldDeletedBy))
}

// WhereVisibility applies the entql string predicate on the visibility field.
func (f *GroupSettingFilter) WhereVisibility(p entql.StringP) {
	f.Where(p.Field(groupsetting.FieldVisibility))
}

// WhereJoinPolicy applies the entql string predicate on the join_policy field.
func (f *GroupSettingFilter) WhereJoinPolicy(p entql.StringP) {
	f.Where(p.Field(groupsetting.FieldJoinPolicy))
}

// WhereTags applies the entql json.RawMessage predicate on the tags field.
func (f *GroupSettingFilter) WhereTags(p entql.BytesP) {
	f.Where(p.Field(groupsetting.FieldTags))
}

// WhereSyncToSlack applies the entql bool predicate on the sync_to_slack field.
func (f *GroupSettingFilter) WhereSyncToSlack(p entql.BoolP) {
	f.Where(p.Field(groupsetting.FieldSyncToSlack))
}

// WhereSyncToGithub applies the entql bool predicate on the sync_to_github field.
func (f *GroupSettingFilter) WhereSyncToGithub(p entql.BoolP) {
	f.Where(p.Field(groupsetting.FieldSyncToGithub))
}

// WhereHasGroup applies a predicate to check if query has an edge group.
func (f *GroupSettingFilter) WhereHasGroup() {
	f.Where(entql.HasEdge("group"))
}

// WhereHasGroupWith applies a predicate to check if query has an edge group with a given conditions (other predicates).
func (f *GroupSettingFilter) WhereHasGroupWith(preds ...predicate.Group) {
	f.Where(entql.HasEdgeWith("group", sqlgraph.WrapFunc(func(s *sql.Selector) {
		for _, p := range preds {
			p(s)
		}
	})))
}

// addPredicate implements the predicateAdder interface.
func (iq *IntegrationQuery) addPredicate(pred func(s *sql.Selector)) {
	iq.predicates = append(iq.predicates, pred)
}

// Filter returns a Filter implementation to apply filters on the IntegrationQuery builder.
func (iq *IntegrationQuery) Filter() *IntegrationFilter {
	return &IntegrationFilter{config: iq.config, predicateAdder: iq}
}

// addPredicate implements the predicateAdder interface.
func (m *IntegrationMutation) addPredicate(pred func(s *sql.Selector)) {
	m.predicates = append(m.predicates, pred)
}

// Filter returns an entql.Where implementation to apply filters on the IntegrationMutation builder.
func (m *IntegrationMutation) Filter() *IntegrationFilter {
	return &IntegrationFilter{config: m.config, predicateAdder: m}
}

// IntegrationFilter provides a generic filtering capability at runtime for IntegrationQuery.
type IntegrationFilter struct {
	predicateAdder
	config
}

// Where applies the entql predicate on the query filter.
func (f *IntegrationFilter) Where(p entql.P) {
	f.addPredicate(func(s *sql.Selector) {
		if err := schemaGraph.EvalP(schemaGraph.Nodes[4].Type, p, s); err != nil {
			s.AddError(err)
		}
	})
}

// WhereID applies the entql string predicate on the id field.
func (f *IntegrationFilter) WhereID(p entql.StringP) {
	f.Where(p.Field(integration.FieldID))
}

// WhereCreatedAt applies the entql time.Time predicate on the created_at field.
func (f *IntegrationFilter) WhereCreatedAt(p entql.TimeP) {
	f.Where(p.Field(integration.FieldCreatedAt))
}

// WhereUpdatedAt applies the entql time.Time predicate on the updated_at field.
func (f *IntegrationFilter) WhereUpdatedAt(p entql.TimeP) {
	f.Where(p.Field(integration.FieldUpdatedAt))
}

// WhereCreatedBy applies the entql string predicate on the created_by field.
func (f *IntegrationFilter) WhereCreatedBy(p entql.StringP) {
	f.Where(p.Field(integration.FieldCreatedBy))
}

// WhereUpdatedBy applies the entql string predicate on the updated_by field.
func (f *IntegrationFilter) WhereUpdatedBy(p entql.StringP) {
	f.Where(p.Field(integration.FieldUpdatedBy))
}

// WhereDeletedAt applies the entql time.Time predicate on the deleted_at field.
func (f *IntegrationFilter) WhereDeletedAt(p entql.TimeP) {
	f.Where(p.Field(integration.FieldDeletedAt))
}

// WhereDeletedBy applies the entql string predicate on the deleted_by field.
func (f *IntegrationFilter) WhereDeletedBy(p entql.StringP) {
	f.Where(p.Field(integration.FieldDeletedBy))
}

// WhereName applies the entql string predicate on the name field.
func (f *IntegrationFilter) WhereName(p entql.StringP) {
	f.Where(p.Field(integration.FieldName))
}

// WhereDescription applies the entql string predicate on the description field.
func (f *IntegrationFilter) WhereDescription(p entql.StringP) {
	f.Where(p.Field(integration.FieldDescription))
}

// WhereKind applies the entql string predicate on the kind field.
func (f *IntegrationFilter) WhereKind(p entql.StringP) {
	f.Where(p.Field(integration.FieldKind))
}

// WhereSecretName applies the entql string predicate on the secret_name field.
func (f *IntegrationFilter) WhereSecretName(p entql.StringP) {
	f.Where(p.Field(integration.FieldSecretName))
}

// WhereHasOwner applies a predicate to check if query has an edge owner.
func (f *IntegrationFilter) WhereHasOwner() {
	f.Where(entql.HasEdge("owner"))
}

// WhereHasOwnerWith applies a predicate to check if query has an edge owner with a given conditions (other predicates).
func (f *IntegrationFilter) WhereHasOwnerWith(preds ...predicate.Organization) {
	f.Where(entql.HasEdgeWith("owner", sqlgraph.WrapFunc(func(s *sql.Selector) {
		for _, p := range preds {
			p(s)
		}
	})))
}

// addPredicate implements the predicateAdder interface.
func (opq *OauthProviderQuery) addPredicate(pred func(s *sql.Selector)) {
	opq.predicates = append(opq.predicates, pred)
}

// Filter returns a Filter implementation to apply filters on the OauthProviderQuery builder.
func (opq *OauthProviderQuery) Filter() *OauthProviderFilter {
	return &OauthProviderFilter{config: opq.config, predicateAdder: opq}
}

// addPredicate implements the predicateAdder interface.
func (m *OauthProviderMutation) addPredicate(pred func(s *sql.Selector)) {
	m.predicates = append(m.predicates, pred)
}

// Filter returns an entql.Where implementation to apply filters on the OauthProviderMutation builder.
func (m *OauthProviderMutation) Filter() *OauthProviderFilter {
	return &OauthProviderFilter{config: m.config, predicateAdder: m}
}

// OauthProviderFilter provides a generic filtering capability at runtime for OauthProviderQuery.
type OauthProviderFilter struct {
	predicateAdder
	config
}

// Where applies the entql predicate on the query filter.
func (f *OauthProviderFilter) Where(p entql.P) {
	f.addPredicate(func(s *sql.Selector) {
		if err := schemaGraph.EvalP(schemaGraph.Nodes[5].Type, p, s); err != nil {
			s.AddError(err)
		}
	})
}

// WhereID applies the entql string predicate on the id field.
func (f *OauthProviderFilter) WhereID(p entql.StringP) {
	f.Where(p.Field(oauthprovider.FieldID))
}

// WhereCreatedAt applies the entql time.Time predicate on the created_at field.
func (f *OauthProviderFilter) WhereCreatedAt(p entql.TimeP) {
	f.Where(p.Field(oauthprovider.FieldCreatedAt))
}

// WhereUpdatedAt applies the entql time.Time predicate on the updated_at field.
func (f *OauthProviderFilter) WhereUpdatedAt(p entql.TimeP) {
	f.Where(p.Field(oauthprovider.FieldUpdatedAt))
}

// WhereCreatedBy applies the entql string predicate on the created_by field.
func (f *OauthProviderFilter) WhereCreatedBy(p entql.StringP) {
	f.Where(p.Field(oauthprovider.FieldCreatedBy))
}

// WhereUpdatedBy applies the entql string predicate on the updated_by field.
func (f *OauthProviderFilter) WhereUpdatedBy(p entql.StringP) {
	f.Where(p.Field(oauthprovider.FieldUpdatedBy))
}

// WhereDeletedAt applies the entql time.Time predicate on the deleted_at field.
func (f *OauthProviderFilter) WhereDeletedAt(p entql.TimeP) {
	f.Where(p.Field(oauthprovider.FieldDeletedAt))
}

// WhereDeletedBy applies the entql string predicate on the deleted_by field.
func (f *OauthProviderFilter) WhereDeletedBy(p entql.StringP) {
	f.Where(p.Field(oauthprovider.FieldDeletedBy))
}

// WhereName applies the entql string predicate on the name field.
func (f *OauthProviderFilter) WhereName(p entql.StringP) {
	f.Where(p.Field(oauthprovider.FieldName))
}

// WhereClientID applies the entql string predicate on the client_id field.
func (f *OauthProviderFilter) WhereClientID(p entql.StringP) {
	f.Where(p.Field(oauthprovider.FieldClientID))
}

// WhereClientSecret applies the entql string predicate on the client_secret field.
func (f *OauthProviderFilter) WhereClientSecret(p entql.StringP) {
	f.Where(p.Field(oauthprovider.FieldClientSecret))
}

// WhereRedirectURL applies the entql string predicate on the redirect_url field.
func (f *OauthProviderFilter) WhereRedirectURL(p entql.StringP) {
	f.Where(p.Field(oauthprovider.FieldRedirectURL))
}

// WhereScopes applies the entql string predicate on the scopes field.
func (f *OauthProviderFilter) WhereScopes(p entql.StringP) {
	f.Where(p.Field(oauthprovider.FieldScopes))
}

// WhereAuthURL applies the entql string predicate on the auth_url field.
func (f *OauthProviderFilter) WhereAuthURL(p entql.StringP) {
	f.Where(p.Field(oauthprovider.FieldAuthURL))
}

// WhereTokenURL applies the entql string predicate on the token_url field.
func (f *OauthProviderFilter) WhereTokenURL(p entql.StringP) {
	f.Where(p.Field(oauthprovider.FieldTokenURL))
}

// WhereAuthStyle applies the entql uint8 predicate on the auth_style field.
func (f *OauthProviderFilter) WhereAuthStyle(p entql.Uint8P) {
	f.Where(p.Field(oauthprovider.FieldAuthStyle))
}

// WhereInfoURL applies the entql string predicate on the info_url field.
func (f *OauthProviderFilter) WhereInfoURL(p entql.StringP) {
	f.Where(p.Field(oauthprovider.FieldInfoURL))
}

// WhereHasOwner applies a predicate to check if query has an edge owner.
func (f *OauthProviderFilter) WhereHasOwner() {
	f.Where(entql.HasEdge("owner"))
}

// WhereHasOwnerWith applies a predicate to check if query has an edge owner with a given conditions (other predicates).
func (f *OauthProviderFilter) WhereHasOwnerWith(preds ...predicate.Organization) {
	f.Where(entql.HasEdgeWith("owner", sqlgraph.WrapFunc(func(s *sql.Selector) {
		for _, p := range preds {
			p(s)
		}
	})))
}

// addPredicate implements the predicateAdder interface.
func (oattq *OhAuthTooTokenQuery) addPredicate(pred func(s *sql.Selector)) {
	oattq.predicates = append(oattq.predicates, pred)
}

// Filter returns a Filter implementation to apply filters on the OhAuthTooTokenQuery builder.
func (oattq *OhAuthTooTokenQuery) Filter() *OhAuthTooTokenFilter {
	return &OhAuthTooTokenFilter{config: oattq.config, predicateAdder: oattq}
}

// addPredicate implements the predicateAdder interface.
func (m *OhAuthTooTokenMutation) addPredicate(pred func(s *sql.Selector)) {
	m.predicates = append(m.predicates, pred)
}

// Filter returns an entql.Where implementation to apply filters on the OhAuthTooTokenMutation builder.
func (m *OhAuthTooTokenMutation) Filter() *OhAuthTooTokenFilter {
	return &OhAuthTooTokenFilter{config: m.config, predicateAdder: m}
}

// OhAuthTooTokenFilter provides a generic filtering capability at runtime for OhAuthTooTokenQuery.
type OhAuthTooTokenFilter struct {
	predicateAdder
	config
}

// Where applies the entql predicate on the query filter.
func (f *OhAuthTooTokenFilter) Where(p entql.P) {
	f.addPredicate(func(s *sql.Selector) {
		if err := schemaGraph.EvalP(schemaGraph.Nodes[6].Type, p, s); err != nil {
			s.AddError(err)
		}
	})
}

// WhereID applies the entql string predicate on the id field.
func (f *OhAuthTooTokenFilter) WhereID(p entql.StringP) {
	f.Where(p.Field(ohauthtootoken.FieldID))
}

// WhereClientID applies the entql string predicate on the client_id field.
func (f *OhAuthTooTokenFilter) WhereClientID(p entql.StringP) {
	f.Where(p.Field(ohauthtootoken.FieldClientID))
}

// WhereScopes applies the entql json.RawMessage predicate on the scopes field.
func (f *OhAuthTooTokenFilter) WhereScopes(p entql.BytesP) {
	f.Where(p.Field(ohauthtootoken.FieldScopes))
}

// WhereNonce applies the entql string predicate on the nonce field.
func (f *OhAuthTooTokenFilter) WhereNonce(p entql.StringP) {
	f.Where(p.Field(ohauthtootoken.FieldNonce))
}

// WhereClaimsUserID applies the entql string predicate on the claims_user_id field.
func (f *OhAuthTooTokenFilter) WhereClaimsUserID(p entql.StringP) {
	f.Where(p.Field(ohauthtootoken.FieldClaimsUserID))
}

// WhereClaimsUsername applies the entql string predicate on the claims_username field.
func (f *OhAuthTooTokenFilter) WhereClaimsUsername(p entql.StringP) {
	f.Where(p.Field(ohauthtootoken.FieldClaimsUsername))
}

// WhereClaimsEmail applies the entql string predicate on the claims_email field.
func (f *OhAuthTooTokenFilter) WhereClaimsEmail(p entql.StringP) {
	f.Where(p.Field(ohauthtootoken.FieldClaimsEmail))
}

// WhereClaimsEmailVerified applies the entql bool predicate on the claims_email_verified field.
func (f *OhAuthTooTokenFilter) WhereClaimsEmailVerified(p entql.BoolP) {
	f.Where(p.Field(ohauthtootoken.FieldClaimsEmailVerified))
}

// WhereClaimsGroups applies the entql json.RawMessage predicate on the claims_groups field.
func (f *OhAuthTooTokenFilter) WhereClaimsGroups(p entql.BytesP) {
	f.Where(p.Field(ohauthtootoken.FieldClaimsGroups))
}

// WhereClaimsPreferredUsername applies the entql string predicate on the claims_preferred_username field.
func (f *OhAuthTooTokenFilter) WhereClaimsPreferredUsername(p entql.StringP) {
	f.Where(p.Field(ohauthtootoken.FieldClaimsPreferredUsername))
}

// WhereConnectorID applies the entql string predicate on the connector_id field.
func (f *OhAuthTooTokenFilter) WhereConnectorID(p entql.StringP) {
	f.Where(p.Field(ohauthtootoken.FieldConnectorID))
}

// WhereConnectorData applies the entql json.RawMessage predicate on the connector_data field.
func (f *OhAuthTooTokenFilter) WhereConnectorData(p entql.BytesP) {
	f.Where(p.Field(ohauthtootoken.FieldConnectorData))
}

// WhereLastUsed applies the entql time.Time predicate on the last_used field.
func (f *OhAuthTooTokenFilter) WhereLastUsed(p entql.TimeP) {
	f.Where(p.Field(ohauthtootoken.FieldLastUsed))
}

// addPredicate implements the predicateAdder interface.
func (oq *OrganizationQuery) addPredicate(pred func(s *sql.Selector)) {
	oq.predicates = append(oq.predicates, pred)
}

// Filter returns a Filter implementation to apply filters on the OrganizationQuery builder.
func (oq *OrganizationQuery) Filter() *OrganizationFilter {
	return &OrganizationFilter{config: oq.config, predicateAdder: oq}
}

// addPredicate implements the predicateAdder interface.
func (m *OrganizationMutation) addPredicate(pred func(s *sql.Selector)) {
	m.predicates = append(m.predicates, pred)
}

// Filter returns an entql.Where implementation to apply filters on the OrganizationMutation builder.
func (m *OrganizationMutation) Filter() *OrganizationFilter {
	return &OrganizationFilter{config: m.config, predicateAdder: m}
}

// OrganizationFilter provides a generic filtering capability at runtime for OrganizationQuery.
type OrganizationFilter struct {
	predicateAdder
	config
}

// Where applies the entql predicate on the query filter.
func (f *OrganizationFilter) Where(p entql.P) {
	f.addPredicate(func(s *sql.Selector) {
		if err := schemaGraph.EvalP(schemaGraph.Nodes[7].Type, p, s); err != nil {
			s.AddError(err)
		}
	})
}

// WhereID applies the entql string predicate on the id field.
func (f *OrganizationFilter) WhereID(p entql.StringP) {
	f.Where(p.Field(organization.FieldID))
}

// WhereCreatedAt applies the entql time.Time predicate on the created_at field.
func (f *OrganizationFilter) WhereCreatedAt(p entql.TimeP) {
	f.Where(p.Field(organization.FieldCreatedAt))
}

// WhereUpdatedAt applies the entql time.Time predicate on the updated_at field.
func (f *OrganizationFilter) WhereUpdatedAt(p entql.TimeP) {
	f.Where(p.Field(organization.FieldUpdatedAt))
}

// WhereCreatedBy applies the entql string predicate on the created_by field.
func (f *OrganizationFilter) WhereCreatedBy(p entql.StringP) {
	f.Where(p.Field(organization.FieldCreatedBy))
}

// WhereUpdatedBy applies the entql string predicate on the updated_by field.
func (f *OrganizationFilter) WhereUpdatedBy(p entql.StringP) {
	f.Where(p.Field(organization.FieldUpdatedBy))
}

// WhereDeletedAt applies the entql time.Time predicate on the deleted_at field.
func (f *OrganizationFilter) WhereDeletedAt(p entql.TimeP) {
	f.Where(p.Field(organization.FieldDeletedAt))
}

// WhereDeletedBy applies the entql string predicate on the deleted_by field.
func (f *OrganizationFilter) WhereDeletedBy(p entql.StringP) {
	f.Where(p.Field(organization.FieldDeletedBy))
}

// WhereName applies the entql string predicate on the name field.
func (f *OrganizationFilter) WhereName(p entql.StringP) {
	f.Where(p.Field(organization.FieldName))
}

// WhereDisplayName applies the entql string predicate on the display_name field.
func (f *OrganizationFilter) WhereDisplayName(p entql.StringP) {
	f.Where(p.Field(organization.FieldDisplayName))
}

// WhereDescription applies the entql string predicate on the description field.
func (f *OrganizationFilter) WhereDescription(p entql.StringP) {
	f.Where(p.Field(organization.FieldDescription))
}

// WhereParentOrganizationID applies the entql string predicate on the parent_organization_id field.
func (f *OrganizationFilter) WhereParentOrganizationID(p entql.StringP) {
	f.Where(p.Field(organization.FieldParentOrganizationID))
}

// WherePersonalOrg applies the entql bool predicate on the personal_org field.
func (f *OrganizationFilter) WherePersonalOrg(p entql.BoolP) {
	f.Where(p.Field(organization.FieldPersonalOrg))
}

// WhereHasParent applies a predicate to check if query has an edge parent.
func (f *OrganizationFilter) WhereHasParent() {
	f.Where(entql.HasEdge("parent"))
}

// WhereHasParentWith applies a predicate to check if query has an edge parent with a given conditions (other predicates).
func (f *OrganizationFilter) WhereHasParentWith(preds ...predicate.Organization) {
	f.Where(entql.HasEdgeWith("parent", sqlgraph.WrapFunc(func(s *sql.Selector) {
		for _, p := range preds {
			p(s)
		}
	})))
}

// WhereHasChildren applies a predicate to check if query has an edge children.
func (f *OrganizationFilter) WhereHasChildren() {
	f.Where(entql.HasEdge("children"))
}

// WhereHasChildrenWith applies a predicate to check if query has an edge children with a given conditions (other predicates).
func (f *OrganizationFilter) WhereHasChildrenWith(preds ...predicate.Organization) {
	f.Where(entql.HasEdgeWith("children", sqlgraph.WrapFunc(func(s *sql.Selector) {
		for _, p := range preds {
			p(s)
		}
	})))
}

// WhereHasUsers applies a predicate to check if query has an edge users.
func (f *OrganizationFilter) WhereHasUsers() {
	f.Where(entql.HasEdge("users"))
}

// WhereHasUsersWith applies a predicate to check if query has an edge users with a given conditions (other predicates).
func (f *OrganizationFilter) WhereHasUsersWith(preds ...predicate.User) {
	f.Where(entql.HasEdgeWith("users", sqlgraph.WrapFunc(func(s *sql.Selector) {
		for _, p := range preds {
			p(s)
		}
	})))
}

// WhereHasGroups applies a predicate to check if query has an edge groups.
func (f *OrganizationFilter) WhereHasGroups() {
	f.Where(entql.HasEdge("groups"))
}

// WhereHasGroupsWith applies a predicate to check if query has an edge groups with a given conditions (other predicates).
func (f *OrganizationFilter) WhereHasGroupsWith(preds ...predicate.Group) {
	f.Where(entql.HasEdgeWith("groups", sqlgraph.WrapFunc(func(s *sql.Selector) {
		for _, p := range preds {
			p(s)
		}
	})))
}

// WhereHasIntegrations applies a predicate to check if query has an edge integrations.
func (f *OrganizationFilter) WhereHasIntegrations() {
	f.Where(entql.HasEdge("integrations"))
}

// WhereHasIntegrationsWith applies a predicate to check if query has an edge integrations with a given conditions (other predicates).
func (f *OrganizationFilter) WhereHasIntegrationsWith(preds ...predicate.Integration) {
	f.Where(entql.HasEdgeWith("integrations", sqlgraph.WrapFunc(func(s *sql.Selector) {
		for _, p := range preds {
			p(s)
		}
	})))
}

// WhereHasSetting applies a predicate to check if query has an edge setting.
func (f *OrganizationFilter) WhereHasSetting() {
	f.Where(entql.HasEdge("setting"))
}

// WhereHasSettingWith applies a predicate to check if query has an edge setting with a given conditions (other predicates).
func (f *OrganizationFilter) WhereHasSettingWith(preds ...predicate.OrganizationSetting) {
	f.Where(entql.HasEdgeWith("setting", sqlgraph.WrapFunc(func(s *sql.Selector) {
		for _, p := range preds {
			p(s)
		}
	})))
}

// WhereHasEntitlements applies a predicate to check if query has an edge entitlements.
func (f *OrganizationFilter) WhereHasEntitlements() {
	f.Where(entql.HasEdge("entitlements"))
}

// WhereHasEntitlementsWith applies a predicate to check if query has an edge entitlements with a given conditions (other predicates).
func (f *OrganizationFilter) WhereHasEntitlementsWith(preds ...predicate.Entitlement) {
	f.Where(entql.HasEdgeWith("entitlements", sqlgraph.WrapFunc(func(s *sql.Selector) {
		for _, p := range preds {
			p(s)
		}
	})))
}

// WhereHasOauthprovider applies a predicate to check if query has an edge oauthprovider.
func (f *OrganizationFilter) WhereHasOauthprovider() {
	f.Where(entql.HasEdge("oauthprovider"))
}

// WhereHasOauthproviderWith applies a predicate to check if query has an edge oauthprovider with a given conditions (other predicates).
func (f *OrganizationFilter) WhereHasOauthproviderWith(preds ...predicate.OauthProvider) {
	f.Where(entql.HasEdgeWith("oauthprovider", sqlgraph.WrapFunc(func(s *sql.Selector) {
		for _, p := range preds {
			p(s)
		}
	})))
}

// addPredicate implements the predicateAdder interface.
func (osq *OrganizationSettingQuery) addPredicate(pred func(s *sql.Selector)) {
	osq.predicates = append(osq.predicates, pred)
}

// Filter returns a Filter implementation to apply filters on the OrganizationSettingQuery builder.
func (osq *OrganizationSettingQuery) Filter() *OrganizationSettingFilter {
	return &OrganizationSettingFilter{config: osq.config, predicateAdder: osq}
}

// addPredicate implements the predicateAdder interface.
func (m *OrganizationSettingMutation) addPredicate(pred func(s *sql.Selector)) {
	m.predicates = append(m.predicates, pred)
}

// Filter returns an entql.Where implementation to apply filters on the OrganizationSettingMutation builder.
func (m *OrganizationSettingMutation) Filter() *OrganizationSettingFilter {
	return &OrganizationSettingFilter{config: m.config, predicateAdder: m}
}

// OrganizationSettingFilter provides a generic filtering capability at runtime for OrganizationSettingQuery.
type OrganizationSettingFilter struct {
	predicateAdder
	config
}

// Where applies the entql predicate on the query filter.
func (f *OrganizationSettingFilter) Where(p entql.P) {
	f.addPredicate(func(s *sql.Selector) {
		if err := schemaGraph.EvalP(schemaGraph.Nodes[8].Type, p, s); err != nil {
			s.AddError(err)
		}
	})
}

// WhereID applies the entql string predicate on the id field.
func (f *OrganizationSettingFilter) WhereID(p entql.StringP) {
	f.Where(p.Field(organizationsetting.FieldID))
}

// WhereCreatedAt applies the entql time.Time predicate on the created_at field.
func (f *OrganizationSettingFilter) WhereCreatedAt(p entql.TimeP) {
	f.Where(p.Field(organizationsetting.FieldCreatedAt))
}

// WhereUpdatedAt applies the entql time.Time predicate on the updated_at field.
func (f *OrganizationSettingFilter) WhereUpdatedAt(p entql.TimeP) {
	f.Where(p.Field(organizationsetting.FieldUpdatedAt))
}

// WhereCreatedBy applies the entql string predicate on the created_by field.
func (f *OrganizationSettingFilter) WhereCreatedBy(p entql.StringP) {
	f.Where(p.Field(organizationsetting.FieldCreatedBy))
}

// WhereUpdatedBy applies the entql string predicate on the updated_by field.
func (f *OrganizationSettingFilter) WhereUpdatedBy(p entql.StringP) {
	f.Where(p.Field(organizationsetting.FieldUpdatedBy))
}

// WhereDeletedAt applies the entql time.Time predicate on the deleted_at field.
func (f *OrganizationSettingFilter) WhereDeletedAt(p entql.TimeP) {
	f.Where(p.Field(organizationsetting.FieldDeletedAt))
}

// WhereDeletedBy applies the entql string predicate on the deleted_by field.
func (f *OrganizationSettingFilter) WhereDeletedBy(p entql.StringP) {
	f.Where(p.Field(organizationsetting.FieldDeletedBy))
}

// WhereDomains applies the entql json.RawMessage predicate on the domains field.
func (f *OrganizationSettingFilter) WhereDomains(p entql.BytesP) {
	f.Where(p.Field(organizationsetting.FieldDomains))
}

// WhereSSOCert applies the entql string predicate on the sso_cert field.
func (f *OrganizationSettingFilter) WhereSSOCert(p entql.StringP) {
	f.Where(p.Field(organizationsetting.FieldSSOCert))
}

// WhereSSOEntrypoint applies the entql string predicate on the sso_entrypoint field.
func (f *OrganizationSettingFilter) WhereSSOEntrypoint(p entql.StringP) {
	f.Where(p.Field(organizationsetting.FieldSSOEntrypoint))
}

// WhereSSOIssuer applies the entql string predicate on the sso_issuer field.
func (f *OrganizationSettingFilter) WhereSSOIssuer(p entql.StringP) {
	f.Where(p.Field(organizationsetting.FieldSSOIssuer))
}

// WhereBillingContact applies the entql string predicate on the billing_contact field.
func (f *OrganizationSettingFilter) WhereBillingContact(p entql.StringP) {
	f.Where(p.Field(organizationsetting.FieldBillingContact))
}

// WhereBillingEmail applies the entql string predicate on the billing_email field.
func (f *OrganizationSettingFilter) WhereBillingEmail(p entql.StringP) {
	f.Where(p.Field(organizationsetting.FieldBillingEmail))
}

// WhereBillingPhone applies the entql string predicate on the billing_phone field.
func (f *OrganizationSettingFilter) WhereBillingPhone(p entql.StringP) {
	f.Where(p.Field(organizationsetting.FieldBillingPhone))
}

// WhereBillingAddress applies the entql string predicate on the billing_address field.
func (f *OrganizationSettingFilter) WhereBillingAddress(p entql.StringP) {
	f.Where(p.Field(organizationsetting.FieldBillingAddress))
}

// WhereTaxIdentifier applies the entql string predicate on the tax_identifier field.
func (f *OrganizationSettingFilter) WhereTaxIdentifier(p entql.StringP) {
	f.Where(p.Field(organizationsetting.FieldTaxIdentifier))
}

// WhereTags applies the entql json.RawMessage predicate on the tags field.
func (f *OrganizationSettingFilter) WhereTags(p entql.BytesP) {
	f.Where(p.Field(organizationsetting.FieldTags))
}

// WhereHasOrganization applies a predicate to check if query has an edge organization.
func (f *OrganizationSettingFilter) WhereHasOrganization() {
	f.Where(entql.HasEdge("organization"))
}

// WhereHasOrganizationWith applies a predicate to check if query has an edge organization with a given conditions (other predicates).
func (f *OrganizationSettingFilter) WhereHasOrganizationWith(preds ...predicate.Organization) {
	f.Where(entql.HasEdgeWith("organization", sqlgraph.WrapFunc(func(s *sql.Selector) {
		for _, p := range preds {
			p(s)
		}
	})))
}

// addPredicate implements the predicateAdder interface.
func (patq *PersonalAccessTokenQuery) addPredicate(pred func(s *sql.Selector)) {
	patq.predicates = append(patq.predicates, pred)
}

// Filter returns a Filter implementation to apply filters on the PersonalAccessTokenQuery builder.
func (patq *PersonalAccessTokenQuery) Filter() *PersonalAccessTokenFilter {
	return &PersonalAccessTokenFilter{config: patq.config, predicateAdder: patq}
}

// addPredicate implements the predicateAdder interface.
func (m *PersonalAccessTokenMutation) addPredicate(pred func(s *sql.Selector)) {
	m.predicates = append(m.predicates, pred)
}

// Filter returns an entql.Where implementation to apply filters on the PersonalAccessTokenMutation builder.
func (m *PersonalAccessTokenMutation) Filter() *PersonalAccessTokenFilter {
	return &PersonalAccessTokenFilter{config: m.config, predicateAdder: m}
}

// PersonalAccessTokenFilter provides a generic filtering capability at runtime for PersonalAccessTokenQuery.
type PersonalAccessTokenFilter struct {
	predicateAdder
	config
}

// Where applies the entql predicate on the query filter.
func (f *PersonalAccessTokenFilter) Where(p entql.P) {
	f.addPredicate(func(s *sql.Selector) {
		if err := schemaGraph.EvalP(schemaGraph.Nodes[9].Type, p, s); err != nil {
			s.AddError(err)
		}
	})
}

// WhereID applies the entql string predicate on the id field.
func (f *PersonalAccessTokenFilter) WhereID(p entql.StringP) {
	f.Where(p.Field(personalaccesstoken.FieldID))
}

// WhereCreatedAt applies the entql time.Time predicate on the created_at field.
func (f *PersonalAccessTokenFilter) WhereCreatedAt(p entql.TimeP) {
	f.Where(p.Field(personalaccesstoken.FieldCreatedAt))
}

// WhereUpdatedAt applies the entql time.Time predicate on the updated_at field.
func (f *PersonalAccessTokenFilter) WhereUpdatedAt(p entql.TimeP) {
	f.Where(p.Field(personalaccesstoken.FieldUpdatedAt))
}

// WhereCreatedBy applies the entql string predicate on the created_by field.
func (f *PersonalAccessTokenFilter) WhereCreatedBy(p entql.StringP) {
	f.Where(p.Field(personalaccesstoken.FieldCreatedBy))
}

// WhereUpdatedBy applies the entql string predicate on the updated_by field.
func (f *PersonalAccessTokenFilter) WhereUpdatedBy(p entql.StringP) {
	f.Where(p.Field(personalaccesstoken.FieldUpdatedBy))
}

// WhereName applies the entql string predicate on the name field.
func (f *PersonalAccessTokenFilter) WhereName(p entql.StringP) {
	f.Where(p.Field(personalaccesstoken.FieldName))
}

// WhereToken applies the entql string predicate on the token field.
func (f *PersonalAccessTokenFilter) WhereToken(p entql.StringP) {
	f.Where(p.Field(personalaccesstoken.FieldToken))
}

// WhereAbilities applies the entql json.RawMessage predicate on the abilities field.
func (f *PersonalAccessTokenFilter) WhereAbilities(p entql.BytesP) {
	f.Where(p.Field(personalaccesstoken.FieldAbilities))
}

// WhereExpiresAt applies the entql time.Time predicate on the expires_at field.
func (f *PersonalAccessTokenFilter) WhereExpiresAt(p entql.TimeP) {
	f.Where(p.Field(personalaccesstoken.FieldExpiresAt))
}

// WhereDescription applies the entql string predicate on the description field.
func (f *PersonalAccessTokenFilter) WhereDescription(p entql.StringP) {
	f.Where(p.Field(personalaccesstoken.FieldDescription))
}

// WhereLastUsedAt applies the entql time.Time predicate on the last_used_at field.
func (f *PersonalAccessTokenFilter) WhereLastUsedAt(p entql.TimeP) {
	f.Where(p.Field(personalaccesstoken.FieldLastUsedAt))
}

// WhereHasOwner applies a predicate to check if query has an edge owner.
func (f *PersonalAccessTokenFilter) WhereHasOwner() {
	f.Where(entql.HasEdge("owner"))
}

// WhereHasOwnerWith applies a predicate to check if query has an edge owner with a given conditions (other predicates).
func (f *PersonalAccessTokenFilter) WhereHasOwnerWith(preds ...predicate.User) {
	f.Where(entql.HasEdgeWith("owner", sqlgraph.WrapFunc(func(s *sql.Selector) {
		for _, p := range preds {
			p(s)
		}
	})))
}

// addPredicate implements the predicateAdder interface.
func (sq *SessionQuery) addPredicate(pred func(s *sql.Selector)) {
	sq.predicates = append(sq.predicates, pred)
}

// Filter returns a Filter implementation to apply filters on the SessionQuery builder.
func (sq *SessionQuery) Filter() *SessionFilter {
	return &SessionFilter{config: sq.config, predicateAdder: sq}
}

// addPredicate implements the predicateAdder interface.
func (m *SessionMutation) addPredicate(pred func(s *sql.Selector)) {
	m.predicates = append(m.predicates, pred)
}

// Filter returns an entql.Where implementation to apply filters on the SessionMutation builder.
func (m *SessionMutation) Filter() *SessionFilter {
	return &SessionFilter{config: m.config, predicateAdder: m}
}

// SessionFilter provides a generic filtering capability at runtime for SessionQuery.
type SessionFilter struct {
	predicateAdder
	config
}

// Where applies the entql predicate on the query filter.
func (f *SessionFilter) Where(p entql.P) {
	f.addPredicate(func(s *sql.Selector) {
		if err := schemaGraph.EvalP(schemaGraph.Nodes[10].Type, p, s); err != nil {
			s.AddError(err)
		}
	})
}

// WhereID applies the entql string predicate on the id field.
func (f *SessionFilter) WhereID(p entql.StringP) {
	f.Where(p.Field(session.FieldID))
}

// WhereCreatedAt applies the entql time.Time predicate on the created_at field.
func (f *SessionFilter) WhereCreatedAt(p entql.TimeP) {
	f.Where(p.Field(session.FieldCreatedAt))
}

// WhereUpdatedAt applies the entql time.Time predicate on the updated_at field.
func (f *SessionFilter) WhereUpdatedAt(p entql.TimeP) {
	f.Where(p.Field(session.FieldUpdatedAt))
}

// WhereCreatedBy applies the entql string predicate on the created_by field.
func (f *SessionFilter) WhereCreatedBy(p entql.StringP) {
	f.Where(p.Field(session.FieldCreatedBy))
}

// WhereUpdatedBy applies the entql string predicate on the updated_by field.
func (f *SessionFilter) WhereUpdatedBy(p entql.StringP) {
	f.Where(p.Field(session.FieldUpdatedBy))
}

// WhereSessionToken applies the entql string predicate on the session_token field.
func (f *SessionFilter) WhereSessionToken(p entql.StringP) {
	f.Where(p.Field(session.FieldSessionToken))
}

// WhereIssuedAt applies the entql time.Time predicate on the issued_at field.
func (f *SessionFilter) WhereIssuedAt(p entql.TimeP) {
	f.Where(p.Field(session.FieldIssuedAt))
}

// WhereExpiresAt applies the entql time.Time predicate on the expires_at field.
func (f *SessionFilter) WhereExpiresAt(p entql.TimeP) {
	f.Where(p.Field(session.FieldExpiresAt))
}

// WhereOrganizationID applies the entql string predicate on the organization_id field.
func (f *SessionFilter) WhereOrganizationID(p entql.StringP) {
	f.Where(p.Field(session.FieldOrganizationID))
}

// WhereUserID applies the entql string predicate on the user_id field.
func (f *SessionFilter) WhereUserID(p entql.StringP) {
	f.Where(p.Field(session.FieldUserID))
}

// WhereHasOwner applies a predicate to check if query has an edge owner.
func (f *SessionFilter) WhereHasOwner() {
	f.Where(entql.HasEdge("owner"))
}

// WhereHasOwnerWith applies a predicate to check if query has an edge owner with a given conditions (other predicates).
func (f *SessionFilter) WhereHasOwnerWith(preds ...predicate.User) {
	f.Where(entql.HasEdgeWith("owner", sqlgraph.WrapFunc(func(s *sql.Selector) {
		for _, p := range preds {
			p(s)
		}
	})))
}

// addPredicate implements the predicateAdder interface.
func (uq *UserQuery) addPredicate(pred func(s *sql.Selector)) {
	uq.predicates = append(uq.predicates, pred)
}

// Filter returns a Filter implementation to apply filters on the UserQuery builder.
func (uq *UserQuery) Filter() *UserFilter {
	return &UserFilter{config: uq.config, predicateAdder: uq}
}

// addPredicate implements the predicateAdder interface.
func (m *UserMutation) addPredicate(pred func(s *sql.Selector)) {
	m.predicates = append(m.predicates, pred)
}

// Filter returns an entql.Where implementation to apply filters on the UserMutation builder.
func (m *UserMutation) Filter() *UserFilter {
	return &UserFilter{config: m.config, predicateAdder: m}
}

// UserFilter provides a generic filtering capability at runtime for UserQuery.
type UserFilter struct {
	predicateAdder
	config
}

// Where applies the entql predicate on the query filter.
func (f *UserFilter) Where(p entql.P) {
	f.addPredicate(func(s *sql.Selector) {
		if err := schemaGraph.EvalP(schemaGraph.Nodes[11].Type, p, s); err != nil {
			s.AddError(err)
		}
	})
}

// WhereID applies the entql string predicate on the id field.
func (f *UserFilter) WhereID(p entql.StringP) {
	f.Where(p.Field(user.FieldID))
}

// WhereCreatedAt applies the entql time.Time predicate on the created_at field.
func (f *UserFilter) WhereCreatedAt(p entql.TimeP) {
	f.Where(p.Field(user.FieldCreatedAt))
}

// WhereUpdatedAt applies the entql time.Time predicate on the updated_at field.
func (f *UserFilter) WhereUpdatedAt(p entql.TimeP) {
	f.Where(p.Field(user.FieldUpdatedAt))
}

// WhereCreatedBy applies the entql string predicate on the created_by field.
func (f *UserFilter) WhereCreatedBy(p entql.StringP) {
	f.Where(p.Field(user.FieldCreatedBy))
}

// WhereUpdatedBy applies the entql string predicate on the updated_by field.
func (f *UserFilter) WhereUpdatedBy(p entql.StringP) {
	f.Where(p.Field(user.FieldUpdatedBy))
}

// WhereDeletedAt applies the entql time.Time predicate on the deleted_at field.
func (f *UserFilter) WhereDeletedAt(p entql.TimeP) {
	f.Where(p.Field(user.FieldDeletedAt))
}

// WhereDeletedBy applies the entql string predicate on the deleted_by field.
func (f *UserFilter) WhereDeletedBy(p entql.StringP) {
	f.Where(p.Field(user.FieldDeletedBy))
}

// WhereEmail applies the entql string predicate on the email field.
func (f *UserFilter) WhereEmail(p entql.StringP) {
	f.Where(p.Field(user.FieldEmail))
}

// WhereFirstName applies the entql string predicate on the first_name field.
func (f *UserFilter) WhereFirstName(p entql.StringP) {
	f.Where(p.Field(user.FieldFirstName))
}

// WhereLastName applies the entql string predicate on the last_name field.
func (f *UserFilter) WhereLastName(p entql.StringP) {
	f.Where(p.Field(user.FieldLastName))
}

// WhereDisplayName applies the entql string predicate on the display_name field.
func (f *UserFilter) WhereDisplayName(p entql.StringP) {
	f.Where(p.Field(user.FieldDisplayName))
}

// WhereAvatarRemoteURL applies the entql string predicate on the avatar_remote_url field.
func (f *UserFilter) WhereAvatarRemoteURL(p entql.StringP) {
	f.Where(p.Field(user.FieldAvatarRemoteURL))
}

// WhereAvatarLocalFile applies the entql string predicate on the avatar_local_file field.
func (f *UserFilter) WhereAvatarLocalFile(p entql.StringP) {
	f.Where(p.Field(user.FieldAvatarLocalFile))
}

// WhereAvatarUpdatedAt applies the entql time.Time predicate on the avatar_updated_at field.
func (f *UserFilter) WhereAvatarUpdatedAt(p entql.TimeP) {
	f.Where(p.Field(user.FieldAvatarUpdatedAt))
}

// WhereLastSeen applies the entql time.Time predicate on the last_seen field.
func (f *UserFilter) WhereLastSeen(p entql.TimeP) {
	f.Where(p.Field(user.FieldLastSeen))
}

// WherePassword applies the entql string predicate on the password field.
func (f *UserFilter) WherePassword(p entql.StringP) {
	f.Where(p.Field(user.FieldPassword))
}

// WhereSub applies the entql string predicate on the sub field.
func (f *UserFilter) WhereSub(p entql.StringP) {
	f.Where(p.Field(user.FieldSub))
}

// WhereOauth applies the entql bool predicate on the oauth field.
func (f *UserFilter) WhereOauth(p entql.BoolP) {
	f.Where(p.Field(user.FieldOauth))
}

// WhereHasOrganizations applies a predicate to check if query has an edge organizations.
func (f *UserFilter) WhereHasOrganizations() {
	f.Where(entql.HasEdge("organizations"))
}

// WhereHasOrganizationsWith applies a predicate to check if query has an edge organizations with a given conditions (other predicates).
func (f *UserFilter) WhereHasOrganizationsWith(preds ...predicate.Organization) {
	f.Where(entql.HasEdgeWith("organizations", sqlgraph.WrapFunc(func(s *sql.Selector) {
		for _, p := range preds {
			p(s)
		}
	})))
}

// WhereHasSessions applies a predicate to check if query has an edge sessions.
func (f *UserFilter) WhereHasSessions() {
	f.Where(entql.HasEdge("sessions"))
}

// WhereHasSessionsWith applies a predicate to check if query has an edge sessions with a given conditions (other predicates).
func (f *UserFilter) WhereHasSessionsWith(preds ...predicate.Session) {
	f.Where(entql.HasEdgeWith("sessions", sqlgraph.WrapFunc(func(s *sql.Selector) {
		for _, p := range preds {
			p(s)
		}
	})))
}

// WhereHasGroups applies a predicate to check if query has an edge groups.
func (f *UserFilter) WhereHasGroups() {
	f.Where(entql.HasEdge("groups"))
}

// WhereHasGroupsWith applies a predicate to check if query has an edge groups with a given conditions (other predicates).
func (f *UserFilter) WhereHasGroupsWith(preds ...predicate.Group) {
	f.Where(entql.HasEdgeWith("groups", sqlgraph.WrapFunc(func(s *sql.Selector) {
		for _, p := range preds {
			p(s)
		}
	})))
}

// WhereHasPersonalAccessTokens applies a predicate to check if query has an edge personal_access_tokens.
func (f *UserFilter) WhereHasPersonalAccessTokens() {
	f.Where(entql.HasEdge("personal_access_tokens"))
}

// WhereHasPersonalAccessTokensWith applies a predicate to check if query has an edge personal_access_tokens with a given conditions (other predicates).
func (f *UserFilter) WhereHasPersonalAccessTokensWith(preds ...predicate.PersonalAccessToken) {
	f.Where(entql.HasEdgeWith("personal_access_tokens", sqlgraph.WrapFunc(func(s *sql.Selector) {
		for _, p := range preds {
			p(s)
		}
	})))
}

// WhereHasSetting applies a predicate to check if query has an edge setting.
func (f *UserFilter) WhereHasSetting() {
	f.Where(entql.HasEdge("setting"))
}

// WhereHasSettingWith applies a predicate to check if query has an edge setting with a given conditions (other predicates).
func (f *UserFilter) WhereHasSettingWith(preds ...predicate.UserSetting) {
	f.Where(entql.HasEdgeWith("setting", sqlgraph.WrapFunc(func(s *sql.Selector) {
		for _, p := range preds {
			p(s)
		}
	})))
}

// WhereHasEmailVerificationTokens applies a predicate to check if query has an edge email_verification_tokens.
func (f *UserFilter) WhereHasEmailVerificationTokens() {
	f.Where(entql.HasEdge("email_verification_tokens"))
}

// WhereHasEmailVerificationTokensWith applies a predicate to check if query has an edge email_verification_tokens with a given conditions (other predicates).
func (f *UserFilter) WhereHasEmailVerificationTokensWith(preds ...predicate.EmailVerificationToken) {
	f.Where(entql.HasEdgeWith("email_verification_tokens", sqlgraph.WrapFunc(func(s *sql.Selector) {
		for _, p := range preds {
			p(s)
		}
	})))
}

// addPredicate implements the predicateAdder interface.
func (usq *UserSettingQuery) addPredicate(pred func(s *sql.Selector)) {
	usq.predicates = append(usq.predicates, pred)
}

// Filter returns a Filter implementation to apply filters on the UserSettingQuery builder.
func (usq *UserSettingQuery) Filter() *UserSettingFilter {
	return &UserSettingFilter{config: usq.config, predicateAdder: usq}
}

// addPredicate implements the predicateAdder interface.
func (m *UserSettingMutation) addPredicate(pred func(s *sql.Selector)) {
	m.predicates = append(m.predicates, pred)
}

// Filter returns an entql.Where implementation to apply filters on the UserSettingMutation builder.
func (m *UserSettingMutation) Filter() *UserSettingFilter {
	return &UserSettingFilter{config: m.config, predicateAdder: m}
}

// UserSettingFilter provides a generic filtering capability at runtime for UserSettingQuery.
type UserSettingFilter struct {
	predicateAdder
	config
}

// Where applies the entql predicate on the query filter.
func (f *UserSettingFilter) Where(p entql.P) {
	f.addPredicate(func(s *sql.Selector) {
		if err := schemaGraph.EvalP(schemaGraph.Nodes[12].Type, p, s); err != nil {
			s.AddError(err)
		}
	})
}

// WhereID applies the entql string predicate on the id field.
func (f *UserSettingFilter) WhereID(p entql.StringP) {
	f.Where(p.Field(usersetting.FieldID))
}

// WhereCreatedAt applies the entql time.Time predicate on the created_at field.
func (f *UserSettingFilter) WhereCreatedAt(p entql.TimeP) {
	f.Where(p.Field(usersetting.FieldCreatedAt))
}

// WhereUpdatedAt applies the entql time.Time predicate on the updated_at field.
func (f *UserSettingFilter) WhereUpdatedAt(p entql.TimeP) {
	f.Where(p.Field(usersetting.FieldUpdatedAt))
}

// WhereCreatedBy applies the entql string predicate on the created_by field.
func (f *UserSettingFilter) WhereCreatedBy(p entql.StringP) {
	f.Where(p.Field(usersetting.FieldCreatedBy))
}

// WhereUpdatedBy applies the entql string predicate on the updated_by field.
func (f *UserSettingFilter) WhereUpdatedBy(p entql.StringP) {
	f.Where(p.Field(usersetting.FieldUpdatedBy))
}

// WhereDeletedAt applies the entql time.Time predicate on the deleted_at field.
func (f *UserSettingFilter) WhereDeletedAt(p entql.TimeP) {
	f.Where(p.Field(usersetting.FieldDeletedAt))
}

// WhereDeletedBy applies the entql string predicate on the deleted_by field.
func (f *UserSettingFilter) WhereDeletedBy(p entql.StringP) {
	f.Where(p.Field(usersetting.FieldDeletedBy))
}

// WhereLocked applies the entql bool predicate on the locked field.
func (f *UserSettingFilter) WhereLocked(p entql.BoolP) {
	f.Where(p.Field(usersetting.FieldLocked))
}

// WhereSilencedAt applies the entql time.Time predicate on the silenced_at field.
func (f *UserSettingFilter) WhereSilencedAt(p entql.TimeP) {
	f.Where(p.Field(usersetting.FieldSilencedAt))
}

// WhereSuspendedAt applies the entql time.Time predicate on the suspended_at field.
func (f *UserSettingFilter) WhereSuspendedAt(p entql.TimeP) {
	f.Where(p.Field(usersetting.FieldSuspendedAt))
}

// WhereRecoveryCode applies the entql string predicate on the recovery_code field.
func (f *UserSettingFilter) WhereRecoveryCode(p entql.StringP) {
	f.Where(p.Field(usersetting.FieldRecoveryCode))
}

// WhereStatus applies the entql string predicate on the status field.
func (f *UserSettingFilter) WhereStatus(p entql.StringP) {
	f.Where(p.Field(usersetting.FieldStatus))
}

// WhereRole applies the entql string predicate on the role field.
func (f *UserSettingFilter) WhereRole(p entql.StringP) {
	f.Where(p.Field(usersetting.FieldRole))
}

// WherePermissions applies the entql json.RawMessage predicate on the permissions field.
func (f *UserSettingFilter) WherePermissions(p entql.BytesP) {
	f.Where(p.Field(usersetting.FieldPermissions))
}

// WhereEmailConfirmed applies the entql bool predicate on the email_confirmed field.
func (f *UserSettingFilter) WhereEmailConfirmed(p entql.BoolP) {
	f.Where(p.Field(usersetting.FieldEmailConfirmed))
}

// WhereTags applies the entql json.RawMessage predicate on the tags field.
func (f *UserSettingFilter) WhereTags(p entql.BytesP) {
	f.Where(p.Field(usersetting.FieldTags))
}

// WhereHasUser applies a predicate to check if query has an edge user.
func (f *UserSettingFilter) WhereHasUser() {
	f.Where(entql.HasEdge("user"))
}

// WhereHasUserWith applies a predicate to check if query has an edge user with a given conditions (other predicates).
func (f *UserSettingFilter) WhereHasUserWith(preds ...predicate.User) {
	f.Where(entql.HasEdgeWith("user", sqlgraph.WrapFunc(func(s *sql.Selector) {
		for _, p := range preds {
			p(s)
		}
	})))
}