probo/pkg/server/api/connect/v1/schema/schema.go

// Code generated by github.com/99designs/gqlgen, DO NOT EDIT.

package schema

import (
	"bytes"
	"context"
	"errors"
	"fmt"
	"strconv"
	"sync"
	"sync/atomic"
	"time"

	"github.com/99designs/gqlgen/graphql"
	"github.com/99designs/gqlgen/graphql/introspection"
	gqlparser "github.com/vektah/gqlparser/v2"
	"github.com/vektah/gqlparser/v2/ast"
	"go.probo.inc/probo/pkg/coredata"
	"go.probo.inc/probo/pkg/gid"
	"go.probo.inc/probo/pkg/mail"
	"go.probo.inc/probo/pkg/page"
	"go.probo.inc/probo/pkg/server/api/connect/v1/types"
	"go.probo.inc/probo/pkg/server/gqlutils/directives/session"
	"go.probo.inc/probo/pkg/server/gqlutils/types/cursor"
	gid1 "go.probo.inc/probo/pkg/server/gqlutils/types/gid"
	mail1 "go.probo.inc/probo/pkg/server/gqlutils/types/mail"
)

// region    ************************** generated!.gotpl **************************

// NewExecutableSchema creates an ExecutableSchema from the ResolverRoot interface.
func NewExecutableSchema(cfg Config) graphql.ExecutableSchema {
	return &executableSchema{
		schema:     cfg.Schema,
		resolvers:  cfg.Resolvers,
		directives: cfg.Directives,
		complexity: cfg.Complexity,
	}
}

type Config struct {
	Schema     *ast.Schema
	Resolvers  ResolverRoot
	Directives DirectiveRoot
	Complexity ComplexityRoot
}

type ResolverRoot interface {
	Connector() ConnectorResolver
	Identity() IdentityResolver
	Invitation() InvitationResolver
	InvitationConnection() InvitationConnectionResolver
	Membership() MembershipResolver
	MembershipConnection() MembershipConnectionResolver
	MembershipProfile() MembershipProfileResolver
	Mutation() MutationResolver
	Organization() OrganizationResolver
	PersonalAPIKey() PersonalAPIKeyResolver
	PersonalAPIKeyConnection() PersonalAPIKeyConnectionResolver
	Query() QueryResolver
	SAMLConfiguration() SAMLConfigurationResolver
	SAMLConfigurationConnection() SAMLConfigurationConnectionResolver
	SCIMBridge() SCIMBridgeResolver
	SCIMConfiguration() SCIMConfigurationResolver
	SCIMEvent() SCIMEventResolver
	SCIMEventConnection() SCIMEventConnectionResolver
	Session() SessionResolver
	SessionConnection() SessionConnectionResolver
}

type DirectiveRoot struct {
	Session func(ctx context.Context, obj any, next graphql.Resolver, required session.SessionRequirement) (res any, err error)
}

type ComplexityRoot struct {
	AcceptInvitationPayload struct {
		Invitation     func(childComplexity int) int
		MembershipEdge func(childComplexity int) int
	}

	AssumeOrganizationSessionPayload struct {
		Result func(childComplexity int) int
	}

	ChangeEmailPayload struct {
		Success func(childComplexity int) int
	}

	ChangePasswordPayload struct {
		Success func(childComplexity int) int
	}

	Connector struct {
		CreatedAt  func(childComplexity int) int
		ID         func(childComplexity int) int
		Permission func(childComplexity int, action string) int
		Provider   func(childComplexity int) int
		UpdatedAt  func(childComplexity int) int
	}

	CreateOrganizationPayload struct {
		MembershipEdge func(childComplexity int) int
		Organization   func(childComplexity int) int
	}

	CreatePersonalAPIKeyPayload struct {
		PersonalAPIKeyEdge func(childComplexity int) int
		Token              func(childComplexity int) int
	}

	CreateSAMLConfigurationPayload struct {
		SamlConfigurationEdge func(childComplexity int) int
	}

	CreateSCIMConfigurationPayload struct {
		ScimBridge        func(childComplexity int) int
		ScimConfiguration func(childComplexity int) int
		Token             func(childComplexity int) int
	}

	DeleteInvitationPayload struct {
		DeletedInvitationID func(childComplexity int) int
	}

	DeleteOrganizationHorizontalLogoPayload struct {
		Organization func(childComplexity int) int
	}

	DeleteOrganizationPayload struct {
		DeletedOrganizationID func(childComplexity int) int
	}

	DeleteSAMLConfigurationPayload struct {
		DeletedSamlConfigurationID func(childComplexity int) int
	}

	DeleteSCIMConfigurationPayload struct {
		DeletedScimConfigurationID func(childComplexity int) int
	}

	ForgotPasswordPayload struct {
		Success func(childComplexity int) int
	}

	Identity struct {
		CreatedAt          func(childComplexity int) int
		Email              func(childComplexity int) int
		EmailVerified      func(childComplexity int) int
		FullName           func(childComplexity int) int
		ID                 func(childComplexity int) int
		Memberships        func(childComplexity int, first *int, after *page.CursorKey, last *int, before *page.CursorKey, orderBy *types.MembershipOrderBy) int
		PendingInvitations func(childComplexity int, first *int, after *page.CursorKey, last *int, before *page.CursorKey, orderBy *types.InvitationOrderBy) int
		Permission         func(childComplexity int, action string) int
		PersonalAPIKeys    func(childComplexity int, first *int, after *page.CursorKey, last *int, before *page.CursorKey) int
		Sessions           func(childComplexity int, first *int, after *page.CursorKey, last *int, before *page.CursorKey, orderBy *types.SessionOrder) int
		UpdatedAt          func(childComplexity int) int
	}

	Invitation struct {
		AcceptedAt   func(childComplexity int) int
		CreatedAt    func(childComplexity int) int
		Email        func(childComplexity int) int
		ExpiresAt    func(childComplexity int) int
		FullName     func(childComplexity int) int
		ID           func(childComplexity int) int
		Organization func(childComplexity int) int
		Permission   func(childComplexity int, action string) int
		Role         func(childComplexity int) int
		Status       func(childComplexity int) int
	}

	InvitationConnection struct {
		Edges      func(childComplexity int) int
		PageInfo   func(childComplexity int) int
		TotalCount func(childComplexity int) int
	}

	InvitationEdge struct {
		Cursor func(childComplexity int) int
		Node   func(childComplexity int) int
	}

	InviteMemberPayload struct {
		InvitationEdge func(childComplexity int) int
	}

	Membership struct {
		CreatedAt    func(childComplexity int) int
		ID           func(childComplexity int) int
		Identity     func(childComplexity int) int
		LastSession  func(childComplexity int) int
		Organization func(childComplexity int) int
		Permission   func(childComplexity int, action string) int
		Profile      func(childComplexity int) int
		Role         func(childComplexity int) int
		Source       func(childComplexity int) int
		State        func(childComplexity int) int
	}

	MembershipConnection struct {
		Edges      func(childComplexity int) int
		PageInfo   func(childComplexity int) int
		TotalCount func(childComplexity int) int
	}

	MembershipEdge struct {
		Cursor func(childComplexity int) int
		Node   func(childComplexity int) int
	}

	MembershipProfile struct {
		AdditionalEmailAddresses func(childComplexity int) int
		ContractEndDate          func(childComplexity int) int
		ContractStartDate        func(childComplexity int) int
		CreatedAt                func(childComplexity int) int
		FullName                 func(childComplexity int) int
		ID                       func(childComplexity int) int
		Identity                 func(childComplexity int) int
		Kind                     func(childComplexity int) int
		MembershipID             func(childComplexity int) int
		Organization             func(childComplexity int) int
		Permission               func(childComplexity int, action string) int
		Position                 func(childComplexity int) int
		UpdatedAt                func(childComplexity int) int
	}

	Mutation struct {
		AcceptInvitation                 func(childComplexity int, input types.AcceptInvitationInput) int
		AssumeOrganizationSession        func(childComplexity int, input types.AssumeOrganizationSessionInput) int
		ChangeEmail                      func(childComplexity int, input types.ChangeEmailInput) int
		ChangePassword                   func(childComplexity int, input types.ChangePasswordInput) int
		CreateOrganization               func(childComplexity int, input types.CreateOrganizationInput) int
		CreatePersonalAPIKey             func(childComplexity int, input types.CreatePersonalAPIKeyInput) int
		CreateSAMLConfiguration          func(childComplexity int, input types.CreateSAMLConfigurationInput) int
		CreateSCIMConfiguration          func(childComplexity int, input types.CreateSCIMConfigurationInput) int
		DeleteInvitation                 func(childComplexity int, input types.DeleteInvitationInput) int
		DeleteOrganization               func(childComplexity int, input types.DeleteOrganizationInput) int
		DeleteOrganizationHorizontalLogo func(childComplexity int, input types.DeleteOrganizationHorizontalLogoInput) int
		DeleteSAMLConfiguration          func(childComplexity int, input types.DeleteSAMLConfigurationInput) int
		DeleteSCIMConfiguration          func(childComplexity int, input types.DeleteSCIMConfigurationInput) int
		ForgotPassword                   func(childComplexity int, input types.ForgotPasswordInput) int
		InviteMember                     func(childComplexity int, input types.InviteMemberInput) int
		RegenerateSCIMToken              func(childComplexity int, input types.RegenerateSCIMTokenInput) int
		RemoveMember                     func(childComplexity int, input types.RemoveMemberInput) int
		ResetPassword                    func(childComplexity int, input types.ResetPasswordInput) int
		RevokeAllSessions                func(childComplexity int) int
		RevokePersonalAPIKey             func(childComplexity int, input types.RevokePersonalAPIKeyInput) int
		RevokeSession                    func(childComplexity int, input types.RevokeSessionInput) int
		SignIn                           func(childComplexity int, input types.SignInInput) int
		SignOut                          func(childComplexity int) int
		SignUp                           func(childComplexity int, input types.SignUpInput) int
		SignUpFromInvitation             func(childComplexity int, input types.SignUpFromInvitationInput) int
		UpdateMembership                 func(childComplexity int, input types.UpdateMembershipInput) int
		UpdateOrganization               func(childComplexity int, input types.UpdateOrganizationInput) int
		UpdateProfile                    func(childComplexity int, input types.UpdateProfileInput) int
		UpdateSAMLConfiguration          func(childComplexity int, input types.UpdateSAMLConfigurationInput) int
		UpdateSCIMBridge                 func(childComplexity int, input types.UpdateSCIMBridgeInput) int
		VerifyEmail                      func(childComplexity int, input types.VerifyEmailInput) int
	}

	Organization struct {
		CreatedAt          func(childComplexity int) int
		Description        func(childComplexity int) int
		Email              func(childComplexity int) int
		HeadquarterAddress func(childComplexity int) int
		HorizontalLogoURL  func(childComplexity int) int
		ID                 func(childComplexity int) int
		Invitations        func(childComplexity int, first *int, after *page.CursorKey, last *int, before *page.CursorKey, status *coredata.InvitationStatus, orderBy *types.InvitationOrderBy) int
		LogoURL            func(childComplexity int) int
		Members            func(childComplexity int, first *int, after *page.CursorKey, last *int, before *page.CursorKey, orderBy *types.MembershipOrderBy) int
		Name               func(childComplexity int) int
		Permission         func(childComplexity int, action string) int
		SamlConfigurations func(childComplexity int, first *int, after *page.CursorKey, last *int, before *page.CursorKey) int
		ScimConfiguration  func(childComplexity int) int
		UpdatedAt          func(childComplexity int) int
		ViewerMembership   func(childComplexity int) int
		WebsiteURL         func(childComplexity int) int
	}

	OrganizationSessionCreated struct {
		Membership func(childComplexity int) int
		Session    func(childComplexity int) int
	}

	PageInfo struct {
		EndCursor       func(childComplexity int) int
		HasNextPage     func(childComplexity int) int
		HasPreviousPage func(childComplexity int) int
		StartCursor     func(childComplexity int) int
	}

	PasswordRequired struct {
		Reason func(childComplexity int) int
	}

	PersonalAPIKey struct {
		CreatedAt  func(childComplexity int) int
		ExpiresAt  func(childComplexity int) int
		ID         func(childComplexity int) int
		LastUsedAt func(childComplexity int) int
		Name       func(childComplexity int) int
		Permission func(childComplexity int, action string) int
		Token      func(childComplexity int) int
	}

	PersonalAPIKeyConnection struct {
		Edges      func(childComplexity int) int
		PageInfo   func(childComplexity int) int
		TotalCount func(childComplexity int) int
	}

	PersonalAPIKeyEdge struct {
		Cursor func(childComplexity int) int
		Node   func(childComplexity int) int
	}

	Query struct {
		Node        func(childComplexity int, id gid.GID) int
		SsoLoginURL func(childComplexity int, email mail.Addr) int
		Viewer      func(childComplexity int) int
	}

	RegenerateSCIMTokenPayload struct {
		ScimConfiguration func(childComplexity int) int
		Token             func(childComplexity int) int
	}

	RemoveMemberPayload struct {
		DeletedMembershipID func(childComplexity int) int
	}

	ResetPasswordPayload struct {
		Success func(childComplexity int) int
	}

	RevokeAllSessionsPayload struct {
		RevokedCount func(childComplexity int) int
	}

	RevokePersonalAPIKeyPayload struct {
		PersonalAPIKeyID func(childComplexity int) int
	}

	RevokeSessionPayload struct {
		Success func(childComplexity int) int
	}

	SAMLAttributeMappings struct {
		Email     func(childComplexity int) int
		FirstName func(childComplexity int) int
		LastName  func(childComplexity int) int
		Role      func(childComplexity int) int
	}

	SAMLAuthenticationRequired struct {
		Reason      func(childComplexity int) int
		RedirectURL func(childComplexity int) int
	}

	SAMLConfiguration struct {
		AttributeMappings       func(childComplexity int) int
		AutoSignupEnabled       func(childComplexity int) int
		CreatedAt               func(childComplexity int) int
		DomainVerificationToken func(childComplexity int) int
		DomainVerifiedAt        func(childComplexity int) int
		EmailDomain             func(childComplexity int) int
		EnforcementPolicy       func(childComplexity int) int
		ID                      func(childComplexity int) int
		IdpCertificate          func(childComplexity int) int
		IdpEntityID             func(childComplexity int) int
		IdpSsoURL               func(childComplexity int) int
		Permission              func(childComplexity int, action string) int
		TestLoginURL            func(childComplexity int) int
		UpdatedAt               func(childComplexity int) int
	}

	SAMLConfigurationConnection struct {
		Edges      func(childComplexity int) int
		PageInfo   func(childComplexity int) int
		TotalCount func(childComplexity int) int
	}

	SAMLConfigurationEdge struct {
		Cursor func(childComplexity int) int
		Node   func(childComplexity int) int
	}

	SCIMBridge struct {
		Connector         func(childComplexity int) int
		CreatedAt         func(childComplexity int) int
		ExcludedUserNames func(childComplexity int) int
		ID                func(childComplexity int) int
		Permission        func(childComplexity int, action string) int
		ScimConfiguration func(childComplexity int) int
		State             func(childComplexity int) int
		Type              func(childComplexity int) int
		UpdatedAt         func(childComplexity int) int
	}

	SCIMConfiguration struct {
		Bridge       func(childComplexity int) int
		CreatedAt    func(childComplexity int) int
		EndpointURL  func(childComplexity int) int
		Events       func(childComplexity int, first *int, after *page.CursorKey, last *int, before *page.CursorKey, orderBy *types.SCIMEventOrderBy) int
		ID           func(childComplexity int) int
		Organization func(childComplexity int) int
		Permission   func(childComplexity int, action string) int
		UpdatedAt    func(childComplexity int) int
	}

	SCIMEvent struct {
		CreatedAt    func(childComplexity int) int
		ErrorMessage func(childComplexity int) int
		ID           func(childComplexity int) int
		IPAddress    func(childComplexity int) int
		Membership   func(childComplexity int) int
		Method       func(childComplexity int) int
		Path         func(childComplexity int) int
		Permission   func(childComplexity int, action string) int
		RequestBody  func(childComplexity int) int
		ResponseBody func(childComplexity int) int
		StatusCode   func(childComplexity int) int
	}

	SCIMEventConnection struct {
		Edges      func(childComplexity int) int
		PageInfo   func(childComplexity int) int
		TotalCount func(childComplexity int) int
	}

	SCIMEventEdge struct {
		Cursor func(childComplexity int) int
		Node   func(childComplexity int) int
	}

	Session struct {
		CreatedAt  func(childComplexity int) int
		ExpiresAt  func(childComplexity int) int
		ID         func(childComplexity int) int
		IPAddress  func(childComplexity int) int
		Identity   func(childComplexity int) int
		Permission func(childComplexity int, action string) int
		UpdatedAt  func(childComplexity int) int
		UserAgent  func(childComplexity int) int
	}

	SessionConnection struct {
		Edges      func(childComplexity int) int
		PageInfo   func(childComplexity int) int
		TotalCount func(childComplexity int) int
	}

	SessionEdge struct {
		Cursor func(childComplexity int) int
		Node   func(childComplexity int) int
	}

	SignInPayload struct {
		Identity func(childComplexity int) int
		Session  func(childComplexity int) int
	}

	SignOutPayload struct {
		Success func(childComplexity int) int
	}

	SignUpFromInvitationPayload struct {
		Identity func(childComplexity int) int
	}

	SignUpPayload struct {
		Identity func(childComplexity int) int
	}

	UpdateMembershipPayload struct {
		Membership func(childComplexity int) int
	}

	UpdateOrganizationPayload struct {
		Organization func(childComplexity int) int
	}

	UpdateProfilePayload struct {
		Profile func(childComplexity int) int
	}

	UpdateSAMLConfigurationPayload struct {
		SamlConfiguration func(childComplexity int) int
	}

	UpdateSCIMBridgePayload struct {
		ScimBridge func(childComplexity int) int
	}

	VerifyEmailPayload struct {
		Success func(childComplexity int) int
	}
}

type ConnectorResolver interface {
	Permission(ctx context.Context, obj *types.Connector, action string) (bool, error)
}
type IdentityResolver interface {
	Memberships(ctx context.Context, obj *types.Identity, first *int, after *page.CursorKey, last *int, before *page.CursorKey, orderBy *types.MembershipOrderBy) (*types.MembershipConnection, error)
	PendingInvitations(ctx context.Context, obj *types.Identity, first *int, after *page.CursorKey, last *int, before *page.CursorKey, orderBy *types.InvitationOrderBy) (*types.InvitationConnection, error)
	Sessions(ctx context.Context, obj *types.Identity, first *int, after *page.CursorKey, last *int, before *page.CursorKey, orderBy *types.SessionOrder) (*types.SessionConnection, error)
	PersonalAPIKeys(ctx context.Context, obj *types.Identity, first *int, after *page.CursorKey, last *int, before *page.CursorKey) (*types.PersonalAPIKeyConnection, error)
	Permission(ctx context.Context, obj *types.Identity, action string) (bool, error)
}
type InvitationResolver interface {
	Organization(ctx context.Context, obj *types.Invitation) (*types.Organization, error)
	Permission(ctx context.Context, obj *types.Invitation, action string) (bool, error)
}
type InvitationConnectionResolver interface {
	TotalCount(ctx context.Context, obj *types.InvitationConnection) (*int, error)
}
type MembershipResolver interface {
	Identity(ctx context.Context, obj *types.Membership) (*types.Identity, error)
	Profile(ctx context.Context, obj *types.Membership) (*types.MembershipProfile, error)
	Organization(ctx context.Context, obj *types.Membership) (*types.Organization, error)

	LastSession(ctx context.Context, obj *types.Membership) (*types.Session, error)
	Permission(ctx context.Context, obj *types.Membership, action string) (bool, error)
}
type MembershipConnectionResolver interface {
	TotalCount(ctx context.Context, obj *types.MembershipConnection) (*int, error)
}
type MembershipProfileResolver interface {
	Identity(ctx context.Context, obj *types.MembershipProfile) (*types.Identity, error)
	Organization(ctx context.Context, obj *types.MembershipProfile) (*types.Organization, error)

	Permission(ctx context.Context, obj *types.MembershipProfile, action string) (bool, error)
}
type MutationResolver interface {
	SignIn(ctx context.Context, input types.SignInInput) (*types.SignInPayload, error)
	SignUp(ctx context.Context, input types.SignUpInput) (*types.SignUpPayload, error)
	SignOut(ctx context.Context) (*types.SignOutPayload, error)
	SignUpFromInvitation(ctx context.Context, input types.SignUpFromInvitationInput) (*types.SignUpFromInvitationPayload, error)
	ForgotPassword(ctx context.Context, input types.ForgotPasswordInput) (*types.ForgotPasswordPayload, error)
	ResetPassword(ctx context.Context, input types.ResetPasswordInput) (*types.ResetPasswordPayload, error)
	VerifyEmail(ctx context.Context, input types.VerifyEmailInput) (*types.VerifyEmailPayload, error)
	ChangePassword(ctx context.Context, input types.ChangePasswordInput) (*types.ChangePasswordPayload, error)
	ChangeEmail(ctx context.Context, input types.ChangeEmailInput) (*types.ChangeEmailPayload, error)
	AssumeOrganizationSession(ctx context.Context, input types.AssumeOrganizationSessionInput) (*types.AssumeOrganizationSessionPayload, error)
	RevokeSession(ctx context.Context, input types.RevokeSessionInput) (*types.RevokeSessionPayload, error)
	RevokeAllSessions(ctx context.Context) (*types.RevokeAllSessionsPayload, error)
	CreatePersonalAPIKey(ctx context.Context, input types.CreatePersonalAPIKeyInput) (*types.CreatePersonalAPIKeyPayload, error)
	RevokePersonalAPIKey(ctx context.Context, input types.RevokePersonalAPIKeyInput) (*types.RevokePersonalAPIKeyPayload, error)
	CreateOrganization(ctx context.Context, input types.CreateOrganizationInput) (*types.CreateOrganizationPayload, error)
	UpdateOrganization(ctx context.Context, input types.UpdateOrganizationInput) (*types.UpdateOrganizationPayload, error)
	DeleteOrganization(ctx context.Context, input types.DeleteOrganizationInput) (*types.DeleteOrganizationPayload, error)
	DeleteOrganizationHorizontalLogo(ctx context.Context, input types.DeleteOrganizationHorizontalLogoInput) (*types.DeleteOrganizationHorizontalLogoPayload, error)
	InviteMember(ctx context.Context, input types.InviteMemberInput) (*types.InviteMemberPayload, error)
	DeleteInvitation(ctx context.Context, input types.DeleteInvitationInput) (*types.DeleteInvitationPayload, error)
	UpdateProfile(ctx context.Context, input types.UpdateProfileInput) (*types.UpdateProfilePayload, error)
	UpdateMembership(ctx context.Context, input types.UpdateMembershipInput) (*types.UpdateMembershipPayload, error)
	RemoveMember(ctx context.Context, input types.RemoveMemberInput) (*types.RemoveMemberPayload, error)
	AcceptInvitation(ctx context.Context, input types.AcceptInvitationInput) (*types.AcceptInvitationPayload, error)
	CreateSAMLConfiguration(ctx context.Context, input types.CreateSAMLConfigurationInput) (*types.CreateSAMLConfigurationPayload, error)
	UpdateSAMLConfiguration(ctx context.Context, input types.UpdateSAMLConfigurationInput) (*types.UpdateSAMLConfigurationPayload, error)
	DeleteSAMLConfiguration(ctx context.Context, input types.DeleteSAMLConfigurationInput) (*types.DeleteSAMLConfigurationPayload, error)
	CreateSCIMConfiguration(ctx context.Context, input types.CreateSCIMConfigurationInput) (*types.CreateSCIMConfigurationPayload, error)
	DeleteSCIMConfiguration(ctx context.Context, input types.DeleteSCIMConfigurationInput) (*types.DeleteSCIMConfigurationPayload, error)
	RegenerateSCIMToken(ctx context.Context, input types.RegenerateSCIMTokenInput) (*types.RegenerateSCIMTokenPayload, error)
	UpdateSCIMBridge(ctx context.Context, input types.UpdateSCIMBridgeInput) (*types.UpdateSCIMBridgePayload, error)
}
type OrganizationResolver interface {
	LogoURL(ctx context.Context, obj *types.Organization) (*string, error)
	HorizontalLogoURL(ctx context.Context, obj *types.Organization) (*string, error)

	Members(ctx context.Context, obj *types.Organization, first *int, after *page.CursorKey, last *int, before *page.CursorKey, orderBy *types.MembershipOrderBy) (*types.MembershipConnection, error)
	Invitations(ctx context.Context, obj *types.Organization, first *int, after *page.CursorKey, last *int, before *page.CursorKey, status *coredata.InvitationStatus, orderBy *types.InvitationOrderBy) (*types.InvitationConnection, error)
	SamlConfigurations(ctx context.Context, obj *types.Organization, first *int, after *page.CursorKey, last *int, before *page.CursorKey) (*types.SAMLConfigurationConnection, error)
	ScimConfiguration(ctx context.Context, obj *types.Organization) (*types.SCIMConfiguration, error)
	ViewerMembership(ctx context.Context, obj *types.Organization) (*types.Membership, error)
	Permission(ctx context.Context, obj *types.Organization, action string) (bool, error)
}
type PersonalAPIKeyResolver interface {
	Token(ctx context.Context, obj *types.PersonalAPIKey) (*string, error)
	Permission(ctx context.Context, obj *types.PersonalAPIKey, action string) (bool, error)
}
type PersonalAPIKeyConnectionResolver interface {
	TotalCount(ctx context.Context, obj *types.PersonalAPIKeyConnection) (*int, error)
}
type QueryResolver interface {
	Node(ctx context.Context, id gid.GID) (types.Node, error)
	Viewer(ctx context.Context) (*types.Identity, error)
	SsoLoginURL(ctx context.Context, email mail.Addr) (*string, error)
}
type SAMLConfigurationResolver interface {
	TestLoginURL(ctx context.Context, obj *types.SAMLConfiguration) (string, error)

	Permission(ctx context.Context, obj *types.SAMLConfiguration, action string) (bool, error)
}
type SAMLConfigurationConnectionResolver interface {
	TotalCount(ctx context.Context, obj *types.SAMLConfigurationConnection) (*int, error)
}
type SCIMBridgeResolver interface {
	ScimConfiguration(ctx context.Context, obj *types.SCIMBridge) (*types.SCIMConfiguration, error)
	Connector(ctx context.Context, obj *types.SCIMBridge) (*types.Connector, error)

	Permission(ctx context.Context, obj *types.SCIMBridge, action string) (bool, error)
}
type SCIMConfigurationResolver interface {
	EndpointURL(ctx context.Context, obj *types.SCIMConfiguration) (string, error)

	Organization(ctx context.Context, obj *types.SCIMConfiguration) (*types.Organization, error)
	Bridge(ctx context.Context, obj *types.SCIMConfiguration) (*types.SCIMBridge, error)
	Events(ctx context.Context, obj *types.SCIMConfiguration, first *int, after *page.CursorKey, last *int, before *page.CursorKey, orderBy *types.SCIMEventOrderBy) (*types.SCIMEventConnection, error)
	Permission(ctx context.Context, obj *types.SCIMConfiguration, action string) (bool, error)
}
type SCIMEventResolver interface {
	Membership(ctx context.Context, obj *types.SCIMEvent) (*types.Membership, error)

	Permission(ctx context.Context, obj *types.SCIMEvent, action string) (bool, error)
}
type SCIMEventConnectionResolver interface {
	TotalCount(ctx context.Context, obj *types.SCIMEventConnection) (*int, error)
}
type SessionResolver interface {
	Identity(ctx context.Context, obj *types.Session) (*types.Identity, error)

	Permission(ctx context.Context, obj *types.Session, action string) (bool, error)
}
type SessionConnectionResolver interface {
	TotalCount(ctx context.Context, obj *types.SessionConnection) (*int, error)
}

type executableSchema struct {
	schema     *ast.Schema
	resolvers  ResolverRoot
	directives DirectiveRoot
	complexity ComplexityRoot
}

func (e *executableSchema) Schema() *ast.Schema {
	if e.schema != nil {
		return e.schema
	}
	return parsedSchema
}

func (e *executableSchema) Complexity(ctx context.Context, typeName, field string, childComplexity int, rawArgs map[string]any) (int, bool) {
	ec := executionContext{nil, e, 0, 0, nil}
	_ = ec
	switch typeName + "." + field {

	case "AcceptInvitationPayload.invitation":
		if e.complexity.AcceptInvitationPayload.Invitation == nil {
			break
		}

		return e.complexity.AcceptInvitationPayload.Invitation(childComplexity), true
	case "AcceptInvitationPayload.membershipEdge":
		if e.complexity.AcceptInvitationPayload.MembershipEdge == nil {
			break
		}

		return e.complexity.AcceptInvitationPayload.MembershipEdge(childComplexity), true

	case "AssumeOrganizationSessionPayload.result":
		if e.complexity.AssumeOrganizationSessionPayload.Result == nil {
			break
		}

		return e.complexity.AssumeOrganizationSessionPayload.Result(childComplexity), true

	case "ChangeEmailPayload.success":
		if e.complexity.ChangeEmailPayload.Success == nil {
			break
		}

		return e.complexity.ChangeEmailPayload.Success(childComplexity), true

	case "ChangePasswordPayload.success":
		if e.complexity.ChangePasswordPayload.Success == nil {
			break
		}

		return e.complexity.ChangePasswordPayload.Success(childComplexity), true

	case "Connector.createdAt":
		if e.complexity.Connector.CreatedAt == nil {
			break
		}

		return e.complexity.Connector.CreatedAt(childComplexity), true
	case "Connector.id":
		if e.complexity.Connector.ID == nil {
			break
		}

		return e.complexity.Connector.ID(childComplexity), true
	case "Connector.permission":
		if e.complexity.Connector.Permission == nil {
			break
		}

		args, err := ec.field_Connector_permission_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Connector.Permission(childComplexity, args["action"].(string)), true
	case "Connector.provider":
		if e.complexity.Connector.Provider == nil {
			break
		}

		return e.complexity.Connector.Provider(childComplexity), true
	case "Connector.updatedAt":
		if e.complexity.Connector.UpdatedAt == nil {
			break
		}

		return e.complexity.Connector.UpdatedAt(childComplexity), true

	case "CreateOrganizationPayload.membershipEdge":
		if e.complexity.CreateOrganizationPayload.MembershipEdge == nil {
			break
		}

		return e.complexity.CreateOrganizationPayload.MembershipEdge(childComplexity), true
	case "CreateOrganizationPayload.organization":
		if e.complexity.CreateOrganizationPayload.Organization == nil {
			break
		}

		return e.complexity.CreateOrganizationPayload.Organization(childComplexity), true

	case "CreatePersonalAPIKeyPayload.personalAPIKeyEdge":
		if e.complexity.CreatePersonalAPIKeyPayload.PersonalAPIKeyEdge == nil {
			break
		}

		return e.complexity.CreatePersonalAPIKeyPayload.PersonalAPIKeyEdge(childComplexity), true
	case "CreatePersonalAPIKeyPayload.token":
		if e.complexity.CreatePersonalAPIKeyPayload.Token == nil {
			break
		}

		return e.complexity.CreatePersonalAPIKeyPayload.Token(childComplexity), true

	case "CreateSAMLConfigurationPayload.samlConfigurationEdge":
		if e.complexity.CreateSAMLConfigurationPayload.SamlConfigurationEdge == nil {
			break
		}

		return e.complexity.CreateSAMLConfigurationPayload.SamlConfigurationEdge(childComplexity), true

	case "CreateSCIMConfigurationPayload.scimBridge":
		if e.complexity.CreateSCIMConfigurationPayload.ScimBridge == nil {
			break
		}

		return e.complexity.CreateSCIMConfigurationPayload.ScimBridge(childComplexity), true
	case "CreateSCIMConfigurationPayload.scimConfiguration":
		if e.complexity.CreateSCIMConfigurationPayload.ScimConfiguration == nil {
			break
		}

		return e.complexity.CreateSCIMConfigurationPayload.ScimConfiguration(childComplexity), true
	case "CreateSCIMConfigurationPayload.token":
		if e.complexity.CreateSCIMConfigurationPayload.Token == nil {
			break
		}

		return e.complexity.CreateSCIMConfigurationPayload.Token(childComplexity), true

	case "DeleteInvitationPayload.deletedInvitationId":
		if e.complexity.DeleteInvitationPayload.DeletedInvitationID == nil {
			break
		}

		return e.complexity.DeleteInvitationPayload.DeletedInvitationID(childComplexity), true

	case "DeleteOrganizationHorizontalLogoPayload.organization":
		if e.complexity.DeleteOrganizationHorizontalLogoPayload.Organization == nil {
			break
		}

		return e.complexity.DeleteOrganizationHorizontalLogoPayload.Organization(childComplexity), true

	case "DeleteOrganizationPayload.deletedOrganizationId":
		if e.complexity.DeleteOrganizationPayload.DeletedOrganizationID == nil {
			break
		}

		return e.complexity.DeleteOrganizationPayload.DeletedOrganizationID(childComplexity), true

	case "DeleteSAMLConfigurationPayload.deletedSamlConfigurationId":
		if e.complexity.DeleteSAMLConfigurationPayload.DeletedSamlConfigurationID == nil {
			break
		}

		return e.complexity.DeleteSAMLConfigurationPayload.DeletedSamlConfigurationID(childComplexity), true

	case "DeleteSCIMConfigurationPayload.deletedScimConfigurationId":
		if e.complexity.DeleteSCIMConfigurationPayload.DeletedScimConfigurationID == nil {
			break
		}

		return e.complexity.DeleteSCIMConfigurationPayload.DeletedScimConfigurationID(childComplexity), true

	case "ForgotPasswordPayload.success":
		if e.complexity.ForgotPasswordPayload.Success == nil {
			break
		}

		return e.complexity.ForgotPasswordPayload.Success(childComplexity), true

	case "Identity.createdAt":
		if e.complexity.Identity.CreatedAt == nil {
			break
		}

		return e.complexity.Identity.CreatedAt(childComplexity), true
	case "Identity.email":
		if e.complexity.Identity.Email == nil {
			break
		}

		return e.complexity.Identity.Email(childComplexity), true
	case "Identity.emailVerified":
		if e.complexity.Identity.EmailVerified == nil {
			break
		}

		return e.complexity.Identity.EmailVerified(childComplexity), true
	case "Identity.fullName":
		if e.complexity.Identity.FullName == nil {
			break
		}

		return e.complexity.Identity.FullName(childComplexity), true
	case "Identity.id":
		if e.complexity.Identity.ID == nil {
			break
		}

		return e.complexity.Identity.ID(childComplexity), true
	case "Identity.memberships":
		if e.complexity.Identity.Memberships == nil {
			break
		}

		args, err := ec.field_Identity_memberships_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Identity.Memberships(childComplexity, args["first"].(*int), args["after"].(*page.CursorKey), args["last"].(*int), args["before"].(*page.CursorKey), args["orderBy"].(*types.MembershipOrderBy)), true
	case "Identity.pendingInvitations":
		if e.complexity.Identity.PendingInvitations == nil {
			break
		}

		args, err := ec.field_Identity_pendingInvitations_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Identity.PendingInvitations(childComplexity, args["first"].(*int), args["after"].(*page.CursorKey), args["last"].(*int), args["before"].(*page.CursorKey), args["orderBy"].(*types.InvitationOrderBy)), true
	case "Identity.permission":
		if e.complexity.Identity.Permission == nil {
			break
		}

		args, err := ec.field_Identity_permission_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Identity.Permission(childComplexity, args["action"].(string)), true
	case "Identity.personalAPIKeys":
		if e.complexity.Identity.PersonalAPIKeys == nil {
			break
		}

		args, err := ec.field_Identity_personalAPIKeys_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Identity.PersonalAPIKeys(childComplexity, args["first"].(*int), args["after"].(*page.CursorKey), args["last"].(*int), args["before"].(*page.CursorKey)), true
	case "Identity.sessions":
		if e.complexity.Identity.Sessions == nil {
			break
		}

		args, err := ec.field_Identity_sessions_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Identity.Sessions(childComplexity, args["first"].(*int), args["after"].(*page.CursorKey), args["last"].(*int), args["before"].(*page.CursorKey), args["orderBy"].(*types.SessionOrder)), true
	case "Identity.updatedAt":
		if e.complexity.Identity.UpdatedAt == nil {
			break
		}

		return e.complexity.Identity.UpdatedAt(childComplexity), true

	case "Invitation.acceptedAt":
		if e.complexity.Invitation.AcceptedAt == nil {
			break
		}

		return e.complexity.Invitation.AcceptedAt(childComplexity), true
	case "Invitation.createdAt":
		if e.complexity.Invitation.CreatedAt == nil {
			break
		}

		return e.complexity.Invitation.CreatedAt(childComplexity), true
	case "Invitation.email":
		if e.complexity.Invitation.Email == nil {
			break
		}

		return e.complexity.Invitation.Email(childComplexity), true
	case "Invitation.expiresAt":
		if e.complexity.Invitation.ExpiresAt == nil {
			break
		}

		return e.complexity.Invitation.ExpiresAt(childComplexity), true
	case "Invitation.fullName":
		if e.complexity.Invitation.FullName == nil {
			break
		}

		return e.complexity.Invitation.FullName(childComplexity), true
	case "Invitation.id":
		if e.complexity.Invitation.ID == nil {
			break
		}

		return e.complexity.Invitation.ID(childComplexity), true
	case "Invitation.organization":
		if e.complexity.Invitation.Organization == nil {
			break
		}

		return e.complexity.Invitation.Organization(childComplexity), true
	case "Invitation.permission":
		if e.complexity.Invitation.Permission == nil {
			break
		}

		args, err := ec.field_Invitation_permission_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Invitation.Permission(childComplexity, args["action"].(string)), true
	case "Invitation.role":
		if e.complexity.Invitation.Role == nil {
			break
		}

		return e.complexity.Invitation.Role(childComplexity), true
	case "Invitation.status":
		if e.complexity.Invitation.Status == nil {
			break
		}

		return e.complexity.Invitation.Status(childComplexity), true

	case "InvitationConnection.edges":
		if e.complexity.InvitationConnection.Edges == nil {
			break
		}

		return e.complexity.InvitationConnection.Edges(childComplexity), true
	case "InvitationConnection.pageInfo":
		if e.complexity.InvitationConnection.PageInfo == nil {
			break
		}

		return e.complexity.InvitationConnection.PageInfo(childComplexity), true
	case "InvitationConnection.totalCount":
		if e.complexity.InvitationConnection.TotalCount == nil {
			break
		}

		return e.complexity.InvitationConnection.TotalCount(childComplexity), true

	case "InvitationEdge.cursor":
		if e.complexity.InvitationEdge.Cursor == nil {
			break
		}

		return e.complexity.InvitationEdge.Cursor(childComplexity), true
	case "InvitationEdge.node":
		if e.complexity.InvitationEdge.Node == nil {
			break
		}

		return e.complexity.InvitationEdge.Node(childComplexity), true

	case "InviteMemberPayload.invitationEdge":
		if e.complexity.InviteMemberPayload.InvitationEdge == nil {
			break
		}

		return e.complexity.InviteMemberPayload.InvitationEdge(childComplexity), true

	case "Membership.createdAt":
		if e.complexity.Membership.CreatedAt == nil {
			break
		}

		return e.complexity.Membership.CreatedAt(childComplexity), true
	case "Membership.id":
		if e.complexity.Membership.ID == nil {
			break
		}

		return e.complexity.Membership.ID(childComplexity), true
	case "Membership.identity":
		if e.complexity.Membership.Identity == nil {
			break
		}

		return e.complexity.Membership.Identity(childComplexity), true
	case "Membership.lastSession":
		if e.complexity.Membership.LastSession == nil {
			break
		}

		return e.complexity.Membership.LastSession(childComplexity), true
	case "Membership.organization":
		if e.complexity.Membership.Organization == nil {
			break
		}

		return e.complexity.Membership.Organization(childComplexity), true
	case "Membership.permission":
		if e.complexity.Membership.Permission == nil {
			break
		}

		args, err := ec.field_Membership_permission_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Membership.Permission(childComplexity, args["action"].(string)), true
	case "Membership.profile":
		if e.complexity.Membership.Profile == nil {
			break
		}

		return e.complexity.Membership.Profile(childComplexity), true
	case "Membership.role":
		if e.complexity.Membership.Role == nil {
			break
		}

		return e.complexity.Membership.Role(childComplexity), true
	case "Membership.source":
		if e.complexity.Membership.Source == nil {
			break
		}

		return e.complexity.Membership.Source(childComplexity), true
	case "Membership.state":
		if e.complexity.Membership.State == nil {
			break
		}

		return e.complexity.Membership.State(childComplexity), true

	case "MembershipConnection.edges":
		if e.complexity.MembershipConnection.Edges == nil {
			break
		}

		return e.complexity.MembershipConnection.Edges(childComplexity), true
	case "MembershipConnection.pageInfo":
		if e.complexity.MembershipConnection.PageInfo == nil {
			break
		}

		return e.complexity.MembershipConnection.PageInfo(childComplexity), true
	case "MembershipConnection.totalCount":
		if e.complexity.MembershipConnection.TotalCount == nil {
			break
		}

		return e.complexity.MembershipConnection.TotalCount(childComplexity), true

	case "MembershipEdge.cursor":
		if e.complexity.MembershipEdge.Cursor == nil {
			break
		}

		return e.complexity.MembershipEdge.Cursor(childComplexity), true
	case "MembershipEdge.node":
		if e.complexity.MembershipEdge.Node == nil {
			break
		}

		return e.complexity.MembershipEdge.Node(childComplexity), true

	case "MembershipProfile.additionalEmailAddresses":
		if e.complexity.MembershipProfile.AdditionalEmailAddresses == nil {
			break
		}

		return e.complexity.MembershipProfile.AdditionalEmailAddresses(childComplexity), true
	case "MembershipProfile.contractEndDate":
		if e.complexity.MembershipProfile.ContractEndDate == nil {
			break
		}

		return e.complexity.MembershipProfile.ContractEndDate(childComplexity), true
	case "MembershipProfile.contractStartDate":
		if e.complexity.MembershipProfile.ContractStartDate == nil {
			break
		}

		return e.complexity.MembershipProfile.ContractStartDate(childComplexity), true
	case "MembershipProfile.createdAt":
		if e.complexity.MembershipProfile.CreatedAt == nil {
			break
		}

		return e.complexity.MembershipProfile.CreatedAt(childComplexity), true
	case "MembershipProfile.fullName":
		if e.complexity.MembershipProfile.FullName == nil {
			break
		}

		return e.complexity.MembershipProfile.FullName(childComplexity), true
	case "MembershipProfile.id":
		if e.complexity.MembershipProfile.ID == nil {
			break
		}

		return e.complexity.MembershipProfile.ID(childComplexity), true
	case "MembershipProfile.identity":
		if e.complexity.MembershipProfile.Identity == nil {
			break
		}

		return e.complexity.MembershipProfile.Identity(childComplexity), true
	case "MembershipProfile.kind":
		if e.complexity.MembershipProfile.Kind == nil {
			break
		}

		return e.complexity.MembershipProfile.Kind(childComplexity), true
	case "MembershipProfile.membershipId":
		if e.complexity.MembershipProfile.MembershipID == nil {
			break
		}

		return e.complexity.MembershipProfile.MembershipID(childComplexity), true
	case "MembershipProfile.organization":
		if e.complexity.MembershipProfile.Organization == nil {
			break
		}

		return e.complexity.MembershipProfile.Organization(childComplexity), true
	case "MembershipProfile.permission":
		if e.complexity.MembershipProfile.Permission == nil {
			break
		}

		args, err := ec.field_MembershipProfile_permission_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.MembershipProfile.Permission(childComplexity, args["action"].(string)), true
	case "MembershipProfile.position":
		if e.complexity.MembershipProfile.Position == nil {
			break
		}

		return e.complexity.MembershipProfile.Position(childComplexity), true
	case "MembershipProfile.updatedAt":
		if e.complexity.MembershipProfile.UpdatedAt == nil {
			break
		}

		return e.complexity.MembershipProfile.UpdatedAt(childComplexity), true

	case "Mutation.acceptInvitation":
		if e.complexity.Mutation.AcceptInvitation == nil {
			break
		}

		args, err := ec.field_Mutation_acceptInvitation_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Mutation.AcceptInvitation(childComplexity, args["input"].(types.AcceptInvitationInput)), true
	case "Mutation.assumeOrganizationSession":
		if e.complexity.Mutation.AssumeOrganizationSession == nil {
			break
		}

		args, err := ec.field_Mutation_assumeOrganizationSession_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Mutation.AssumeOrganizationSession(childComplexity, args["input"].(types.AssumeOrganizationSessionInput)), true
	case "Mutation.changeEmail":
		if e.complexity.Mutation.ChangeEmail == nil {
			break
		}

		args, err := ec.field_Mutation_changeEmail_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Mutation.ChangeEmail(childComplexity, args["input"].(types.ChangeEmailInput)), true
	case "Mutation.changePassword":
		if e.complexity.Mutation.ChangePassword == nil {
			break
		}

		args, err := ec.field_Mutation_changePassword_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Mutation.ChangePassword(childComplexity, args["input"].(types.ChangePasswordInput)), true
	case "Mutation.createOrganization":
		if e.complexity.Mutation.CreateOrganization == nil {
			break
		}

		args, err := ec.field_Mutation_createOrganization_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Mutation.CreateOrganization(childComplexity, args["input"].(types.CreateOrganizationInput)), true
	case "Mutation.createPersonalAPIKey":
		if e.complexity.Mutation.CreatePersonalAPIKey == nil {
			break
		}

		args, err := ec.field_Mutation_createPersonalAPIKey_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Mutation.CreatePersonalAPIKey(childComplexity, args["input"].(types.CreatePersonalAPIKeyInput)), true
	case "Mutation.createSAMLConfiguration":
		if e.complexity.Mutation.CreateSAMLConfiguration == nil {
			break
		}

		args, err := ec.field_Mutation_createSAMLConfiguration_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Mutation.CreateSAMLConfiguration(childComplexity, args["input"].(types.CreateSAMLConfigurationInput)), true
	case "Mutation.createSCIMConfiguration":
		if e.complexity.Mutation.CreateSCIMConfiguration == nil {
			break
		}

		args, err := ec.field_Mutation_createSCIMConfiguration_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Mutation.CreateSCIMConfiguration(childComplexity, args["input"].(types.CreateSCIMConfigurationInput)), true
	case "Mutation.deleteInvitation":
		if e.complexity.Mutation.DeleteInvitation == nil {
			break
		}

		args, err := ec.field_Mutation_deleteInvitation_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Mutation.DeleteInvitation(childComplexity, args["input"].(types.DeleteInvitationInput)), true
	case "Mutation.deleteOrganization":
		if e.complexity.Mutation.DeleteOrganization == nil {
			break
		}

		args, err := ec.field_Mutation_deleteOrganization_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Mutation.DeleteOrganization(childComplexity, args["input"].(types.DeleteOrganizationInput)), true
	case "Mutation.deleteOrganizationHorizontalLogo":
		if e.complexity.Mutation.DeleteOrganizationHorizontalLogo == nil {
			break
		}

		args, err := ec.field_Mutation_deleteOrganizationHorizontalLogo_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Mutation.DeleteOrganizationHorizontalLogo(childComplexity, args["input"].(types.DeleteOrganizationHorizontalLogoInput)), true
	case "Mutation.deleteSAMLConfiguration":
		if e.complexity.Mutation.DeleteSAMLConfiguration == nil {
			break
		}

		args, err := ec.field_Mutation_deleteSAMLConfiguration_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Mutation.DeleteSAMLConfiguration(childComplexity, args["input"].(types.DeleteSAMLConfigurationInput)), true
	case "Mutation.deleteSCIMConfiguration":
		if e.complexity.Mutation.DeleteSCIMConfiguration == nil {
			break
		}

		args, err := ec.field_Mutation_deleteSCIMConfiguration_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Mutation.DeleteSCIMConfiguration(childComplexity, args["input"].(types.DeleteSCIMConfigurationInput)), true
	case "Mutation.forgotPassword":
		if e.complexity.Mutation.ForgotPassword == nil {
			break
		}

		args, err := ec.field_Mutation_forgotPassword_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Mutation.ForgotPassword(childComplexity, args["input"].(types.ForgotPasswordInput)), true
	case "Mutation.inviteMember":
		if e.complexity.Mutation.InviteMember == nil {
			break
		}

		args, err := ec.field_Mutation_inviteMember_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Mutation.InviteMember(childComplexity, args["input"].(types.InviteMemberInput)), true
	case "Mutation.regenerateSCIMToken":
		if e.complexity.Mutation.RegenerateSCIMToken == nil {
			break
		}

		args, err := ec.field_Mutation_regenerateSCIMToken_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Mutation.RegenerateSCIMToken(childComplexity, args["input"].(types.RegenerateSCIMTokenInput)), true
	case "Mutation.removeMember":
		if e.complexity.Mutation.RemoveMember == nil {
			break
		}

		args, err := ec.field_Mutation_removeMember_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Mutation.RemoveMember(childComplexity, args["input"].(types.RemoveMemberInput)), true
	case "Mutation.resetPassword":
		if e.complexity.Mutation.ResetPassword == nil {
			break
		}

		args, err := ec.field_Mutation_resetPassword_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Mutation.ResetPassword(childComplexity, args["input"].(types.ResetPasswordInput)), true
	case "Mutation.revokeAllSessions":
		if e.complexity.Mutation.RevokeAllSessions == nil {
			break
		}

		return e.complexity.Mutation.RevokeAllSessions(childComplexity), true
	case "Mutation.revokePersonalAPIKey":
		if e.complexity.Mutation.RevokePersonalAPIKey == nil {
			break
		}

		args, err := ec.field_Mutation_revokePersonalAPIKey_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Mutation.RevokePersonalAPIKey(childComplexity, args["input"].(types.RevokePersonalAPIKeyInput)), true
	case "Mutation.revokeSession":
		if e.complexity.Mutation.RevokeSession == nil {
			break
		}

		args, err := ec.field_Mutation_revokeSession_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Mutation.RevokeSession(childComplexity, args["input"].(types.RevokeSessionInput)), true
	case "Mutation.signIn":
		if e.complexity.Mutation.SignIn == nil {
			break
		}

		args, err := ec.field_Mutation_signIn_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Mutation.SignIn(childComplexity, args["input"].(types.SignInInput)), true
	case "Mutation.signOut":
		if e.complexity.Mutation.SignOut == nil {
			break
		}

		return e.complexity.Mutation.SignOut(childComplexity), true
	case "Mutation.signUp":
		if e.complexity.Mutation.SignUp == nil {
			break
		}

		args, err := ec.field_Mutation_signUp_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Mutation.SignUp(childComplexity, args["input"].(types.SignUpInput)), true
	case "Mutation.signUpFromInvitation":
		if e.complexity.Mutation.SignUpFromInvitation == nil {
			break
		}

		args, err := ec.field_Mutation_signUpFromInvitation_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Mutation.SignUpFromInvitation(childComplexity, args["input"].(types.SignUpFromInvitationInput)), true
	case "Mutation.updateMembership":
		if e.complexity.Mutation.UpdateMembership == nil {
			break
		}

		args, err := ec.field_Mutation_updateMembership_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Mutation.UpdateMembership(childComplexity, args["input"].(types.UpdateMembershipInput)), true
	case "Mutation.updateOrganization":
		if e.complexity.Mutation.UpdateOrganization == nil {
			break
		}

		args, err := ec.field_Mutation_updateOrganization_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Mutation.UpdateOrganization(childComplexity, args["input"].(types.UpdateOrganizationInput)), true
	case "Mutation.updateProfile":
		if e.complexity.Mutation.UpdateProfile == nil {
			break
		}

		args, err := ec.field_Mutation_updateProfile_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Mutation.UpdateProfile(childComplexity, args["input"].(types.UpdateProfileInput)), true
	case "Mutation.updateSAMLConfiguration":
		if e.complexity.Mutation.UpdateSAMLConfiguration == nil {
			break
		}

		args, err := ec.field_Mutation_updateSAMLConfiguration_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Mutation.UpdateSAMLConfiguration(childComplexity, args["input"].(types.UpdateSAMLConfigurationInput)), true
	case "Mutation.updateSCIMBridge":
		if e.complexity.Mutation.UpdateSCIMBridge == nil {
			break
		}

		args, err := ec.field_Mutation_updateSCIMBridge_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Mutation.UpdateSCIMBridge(childComplexity, args["input"].(types.UpdateSCIMBridgeInput)), true
	case "Mutation.verifyEmail":
		if e.complexity.Mutation.VerifyEmail == nil {
			break
		}

		args, err := ec.field_Mutation_verifyEmail_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Mutation.VerifyEmail(childComplexity, args["input"].(types.VerifyEmailInput)), true

	case "Organization.createdAt":
		if e.complexity.Organization.CreatedAt == nil {
			break
		}

		return e.complexity.Organization.CreatedAt(childComplexity), true
	case "Organization.description":
		if e.complexity.Organization.Description == nil {
			break
		}

		return e.complexity.Organization.Description(childComplexity), true
	case "Organization.email":
		if e.complexity.Organization.Email == nil {
			break
		}

		return e.complexity.Organization.Email(childComplexity), true
	case "Organization.headquarterAddress":
		if e.complexity.Organization.HeadquarterAddress == nil {
			break
		}

		return e.complexity.Organization.HeadquarterAddress(childComplexity), true
	case "Organization.horizontalLogoUrl":
		if e.complexity.Organization.HorizontalLogoURL == nil {
			break
		}

		return e.complexity.Organization.HorizontalLogoURL(childComplexity), true
	case "Organization.id":
		if e.complexity.Organization.ID == nil {
			break
		}

		return e.complexity.Organization.ID(childComplexity), true
	case "Organization.invitations":
		if e.complexity.Organization.Invitations == nil {
			break
		}

		args, err := ec.field_Organization_invitations_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Organization.Invitations(childComplexity, args["first"].(*int), args["after"].(*page.CursorKey), args["last"].(*int), args["before"].(*page.CursorKey), args["status"].(*coredata.InvitationStatus), args["orderBy"].(*types.InvitationOrderBy)), true
	case "Organization.logoUrl":
		if e.complexity.Organization.LogoURL == nil {
			break
		}

		return e.complexity.Organization.LogoURL(childComplexity), true
	case "Organization.members":
		if e.complexity.Organization.Members == nil {
			break
		}

		args, err := ec.field_Organization_members_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Organization.Members(childComplexity, args["first"].(*int), args["after"].(*page.CursorKey), args["last"].(*int), args["before"].(*page.CursorKey), args["orderBy"].(*types.MembershipOrderBy)), true
	case "Organization.name":
		if e.complexity.Organization.Name == nil {
			break
		}

		return e.complexity.Organization.Name(childComplexity), true
	case "Organization.permission":
		if e.complexity.Organization.Permission == nil {
			break
		}

		args, err := ec.field_Organization_permission_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Organization.Permission(childComplexity, args["action"].(string)), true
	case "Organization.samlConfigurations":
		if e.complexity.Organization.SamlConfigurations == nil {
			break
		}

		args, err := ec.field_Organization_samlConfigurations_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Organization.SamlConfigurations(childComplexity, args["first"].(*int), args["after"].(*page.CursorKey), args["last"].(*int), args["before"].(*page.CursorKey)), true
	case "Organization.scimConfiguration":
		if e.complexity.Organization.ScimConfiguration == nil {
			break
		}

		return e.complexity.Organization.ScimConfiguration(childComplexity), true
	case "Organization.updatedAt":
		if e.complexity.Organization.UpdatedAt == nil {
			break
		}

		return e.complexity.Organization.UpdatedAt(childComplexity), true
	case "Organization.viewerMembership":
		if e.complexity.Organization.ViewerMembership == nil {
			break
		}

		return e.complexity.Organization.ViewerMembership(childComplexity), true
	case "Organization.websiteUrl":
		if e.complexity.Organization.WebsiteURL == nil {
			break
		}

		return e.complexity.Organization.WebsiteURL(childComplexity), true

	case "OrganizationSessionCreated.membership":
		if e.complexity.OrganizationSessionCreated.Membership == nil {
			break
		}

		return e.complexity.OrganizationSessionCreated.Membership(childComplexity), true
	case "OrganizationSessionCreated.session":
		if e.complexity.OrganizationSessionCreated.Session == nil {
			break
		}

		return e.complexity.OrganizationSessionCreated.Session(childComplexity), true

	case "PageInfo.endCursor":
		if e.complexity.PageInfo.EndCursor == nil {
			break
		}

		return e.complexity.PageInfo.EndCursor(childComplexity), true
	case "PageInfo.hasNextPage":
		if e.complexity.PageInfo.HasNextPage == nil {
			break
		}

		return e.complexity.PageInfo.HasNextPage(childComplexity), true
	case "PageInfo.hasPreviousPage":
		if e.complexity.PageInfo.HasPreviousPage == nil {
			break
		}

		return e.complexity.PageInfo.HasPreviousPage(childComplexity), true
	case "PageInfo.startCursor":
		if e.complexity.PageInfo.StartCursor == nil {
			break
		}

		return e.complexity.PageInfo.StartCursor(childComplexity), true

	case "PasswordRequired.reason":
		if e.complexity.PasswordRequired.Reason == nil {
			break
		}

		return e.complexity.PasswordRequired.Reason(childComplexity), true

	case "PersonalAPIKey.createdAt":
		if e.complexity.PersonalAPIKey.CreatedAt == nil {
			break
		}

		return e.complexity.PersonalAPIKey.CreatedAt(childComplexity), true
	case "PersonalAPIKey.expiresAt":
		if e.complexity.PersonalAPIKey.ExpiresAt == nil {
			break
		}

		return e.complexity.PersonalAPIKey.ExpiresAt(childComplexity), true
	case "PersonalAPIKey.id":
		if e.complexity.PersonalAPIKey.ID == nil {
			break
		}

		return e.complexity.PersonalAPIKey.ID(childComplexity), true
	case "PersonalAPIKey.lastUsedAt":
		if e.complexity.PersonalAPIKey.LastUsedAt == nil {
			break
		}

		return e.complexity.PersonalAPIKey.LastUsedAt(childComplexity), true
	case "PersonalAPIKey.name":
		if e.complexity.PersonalAPIKey.Name == nil {
			break
		}

		return e.complexity.PersonalAPIKey.Name(childComplexity), true
	case "PersonalAPIKey.permission":
		if e.complexity.PersonalAPIKey.Permission == nil {
			break
		}

		args, err := ec.field_PersonalAPIKey_permission_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.PersonalAPIKey.Permission(childComplexity, args["action"].(string)), true
	case "PersonalAPIKey.token":
		if e.complexity.PersonalAPIKey.Token == nil {
			break
		}

		return e.complexity.PersonalAPIKey.Token(childComplexity), true

	case "PersonalAPIKeyConnection.edges":
		if e.complexity.PersonalAPIKeyConnection.Edges == nil {
			break
		}

		return e.complexity.PersonalAPIKeyConnection.Edges(childComplexity), true
	case "PersonalAPIKeyConnection.pageInfo":
		if e.complexity.PersonalAPIKeyConnection.PageInfo == nil {
			break
		}

		return e.complexity.PersonalAPIKeyConnection.PageInfo(childComplexity), true
	case "PersonalAPIKeyConnection.totalCount":
		if e.complexity.PersonalAPIKeyConnection.TotalCount == nil {
			break
		}

		return e.complexity.PersonalAPIKeyConnection.TotalCount(childComplexity), true

	case "PersonalAPIKeyEdge.cursor":
		if e.complexity.PersonalAPIKeyEdge.Cursor == nil {
			break
		}

		return e.complexity.PersonalAPIKeyEdge.Cursor(childComplexity), true
	case "PersonalAPIKeyEdge.node":
		if e.complexity.PersonalAPIKeyEdge.Node == nil {
			break
		}

		return e.complexity.PersonalAPIKeyEdge.Node(childComplexity), true

	case "Query.node":
		if e.complexity.Query.Node == nil {
			break
		}

		args, err := ec.field_Query_node_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Query.Node(childComplexity, args["id"].(gid.GID)), true
	case "Query.ssoLoginURL":
		if e.complexity.Query.SsoLoginURL == nil {
			break
		}

		args, err := ec.field_Query_ssoLoginURL_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Query.SsoLoginURL(childComplexity, args["email"].(mail.Addr)), true
	case "Query.viewer":
		if e.complexity.Query.Viewer == nil {
			break
		}

		return e.complexity.Query.Viewer(childComplexity), true

	case "RegenerateSCIMTokenPayload.scimConfiguration":
		if e.complexity.RegenerateSCIMTokenPayload.ScimConfiguration == nil {
			break
		}

		return e.complexity.RegenerateSCIMTokenPayload.ScimConfiguration(childComplexity), true
	case "RegenerateSCIMTokenPayload.token":
		if e.complexity.RegenerateSCIMTokenPayload.Token == nil {
			break
		}

		return e.complexity.RegenerateSCIMTokenPayload.Token(childComplexity), true

	case "RemoveMemberPayload.deletedMembershipId":
		if e.complexity.RemoveMemberPayload.DeletedMembershipID == nil {
			break
		}

		return e.complexity.RemoveMemberPayload.DeletedMembershipID(childComplexity), true

	case "ResetPasswordPayload.success":
		if e.complexity.ResetPasswordPayload.Success == nil {
			break
		}

		return e.complexity.ResetPasswordPayload.Success(childComplexity), true

	case "RevokeAllSessionsPayload.revokedCount":
		if e.complexity.RevokeAllSessionsPayload.RevokedCount == nil {
			break
		}

		return e.complexity.RevokeAllSessionsPayload.RevokedCount(childComplexity), true

	case "RevokePersonalAPIKeyPayload.personalAPIKeyId":
		if e.complexity.RevokePersonalAPIKeyPayload.PersonalAPIKeyID == nil {
			break
		}

		return e.complexity.RevokePersonalAPIKeyPayload.PersonalAPIKeyID(childComplexity), true

	case "RevokeSessionPayload.success":
		if e.complexity.RevokeSessionPayload.Success == nil {
			break
		}

		return e.complexity.RevokeSessionPayload.Success(childComplexity), true

	case "SAMLAttributeMappings.email":
		if e.complexity.SAMLAttributeMappings.Email == nil {
			break
		}

		return e.complexity.SAMLAttributeMappings.Email(childComplexity), true
	case "SAMLAttributeMappings.firstName":
		if e.complexity.SAMLAttributeMappings.FirstName == nil {
			break
		}

		return e.complexity.SAMLAttributeMappings.FirstName(childComplexity), true
	case "SAMLAttributeMappings.lastName":
		if e.complexity.SAMLAttributeMappings.LastName == nil {
			break
		}

		return e.complexity.SAMLAttributeMappings.LastName(childComplexity), true
	case "SAMLAttributeMappings.role":
		if e.complexity.SAMLAttributeMappings.Role == nil {
			break
		}

		return e.complexity.SAMLAttributeMappings.Role(childComplexity), true

	case "SAMLAuthenticationRequired.reason":
		if e.complexity.SAMLAuthenticationRequired.Reason == nil {
			break
		}

		return e.complexity.SAMLAuthenticationRequired.Reason(childComplexity), true
	case "SAMLAuthenticationRequired.redirectUrl":
		if e.complexity.SAMLAuthenticationRequired.RedirectURL == nil {
			break
		}

		return e.complexity.SAMLAuthenticationRequired.RedirectURL(childComplexity), true

	case "SAMLConfiguration.attributeMappings":
		if e.complexity.SAMLConfiguration.AttributeMappings == nil {
			break
		}

		return e.complexity.SAMLConfiguration.AttributeMappings(childComplexity), true
	case "SAMLConfiguration.autoSignupEnabled":
		if e.complexity.SAMLConfiguration.AutoSignupEnabled == nil {
			break
		}

		return e.complexity.SAMLConfiguration.AutoSignupEnabled(childComplexity), true
	case "SAMLConfiguration.createdAt":
		if e.complexity.SAMLConfiguration.CreatedAt == nil {
			break
		}

		return e.complexity.SAMLConfiguration.CreatedAt(childComplexity), true
	case "SAMLConfiguration.domainVerificationToken":
		if e.complexity.SAMLConfiguration.DomainVerificationToken == nil {
			break
		}

		return e.complexity.SAMLConfiguration.DomainVerificationToken(childComplexity), true
	case "SAMLConfiguration.domainVerifiedAt":
		if e.complexity.SAMLConfiguration.DomainVerifiedAt == nil {
			break
		}

		return e.complexity.SAMLConfiguration.DomainVerifiedAt(childComplexity), true
	case "SAMLConfiguration.emailDomain":
		if e.complexity.SAMLConfiguration.EmailDomain == nil {
			break
		}

		return e.complexity.SAMLConfiguration.EmailDomain(childComplexity), true
	case "SAMLConfiguration.enforcementPolicy":
		if e.complexity.SAMLConfiguration.EnforcementPolicy == nil {
			break
		}

		return e.complexity.SAMLConfiguration.EnforcementPolicy(childComplexity), true
	case "SAMLConfiguration.id":
		if e.complexity.SAMLConfiguration.ID == nil {
			break
		}

		return e.complexity.SAMLConfiguration.ID(childComplexity), true
	case "SAMLConfiguration.idpCertificate":
		if e.complexity.SAMLConfiguration.IdpCertificate == nil {
			break
		}

		return e.complexity.SAMLConfiguration.IdpCertificate(childComplexity), true
	case "SAMLConfiguration.idpEntityId":
		if e.complexity.SAMLConfiguration.IdpEntityID == nil {
			break
		}

		return e.complexity.SAMLConfiguration.IdpEntityID(childComplexity), true
	case "SAMLConfiguration.idpSsoUrl":
		if e.complexity.SAMLConfiguration.IdpSsoURL == nil {
			break
		}

		return e.complexity.SAMLConfiguration.IdpSsoURL(childComplexity), true
	case "SAMLConfiguration.permission":
		if e.complexity.SAMLConfiguration.Permission == nil {
			break
		}

		args, err := ec.field_SAMLConfiguration_permission_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.SAMLConfiguration.Permission(childComplexity, args["action"].(string)), true
	case "SAMLConfiguration.testLoginUrl":
		if e.complexity.SAMLConfiguration.TestLoginURL == nil {
			break
		}

		return e.complexity.SAMLConfiguration.TestLoginURL(childComplexity), true
	case "SAMLConfiguration.updatedAt":
		if e.complexity.SAMLConfiguration.UpdatedAt == nil {
			break
		}

		return e.complexity.SAMLConfiguration.UpdatedAt(childComplexity), true

	case "SAMLConfigurationConnection.edges":
		if e.complexity.SAMLConfigurationConnection.Edges == nil {
			break
		}

		return e.complexity.SAMLConfigurationConnection.Edges(childComplexity), true
	case "SAMLConfigurationConnection.pageInfo":
		if e.complexity.SAMLConfigurationConnection.PageInfo == nil {
			break
		}

		return e.complexity.SAMLConfigurationConnection.PageInfo(childComplexity), true
	case "SAMLConfigurationConnection.totalCount":
		if e.complexity.SAMLConfigurationConnection.TotalCount == nil {
			break
		}

		return e.complexity.SAMLConfigurationConnection.TotalCount(childComplexity), true

	case "SAMLConfigurationEdge.cursor":
		if e.complexity.SAMLConfigurationEdge.Cursor == nil {
			break
		}

		return e.complexity.SAMLConfigurationEdge.Cursor(childComplexity), true
	case "SAMLConfigurationEdge.node":
		if e.complexity.SAMLConfigurationEdge.Node == nil {
			break
		}

		return e.complexity.SAMLConfigurationEdge.Node(childComplexity), true

	case "SCIMBridge.connector":
		if e.complexity.SCIMBridge.Connector == nil {
			break
		}

		return e.complexity.SCIMBridge.Connector(childComplexity), true
	case "SCIMBridge.createdAt":
		if e.complexity.SCIMBridge.CreatedAt == nil {
			break
		}

		return e.complexity.SCIMBridge.CreatedAt(childComplexity), true
	case "SCIMBridge.excludedUserNames":
		if e.complexity.SCIMBridge.ExcludedUserNames == nil {
			break
		}

		return e.complexity.SCIMBridge.ExcludedUserNames(childComplexity), true
	case "SCIMBridge.id":
		if e.complexity.SCIMBridge.ID == nil {
			break
		}

		return e.complexity.SCIMBridge.ID(childComplexity), true
	case "SCIMBridge.permission":
		if e.complexity.SCIMBridge.Permission == nil {
			break
		}

		args, err := ec.field_SCIMBridge_permission_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.SCIMBridge.Permission(childComplexity, args["action"].(string)), true
	case "SCIMBridge.scimConfiguration":
		if e.complexity.SCIMBridge.ScimConfiguration == nil {
			break
		}

		return e.complexity.SCIMBridge.ScimConfiguration(childComplexity), true
	case "SCIMBridge.state":
		if e.complexity.SCIMBridge.State == nil {
			break
		}

		return e.complexity.SCIMBridge.State(childComplexity), true
	case "SCIMBridge.type":
		if e.complexity.SCIMBridge.Type == nil {
			break
		}

		return e.complexity.SCIMBridge.Type(childComplexity), true
	case "SCIMBridge.updatedAt":
		if e.complexity.SCIMBridge.UpdatedAt == nil {
			break
		}

		return e.complexity.SCIMBridge.UpdatedAt(childComplexity), true

	case "SCIMConfiguration.bridge":
		if e.complexity.SCIMConfiguration.Bridge == nil {
			break
		}

		return e.complexity.SCIMConfiguration.Bridge(childComplexity), true
	case "SCIMConfiguration.createdAt":
		if e.complexity.SCIMConfiguration.CreatedAt == nil {
			break
		}

		return e.complexity.SCIMConfiguration.CreatedAt(childComplexity), true
	case "SCIMConfiguration.endpointUrl":
		if e.complexity.SCIMConfiguration.EndpointURL == nil {
			break
		}

		return e.complexity.SCIMConfiguration.EndpointURL(childComplexity), true
	case "SCIMConfiguration.events":
		if e.complexity.SCIMConfiguration.Events == nil {
			break
		}

		args, err := ec.field_SCIMConfiguration_events_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.SCIMConfiguration.Events(childComplexity, args["first"].(*int), args["after"].(*page.CursorKey), args["last"].(*int), args["before"].(*page.CursorKey), args["orderBy"].(*types.SCIMEventOrderBy)), true
	case "SCIMConfiguration.id":
		if e.complexity.SCIMConfiguration.ID == nil {
			break
		}

		return e.complexity.SCIMConfiguration.ID(childComplexity), true
	case "SCIMConfiguration.organization":
		if e.complexity.SCIMConfiguration.Organization == nil {
			break
		}

		return e.complexity.SCIMConfiguration.Organization(childComplexity), true
	case "SCIMConfiguration.permission":
		if e.complexity.SCIMConfiguration.Permission == nil {
			break
		}

		args, err := ec.field_SCIMConfiguration_permission_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.SCIMConfiguration.Permission(childComplexity, args["action"].(string)), true
	case "SCIMConfiguration.updatedAt":
		if e.complexity.SCIMConfiguration.UpdatedAt == nil {
			break
		}

		return e.complexity.SCIMConfiguration.UpdatedAt(childComplexity), true

	case "SCIMEvent.createdAt":
		if e.complexity.SCIMEvent.CreatedAt == nil {
			break
		}

		return e.complexity.SCIMEvent.CreatedAt(childComplexity), true
	case "SCIMEvent.errorMessage":
		if e.complexity.SCIMEvent.ErrorMessage == nil {
			break
		}

		return e.complexity.SCIMEvent.ErrorMessage(childComplexity), true
	case "SCIMEvent.id":
		if e.complexity.SCIMEvent.ID == nil {
			break
		}

		return e.complexity.SCIMEvent.ID(childComplexity), true
	case "SCIMEvent.ipAddress":
		if e.complexity.SCIMEvent.IPAddress == nil {
			break
		}

		return e.complexity.SCIMEvent.IPAddress(childComplexity), true
	case "SCIMEvent.membership":
		if e.complexity.SCIMEvent.Membership == nil {
			break
		}

		return e.complexity.SCIMEvent.Membership(childComplexity), true
	case "SCIMEvent.method":
		if e.complexity.SCIMEvent.Method == nil {
			break
		}

		return e.complexity.SCIMEvent.Method(childComplexity), true
	case "SCIMEvent.path":
		if e.complexity.SCIMEvent.Path == nil {
			break
		}

		return e.complexity.SCIMEvent.Path(childComplexity), true
	case "SCIMEvent.permission":
		if e.complexity.SCIMEvent.Permission == nil {
			break
		}

		args, err := ec.field_SCIMEvent_permission_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.SCIMEvent.Permission(childComplexity, args["action"].(string)), true
	case "SCIMEvent.requestBody":
		if e.complexity.SCIMEvent.RequestBody == nil {
			break
		}

		return e.complexity.SCIMEvent.RequestBody(childComplexity), true
	case "SCIMEvent.responseBody":
		if e.complexity.SCIMEvent.ResponseBody == nil {
			break
		}

		return e.complexity.SCIMEvent.ResponseBody(childComplexity), true
	case "SCIMEvent.statusCode":
		if e.complexity.SCIMEvent.StatusCode == nil {
			break
		}

		return e.complexity.SCIMEvent.StatusCode(childComplexity), true

	case "SCIMEventConnection.edges":
		if e.complexity.SCIMEventConnection.Edges == nil {
			break
		}

		return e.complexity.SCIMEventConnection.Edges(childComplexity), true
	case "SCIMEventConnection.pageInfo":
		if e.complexity.SCIMEventConnection.PageInfo == nil {
			break
		}

		return e.complexity.SCIMEventConnection.PageInfo(childComplexity), true
	case "SCIMEventConnection.totalCount":
		if e.complexity.SCIMEventConnection.TotalCount == nil {
			break
		}

		return e.complexity.SCIMEventConnection.TotalCount(childComplexity), true

	case "SCIMEventEdge.cursor":
		if e.complexity.SCIMEventEdge.Cursor == nil {
			break
		}

		return e.complexity.SCIMEventEdge.Cursor(childComplexity), true
	case "SCIMEventEdge.node":
		if e.complexity.SCIMEventEdge.Node == nil {
			break
		}

		return e.complexity.SCIMEventEdge.Node(childComplexity), true

	case "Session.createdAt":
		if e.complexity.Session.CreatedAt == nil {
			break
		}

		return e.complexity.Session.CreatedAt(childComplexity), true
	case "Session.expiresAt":
		if e.complexity.Session.ExpiresAt == nil {
			break
		}

		return e.complexity.Session.ExpiresAt(childComplexity), true
	case "Session.id":
		if e.complexity.Session.ID == nil {
			break
		}

		return e.complexity.Session.ID(childComplexity), true
	case "Session.ipAddress":
		if e.complexity.Session.IPAddress == nil {
			break
		}

		return e.complexity.Session.IPAddress(childComplexity), true
	case "Session.identity":
		if e.complexity.Session.Identity == nil {
			break
		}

		return e.complexity.Session.Identity(childComplexity), true
	case "Session.permission":
		if e.complexity.Session.Permission == nil {
			break
		}

		args, err := ec.field_Session_permission_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Session.Permission(childComplexity, args["action"].(string)), true
	case "Session.updatedAt":
		if e.complexity.Session.UpdatedAt == nil {
			break
		}

		return e.complexity.Session.UpdatedAt(childComplexity), true
	case "Session.userAgent":
		if e.complexity.Session.UserAgent == nil {
			break
		}

		return e.complexity.Session.UserAgent(childComplexity), true

	case "SessionConnection.edges":
		if e.complexity.SessionConnection.Edges == nil {
			break
		}

		return e.complexity.SessionConnection.Edges(childComplexity), true
	case "SessionConnection.pageInfo":
		if e.complexity.SessionConnection.PageInfo == nil {
			break
		}

		return e.complexity.SessionConnection.PageInfo(childComplexity), true
	case "SessionConnection.totalCount":
		if e.complexity.SessionConnection.TotalCount == nil {
			break
		}

		return e.complexity.SessionConnection.TotalCount(childComplexity), true

	case "SessionEdge.cursor":
		if e.complexity.SessionEdge.Cursor == nil {
			break
		}

		return e.complexity.SessionEdge.Cursor(childComplexity), true
	case "SessionEdge.node":
		if e.complexity.SessionEdge.Node == nil {
			break
		}

		return e.complexity.SessionEdge.Node(childComplexity), true

	case "SignInPayload.identity":
		if e.complexity.SignInPayload.Identity == nil {
			break
		}

		return e.complexity.SignInPayload.Identity(childComplexity), true
	case "SignInPayload.session":
		if e.complexity.SignInPayload.Session == nil {
			break
		}

		return e.complexity.SignInPayload.Session(childComplexity), true

	case "SignOutPayload.success":
		if e.complexity.SignOutPayload.Success == nil {
			break
		}

		return e.complexity.SignOutPayload.Success(childComplexity), true

	case "SignUpFromInvitationPayload.identity":
		if e.complexity.SignUpFromInvitationPayload.Identity == nil {
			break
		}

		return e.complexity.SignUpFromInvitationPayload.Identity(childComplexity), true

	case "SignUpPayload.identity":
		if e.complexity.SignUpPayload.Identity == nil {
			break
		}

		return e.complexity.SignUpPayload.Identity(childComplexity), true

	case "UpdateMembershipPayload.membership":
		if e.complexity.UpdateMembershipPayload.Membership == nil {
			break
		}

		return e.complexity.UpdateMembershipPayload.Membership(childComplexity), true

	case "UpdateOrganizationPayload.organization":
		if e.complexity.UpdateOrganizationPayload.Organization == nil {
			break
		}

		return e.complexity.UpdateOrganizationPayload.Organization(childComplexity), true

	case "UpdateProfilePayload.profile":
		if e.complexity.UpdateProfilePayload.Profile == nil {
			break
		}

		return e.complexity.UpdateProfilePayload.Profile(childComplexity), true

	case "UpdateSAMLConfigurationPayload.samlConfiguration":
		if e.complexity.UpdateSAMLConfigurationPayload.SamlConfiguration == nil {
			break
		}

		return e.complexity.UpdateSAMLConfigurationPayload.SamlConfiguration(childComplexity), true

	case "UpdateSCIMBridgePayload.scimBridge":
		if e.complexity.UpdateSCIMBridgePayload.ScimBridge == nil {
			break
		}

		return e.complexity.UpdateSCIMBridgePayload.ScimBridge(childComplexity), true

	case "VerifyEmailPayload.success":
		if e.complexity.VerifyEmailPayload.Success == nil {
			break
		}

		return e.complexity.VerifyEmailPayload.Success(childComplexity), true

	}
	return 0, false
}

func (e *executableSchema) Exec(ctx context.Context) graphql.ResponseHandler {
	opCtx := graphql.GetOperationContext(ctx)
	ec := executionContext{opCtx, e, 0, 0, make(chan graphql.DeferredResult)}
	inputUnmarshalMap := graphql.BuildUnmarshalerMap(
		ec.unmarshalInputAcceptInvitationInput,
		ec.unmarshalInputAssumeOrganizationSessionInput,
		ec.unmarshalInputChangeEmailInput,
		ec.unmarshalInputChangePasswordInput,
		ec.unmarshalInputCreateOrganizationInput,
		ec.unmarshalInputCreatePersonalAPIKeyInput,
		ec.unmarshalInputCreateSAMLConfigurationInput,
		ec.unmarshalInputCreateSCIMConfigurationInput,
		ec.unmarshalInputDeleteInvitationInput,
		ec.unmarshalInputDeleteOrganizationHorizontalLogoInput,
		ec.unmarshalInputDeleteOrganizationInput,
		ec.unmarshalInputDeleteSAMLConfigurationInput,
		ec.unmarshalInputDeleteSCIMConfigurationInput,
		ec.unmarshalInputForgotPasswordInput,
		ec.unmarshalInputInvitationOrder,
		ec.unmarshalInputInviteMemberInput,
		ec.unmarshalInputMembershipOrder,
		ec.unmarshalInputRegenerateSCIMTokenInput,
		ec.unmarshalInputRemoveMemberInput,
		ec.unmarshalInputResetPasswordInput,
		ec.unmarshalInputRevokePersonalAPIKeyInput,
		ec.unmarshalInputRevokeSessionInput,
		ec.unmarshalInputSAMLAttributeMappingsInput,
		ec.unmarshalInputSCIMEventOrder,
		ec.unmarshalInputSessionOrder,
		ec.unmarshalInputSignInInput,
		ec.unmarshalInputSignUpFromInvitationInput,
		ec.unmarshalInputSignUpInput,
		ec.unmarshalInputUpdateMembershipInput,
		ec.unmarshalInputUpdateOrganizationInput,
		ec.unmarshalInputUpdateProfileInput,
		ec.unmarshalInputUpdateSAMLConfigurationInput,
		ec.unmarshalInputUpdateSCIMBridgeInput,
		ec.unmarshalInputVerifyEmailInput,
	)
	first := true

	switch opCtx.Operation.Operation {
	case ast.Query:
		return func(ctx context.Context) *graphql.Response {
			var response graphql.Response
			var data graphql.Marshaler
			if first {
				first = false
				ctx = graphql.WithUnmarshalerMap(ctx, inputUnmarshalMap)
				data = ec._Query(ctx, opCtx.Operation.SelectionSet)
			} else {
				if atomic.LoadInt32(&ec.pendingDeferred) > 0 {
					result := <-ec.deferredResults
					atomic.AddInt32(&ec.pendingDeferred, -1)
					data = result.Result
					response.Path = result.Path
					response.Label = result.Label
					response.Errors = result.Errors
				} else {
					return nil
				}
			}
			var buf bytes.Buffer
			data.MarshalGQL(&buf)
			response.Data = buf.Bytes()
			if atomic.LoadInt32(&ec.deferred) > 0 {
				hasNext := atomic.LoadInt32(&ec.pendingDeferred) > 0
				response.HasNext = &hasNext
			}

			return &response
		}
	case ast.Mutation:
		return func(ctx context.Context) *graphql.Response {
			if !first {
				return nil
			}
			first = false
			ctx = graphql.WithUnmarshalerMap(ctx, inputUnmarshalMap)
			data := ec._Mutation(ctx, opCtx.Operation.SelectionSet)
			var buf bytes.Buffer
			data.MarshalGQL(&buf)

			return &graphql.Response{
				Data: buf.Bytes(),
			}
		}

	default:
		return graphql.OneShot(graphql.ErrorResponse(ctx, "unsupported GraphQL operation"))
	}
}

type executionContext struct {
	*graphql.OperationContext
	*executableSchema
	deferred        int32
	pendingDeferred int32
	deferredResults chan graphql.DeferredResult
}

func (ec *executionContext) processDeferredGroup(dg graphql.DeferredGroup) {
	atomic.AddInt32(&ec.pendingDeferred, 1)
	go func() {
		ctx := graphql.WithFreshResponseContext(dg.Context)
		dg.FieldSet.Dispatch(ctx)
		ds := graphql.DeferredResult{
			Path:   dg.Path,
			Label:  dg.Label,
			Result: dg.FieldSet,
			Errors: graphql.GetErrors(ctx),
		}
		// null fields should bubble up
		if dg.FieldSet.Invalids > 0 {
			ds.Result = graphql.Null
		}
		ec.deferredResults <- ds
	}()
}

func (ec *executionContext) introspectSchema() (*introspection.Schema, error) {
	if ec.DisableIntrospection {
		return nil, errors.New("introspection disabled")
	}
	return introspection.WrapSchema(ec.Schema()), nil
}

func (ec *executionContext) introspectType(name string) (*introspection.Type, error) {
	if ec.DisableIntrospection {
		return nil, errors.New("introspection disabled")
	}
	return introspection.WrapTypeFromDef(ec.Schema(), ec.Schema().Types[name]), nil
}

var sources = []*ast.Source{
	{Name: "../schema.graphql", Input: `directive @goField(
  forceResolver: Boolean
  name: String
  omittable: Boolean
) on INPUT_FIELD_DEFINITION | FIELD_DEFINITION

directive @goModel(
  model: String
  models: [String!]
) on OBJECT | INPUT_OBJECT | SCALAR | ENUM | INTERFACE | UNION

directive @goEnum(value: String) on ENUM_VALUE

scalar CursorKey
scalar Datetime
scalar Upload
scalar EmailAddr

enum OrderDirection
  @goModel(model: "go.probo.inc/probo/pkg/page.OrderDirection") {
  ASC @goEnum(value: "go.probo.inc/probo/pkg/page.OrderDirectionAsc")
  DESC @goEnum(value: "go.probo.inc/probo/pkg/page.OrderDirectionDesc")
}

enum SessionOrderField
  @goModel(model: "go.probo.inc/probo/pkg/coredata.SessionOrderField") {
  CREATED_AT
    @goEnum(value: "go.probo.inc/probo/pkg/coredata.SessionOrderFieldCreatedAt")
  EXPIRED_AT
    @goEnum(value: "go.probo.inc/probo/pkg/coredata.SessionOrderFieldExpiredAt")
  UPDATED_AT
    @goEnum(value: "go.probo.inc/probo/pkg/coredata.SessionOrderFieldUpdatedAt")
}

input SessionOrder {
  direction: OrderDirection!
  field: SessionOrderField!
}

interface Node {
  id: ID!
}

type Query {
  node(id: ID!): Node @session(required: PRESENT)
  viewer: Identity @session(required: PRESENT)
  ssoLoginURL(email: EmailAddr!): String
    @goField(forceResolver: true)
    @session(required: OPTIONAL)
}

type Mutation {
  signIn(input: SignInInput!): SignInPayload @session(required: OPTIONAL)
  signUp(input: SignUpInput!): SignUpPayload @session(required: NONE)
  signOut: SignOutPayload @session(required: PRESENT)
  signUpFromInvitation(
    input: SignUpFromInvitationInput!
  ): SignUpFromInvitationPayload @session(required: NONE)
  forgotPassword(input: ForgotPasswordInput!): ForgotPasswordPayload
    @session(required: NONE)
  resetPassword(input: ResetPasswordInput!): ResetPasswordPayload
    @session(required: NONE)
  verifyEmail(input: VerifyEmailInput!): VerifyEmailPayload
    @session(required: OPTIONAL)
  changePassword(input: ChangePasswordInput!): ChangePasswordPayload
    @session(required: PRESENT)
  changeEmail(input: ChangeEmailInput!): ChangeEmailPayload
    @session(required: PRESENT)
  assumeOrganizationSession(
    input: AssumeOrganizationSessionInput!
  ): AssumeOrganizationSessionPayload @session(required: PRESENT)

  revokeSession(input: RevokeSessionInput!): RevokeSessionPayload!
    @session(required: PRESENT)
  revokeAllSessions: RevokeAllSessionsPayload @session(required: PRESENT)

  createPersonalAPIKey(
    input: CreatePersonalAPIKeyInput!
  ): CreatePersonalAPIKeyPayload @session(required: PRESENT)
  revokePersonalAPIKey(
    input: RevokePersonalAPIKeyInput!
  ): RevokePersonalAPIKeyPayload @session(required: PRESENT)

  createOrganization(
    input: CreateOrganizationInput!
  ): CreateOrganizationPayload @session(required: PRESENT)
  updateOrganization(
    input: UpdateOrganizationInput!
  ): UpdateOrganizationPayload @session(required: PRESENT)
  deleteOrganization(
    input: DeleteOrganizationInput!
  ): DeleteOrganizationPayload @session(required: PRESENT)
  deleteOrganizationHorizontalLogo(
    input: DeleteOrganizationHorizontalLogoInput!
  ): DeleteOrganizationHorizontalLogoPayload @session(required: PRESENT)

  inviteMember(input: InviteMemberInput!): InviteMemberPayload
    @session(required: PRESENT)
  deleteInvitation(input: DeleteInvitationInput!): DeleteInvitationPayload
    @session(required: PRESENT)
  updateProfile(input: UpdateProfileInput!): UpdateProfilePayload!
  updateMembership(input: UpdateMembershipInput!): UpdateMembershipPayload!
  removeMember(input: RemoveMemberInput!): RemoveMemberPayload
    @session(required: PRESENT)

  acceptInvitation(input: AcceptInvitationInput!): AcceptInvitationPayload
    @session(required: PRESENT)

  createSAMLConfiguration(
    input: CreateSAMLConfigurationInput!
  ): CreateSAMLConfigurationPayload @session(required: PRESENT)
  updateSAMLConfiguration(
    input: UpdateSAMLConfigurationInput!
  ): UpdateSAMLConfigurationPayload @session(required: PRESENT)
  deleteSAMLConfiguration(
    input: DeleteSAMLConfigurationInput!
  ): DeleteSAMLConfigurationPayload @session(required: PRESENT)

  createSCIMConfiguration(
    input: CreateSCIMConfigurationInput!
  ): CreateSCIMConfigurationPayload @session(required: PRESENT)
  deleteSCIMConfiguration(
    input: DeleteSCIMConfigurationInput!
  ): DeleteSCIMConfigurationPayload @session(required: PRESENT)
  regenerateSCIMToken(
    input: RegenerateSCIMTokenInput!
  ): RegenerateSCIMTokenPayload @session(required: PRESENT)
  updateSCIMBridge(
    input: UpdateSCIMBridgeInput!
  ): UpdateSCIMBridgePayload @session(required: PRESENT)
}

type Identity implements Node {
  id: ID!
  email: EmailAddr!
  fullName: String!
  emailVerified: Boolean!
  createdAt: Datetime!
  updatedAt: Datetime!

  memberships(
    first: Int
    after: CursorKey
    last: Int
    before: CursorKey
    orderBy: MembershipOrder
  ): MembershipConnection @goField(forceResolver: true)

  pendingInvitations(
    first: Int
    after: CursorKey
    last: Int
    before: CursorKey
    orderBy: InvitationOrder
  ): InvitationConnection @goField(forceResolver: true)

  sessions(
    first: Int
    after: CursorKey
    last: Int
    before: CursorKey
    orderBy: SessionOrder
  ): SessionConnection @goField(forceResolver: true)

  personalAPIKeys(
    first: Int
    after: CursorKey
    last: Int
    before: CursorKey
  ): PersonalAPIKeyConnection @goField(forceResolver: true)

  permission(action: String!): Boolean!
    @goField(forceResolver: true)
    @session(required: PRESENT)
}

type MembershipProfile implements Node {
  id: ID!
  fullName: String!
  additionalEmailAddresses: [EmailAddr!]!
  kind: ProfileKind!
  position: String
  contractStartDate: Datetime
  contractEndDate: Datetime
  createdAt: Datetime!
  updatedAt: Datetime!

  identity: Identity @goField(forceResolver: true)
  organization: Organization @goField(forceResolver: true)

  # TODO: remove when memberships are under profile
  membershipId: ID!

  permission(action: String!): Boolean!
    @goField(forceResolver: true)
    @session(required: PRESENT)
}

type Organization implements Node {
  id: ID!
  name: String!
  logoUrl: String @goField(forceResolver: true)
  horizontalLogoUrl: String @goField(forceResolver: true)
  email: String
  description: String
  websiteUrl: String
  headquarterAddress: String
  createdAt: Datetime!
  updatedAt: Datetime!

  members(
    first: Int
    after: CursorKey
    last: Int
    before: CursorKey
    orderBy: MembershipOrder
  ): MembershipConnection @goField(forceResolver: true)

  invitations(
    first: Int
    after: CursorKey
    last: Int
    before: CursorKey
    status: InvitationStatus
    orderBy: InvitationOrder
  ): InvitationConnection @goField(forceResolver: true)

  samlConfigurations(
    first: Int
    after: CursorKey
    last: Int
    before: CursorKey
  ): SAMLConfigurationConnection @goField(forceResolver: true)

  scimConfiguration: SCIMConfiguration @goField(forceResolver: true)

  viewerMembership: Membership @goField(forceResolver: true)

  permission(action: String!): Boolean!
    @goField(forceResolver: true)
    @session(required: PRESENT)
}

enum ProfileKind @goModel(model: "go.probo.inc/probo/pkg/coredata.MembershipProfileKind") {
  EMPLOYEE
    @goEnum(value: "go.probo.inc/probo/pkg/coredata.MembershipProfileKindEmployee")
  CONTRACTOR
    @goEnum(value: "go.probo.inc/probo/pkg/coredata.MembershipProfileKindContractor")
  SERVICE_ACCOUNT
    @goEnum(
      value: "go.probo.inc/probo/pkg/coredata.MembershipProfileKindServiceAccount"
    )
}

enum MembershipRole
  @goModel(model: "go.probo.inc/probo/pkg/coredata.MembershipRole") {
  OWNER @goEnum(value: "go.probo.inc/probo/pkg/coredata.MembershipRoleOwner")
  ADMIN @goEnum(value: "go.probo.inc/probo/pkg/coredata.MembershipRoleAdmin")
  EMPLOYEE
    @goEnum(value: "go.probo.inc/probo/pkg/coredata.MembershipRoleEmployee")
  VIEWER @goEnum(value: "go.probo.inc/probo/pkg/coredata.MembershipRoleViewer")
  AUDITOR
    @goEnum(value: "go.probo.inc/probo/pkg/coredata.MembershipRoleAuditor")
}

enum MembershipSource
  @goModel(model: "go.probo.inc/probo/pkg/coredata.MembershipSource") {
  MANUAL
    @goEnum(value: "go.probo.inc/probo/pkg/coredata.MembershipSourceManual")
  SAML @goEnum(value: "go.probo.inc/probo/pkg/coredata.MembershipSourceSAML")
  SCIM @goEnum(value: "go.probo.inc/probo/pkg/coredata.MembershipSourceSCIM")
}

enum MembershipState
  @goModel(model: "go.probo.inc/probo/pkg/coredata.MembershipState") {
  ACTIVE @goEnum(value: "go.probo.inc/probo/pkg/coredata.MembershipStateActive")
  INACTIVE
    @goEnum(value: "go.probo.inc/probo/pkg/coredata.MembershipStateInactive")
}

type Membership implements Node {
  id: ID!
  createdAt: Datetime!
  identity: Identity @goField(forceResolver: true)
  profile: MembershipProfile @goField(forceResolver: true)
  organization: Organization @goField(forceResolver: true)
  role: MembershipRole!
  source: MembershipSource!
  state: MembershipState!

  lastSession: Session @goField(forceResolver: true)

  permission(action: String!): Boolean!
    @goField(forceResolver: true)
    @session(required: PRESENT)
}

type Invitation implements Node {
  id: ID!
  email: EmailAddr!
  fullName: String!
  role: MembershipRole!
  expiresAt: Datetime!
  acceptedAt: Datetime
  createdAt: Datetime!
  status: InvitationStatus!
  organization: Organization @goField(forceResolver: true)

  permission(action: String!): Boolean!
    @goField(forceResolver: true)
    @session(required: PRESENT)
}

type Session implements Node {
  id: ID!
  identity: Identity @goField(forceResolver: true)
  ipAddress: String!
  userAgent: String!
  updatedAt: Datetime!
  createdAt: Datetime!
  expiresAt: Datetime!

  permission(action: String!): Boolean!
    @goField(forceResolver: true)
    @session(required: PRESENT)
}

type PersonalAPIKey implements Node {
  id: ID!
  name: String!
  expiresAt: Datetime!
  lastUsedAt: Datetime
  createdAt: Datetime!

  token: String @goField(forceResolver: true)

  permission(action: String!): Boolean!
    @goField(forceResolver: true)
    @session(required: PRESENT)
}

type SAMLConfiguration implements Node {
  id: ID!
  emailDomain: String!
  enforcementPolicy: SAMLEnforcementPolicy!
  domainVerifiedAt: Datetime
  domainVerificationToken: String
  idpEntityId: String!
  idpSsoUrl: String!
  idpCertificate: String!
  autoSignupEnabled: Boolean!
  createdAt: Datetime!
  updatedAt: Datetime!
  testLoginUrl: String! @goField(forceResolver: true)
  attributeMappings: SAMLAttributeMappings!

  permission(action: String!): Boolean!
    @goField(forceResolver: true)
    @session(required: PRESENT)
}

type SAMLAttributeMappings {
  email: String!
  firstName: String!
  lastName: String!
  role: String!
}

type SCIMConfiguration implements Node {
  id: ID!
  endpointUrl: String! @goField(forceResolver: true)
  createdAt: Datetime!
  updatedAt: Datetime!
  organization: Organization @goField(forceResolver: true)

  bridge: SCIMBridge @goField(forceResolver: true)

  events(
    first: Int
    after: CursorKey
    last: Int
    before: CursorKey
    orderBy: SCIMEventOrder
  ): SCIMEventConnection @goField(forceResolver: true)

  permission(action: String!): Boolean!
    @goField(forceResolver: true)
    @session(required: PRESENT)
}

type SCIMBridge implements Node {
  id: ID!
  state: SCIMBridgeState!
  scimConfiguration: SCIMConfiguration @goField(forceResolver: true)
  connector: Connector @goField(forceResolver: true)
  type: SCIMBridgeType!
  excludedUserNames: [String!]!
  createdAt: Datetime!
  updatedAt: Datetime!

  permission(action: String!): Boolean!
    @goField(forceResolver: true)
    @session(required: PRESENT)
}

type Connector implements Node {
  id: ID!
  provider: ConnectorProvider!
  createdAt: Datetime!
  updatedAt: Datetime!

  permission(action: String!): Boolean!
    @goField(forceResolver: true)
    @session(required: PRESENT)
}

enum ConnectorProvider
  @goModel(model: "go.probo.inc/probo/pkg/coredata.ConnectorProvider") {
  SLACK @goEnum(value: "go.probo.inc/probo/pkg/coredata.ConnectorProviderSlack")
  GOOGLE_WORKSPACE
    @goEnum(value: "go.probo.inc/probo/pkg/coredata.ConnectorProviderGoogleWorkspace")
}

enum SCIMBridgeType
  @goModel(model: "go.probo.inc/probo/pkg/coredata.SCIMBridgeType") {
  GOOGLE_WORKSPACE @goEnum(value: "go.probo.inc/probo/pkg/coredata.SCIMBridgeTypeGoogleWorkspace")
}

enum SCIMBridgeState
  @goModel(model: "go.probo.inc/probo/pkg/coredata.SCIMBridgeState") {
  PENDING @goEnum(value: "go.probo.inc/probo/pkg/coredata.SCIMBridgeStatePending")
  ACTIVE @goEnum(value: "go.probo.inc/probo/pkg/coredata.SCIMBridgeStateActive")
  FAILED @goEnum(value: "go.probo.inc/probo/pkg/coredata.SCIMBridgeStateFailed")
}

type SCIMEvent implements Node {
  id: ID!
  method: String!
  path: String!
  statusCode: Int!
  requestBody: String
  responseBody: String
  errorMessage: String
  membership: Membership @goField(forceResolver: true)
  ipAddress: String!
  createdAt: Datetime!

  permission(action: String!): Boolean!
    @goField(forceResolver: true)
    @session(required: PRESENT)
}

enum InvitationStatus
  @goModel(model: "go.probo.inc/probo/pkg/coredata.InvitationStatus") {
  PENDING
    @goEnum(value: "go.probo.inc/probo/pkg/coredata.InvitationStatusPending")
  ACCEPTED
    @goEnum(value: "go.probo.inc/probo/pkg/coredata.InvitationStatusAccepted")
  EXPIRED
    @goEnum(value: "go.probo.inc/probo/pkg/coredata.InvitationStatusExpired")
}

enum SAMLEnforcementPolicy
  @goModel(model: "go.probo.inc/probo/pkg/coredata.SAMLEnforcementPolicy") {
  OFF @goEnum(value: "go.probo.inc/probo/pkg/coredata.SAMLEnforcementPolicyOff")
  OPTIONAL
    @goEnum(
      value: "go.probo.inc/probo/pkg/coredata.SAMLEnforcementPolicyOptional"
    )
  REQUIRED
    @goEnum(
      value: "go.probo.inc/probo/pkg/coredata.SAMLEnforcementPolicyRequired"
    )
}

enum ReauthenticationReason {
  SESSION_EXPIRED
  SENSITIVE_ACTION
  POLICY_REQUIREMENT
}

enum MembershipOrderField
  @goModel(model: "go.probo.inc/probo/pkg/coredata.MembershipOrderField") {
  FULL_NAME
    @goEnum(
      value: "go.probo.inc/probo/pkg/coredata.MembershipOrderFieldFullName"
    )
  ORGANIZATION_NAME
    @goEnum(
      value: "go.probo.inc/probo/pkg/coredata.MembershipOrderFieldOrganizationName"
    )
  EMAIL_ADDRESS
    @goEnum(
      value: "go.probo.inc/probo/pkg/coredata.MembershipOrderFieldEmailAddress"
    )
  ROLE
    @goEnum(value: "go.probo.inc/probo/pkg/coredata.MembershipOrderFieldRole")
  CREATED_AT
    @goEnum(
      value: "go.probo.inc/probo/pkg/coredata.MembershipOrderFieldCreatedAt"
    )
}

input MembershipOrder
  @goModel(
    model: "go.probo.inc/probo/pkg/server/api/connect/v1/types.MembershipOrderBy"
  ) {
  direction: OrderDirection!
  field: MembershipOrderField!
}

type MembershipConnection
  @goModel(
    model: "go.probo.inc/probo/pkg/server/api/connect/v1/types.MembershipConnection"
  ) {
  edges: [MembershipEdge!]!
  pageInfo: PageInfo!
  totalCount: Int @goField(forceResolver: true)
}

type MembershipEdge {
  node: Membership!
  cursor: CursorKey!
}

enum InvitationOrderField
  @goModel(model: "go.probo.inc/probo/pkg/coredata.InvitationOrderField") {
  FULL_NAME
    @goEnum(
      value: "go.probo.inc/probo/pkg/coredata.InvitationOrderFieldFullName"
    )
  EMAIL
    @goEnum(value: "go.probo.inc/probo/pkg/coredata.InvitationOrderFieldEmail")
  ROLE
    @goEnum(value: "go.probo.inc/probo/pkg/coredata.InvitationOrderFieldRole")
  CREATED_AT
    @goEnum(
      value: "go.probo.inc/probo/pkg/coredata.InvitationOrderFieldCreatedAt"
    )
  EXPIRES_AT
    @goEnum(
      value: "go.probo.inc/probo/pkg/coredata.InvitationOrderFieldExpiresAt"
    )
  ACCEPTED_AT
    @goEnum(
      value: "go.probo.inc/probo/pkg/coredata.InvitationOrderFieldAcceptedAt"
    )
}

input InvitationOrder
  @goModel(
    model: "go.probo.inc/probo/pkg/server/api/connect/v1/types.InvitationOrderBy"
  ) {
  direction: OrderDirection!
  field: InvitationOrderField!
}

type InvitationConnection
  @goModel(
    model: "go.probo.inc/probo/pkg/server/api/connect/v1/types.InvitationConnection"
  ) {
  edges: [InvitationEdge!]!
  pageInfo: PageInfo!
  totalCount: Int @goField(forceResolver: true)
}

type InvitationEdge {
  node: Invitation!
  cursor: CursorKey!
}

type SessionConnection
  @goModel(
    model: "go.probo.inc/probo/pkg/server/api/connect/v1/types.SessionConnection"
  ) {
  edges: [SessionEdge!]!
  pageInfo: PageInfo!
  totalCount: Int @goField(forceResolver: true)
}

type SessionEdge {
  node: Session!
  cursor: CursorKey!
}

type PersonalAPIKeyConnection
  @goModel(
    model: "go.probo.inc/probo/pkg/server/api/connect/v1/types.PersonalAPIKeyConnection"
  ) {
  edges: [PersonalAPIKeyEdge!]!
  pageInfo: PageInfo!
  totalCount: Int @goField(forceResolver: true)
}

type PersonalAPIKeyEdge {
  node: PersonalAPIKey!
  cursor: CursorKey!
}

type SAMLConfigurationConnection
  @goModel(
    model: "go.probo.inc/probo/pkg/server/api/connect/v1/types.SAMLConfigurationConnection"
  ) {
  edges: [SAMLConfigurationEdge!]!
  pageInfo: PageInfo!
  totalCount: Int @goField(forceResolver: true)
}

type SAMLConfigurationEdge {
  node: SAMLConfiguration!
  cursor: CursorKey!
}

enum SCIMEventOrderField
  @goModel(model: "go.probo.inc/probo/pkg/coredata.SCIMEventOrderField") {
  CREATED_AT
    @goEnum(
      value: "go.probo.inc/probo/pkg/coredata.SCIMEventOrderFieldCreatedAt"
    )
}

input SCIMEventOrder
  @goModel(
    model: "go.probo.inc/probo/pkg/server/api/connect/v1/types.SCIMEventOrderBy"
  ) {
  direction: OrderDirection!
  field: SCIMEventOrderField!
}

type SCIMEventConnection
  @goModel(
    model: "go.probo.inc/probo/pkg/server/api/connect/v1/types.SCIMEventConnection"
  ) {
  edges: [SCIMEventEdge!]!
  pageInfo: PageInfo!
  totalCount: Int @goField(forceResolver: true)
}

type SCIMEventEdge {
  node: SCIMEvent!
  cursor: CursorKey!
}

type PageInfo {
  hasNextPage: Boolean!
  hasPreviousPage: Boolean!
  startCursor: CursorKey
  endCursor: CursorKey
}

input SignInInput {
  # When assuming an org with a password auth method
  organizationId: ID
  email: EmailAddr!
  password: String!
}

input SignUpInput {
  email: EmailAddr!
  password: String!
  fullName: String!
}

input SignUpFromInvitationInput {
  token: String!
  password: String!
  fullName: String!
}

input ForgotPasswordInput {
  email: EmailAddr!
}

input ResetPasswordInput {
  token: String!
  password: String!
}

input VerifyEmailInput {
  token: String!
}

input ChangePasswordInput {
  currentPassword: String!
  newPassword: String!
}

input ChangeEmailInput {
  newEmail: EmailAddr!
  password: String!
}

input AssumeOrganizationSessionInput {
  organizationId: ID!
  continue: String!
}

input RevokeSessionInput {
  sessionId: ID!
}

input CreatePersonalAPIKeyInput {
  name: String!
  expiresAt: Datetime!
}

input RevokePersonalAPIKeyInput {
  personalAPIKeyId: ID!
}

input CreateOrganizationInput {
  name: String!
  logoFile: Upload
  horizontalLogoFile: Upload
}

input UpdateOrganizationInput {
  organizationId: ID!
  name: String
  logoFile: Upload
  horizontalLogoFile: Upload
  description: String @goField(omittable: true)
  websiteUrl: String @goField(omittable: true)
  email: String @goField(omittable: true)
  headquarterAddress: String @goField(omittable: true)
}

input DeleteOrganizationInput {
  organizationId: ID!
}

input DeleteOrganizationHorizontalLogoInput {
  organizationId: ID!
}

input InviteMemberInput {
  organizationId: ID!
  email: EmailAddr!
  fullName: String!
  role: MembershipRole!
}

input UpdateProfileInput {
  id: ID!
  fullName: String!
  additionalEmailAddresses: [EmailAddr!]
  kind: ProfileKind!
  position: String @goField(omittable: true)
  contractStartDate: Datetime @goField(omittable: true)
  contractEndDate: Datetime @goField(omittable: true)
}

input UpdateMembershipInput {
  organizationId: ID!
  membershipId: ID!
  role: MembershipRole!
}

input RemoveMemberInput {
  organizationId: ID!
  membershipId: ID!
}

input AcceptInvitationInput {
  invitationId: ID!
}

input DeleteInvitationInput {
  organizationId: ID!
  invitationId: ID!
}

input CreateSAMLConfigurationInput {
  organizationId: ID!
  emailDomain: String!
  idpEntityId: String!
  idpSsoUrl: String!
  idpCertificate: String!
  autoSignupEnabled: Boolean!
  attributeMappings: SAMLAttributeMappingsInput
}

input SAMLAttributeMappingsInput {
  email: String
  firstName: String
  lastName: String
  role: String
}

input UpdateSAMLConfigurationInput {
  organizationId: ID!
  samlConfigurationId: ID!
  idpEntityId: String
  idpSsoUrl: String
  idpCertificate: String
  autoSignupEnabled: Boolean
  enforcementPolicy: SAMLEnforcementPolicy!
  attributeMappings: SAMLAttributeMappingsInput
}

input DeleteSAMLConfigurationInput {
  organizationId: ID!
  samlConfigurationId: ID!
}

type SignInPayload {
  identity: Identity
  session: Session
}

type SignUpPayload {
  identity: Identity
}

type SignOutPayload {
  success: Boolean!
}

type SignUpFromInvitationPayload {
  identity: Identity
}

type ForgotPasswordPayload {
  success: Boolean!
}

type ResetPasswordPayload {
  success: Boolean!
}

type VerifyEmailPayload {
  success: Boolean!
}

type ChangePasswordPayload {
  success: Boolean!
}

type ChangeEmailPayload {
  success: Boolean!
}

union AssumeOrganizationSessionResult =
  | OrganizationSessionCreated
  | PasswordRequired
  | SAMLAuthenticationRequired

type OrganizationSessionCreated {
  session: Session!
  membership: Membership!
}

type PasswordRequired {
  reason: ReauthenticationReason!
}

type SAMLAuthenticationRequired {
  reason: ReauthenticationReason!
  redirectUrl: String!
}

type AssumeOrganizationSessionPayload {
  result: AssumeOrganizationSessionResult!
}

type RevokeSessionPayload {
  success: Boolean!
}

type RevokeAllSessionsPayload {
  revokedCount: Int!
}

type CreatePersonalAPIKeyPayload {
  personalAPIKeyEdge: PersonalAPIKeyEdge!
  token: String!
}

type RevokePersonalAPIKeyPayload {
  personalAPIKeyId: ID!
}

type CreateOrganizationPayload {
  organization: Organization
  membershipEdge: MembershipEdge!
}

type UpdateOrganizationPayload {
  organization: Organization
}

type DeleteOrganizationPayload {
  deletedOrganizationId: ID!
}

type DeleteOrganizationHorizontalLogoPayload {
  organization: Organization!
}

type InviteMemberPayload {
  invitationEdge: InvitationEdge!
}

type UpdateProfilePayload {
  profile: MembershipProfile!
}

type UpdateMembershipPayload {
  membership: Membership!
}

type RemoveMemberPayload {
  deletedMembershipId: ID!
}

type AcceptInvitationPayload {
  membershipEdge: MembershipEdge!
  invitation: Invitation!
}

type DeleteInvitationPayload {
  deletedInvitationId: ID!
}

type CreateSAMLConfigurationPayload {
  samlConfigurationEdge: SAMLConfigurationEdge!
}

type UpdateSAMLConfigurationPayload {
  samlConfiguration: SAMLConfiguration
}

type DeleteSAMLConfigurationPayload {
  deletedSamlConfigurationId: ID!
}

input CreateSCIMConfigurationInput {
  organizationId: ID!
  connectorId: ID
}

input DeleteSCIMConfigurationInput {
  organizationId: ID!
  scimConfigurationId: ID!
}

input RegenerateSCIMTokenInput {
  organizationId: ID!
  scimConfigurationId: ID!
}

input UpdateSCIMBridgeInput {
  organizationId: ID!
  scimBridgeId: ID!
  excludedUserNames: [String!]!
}

type CreateSCIMConfigurationPayload {
  scimConfiguration: SCIMConfiguration!
  scimBridge: SCIMBridge
  token: String!
}

type DeleteSCIMConfigurationPayload {
  deletedScimConfigurationId: ID!
}

type RegenerateSCIMTokenPayload {
  scimConfiguration: SCIMConfiguration!
  token: String!
}

type UpdateSCIMBridgePayload {
  scimBridge: SCIMBridge!
}
`, BuiltIn: false},
	{Name: "../../../../gqlutils/directives/session/schema.graphql", Input: `# Session directive for GraphQL APIs
# Include this schema in your gqlgen configuration to enable session-based access control.
#
# Usage in your schema.graphql:
#   type Query {
#     viewer: User @session(required: PRESENT)
#     publicData: Data @session(required: OPTIONAL)
#     signup(input: SignUpInput!): SignUpPayload @session(required: NONE)
#   }

directive @session(required: SessionRequirement!) on FIELD_DEFINITION

enum SessionRequirement
  @goModel(
    model: "go.probo.inc/probo/pkg/server/gqlutils/directives/session.SessionRequirement"
  ) {
  """
  Requires an authenticated session or API key.
  """
  PRESENT
    @goEnum(
      value: "go.probo.inc/probo/pkg/server/gqlutils/directives/session.SessionRequirementPresent"
    )
  """
  Forbids authenticated access (e.g., for login/signup endpoints).
  """
  NONE
    @goEnum(
      value: "go.probo.inc/probo/pkg/server/gqlutils/directives/session.SessionRequirementNone"
    )
  """
  Allows both authenticated and unauthenticated access.
  """
  OPTIONAL
    @goEnum(
      value: "go.probo.inc/probo/pkg/server/gqlutils/directives/session.SessionRequirementOptional"
    )
}
`, BuiltIn: false},
}
var parsedSchema = gqlparser.MustLoadSchema(sources...)

// endregion ************************** generated!.gotpl **************************

// region    ***************************** args.gotpl *****************************

func (ec *executionContext) dir_session_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "required", ec.unmarshalNSessionRequirement2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋgqlutilsᚋdirectivesᚋsessionᚐSessionRequirement)
	if err != nil {
		return nil, err
	}
	args["required"] = arg0
	return args, nil
}

func (ec *executionContext) field_Connector_permission_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "action", ec.unmarshalNString2string)
	if err != nil {
		return nil, err
	}
	args["action"] = arg0
	return args, nil
}

func (ec *executionContext) field_Identity_memberships_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "first", ec.unmarshalOInt2ᚖint)
	if err != nil {
		return nil, err
	}
	args["first"] = arg0
	arg1, err := graphql.ProcessArgField(ctx, rawArgs, "after", ec.unmarshalOCursorKey2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋpageᚐCursorKey)
	if err != nil {
		return nil, err
	}
	args["after"] = arg1
	arg2, err := graphql.ProcessArgField(ctx, rawArgs, "last", ec.unmarshalOInt2ᚖint)
	if err != nil {
		return nil, err
	}
	args["last"] = arg2
	arg3, err := graphql.ProcessArgField(ctx, rawArgs, "before", ec.unmarshalOCursorKey2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋpageᚐCursorKey)
	if err != nil {
		return nil, err
	}
	args["before"] = arg3
	arg4, err := graphql.ProcessArgField(ctx, rawArgs, "orderBy", ec.unmarshalOMembershipOrder2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐMembershipOrderBy)
	if err != nil {
		return nil, err
	}
	args["orderBy"] = arg4
	return args, nil
}

func (ec *executionContext) field_Identity_pendingInvitations_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "first", ec.unmarshalOInt2ᚖint)
	if err != nil {
		return nil, err
	}
	args["first"] = arg0
	arg1, err := graphql.ProcessArgField(ctx, rawArgs, "after", ec.unmarshalOCursorKey2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋpageᚐCursorKey)
	if err != nil {
		return nil, err
	}
	args["after"] = arg1
	arg2, err := graphql.ProcessArgField(ctx, rawArgs, "last", ec.unmarshalOInt2ᚖint)
	if err != nil {
		return nil, err
	}
	args["last"] = arg2
	arg3, err := graphql.ProcessArgField(ctx, rawArgs, "before", ec.unmarshalOCursorKey2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋpageᚐCursorKey)
	if err != nil {
		return nil, err
	}
	args["before"] = arg3
	arg4, err := graphql.ProcessArgField(ctx, rawArgs, "orderBy", ec.unmarshalOInvitationOrder2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐInvitationOrderBy)
	if err != nil {
		return nil, err
	}
	args["orderBy"] = arg4
	return args, nil
}

func (ec *executionContext) field_Identity_permission_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "action", ec.unmarshalNString2string)
	if err != nil {
		return nil, err
	}
	args["action"] = arg0
	return args, nil
}

func (ec *executionContext) field_Identity_personalAPIKeys_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "first", ec.unmarshalOInt2ᚖint)
	if err != nil {
		return nil, err
	}
	args["first"] = arg0
	arg1, err := graphql.ProcessArgField(ctx, rawArgs, "after", ec.unmarshalOCursorKey2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋpageᚐCursorKey)
	if err != nil {
		return nil, err
	}
	args["after"] = arg1
	arg2, err := graphql.ProcessArgField(ctx, rawArgs, "last", ec.unmarshalOInt2ᚖint)
	if err != nil {
		return nil, err
	}
	args["last"] = arg2
	arg3, err := graphql.ProcessArgField(ctx, rawArgs, "before", ec.unmarshalOCursorKey2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋpageᚐCursorKey)
	if err != nil {
		return nil, err
	}
	args["before"] = arg3
	return args, nil
}

func (ec *executionContext) field_Identity_sessions_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "first", ec.unmarshalOInt2ᚖint)
	if err != nil {
		return nil, err
	}
	args["first"] = arg0
	arg1, err := graphql.ProcessArgField(ctx, rawArgs, "after", ec.unmarshalOCursorKey2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋpageᚐCursorKey)
	if err != nil {
		return nil, err
	}
	args["after"] = arg1
	arg2, err := graphql.ProcessArgField(ctx, rawArgs, "last", ec.unmarshalOInt2ᚖint)
	if err != nil {
		return nil, err
	}
	args["last"] = arg2
	arg3, err := graphql.ProcessArgField(ctx, rawArgs, "before", ec.unmarshalOCursorKey2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋpageᚐCursorKey)
	if err != nil {
		return nil, err
	}
	args["before"] = arg3
	arg4, err := graphql.ProcessArgField(ctx, rawArgs, "orderBy", ec.unmarshalOSessionOrder2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐSessionOrder)
	if err != nil {
		return nil, err
	}
	args["orderBy"] = arg4
	return args, nil
}

func (ec *executionContext) field_Invitation_permission_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "action", ec.unmarshalNString2string)
	if err != nil {
		return nil, err
	}
	args["action"] = arg0
	return args, nil
}

func (ec *executionContext) field_MembershipProfile_permission_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "action", ec.unmarshalNString2string)
	if err != nil {
		return nil, err
	}
	args["action"] = arg0
	return args, nil
}

func (ec *executionContext) field_Membership_permission_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "action", ec.unmarshalNString2string)
	if err != nil {
		return nil, err
	}
	args["action"] = arg0
	return args, nil
}

func (ec *executionContext) field_Mutation_acceptInvitation_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "input", ec.unmarshalNAcceptInvitationInput2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐAcceptInvitationInput)
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}

func (ec *executionContext) field_Mutation_assumeOrganizationSession_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "input", ec.unmarshalNAssumeOrganizationSessionInput2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐAssumeOrganizationSessionInput)
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}

func (ec *executionContext) field_Mutation_changeEmail_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "input", ec.unmarshalNChangeEmailInput2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐChangeEmailInput)
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}

func (ec *executionContext) field_Mutation_changePassword_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "input", ec.unmarshalNChangePasswordInput2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐChangePasswordInput)
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}

func (ec *executionContext) field_Mutation_createOrganization_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "input", ec.unmarshalNCreateOrganizationInput2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐCreateOrganizationInput)
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}

func (ec *executionContext) field_Mutation_createPersonalAPIKey_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "input", ec.unmarshalNCreatePersonalAPIKeyInput2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐCreatePersonalAPIKeyInput)
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}

func (ec *executionContext) field_Mutation_createSAMLConfiguration_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "input", ec.unmarshalNCreateSAMLConfigurationInput2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐCreateSAMLConfigurationInput)
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}

func (ec *executionContext) field_Mutation_createSCIMConfiguration_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "input", ec.unmarshalNCreateSCIMConfigurationInput2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐCreateSCIMConfigurationInput)
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}

func (ec *executionContext) field_Mutation_deleteInvitation_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "input", ec.unmarshalNDeleteInvitationInput2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐDeleteInvitationInput)
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}

func (ec *executionContext) field_Mutation_deleteOrganizationHorizontalLogo_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "input", ec.unmarshalNDeleteOrganizationHorizontalLogoInput2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐDeleteOrganizationHorizontalLogoInput)
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}

func (ec *executionContext) field_Mutation_deleteOrganization_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "input", ec.unmarshalNDeleteOrganizationInput2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐDeleteOrganizationInput)
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}

func (ec *executionContext) field_Mutation_deleteSAMLConfiguration_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "input", ec.unmarshalNDeleteSAMLConfigurationInput2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐDeleteSAMLConfigurationInput)
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}

func (ec *executionContext) field_Mutation_deleteSCIMConfiguration_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "input", ec.unmarshalNDeleteSCIMConfigurationInput2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐDeleteSCIMConfigurationInput)
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}

func (ec *executionContext) field_Mutation_forgotPassword_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "input", ec.unmarshalNForgotPasswordInput2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐForgotPasswordInput)
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}

func (ec *executionContext) field_Mutation_inviteMember_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "input", ec.unmarshalNInviteMemberInput2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐInviteMemberInput)
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}

func (ec *executionContext) field_Mutation_regenerateSCIMToken_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "input", ec.unmarshalNRegenerateSCIMTokenInput2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐRegenerateSCIMTokenInput)
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}

func (ec *executionContext) field_Mutation_removeMember_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "input", ec.unmarshalNRemoveMemberInput2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐRemoveMemberInput)
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}

func (ec *executionContext) field_Mutation_resetPassword_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "input", ec.unmarshalNResetPasswordInput2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐResetPasswordInput)
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}

func (ec *executionContext) field_Mutation_revokePersonalAPIKey_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "input", ec.unmarshalNRevokePersonalAPIKeyInput2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐRevokePersonalAPIKeyInput)
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}

func (ec *executionContext) field_Mutation_revokeSession_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "input", ec.unmarshalNRevokeSessionInput2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐRevokeSessionInput)
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}

func (ec *executionContext) field_Mutation_signIn_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "input", ec.unmarshalNSignInInput2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐSignInInput)
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}

func (ec *executionContext) field_Mutation_signUpFromInvitation_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "input", ec.unmarshalNSignUpFromInvitationInput2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐSignUpFromInvitationInput)
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}

func (ec *executionContext) field_Mutation_signUp_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "input", ec.unmarshalNSignUpInput2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐSignUpInput)
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}

func (ec *executionContext) field_Mutation_updateMembership_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "input", ec.unmarshalNUpdateMembershipInput2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐUpdateMembershipInput)
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}

func (ec *executionContext) field_Mutation_updateOrganization_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "input", ec.unmarshalNUpdateOrganizationInput2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐUpdateOrganizationInput)
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}

func (ec *executionContext) field_Mutation_updateProfile_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "input", ec.unmarshalNUpdateProfileInput2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐUpdateProfileInput)
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}

func (ec *executionContext) field_Mutation_updateSAMLConfiguration_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "input", ec.unmarshalNUpdateSAMLConfigurationInput2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐUpdateSAMLConfigurationInput)
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}

func (ec *executionContext) field_Mutation_updateSCIMBridge_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "input", ec.unmarshalNUpdateSCIMBridgeInput2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐUpdateSCIMBridgeInput)
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}

func (ec *executionContext) field_Mutation_verifyEmail_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "input", ec.unmarshalNVerifyEmailInput2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐVerifyEmailInput)
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}

func (ec *executionContext) field_Organization_invitations_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "first", ec.unmarshalOInt2ᚖint)
	if err != nil {
		return nil, err
	}
	args["first"] = arg0
	arg1, err := graphql.ProcessArgField(ctx, rawArgs, "after", ec.unmarshalOCursorKey2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋpageᚐCursorKey)
	if err != nil {
		return nil, err
	}
	args["after"] = arg1
	arg2, err := graphql.ProcessArgField(ctx, rawArgs, "last", ec.unmarshalOInt2ᚖint)
	if err != nil {
		return nil, err
	}
	args["last"] = arg2
	arg3, err := graphql.ProcessArgField(ctx, rawArgs, "before", ec.unmarshalOCursorKey2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋpageᚐCursorKey)
	if err != nil {
		return nil, err
	}
	args["before"] = arg3
	arg4, err := graphql.ProcessArgField(ctx, rawArgs, "status", ec.unmarshalOInvitationStatus2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐInvitationStatus)
	if err != nil {
		return nil, err
	}
	args["status"] = arg4
	arg5, err := graphql.ProcessArgField(ctx, rawArgs, "orderBy", ec.unmarshalOInvitationOrder2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐInvitationOrderBy)
	if err != nil {
		return nil, err
	}
	args["orderBy"] = arg5
	return args, nil
}

func (ec *executionContext) field_Organization_members_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "first", ec.unmarshalOInt2ᚖint)
	if err != nil {
		return nil, err
	}
	args["first"] = arg0
	arg1, err := graphql.ProcessArgField(ctx, rawArgs, "after", ec.unmarshalOCursorKey2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋpageᚐCursorKey)
	if err != nil {
		return nil, err
	}
	args["after"] = arg1
	arg2, err := graphql.ProcessArgField(ctx, rawArgs, "last", ec.unmarshalOInt2ᚖint)
	if err != nil {
		return nil, err
	}
	args["last"] = arg2
	arg3, err := graphql.ProcessArgField(ctx, rawArgs, "before", ec.unmarshalOCursorKey2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋpageᚐCursorKey)
	if err != nil {
		return nil, err
	}
	args["before"] = arg3
	arg4, err := graphql.ProcessArgField(ctx, rawArgs, "orderBy", ec.unmarshalOMembershipOrder2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐMembershipOrderBy)
	if err != nil {
		return nil, err
	}
	args["orderBy"] = arg4
	return args, nil
}

func (ec *executionContext) field_Organization_permission_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "action", ec.unmarshalNString2string)
	if err != nil {
		return nil, err
	}
	args["action"] = arg0
	return args, nil
}

func (ec *executionContext) field_Organization_samlConfigurations_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "first", ec.unmarshalOInt2ᚖint)
	if err != nil {
		return nil, err
	}
	args["first"] = arg0
	arg1, err := graphql.ProcessArgField(ctx, rawArgs, "after", ec.unmarshalOCursorKey2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋpageᚐCursorKey)
	if err != nil {
		return nil, err
	}
	args["after"] = arg1
	arg2, err := graphql.ProcessArgField(ctx, rawArgs, "last", ec.unmarshalOInt2ᚖint)
	if err != nil {
		return nil, err
	}
	args["last"] = arg2
	arg3, err := graphql.ProcessArgField(ctx, rawArgs, "before", ec.unmarshalOCursorKey2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋpageᚐCursorKey)
	if err != nil {
		return nil, err
	}
	args["before"] = arg3
	return args, nil
}

func (ec *executionContext) field_PersonalAPIKey_permission_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "action", ec.unmarshalNString2string)
	if err != nil {
		return nil, err
	}
	args["action"] = arg0
	return args, nil
}

func (ec *executionContext) field_Query___type_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "name", ec.unmarshalNString2string)
	if err != nil {
		return nil, err
	}
	args["name"] = arg0
	return args, nil
}

func (ec *executionContext) field_Query_node_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "id", ec.unmarshalNID2goᚗproboᚗincᚋproboᚋpkgᚋgidᚐGID)
	if err != nil {
		return nil, err
	}
	args["id"] = arg0
	return args, nil
}

func (ec *executionContext) field_Query_ssoLoginURL_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "email", ec.unmarshalNEmailAddr2goᚗproboᚗincᚋproboᚋpkgᚋmailᚐAddr)
	if err != nil {
		return nil, err
	}
	args["email"] = arg0
	return args, nil
}

func (ec *executionContext) field_SAMLConfiguration_permission_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "action", ec.unmarshalNString2string)
	if err != nil {
		return nil, err
	}
	args["action"] = arg0
	return args, nil
}

func (ec *executionContext) field_SCIMBridge_permission_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "action", ec.unmarshalNString2string)
	if err != nil {
		return nil, err
	}
	args["action"] = arg0
	return args, nil
}

func (ec *executionContext) field_SCIMConfiguration_events_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "first", ec.unmarshalOInt2ᚖint)
	if err != nil {
		return nil, err
	}
	args["first"] = arg0
	arg1, err := graphql.ProcessArgField(ctx, rawArgs, "after", ec.unmarshalOCursorKey2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋpageᚐCursorKey)
	if err != nil {
		return nil, err
	}
	args["after"] = arg1
	arg2, err := graphql.ProcessArgField(ctx, rawArgs, "last", ec.unmarshalOInt2ᚖint)
	if err != nil {
		return nil, err
	}
	args["last"] = arg2
	arg3, err := graphql.ProcessArgField(ctx, rawArgs, "before", ec.unmarshalOCursorKey2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋpageᚐCursorKey)
	if err != nil {
		return nil, err
	}
	args["before"] = arg3
	arg4, err := graphql.ProcessArgField(ctx, rawArgs, "orderBy", ec.unmarshalOSCIMEventOrder2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐSCIMEventOrderBy)
	if err != nil {
		return nil, err
	}
	args["orderBy"] = arg4
	return args, nil
}

func (ec *executionContext) field_SCIMConfiguration_permission_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "action", ec.unmarshalNString2string)
	if err != nil {
		return nil, err
	}
	args["action"] = arg0
	return args, nil
}

func (ec *executionContext) field_SCIMEvent_permission_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "action", ec.unmarshalNString2string)
	if err != nil {
		return nil, err
	}
	args["action"] = arg0
	return args, nil
}

func (ec *executionContext) field_Session_permission_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "action", ec.unmarshalNString2string)
	if err != nil {
		return nil, err
	}
	args["action"] = arg0
	return args, nil
}

func (ec *executionContext) field___Directive_args_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "includeDeprecated", ec.unmarshalOBoolean2ᚖbool)
	if err != nil {
		return nil, err
	}
	args["includeDeprecated"] = arg0
	return args, nil
}

func (ec *executionContext) field___Field_args_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "includeDeprecated", ec.unmarshalOBoolean2ᚖbool)
	if err != nil {
		return nil, err
	}
	args["includeDeprecated"] = arg0
	return args, nil
}

func (ec *executionContext) field___Type_enumValues_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "includeDeprecated", ec.unmarshalOBoolean2bool)
	if err != nil {
		return nil, err
	}
	args["includeDeprecated"] = arg0
	return args, nil
}

func (ec *executionContext) field___Type_fields_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "includeDeprecated", ec.unmarshalOBoolean2bool)
	if err != nil {
		return nil, err
	}
	args["includeDeprecated"] = arg0
	return args, nil
}

// endregion ***************************** args.gotpl *****************************

// region    ************************** directives.gotpl **************************

// endregion ************************** directives.gotpl **************************

// region    **************************** field.gotpl *****************************

func (ec *executionContext) _AcceptInvitationPayload_membershipEdge(ctx context.Context, field graphql.CollectedField, obj *types.AcceptInvitationPayload) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_AcceptInvitationPayload_membershipEdge,
		func(ctx context.Context) (any, error) {
			return obj.MembershipEdge, nil
		},
		nil,
		ec.marshalNMembershipEdge2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐMembershipEdge,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_AcceptInvitationPayload_membershipEdge(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "AcceptInvitationPayload",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "node":
				return ec.fieldContext_MembershipEdge_node(ctx, field)
			case "cursor":
				return ec.fieldContext_MembershipEdge_cursor(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type MembershipEdge", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _AcceptInvitationPayload_invitation(ctx context.Context, field graphql.CollectedField, obj *types.AcceptInvitationPayload) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_AcceptInvitationPayload_invitation,
		func(ctx context.Context) (any, error) {
			return obj.Invitation, nil
		},
		nil,
		ec.marshalNInvitation2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐInvitation,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_AcceptInvitationPayload_invitation(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "AcceptInvitationPayload",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_Invitation_id(ctx, field)
			case "email":
				return ec.fieldContext_Invitation_email(ctx, field)
			case "fullName":
				return ec.fieldContext_Invitation_fullName(ctx, field)
			case "role":
				return ec.fieldContext_Invitation_role(ctx, field)
			case "expiresAt":
				return ec.fieldContext_Invitation_expiresAt(ctx, field)
			case "acceptedAt":
				return ec.fieldContext_Invitation_acceptedAt(ctx, field)
			case "createdAt":
				return ec.fieldContext_Invitation_createdAt(ctx, field)
			case "status":
				return ec.fieldContext_Invitation_status(ctx, field)
			case "organization":
				return ec.fieldContext_Invitation_organization(ctx, field)
			case "permission":
				return ec.fieldContext_Invitation_permission(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type Invitation", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _AssumeOrganizationSessionPayload_result(ctx context.Context, field graphql.CollectedField, obj *types.AssumeOrganizationSessionPayload) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_AssumeOrganizationSessionPayload_result,
		func(ctx context.Context) (any, error) {
			return obj.Result, nil
		},
		nil,
		ec.marshalNAssumeOrganizationSessionResult2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐAssumeOrganizationSessionResult,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_AssumeOrganizationSessionPayload_result(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "AssumeOrganizationSessionPayload",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type AssumeOrganizationSessionResult does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _ChangeEmailPayload_success(ctx context.Context, field graphql.CollectedField, obj *types.ChangeEmailPayload) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_ChangeEmailPayload_success,
		func(ctx context.Context) (any, error) {
			return obj.Success, nil
		},
		nil,
		ec.marshalNBoolean2bool,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_ChangeEmailPayload_success(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "ChangeEmailPayload",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Boolean does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _ChangePasswordPayload_success(ctx context.Context, field graphql.CollectedField, obj *types.ChangePasswordPayload) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_ChangePasswordPayload_success,
		func(ctx context.Context) (any, error) {
			return obj.Success, nil
		},
		nil,
		ec.marshalNBoolean2bool,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_ChangePasswordPayload_success(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "ChangePasswordPayload",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Boolean does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _Connector_id(ctx context.Context, field graphql.CollectedField, obj *types.Connector) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Connector_id,
		func(ctx context.Context) (any, error) {
			return obj.ID, nil
		},
		nil,
		ec.marshalNID2goᚗproboᚗincᚋproboᚋpkgᚋgidᚐGID,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_Connector_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Connector",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type ID does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _Connector_provider(ctx context.Context, field graphql.CollectedField, obj *types.Connector) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Connector_provider,
		func(ctx context.Context) (any, error) {
			return obj.Provider, nil
		},
		nil,
		ec.marshalNConnectorProvider2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐConnectorProvider,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_Connector_provider(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Connector",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type ConnectorProvider does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _Connector_createdAt(ctx context.Context, field graphql.CollectedField, obj *types.Connector) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Connector_createdAt,
		func(ctx context.Context) (any, error) {
			return obj.CreatedAt, nil
		},
		nil,
		ec.marshalNDatetime2timeᚐTime,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_Connector_createdAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Connector",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Datetime does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _Connector_updatedAt(ctx context.Context, field graphql.CollectedField, obj *types.Connector) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Connector_updatedAt,
		func(ctx context.Context) (any, error) {
			return obj.UpdatedAt, nil
		},
		nil,
		ec.marshalNDatetime2timeᚐTime,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_Connector_updatedAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Connector",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Datetime does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _Connector_permission(ctx context.Context, field graphql.CollectedField, obj *types.Connector) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Connector_permission,
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.resolvers.Connector().Permission(ctx, obj, fc.Args["action"].(string))
		},
		func(ctx context.Context, next graphql.Resolver) graphql.Resolver {
			directive0 := next

			directive1 := func(ctx context.Context) (any, error) {
				required, err := ec.unmarshalNSessionRequirement2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋgqlutilsᚋdirectivesᚋsessionᚐSessionRequirement(ctx, "PRESENT")
				if err != nil {
					var zeroVal bool
					return zeroVal, err
				}
				if ec.directives.Session == nil {
					var zeroVal bool
					return zeroVal, errors.New("directive session is not implemented")
				}
				return ec.directives.Session(ctx, obj, directive0, required)
			}

			next = directive1
			return next
		},
		ec.marshalNBoolean2bool,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_Connector_permission(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Connector",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Boolean does not have child fields")
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Connector_permission_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _CreateOrganizationPayload_organization(ctx context.Context, field graphql.CollectedField, obj *types.CreateOrganizationPayload) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_CreateOrganizationPayload_organization,
		func(ctx context.Context) (any, error) {
			return obj.Organization, nil
		},
		nil,
		ec.marshalOOrganization2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐOrganization,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_CreateOrganizationPayload_organization(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "CreateOrganizationPayload",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_Organization_id(ctx, field)
			case "name":
				return ec.fieldContext_Organization_name(ctx, field)
			case "logoUrl":
				return ec.fieldContext_Organization_logoUrl(ctx, field)
			case "horizontalLogoUrl":
				return ec.fieldContext_Organization_horizontalLogoUrl(ctx, field)
			case "email":
				return ec.fieldContext_Organization_email(ctx, field)
			case "description":
				return ec.fieldContext_Organization_description(ctx, field)
			case "websiteUrl":
				return ec.fieldContext_Organization_websiteUrl(ctx, field)
			case "headquarterAddress":
				return ec.fieldContext_Organization_headquarterAddress(ctx, field)
			case "createdAt":
				return ec.fieldContext_Organization_createdAt(ctx, field)
			case "updatedAt":
				return ec.fieldContext_Organization_updatedAt(ctx, field)
			case "members":
				return ec.fieldContext_Organization_members(ctx, field)
			case "invitations":
				return ec.fieldContext_Organization_invitations(ctx, field)
			case "samlConfigurations":
				return ec.fieldContext_Organization_samlConfigurations(ctx, field)
			case "scimConfiguration":
				return ec.fieldContext_Organization_scimConfiguration(ctx, field)
			case "viewerMembership":
				return ec.fieldContext_Organization_viewerMembership(ctx, field)
			case "permission":
				return ec.fieldContext_Organization_permission(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type Organization", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _CreateOrganizationPayload_membershipEdge(ctx context.Context, field graphql.CollectedField, obj *types.CreateOrganizationPayload) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_CreateOrganizationPayload_membershipEdge,
		func(ctx context.Context) (any, error) {
			return obj.MembershipEdge, nil
		},
		nil,
		ec.marshalNMembershipEdge2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐMembershipEdge,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_CreateOrganizationPayload_membershipEdge(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "CreateOrganizationPayload",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "node":
				return ec.fieldContext_MembershipEdge_node(ctx, field)
			case "cursor":
				return ec.fieldContext_MembershipEdge_cursor(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type MembershipEdge", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _CreatePersonalAPIKeyPayload_personalAPIKeyEdge(ctx context.Context, field graphql.CollectedField, obj *types.CreatePersonalAPIKeyPayload) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_CreatePersonalAPIKeyPayload_personalAPIKeyEdge,
		func(ctx context.Context) (any, error) {
			return obj.PersonalAPIKeyEdge, nil
		},
		nil,
		ec.marshalNPersonalAPIKeyEdge2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐPersonalAPIKeyEdge,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_CreatePersonalAPIKeyPayload_personalAPIKeyEdge(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "CreatePersonalAPIKeyPayload",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "node":
				return ec.fieldContext_PersonalAPIKeyEdge_node(ctx, field)
			case "cursor":
				return ec.fieldContext_PersonalAPIKeyEdge_cursor(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type PersonalAPIKeyEdge", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _CreatePersonalAPIKeyPayload_token(ctx context.Context, field graphql.CollectedField, obj *types.CreatePersonalAPIKeyPayload) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_CreatePersonalAPIKeyPayload_token,
		func(ctx context.Context) (any, error) {
			return obj.Token, nil
		},
		nil,
		ec.marshalNString2string,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_CreatePersonalAPIKeyPayload_token(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "CreatePersonalAPIKeyPayload",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _CreateSAMLConfigurationPayload_samlConfigurationEdge(ctx context.Context, field graphql.CollectedField, obj *types.CreateSAMLConfigurationPayload) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_CreateSAMLConfigurationPayload_samlConfigurationEdge,
		func(ctx context.Context) (any, error) {
			return obj.SamlConfigurationEdge, nil
		},
		nil,
		ec.marshalNSAMLConfigurationEdge2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐSAMLConfigurationEdge,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_CreateSAMLConfigurationPayload_samlConfigurationEdge(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "CreateSAMLConfigurationPayload",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "node":
				return ec.fieldContext_SAMLConfigurationEdge_node(ctx, field)
			case "cursor":
				return ec.fieldContext_SAMLConfigurationEdge_cursor(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type SAMLConfigurationEdge", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _CreateSCIMConfigurationPayload_scimConfiguration(ctx context.Context, field graphql.CollectedField, obj *types.CreateSCIMConfigurationPayload) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_CreateSCIMConfigurationPayload_scimConfiguration,
		func(ctx context.Context) (any, error) {
			return obj.ScimConfiguration, nil
		},
		nil,
		ec.marshalNSCIMConfiguration2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐSCIMConfiguration,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_CreateSCIMConfigurationPayload_scimConfiguration(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "CreateSCIMConfigurationPayload",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_SCIMConfiguration_id(ctx, field)
			case "endpointUrl":
				return ec.fieldContext_SCIMConfiguration_endpointUrl(ctx, field)
			case "createdAt":
				return ec.fieldContext_SCIMConfiguration_createdAt(ctx, field)
			case "updatedAt":
				return ec.fieldContext_SCIMConfiguration_updatedAt(ctx, field)
			case "organization":
				return ec.fieldContext_SCIMConfiguration_organization(ctx, field)
			case "bridge":
				return ec.fieldContext_SCIMConfiguration_bridge(ctx, field)
			case "events":
				return ec.fieldContext_SCIMConfiguration_events(ctx, field)
			case "permission":
				return ec.fieldContext_SCIMConfiguration_permission(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type SCIMConfiguration", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _CreateSCIMConfigurationPayload_scimBridge(ctx context.Context, field graphql.CollectedField, obj *types.CreateSCIMConfigurationPayload) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_CreateSCIMConfigurationPayload_scimBridge,
		func(ctx context.Context) (any, error) {
			return obj.ScimBridge, nil
		},
		nil,
		ec.marshalOSCIMBridge2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐSCIMBridge,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_CreateSCIMConfigurationPayload_scimBridge(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "CreateSCIMConfigurationPayload",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_SCIMBridge_id(ctx, field)
			case "state":
				return ec.fieldContext_SCIMBridge_state(ctx, field)
			case "scimConfiguration":
				return ec.fieldContext_SCIMBridge_scimConfiguration(ctx, field)
			case "connector":
				return ec.fieldContext_SCIMBridge_connector(ctx, field)
			case "type":
				return ec.fieldContext_SCIMBridge_type(ctx, field)
			case "excludedUserNames":
				return ec.fieldContext_SCIMBridge_excludedUserNames(ctx, field)
			case "createdAt":
				return ec.fieldContext_SCIMBridge_createdAt(ctx, field)
			case "updatedAt":
				return ec.fieldContext_SCIMBridge_updatedAt(ctx, field)
			case "permission":
				return ec.fieldContext_SCIMBridge_permission(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type SCIMBridge", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _CreateSCIMConfigurationPayload_token(ctx context.Context, field graphql.CollectedField, obj *types.CreateSCIMConfigurationPayload) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_CreateSCIMConfigurationPayload_token,
		func(ctx context.Context) (any, error) {
			return obj.Token, nil
		},
		nil,
		ec.marshalNString2string,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_CreateSCIMConfigurationPayload_token(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "CreateSCIMConfigurationPayload",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _DeleteInvitationPayload_deletedInvitationId(ctx context.Context, field graphql.CollectedField, obj *types.DeleteInvitationPayload) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_DeleteInvitationPayload_deletedInvitationId,
		func(ctx context.Context) (any, error) {
			return obj.DeletedInvitationID, nil
		},
		nil,
		ec.marshalNID2goᚗproboᚗincᚋproboᚋpkgᚋgidᚐGID,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_DeleteInvitationPayload_deletedInvitationId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "DeleteInvitationPayload",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type ID does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _DeleteOrganizationHorizontalLogoPayload_organization(ctx context.Context, field graphql.CollectedField, obj *types.DeleteOrganizationHorizontalLogoPayload) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_DeleteOrganizationHorizontalLogoPayload_organization,
		func(ctx context.Context) (any, error) {
			return obj.Organization, nil
		},
		nil,
		ec.marshalNOrganization2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐOrganization,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_DeleteOrganizationHorizontalLogoPayload_organization(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "DeleteOrganizationHorizontalLogoPayload",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_Organization_id(ctx, field)
			case "name":
				return ec.fieldContext_Organization_name(ctx, field)
			case "logoUrl":
				return ec.fieldContext_Organization_logoUrl(ctx, field)
			case "horizontalLogoUrl":
				return ec.fieldContext_Organization_horizontalLogoUrl(ctx, field)
			case "email":
				return ec.fieldContext_Organization_email(ctx, field)
			case "description":
				return ec.fieldContext_Organization_description(ctx, field)
			case "websiteUrl":
				return ec.fieldContext_Organization_websiteUrl(ctx, field)
			case "headquarterAddress":
				return ec.fieldContext_Organization_headquarterAddress(ctx, field)
			case "createdAt":
				return ec.fieldContext_Organization_createdAt(ctx, field)
			case "updatedAt":
				return ec.fieldContext_Organization_updatedAt(ctx, field)
			case "members":
				return ec.fieldContext_Organization_members(ctx, field)
			case "invitations":
				return ec.fieldContext_Organization_invitations(ctx, field)
			case "samlConfigurations":
				return ec.fieldContext_Organization_samlConfigurations(ctx, field)
			case "scimConfiguration":
				return ec.fieldContext_Organization_scimConfiguration(ctx, field)
			case "viewerMembership":
				return ec.fieldContext_Organization_viewerMembership(ctx, field)
			case "permission":
				return ec.fieldContext_Organization_permission(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type Organization", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _DeleteOrganizationPayload_deletedOrganizationId(ctx context.Context, field graphql.CollectedField, obj *types.DeleteOrganizationPayload) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_DeleteOrganizationPayload_deletedOrganizationId,
		func(ctx context.Context) (any, error) {
			return obj.DeletedOrganizationID, nil
		},
		nil,
		ec.marshalNID2goᚗproboᚗincᚋproboᚋpkgᚋgidᚐGID,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_DeleteOrganizationPayload_deletedOrganizationId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "DeleteOrganizationPayload",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type ID does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _DeleteSAMLConfigurationPayload_deletedSamlConfigurationId(ctx context.Context, field graphql.CollectedField, obj *types.DeleteSAMLConfigurationPayload) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_DeleteSAMLConfigurationPayload_deletedSamlConfigurationId,
		func(ctx context.Context) (any, error) {
			return obj.DeletedSamlConfigurationID, nil
		},
		nil,
		ec.marshalNID2goᚗproboᚗincᚋproboᚋpkgᚋgidᚐGID,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_DeleteSAMLConfigurationPayload_deletedSamlConfigurationId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "DeleteSAMLConfigurationPayload",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type ID does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _DeleteSCIMConfigurationPayload_deletedScimConfigurationId(ctx context.Context, field graphql.CollectedField, obj *types.DeleteSCIMConfigurationPayload) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_DeleteSCIMConfigurationPayload_deletedScimConfigurationId,
		func(ctx context.Context) (any, error) {
			return obj.DeletedScimConfigurationID, nil
		},
		nil,
		ec.marshalNID2goᚗproboᚗincᚋproboᚋpkgᚋgidᚐGID,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_DeleteSCIMConfigurationPayload_deletedScimConfigurationId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "DeleteSCIMConfigurationPayload",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type ID does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _ForgotPasswordPayload_success(ctx context.Context, field graphql.CollectedField, obj *types.ForgotPasswordPayload) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_ForgotPasswordPayload_success,
		func(ctx context.Context) (any, error) {
			return obj.Success, nil
		},
		nil,
		ec.marshalNBoolean2bool,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_ForgotPasswordPayload_success(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "ForgotPasswordPayload",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Boolean does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _Identity_id(ctx context.Context, field graphql.CollectedField, obj *types.Identity) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Identity_id,
		func(ctx context.Context) (any, error) {
			return obj.ID, nil
		},
		nil,
		ec.marshalNID2goᚗproboᚗincᚋproboᚋpkgᚋgidᚐGID,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_Identity_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Identity",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type ID does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _Identity_email(ctx context.Context, field graphql.CollectedField, obj *types.Identity) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Identity_email,
		func(ctx context.Context) (any, error) {
			return obj.Email, nil
		},
		nil,
		ec.marshalNEmailAddr2goᚗproboᚗincᚋproboᚋpkgᚋmailᚐAddr,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_Identity_email(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Identity",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type EmailAddr does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _Identity_fullName(ctx context.Context, field graphql.CollectedField, obj *types.Identity) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Identity_fullName,
		func(ctx context.Context) (any, error) {
			return obj.FullName, nil
		},
		nil,
		ec.marshalNString2string,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_Identity_fullName(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Identity",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _Identity_emailVerified(ctx context.Context, field graphql.CollectedField, obj *types.Identity) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Identity_emailVerified,
		func(ctx context.Context) (any, error) {
			return obj.EmailVerified, nil
		},
		nil,
		ec.marshalNBoolean2bool,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_Identity_emailVerified(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Identity",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Boolean does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _Identity_createdAt(ctx context.Context, field graphql.CollectedField, obj *types.Identity) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Identity_createdAt,
		func(ctx context.Context) (any, error) {
			return obj.CreatedAt, nil
		},
		nil,
		ec.marshalNDatetime2timeᚐTime,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_Identity_createdAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Identity",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Datetime does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _Identity_updatedAt(ctx context.Context, field graphql.CollectedField, obj *types.Identity) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Identity_updatedAt,
		func(ctx context.Context) (any, error) {
			return obj.UpdatedAt, nil
		},
		nil,
		ec.marshalNDatetime2timeᚐTime,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_Identity_updatedAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Identity",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Datetime does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _Identity_memberships(ctx context.Context, field graphql.CollectedField, obj *types.Identity) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Identity_memberships,
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.resolvers.Identity().Memberships(ctx, obj, fc.Args["first"].(*int), fc.Args["after"].(*page.CursorKey), fc.Args["last"].(*int), fc.Args["before"].(*page.CursorKey), fc.Args["orderBy"].(*types.MembershipOrderBy))
		},
		nil,
		ec.marshalOMembershipConnection2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐMembershipConnection,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_Identity_memberships(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Identity",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "edges":
				return ec.fieldContext_MembershipConnection_edges(ctx, field)
			case "pageInfo":
				return ec.fieldContext_MembershipConnection_pageInfo(ctx, field)
			case "totalCount":
				return ec.fieldContext_MembershipConnection_totalCount(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type MembershipConnection", field.Name)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Identity_memberships_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Identity_pendingInvitations(ctx context.Context, field graphql.CollectedField, obj *types.Identity) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Identity_pendingInvitations,
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.resolvers.Identity().PendingInvitations(ctx, obj, fc.Args["first"].(*int), fc.Args["after"].(*page.CursorKey), fc.Args["last"].(*int), fc.Args["before"].(*page.CursorKey), fc.Args["orderBy"].(*types.InvitationOrderBy))
		},
		nil,
		ec.marshalOInvitationConnection2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐInvitationConnection,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_Identity_pendingInvitations(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Identity",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "edges":
				return ec.fieldContext_InvitationConnection_edges(ctx, field)
			case "pageInfo":
				return ec.fieldContext_InvitationConnection_pageInfo(ctx, field)
			case "totalCount":
				return ec.fieldContext_InvitationConnection_totalCount(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type InvitationConnection", field.Name)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Identity_pendingInvitations_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Identity_sessions(ctx context.Context, field graphql.CollectedField, obj *types.Identity) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Identity_sessions,
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.resolvers.Identity().Sessions(ctx, obj, fc.Args["first"].(*int), fc.Args["after"].(*page.CursorKey), fc.Args["last"].(*int), fc.Args["before"].(*page.CursorKey), fc.Args["orderBy"].(*types.SessionOrder))
		},
		nil,
		ec.marshalOSessionConnection2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐSessionConnection,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_Identity_sessions(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Identity",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "edges":
				return ec.fieldContext_SessionConnection_edges(ctx, field)
			case "pageInfo":
				return ec.fieldContext_SessionConnection_pageInfo(ctx, field)
			case "totalCount":
				return ec.fieldContext_SessionConnection_totalCount(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type SessionConnection", field.Name)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Identity_sessions_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Identity_personalAPIKeys(ctx context.Context, field graphql.CollectedField, obj *types.Identity) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Identity_personalAPIKeys,
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.resolvers.Identity().PersonalAPIKeys(ctx, obj, fc.Args["first"].(*int), fc.Args["after"].(*page.CursorKey), fc.Args["last"].(*int), fc.Args["before"].(*page.CursorKey))
		},
		nil,
		ec.marshalOPersonalAPIKeyConnection2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐPersonalAPIKeyConnection,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_Identity_personalAPIKeys(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Identity",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "edges":
				return ec.fieldContext_PersonalAPIKeyConnection_edges(ctx, field)
			case "pageInfo":
				return ec.fieldContext_PersonalAPIKeyConnection_pageInfo(ctx, field)
			case "totalCount":
				return ec.fieldContext_PersonalAPIKeyConnection_totalCount(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type PersonalAPIKeyConnection", field.Name)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Identity_personalAPIKeys_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Identity_permission(ctx context.Context, field graphql.CollectedField, obj *types.Identity) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Identity_permission,
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.resolvers.Identity().Permission(ctx, obj, fc.Args["action"].(string))
		},
		func(ctx context.Context, next graphql.Resolver) graphql.Resolver {
			directive0 := next

			directive1 := func(ctx context.Context) (any, error) {
				required, err := ec.unmarshalNSessionRequirement2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋgqlutilsᚋdirectivesᚋsessionᚐSessionRequirement(ctx, "PRESENT")
				if err != nil {
					var zeroVal bool
					return zeroVal, err
				}
				if ec.directives.Session == nil {
					var zeroVal bool
					return zeroVal, errors.New("directive session is not implemented")
				}
				return ec.directives.Session(ctx, obj, directive0, required)
			}

			next = directive1
			return next
		},
		ec.marshalNBoolean2bool,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_Identity_permission(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Identity",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Boolean does not have child fields")
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Identity_permission_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Invitation_id(ctx context.Context, field graphql.CollectedField, obj *types.Invitation) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Invitation_id,
		func(ctx context.Context) (any, error) {
			return obj.ID, nil
		},
		nil,
		ec.marshalNID2goᚗproboᚗincᚋproboᚋpkgᚋgidᚐGID,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_Invitation_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Invitation",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type ID does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _Invitation_email(ctx context.Context, field graphql.CollectedField, obj *types.Invitation) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Invitation_email,
		func(ctx context.Context) (any, error) {
			return obj.Email, nil
		},
		nil,
		ec.marshalNEmailAddr2goᚗproboᚗincᚋproboᚋpkgᚋmailᚐAddr,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_Invitation_email(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Invitation",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type EmailAddr does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _Invitation_fullName(ctx context.Context, field graphql.CollectedField, obj *types.Invitation) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Invitation_fullName,
		func(ctx context.Context) (any, error) {
			return obj.FullName, nil
		},
		nil,
		ec.marshalNString2string,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_Invitation_fullName(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Invitation",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _Invitation_role(ctx context.Context, field graphql.CollectedField, obj *types.Invitation) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Invitation_role,
		func(ctx context.Context) (any, error) {
			return obj.Role, nil
		},
		nil,
		ec.marshalNMembershipRole2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐMembershipRole,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_Invitation_role(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Invitation",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type MembershipRole does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _Invitation_expiresAt(ctx context.Context, field graphql.CollectedField, obj *types.Invitation) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Invitation_expiresAt,
		func(ctx context.Context) (any, error) {
			return obj.ExpiresAt, nil
		},
		nil,
		ec.marshalNDatetime2timeᚐTime,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_Invitation_expiresAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Invitation",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Datetime does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _Invitation_acceptedAt(ctx context.Context, field graphql.CollectedField, obj *types.Invitation) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Invitation_acceptedAt,
		func(ctx context.Context) (any, error) {
			return obj.AcceptedAt, nil
		},
		nil,
		ec.marshalODatetime2ᚖtimeᚐTime,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_Invitation_acceptedAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Invitation",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Datetime does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _Invitation_createdAt(ctx context.Context, field graphql.CollectedField, obj *types.Invitation) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Invitation_createdAt,
		func(ctx context.Context) (any, error) {
			return obj.CreatedAt, nil
		},
		nil,
		ec.marshalNDatetime2timeᚐTime,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_Invitation_createdAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Invitation",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Datetime does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _Invitation_status(ctx context.Context, field graphql.CollectedField, obj *types.Invitation) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Invitation_status,
		func(ctx context.Context) (any, error) {
			return obj.Status, nil
		},
		nil,
		ec.marshalNInvitationStatus2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐInvitationStatus,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_Invitation_status(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Invitation",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type InvitationStatus does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _Invitation_organization(ctx context.Context, field graphql.CollectedField, obj *types.Invitation) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Invitation_organization,
		func(ctx context.Context) (any, error) {
			return ec.resolvers.Invitation().Organization(ctx, obj)
		},
		nil,
		ec.marshalOOrganization2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐOrganization,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_Invitation_organization(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Invitation",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_Organization_id(ctx, field)
			case "name":
				return ec.fieldContext_Organization_name(ctx, field)
			case "logoUrl":
				return ec.fieldContext_Organization_logoUrl(ctx, field)
			case "horizontalLogoUrl":
				return ec.fieldContext_Organization_horizontalLogoUrl(ctx, field)
			case "email":
				return ec.fieldContext_Organization_email(ctx, field)
			case "description":
				return ec.fieldContext_Organization_description(ctx, field)
			case "websiteUrl":
				return ec.fieldContext_Organization_websiteUrl(ctx, field)
			case "headquarterAddress":
				return ec.fieldContext_Organization_headquarterAddress(ctx, field)
			case "createdAt":
				return ec.fieldContext_Organization_createdAt(ctx, field)
			case "updatedAt":
				return ec.fieldContext_Organization_updatedAt(ctx, field)
			case "members":
				return ec.fieldContext_Organization_members(ctx, field)
			case "invitations":
				return ec.fieldContext_Organization_invitations(ctx, field)
			case "samlConfigurations":
				return ec.fieldContext_Organization_samlConfigurations(ctx, field)
			case "scimConfiguration":
				return ec.fieldContext_Organization_scimConfiguration(ctx, field)
			case "viewerMembership":
				return ec.fieldContext_Organization_viewerMembership(ctx, field)
			case "permission":
				return ec.fieldContext_Organization_permission(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type Organization", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _Invitation_permission(ctx context.Context, field graphql.CollectedField, obj *types.Invitation) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Invitation_permission,
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.resolvers.Invitation().Permission(ctx, obj, fc.Args["action"].(string))
		},
		func(ctx context.Context, next graphql.Resolver) graphql.Resolver {
			directive0 := next

			directive1 := func(ctx context.Context) (any, error) {
				required, err := ec.unmarshalNSessionRequirement2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋgqlutilsᚋdirectivesᚋsessionᚐSessionRequirement(ctx, "PRESENT")
				if err != nil {
					var zeroVal bool
					return zeroVal, err
				}
				if ec.directives.Session == nil {
					var zeroVal bool
					return zeroVal, errors.New("directive session is not implemented")
				}
				return ec.directives.Session(ctx, obj, directive0, required)
			}

			next = directive1
			return next
		},
		ec.marshalNBoolean2bool,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_Invitation_permission(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Invitation",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Boolean does not have child fields")
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Invitation_permission_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _InvitationConnection_edges(ctx context.Context, field graphql.CollectedField, obj *types.InvitationConnection) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_InvitationConnection_edges,
		func(ctx context.Context) (any, error) {
			return obj.Edges, nil
		},
		nil,
		ec.marshalNInvitationEdge2ᚕᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐInvitationEdgeᚄ,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_InvitationConnection_edges(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "InvitationConnection",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "node":
				return ec.fieldContext_InvitationEdge_node(ctx, field)
			case "cursor":
				return ec.fieldContext_InvitationEdge_cursor(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type InvitationEdge", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _InvitationConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *types.InvitationConnection) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_InvitationConnection_pageInfo,
		func(ctx context.Context) (any, error) {
			return obj.PageInfo, nil
		},
		nil,
		ec.marshalNPageInfo2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐPageInfo,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_InvitationConnection_pageInfo(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "InvitationConnection",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "hasNextPage":
				return ec.fieldContext_PageInfo_hasNextPage(ctx, field)
			case "hasPreviousPage":
				return ec.fieldContext_PageInfo_hasPreviousPage(ctx, field)
			case "startCursor":
				return ec.fieldContext_PageInfo_startCursor(ctx, field)
			case "endCursor":
				return ec.fieldContext_PageInfo_endCursor(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type PageInfo", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _InvitationConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *types.InvitationConnection) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_InvitationConnection_totalCount,
		func(ctx context.Context) (any, error) {
			return ec.resolvers.InvitationConnection().TotalCount(ctx, obj)
		},
		nil,
		ec.marshalOInt2ᚖint,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_InvitationConnection_totalCount(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "InvitationConnection",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Int does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _InvitationEdge_node(ctx context.Context, field graphql.CollectedField, obj *types.InvitationEdge) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_InvitationEdge_node,
		func(ctx context.Context) (any, error) {
			return obj.Node, nil
		},
		nil,
		ec.marshalNInvitation2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐInvitation,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_InvitationEdge_node(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "InvitationEdge",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_Invitation_id(ctx, field)
			case "email":
				return ec.fieldContext_Invitation_email(ctx, field)
			case "fullName":
				return ec.fieldContext_Invitation_fullName(ctx, field)
			case "role":
				return ec.fieldContext_Invitation_role(ctx, field)
			case "expiresAt":
				return ec.fieldContext_Invitation_expiresAt(ctx, field)
			case "acceptedAt":
				return ec.fieldContext_Invitation_acceptedAt(ctx, field)
			case "createdAt":
				return ec.fieldContext_Invitation_createdAt(ctx, field)
			case "status":
				return ec.fieldContext_Invitation_status(ctx, field)
			case "organization":
				return ec.fieldContext_Invitation_organization(ctx, field)
			case "permission":
				return ec.fieldContext_Invitation_permission(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type Invitation", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _InvitationEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *types.InvitationEdge) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_InvitationEdge_cursor,
		func(ctx context.Context) (any, error) {
			return obj.Cursor, nil
		},
		nil,
		ec.marshalNCursorKey2goᚗproboᚗincᚋproboᚋpkgᚋpageᚐCursorKey,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_InvitationEdge_cursor(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "InvitationEdge",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type CursorKey does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _InviteMemberPayload_invitationEdge(ctx context.Context, field graphql.CollectedField, obj *types.InviteMemberPayload) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_InviteMemberPayload_invitationEdge,
		func(ctx context.Context) (any, error) {
			return obj.InvitationEdge, nil
		},
		nil,
		ec.marshalNInvitationEdge2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐInvitationEdge,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_InviteMemberPayload_invitationEdge(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "InviteMemberPayload",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "node":
				return ec.fieldContext_InvitationEdge_node(ctx, field)
			case "cursor":
				return ec.fieldContext_InvitationEdge_cursor(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type InvitationEdge", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _Membership_id(ctx context.Context, field graphql.CollectedField, obj *types.Membership) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Membership_id,
		func(ctx context.Context) (any, error) {
			return obj.ID, nil
		},
		nil,
		ec.marshalNID2goᚗproboᚗincᚋproboᚋpkgᚋgidᚐGID,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_Membership_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Membership",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type ID does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _Membership_createdAt(ctx context.Context, field graphql.CollectedField, obj *types.Membership) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Membership_createdAt,
		func(ctx context.Context) (any, error) {
			return obj.CreatedAt, nil
		},
		nil,
		ec.marshalNDatetime2timeᚐTime,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_Membership_createdAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Membership",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Datetime does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _Membership_identity(ctx context.Context, field graphql.CollectedField, obj *types.Membership) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Membership_identity,
		func(ctx context.Context) (any, error) {
			return ec.resolvers.Membership().Identity(ctx, obj)
		},
		nil,
		ec.marshalOIdentity2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐIdentity,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_Membership_identity(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Membership",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_Identity_id(ctx, field)
			case "email":
				return ec.fieldContext_Identity_email(ctx, field)
			case "fullName":
				return ec.fieldContext_Identity_fullName(ctx, field)
			case "emailVerified":
				return ec.fieldContext_Identity_emailVerified(ctx, field)
			case "createdAt":
				return ec.fieldContext_Identity_createdAt(ctx, field)
			case "updatedAt":
				return ec.fieldContext_Identity_updatedAt(ctx, field)
			case "memberships":
				return ec.fieldContext_Identity_memberships(ctx, field)
			case "pendingInvitations":
				return ec.fieldContext_Identity_pendingInvitations(ctx, field)
			case "sessions":
				return ec.fieldContext_Identity_sessions(ctx, field)
			case "personalAPIKeys":
				return ec.fieldContext_Identity_personalAPIKeys(ctx, field)
			case "permission":
				return ec.fieldContext_Identity_permission(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type Identity", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _Membership_profile(ctx context.Context, field graphql.CollectedField, obj *types.Membership) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Membership_profile,
		func(ctx context.Context) (any, error) {
			return ec.resolvers.Membership().Profile(ctx, obj)
		},
		nil,
		ec.marshalOMembershipProfile2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐMembershipProfile,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_Membership_profile(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Membership",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_MembershipProfile_id(ctx, field)
			case "fullName":
				return ec.fieldContext_MembershipProfile_fullName(ctx, field)
			case "additionalEmailAddresses":
				return ec.fieldContext_MembershipProfile_additionalEmailAddresses(ctx, field)
			case "kind":
				return ec.fieldContext_MembershipProfile_kind(ctx, field)
			case "position":
				return ec.fieldContext_MembershipProfile_position(ctx, field)
			case "contractStartDate":
				return ec.fieldContext_MembershipProfile_contractStartDate(ctx, field)
			case "contractEndDate":
				return ec.fieldContext_MembershipProfile_contractEndDate(ctx, field)
			case "createdAt":
				return ec.fieldContext_MembershipProfile_createdAt(ctx, field)
			case "updatedAt":
				return ec.fieldContext_MembershipProfile_updatedAt(ctx, field)
			case "identity":
				return ec.fieldContext_MembershipProfile_identity(ctx, field)
			case "organization":
				return ec.fieldContext_MembershipProfile_organization(ctx, field)
			case "membershipId":
				return ec.fieldContext_MembershipProfile_membershipId(ctx, field)
			case "permission":
				return ec.fieldContext_MembershipProfile_permission(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type MembershipProfile", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _Membership_organization(ctx context.Context, field graphql.CollectedField, obj *types.Membership) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Membership_organization,
		func(ctx context.Context) (any, error) {
			return ec.resolvers.Membership().Organization(ctx, obj)
		},
		nil,
		ec.marshalOOrganization2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐOrganization,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_Membership_organization(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Membership",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_Organization_id(ctx, field)
			case "name":
				return ec.fieldContext_Organization_name(ctx, field)
			case "logoUrl":
				return ec.fieldContext_Organization_logoUrl(ctx, field)
			case "horizontalLogoUrl":
				return ec.fieldContext_Organization_horizontalLogoUrl(ctx, field)
			case "email":
				return ec.fieldContext_Organization_email(ctx, field)
			case "description":
				return ec.fieldContext_Organization_description(ctx, field)
			case "websiteUrl":
				return ec.fieldContext_Organization_websiteUrl(ctx, field)
			case "headquarterAddress":
				return ec.fieldContext_Organization_headquarterAddress(ctx, field)
			case "createdAt":
				return ec.fieldContext_Organization_createdAt(ctx, field)
			case "updatedAt":
				return ec.fieldContext_Organization_updatedAt(ctx, field)
			case "members":
				return ec.fieldContext_Organization_members(ctx, field)
			case "invitations":
				return ec.fieldContext_Organization_invitations(ctx, field)
			case "samlConfigurations":
				return ec.fieldContext_Organization_samlConfigurations(ctx, field)
			case "scimConfiguration":
				return ec.fieldContext_Organization_scimConfiguration(ctx, field)
			case "viewerMembership":
				return ec.fieldContext_Organization_viewerMembership(ctx, field)
			case "permission":
				return ec.fieldContext_Organization_permission(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type Organization", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _Membership_role(ctx context.Context, field graphql.CollectedField, obj *types.Membership) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Membership_role,
		func(ctx context.Context) (any, error) {
			return obj.Role, nil
		},
		nil,
		ec.marshalNMembershipRole2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐMembershipRole,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_Membership_role(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Membership",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type MembershipRole does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _Membership_source(ctx context.Context, field graphql.CollectedField, obj *types.Membership) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Membership_source,
		func(ctx context.Context) (any, error) {
			return obj.Source, nil
		},
		nil,
		ec.marshalNMembershipSource2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐMembershipSource,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_Membership_source(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Membership",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type MembershipSource does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _Membership_state(ctx context.Context, field graphql.CollectedField, obj *types.Membership) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Membership_state,
		func(ctx context.Context) (any, error) {
			return obj.State, nil
		},
		nil,
		ec.marshalNMembershipState2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐMembershipState,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_Membership_state(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Membership",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type MembershipState does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _Membership_lastSession(ctx context.Context, field graphql.CollectedField, obj *types.Membership) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Membership_lastSession,
		func(ctx context.Context) (any, error) {
			return ec.resolvers.Membership().LastSession(ctx, obj)
		},
		nil,
		ec.marshalOSession2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐSession,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_Membership_lastSession(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Membership",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_Session_id(ctx, field)
			case "identity":
				return ec.fieldContext_Session_identity(ctx, field)
			case "ipAddress":
				return ec.fieldContext_Session_ipAddress(ctx, field)
			case "userAgent":
				return ec.fieldContext_Session_userAgent(ctx, field)
			case "updatedAt":
				return ec.fieldContext_Session_updatedAt(ctx, field)
			case "createdAt":
				return ec.fieldContext_Session_createdAt(ctx, field)
			case "expiresAt":
				return ec.fieldContext_Session_expiresAt(ctx, field)
			case "permission":
				return ec.fieldContext_Session_permission(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type Session", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _Membership_permission(ctx context.Context, field graphql.CollectedField, obj *types.Membership) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Membership_permission,
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.resolvers.Membership().Permission(ctx, obj, fc.Args["action"].(string))
		},
		func(ctx context.Context, next graphql.Resolver) graphql.Resolver {
			directive0 := next

			directive1 := func(ctx context.Context) (any, error) {
				required, err := ec.unmarshalNSessionRequirement2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋgqlutilsᚋdirectivesᚋsessionᚐSessionRequirement(ctx, "PRESENT")
				if err != nil {
					var zeroVal bool
					return zeroVal, err
				}
				if ec.directives.Session == nil {
					var zeroVal bool
					return zeroVal, errors.New("directive session is not implemented")
				}
				return ec.directives.Session(ctx, obj, directive0, required)
			}

			next = directive1
			return next
		},
		ec.marshalNBoolean2bool,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_Membership_permission(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Membership",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Boolean does not have child fields")
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Membership_permission_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _MembershipConnection_edges(ctx context.Context, field graphql.CollectedField, obj *types.MembershipConnection) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_MembershipConnection_edges,
		func(ctx context.Context) (any, error) {
			return obj.Edges, nil
		},
		nil,
		ec.marshalNMembershipEdge2ᚕᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐMembershipEdgeᚄ,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_MembershipConnection_edges(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "MembershipConnection",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "node":
				return ec.fieldContext_MembershipEdge_node(ctx, field)
			case "cursor":
				return ec.fieldContext_MembershipEdge_cursor(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type MembershipEdge", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _MembershipConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *types.MembershipConnection) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_MembershipConnection_pageInfo,
		func(ctx context.Context) (any, error) {
			return obj.PageInfo, nil
		},
		nil,
		ec.marshalNPageInfo2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐPageInfo,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_MembershipConnection_pageInfo(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "MembershipConnection",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "hasNextPage":
				return ec.fieldContext_PageInfo_hasNextPage(ctx, field)
			case "hasPreviousPage":
				return ec.fieldContext_PageInfo_hasPreviousPage(ctx, field)
			case "startCursor":
				return ec.fieldContext_PageInfo_startCursor(ctx, field)
			case "endCursor":
				return ec.fieldContext_PageInfo_endCursor(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type PageInfo", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _MembershipConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *types.MembershipConnection) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_MembershipConnection_totalCount,
		func(ctx context.Context) (any, error) {
			return ec.resolvers.MembershipConnection().TotalCount(ctx, obj)
		},
		nil,
		ec.marshalOInt2ᚖint,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_MembershipConnection_totalCount(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "MembershipConnection",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Int does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _MembershipEdge_node(ctx context.Context, field graphql.CollectedField, obj *types.MembershipEdge) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_MembershipEdge_node,
		func(ctx context.Context) (any, error) {
			return obj.Node, nil
		},
		nil,
		ec.marshalNMembership2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐMembership,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_MembershipEdge_node(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "MembershipEdge",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_Membership_id(ctx, field)
			case "createdAt":
				return ec.fieldContext_Membership_createdAt(ctx, field)
			case "identity":
				return ec.fieldContext_Membership_identity(ctx, field)
			case "profile":
				return ec.fieldContext_Membership_profile(ctx, field)
			case "organization":
				return ec.fieldContext_Membership_organization(ctx, field)
			case "role":
				return ec.fieldContext_Membership_role(ctx, field)
			case "source":
				return ec.fieldContext_Membership_source(ctx, field)
			case "state":
				return ec.fieldContext_Membership_state(ctx, field)
			case "lastSession":
				return ec.fieldContext_Membership_lastSession(ctx, field)
			case "permission":
				return ec.fieldContext_Membership_permission(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type Membership", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _MembershipEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *types.MembershipEdge) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_MembershipEdge_cursor,
		func(ctx context.Context) (any, error) {
			return obj.Cursor, nil
		},
		nil,
		ec.marshalNCursorKey2goᚗproboᚗincᚋproboᚋpkgᚋpageᚐCursorKey,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_MembershipEdge_cursor(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "MembershipEdge",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type CursorKey does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _MembershipProfile_id(ctx context.Context, field graphql.CollectedField, obj *types.MembershipProfile) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_MembershipProfile_id,
		func(ctx context.Context) (any, error) {
			return obj.ID, nil
		},
		nil,
		ec.marshalNID2goᚗproboᚗincᚋproboᚋpkgᚋgidᚐGID,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_MembershipProfile_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "MembershipProfile",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type ID does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _MembershipProfile_fullName(ctx context.Context, field graphql.CollectedField, obj *types.MembershipProfile) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_MembershipProfile_fullName,
		func(ctx context.Context) (any, error) {
			return obj.FullName, nil
		},
		nil,
		ec.marshalNString2string,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_MembershipProfile_fullName(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "MembershipProfile",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _MembershipProfile_additionalEmailAddresses(ctx context.Context, field graphql.CollectedField, obj *types.MembershipProfile) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_MembershipProfile_additionalEmailAddresses,
		func(ctx context.Context) (any, error) {
			return obj.AdditionalEmailAddresses, nil
		},
		nil,
		ec.marshalNEmailAddr2ᚕgoᚗproboᚗincᚋproboᚋpkgᚋmailᚐAddrᚄ,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_MembershipProfile_additionalEmailAddresses(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "MembershipProfile",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type EmailAddr does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _MembershipProfile_kind(ctx context.Context, field graphql.CollectedField, obj *types.MembershipProfile) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_MembershipProfile_kind,
		func(ctx context.Context) (any, error) {
			return obj.Kind, nil
		},
		nil,
		ec.marshalNProfileKind2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐMembershipProfileKind,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_MembershipProfile_kind(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "MembershipProfile",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type ProfileKind does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _MembershipProfile_position(ctx context.Context, field graphql.CollectedField, obj *types.MembershipProfile) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_MembershipProfile_position,
		func(ctx context.Context) (any, error) {
			return obj.Position, nil
		},
		nil,
		ec.marshalOString2ᚖstring,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_MembershipProfile_position(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "MembershipProfile",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _MembershipProfile_contractStartDate(ctx context.Context, field graphql.CollectedField, obj *types.MembershipProfile) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_MembershipProfile_contractStartDate,
		func(ctx context.Context) (any, error) {
			return obj.ContractStartDate, nil
		},
		nil,
		ec.marshalODatetime2ᚖtimeᚐTime,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_MembershipProfile_contractStartDate(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "MembershipProfile",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Datetime does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _MembershipProfile_contractEndDate(ctx context.Context, field graphql.CollectedField, obj *types.MembershipProfile) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_MembershipProfile_contractEndDate,
		func(ctx context.Context) (any, error) {
			return obj.ContractEndDate, nil
		},
		nil,
		ec.marshalODatetime2ᚖtimeᚐTime,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_MembershipProfile_contractEndDate(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "MembershipProfile",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Datetime does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _MembershipProfile_createdAt(ctx context.Context, field graphql.CollectedField, obj *types.MembershipProfile) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_MembershipProfile_createdAt,
		func(ctx context.Context) (any, error) {
			return obj.CreatedAt, nil
		},
		nil,
		ec.marshalNDatetime2timeᚐTime,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_MembershipProfile_createdAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "MembershipProfile",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Datetime does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _MembershipProfile_updatedAt(ctx context.Context, field graphql.CollectedField, obj *types.MembershipProfile) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_MembershipProfile_updatedAt,
		func(ctx context.Context) (any, error) {
			return obj.UpdatedAt, nil
		},
		nil,
		ec.marshalNDatetime2timeᚐTime,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_MembershipProfile_updatedAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "MembershipProfile",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Datetime does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _MembershipProfile_identity(ctx context.Context, field graphql.CollectedField, obj *types.MembershipProfile) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_MembershipProfile_identity,
		func(ctx context.Context) (any, error) {
			return ec.resolvers.MembershipProfile().Identity(ctx, obj)
		},
		nil,
		ec.marshalOIdentity2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐIdentity,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_MembershipProfile_identity(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "MembershipProfile",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_Identity_id(ctx, field)
			case "email":
				return ec.fieldContext_Identity_email(ctx, field)
			case "fullName":
				return ec.fieldContext_Identity_fullName(ctx, field)
			case "emailVerified":
				return ec.fieldContext_Identity_emailVerified(ctx, field)
			case "createdAt":
				return ec.fieldContext_Identity_createdAt(ctx, field)
			case "updatedAt":
				return ec.fieldContext_Identity_updatedAt(ctx, field)
			case "memberships":
				return ec.fieldContext_Identity_memberships(ctx, field)
			case "pendingInvitations":
				return ec.fieldContext_Identity_pendingInvitations(ctx, field)
			case "sessions":
				return ec.fieldContext_Identity_sessions(ctx, field)
			case "personalAPIKeys":
				return ec.fieldContext_Identity_personalAPIKeys(ctx, field)
			case "permission":
				return ec.fieldContext_Identity_permission(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type Identity", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _MembershipProfile_organization(ctx context.Context, field graphql.CollectedField, obj *types.MembershipProfile) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_MembershipProfile_organization,
		func(ctx context.Context) (any, error) {
			return ec.resolvers.MembershipProfile().Organization(ctx, obj)
		},
		nil,
		ec.marshalOOrganization2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐOrganization,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_MembershipProfile_organization(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "MembershipProfile",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_Organization_id(ctx, field)
			case "name":
				return ec.fieldContext_Organization_name(ctx, field)
			case "logoUrl":
				return ec.fieldContext_Organization_logoUrl(ctx, field)
			case "horizontalLogoUrl":
				return ec.fieldContext_Organization_horizontalLogoUrl(ctx, field)
			case "email":
				return ec.fieldContext_Organization_email(ctx, field)
			case "description":
				return ec.fieldContext_Organization_description(ctx, field)
			case "websiteUrl":
				return ec.fieldContext_Organization_websiteUrl(ctx, field)
			case "headquarterAddress":
				return ec.fieldContext_Organization_headquarterAddress(ctx, field)
			case "createdAt":
				return ec.fieldContext_Organization_createdAt(ctx, field)
			case "updatedAt":
				return ec.fieldContext_Organization_updatedAt(ctx, field)
			case "members":
				return ec.fieldContext_Organization_members(ctx, field)
			case "invitations":
				return ec.fieldContext_Organization_invitations(ctx, field)
			case "samlConfigurations":
				return ec.fieldContext_Organization_samlConfigurations(ctx, field)
			case "scimConfiguration":
				return ec.fieldContext_Organization_scimConfiguration(ctx, field)
			case "viewerMembership":
				return ec.fieldContext_Organization_viewerMembership(ctx, field)
			case "permission":
				return ec.fieldContext_Organization_permission(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type Organization", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _MembershipProfile_membershipId(ctx context.Context, field graphql.CollectedField, obj *types.MembershipProfile) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_MembershipProfile_membershipId,
		func(ctx context.Context) (any, error) {
			return obj.MembershipID, nil
		},
		nil,
		ec.marshalNID2goᚗproboᚗincᚋproboᚋpkgᚋgidᚐGID,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_MembershipProfile_membershipId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "MembershipProfile",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type ID does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _MembershipProfile_permission(ctx context.Context, field graphql.CollectedField, obj *types.MembershipProfile) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_MembershipProfile_permission,
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.resolvers.MembershipProfile().Permission(ctx, obj, fc.Args["action"].(string))
		},
		func(ctx context.Context, next graphql.Resolver) graphql.Resolver {
			directive0 := next

			directive1 := func(ctx context.Context) (any, error) {
				required, err := ec.unmarshalNSessionRequirement2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋgqlutilsᚋdirectivesᚋsessionᚐSessionRequirement(ctx, "PRESENT")
				if err != nil {
					var zeroVal bool
					return zeroVal, err
				}
				if ec.directives.Session == nil {
					var zeroVal bool
					return zeroVal, errors.New("directive session is not implemented")
				}
				return ec.directives.Session(ctx, obj, directive0, required)
			}

			next = directive1
			return next
		},
		ec.marshalNBoolean2bool,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_MembershipProfile_permission(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "MembershipProfile",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Boolean does not have child fields")
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_MembershipProfile_permission_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Mutation_signIn(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Mutation_signIn,
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.resolvers.Mutation().SignIn(ctx, fc.Args["input"].(types.SignInInput))
		},
		func(ctx context.Context, next graphql.Resolver) graphql.Resolver {
			directive0 := next

			directive1 := func(ctx context.Context) (any, error) {
				required, err := ec.unmarshalNSessionRequirement2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋgqlutilsᚋdirectivesᚋsessionᚐSessionRequirement(ctx, "OPTIONAL")
				if err != nil {
					var zeroVal *types.SignInPayload
					return zeroVal, err
				}
				if ec.directives.Session == nil {
					var zeroVal *types.SignInPayload
					return zeroVal, errors.New("directive session is not implemented")
				}
				return ec.directives.Session(ctx, nil, directive0, required)
			}

			next = directive1
			return next
		},
		ec.marshalOSignInPayload2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐSignInPayload,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_Mutation_signIn(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "identity":
				return ec.fieldContext_SignInPayload_identity(ctx, field)
			case "session":
				return ec.fieldContext_SignInPayload_session(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type SignInPayload", field.Name)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Mutation_signIn_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Mutation_signUp(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Mutation_signUp,
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.resolvers.Mutation().SignUp(ctx, fc.Args["input"].(types.SignUpInput))
		},
		func(ctx context.Context, next graphql.Resolver) graphql.Resolver {
			directive0 := next

			directive1 := func(ctx context.Context) (any, error) {
				required, err := ec.unmarshalNSessionRequirement2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋgqlutilsᚋdirectivesᚋsessionᚐSessionRequirement(ctx, "NONE")
				if err != nil {
					var zeroVal *types.SignUpPayload
					return zeroVal, err
				}
				if ec.directives.Session == nil {
					var zeroVal *types.SignUpPayload
					return zeroVal, errors.New("directive session is not implemented")
				}
				return ec.directives.Session(ctx, nil, directive0, required)
			}

			next = directive1
			return next
		},
		ec.marshalOSignUpPayload2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐSignUpPayload,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_Mutation_signUp(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "identity":
				return ec.fieldContext_SignUpPayload_identity(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type SignUpPayload", field.Name)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Mutation_signUp_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Mutation_signOut(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Mutation_signOut,
		func(ctx context.Context) (any, error) {
			return ec.resolvers.Mutation().SignOut(ctx)
		},
		func(ctx context.Context, next graphql.Resolver) graphql.Resolver {
			directive0 := next

			directive1 := func(ctx context.Context) (any, error) {
				required, err := ec.unmarshalNSessionRequirement2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋgqlutilsᚋdirectivesᚋsessionᚐSessionRequirement(ctx, "PRESENT")
				if err != nil {
					var zeroVal *types.SignOutPayload
					return zeroVal, err
				}
				if ec.directives.Session == nil {
					var zeroVal *types.SignOutPayload
					return zeroVal, errors.New("directive session is not implemented")
				}
				return ec.directives.Session(ctx, nil, directive0, required)
			}

			next = directive1
			return next
		},
		ec.marshalOSignOutPayload2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐSignOutPayload,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_Mutation_signOut(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "success":
				return ec.fieldContext_SignOutPayload_success(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type SignOutPayload", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _Mutation_signUpFromInvitation(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Mutation_signUpFromInvitation,
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.resolvers.Mutation().SignUpFromInvitation(ctx, fc.Args["input"].(types.SignUpFromInvitationInput))
		},
		func(ctx context.Context, next graphql.Resolver) graphql.Resolver {
			directive0 := next

			directive1 := func(ctx context.Context) (any, error) {
				required, err := ec.unmarshalNSessionRequirement2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋgqlutilsᚋdirectivesᚋsessionᚐSessionRequirement(ctx, "NONE")
				if err != nil {
					var zeroVal *types.SignUpFromInvitationPayload
					return zeroVal, err
				}
				if ec.directives.Session == nil {
					var zeroVal *types.SignUpFromInvitationPayload
					return zeroVal, errors.New("directive session is not implemented")
				}
				return ec.directives.Session(ctx, nil, directive0, required)
			}

			next = directive1
			return next
		},
		ec.marshalOSignUpFromInvitationPayload2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐSignUpFromInvitationPayload,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_Mutation_signUpFromInvitation(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "identity":
				return ec.fieldContext_SignUpFromInvitationPayload_identity(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type SignUpFromInvitationPayload", field.Name)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Mutation_signUpFromInvitation_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Mutation_forgotPassword(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Mutation_forgotPassword,
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.resolvers.Mutation().ForgotPassword(ctx, fc.Args["input"].(types.ForgotPasswordInput))
		},
		func(ctx context.Context, next graphql.Resolver) graphql.Resolver {
			directive0 := next

			directive1 := func(ctx context.Context) (any, error) {
				required, err := ec.unmarshalNSessionRequirement2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋgqlutilsᚋdirectivesᚋsessionᚐSessionRequirement(ctx, "NONE")
				if err != nil {
					var zeroVal *types.ForgotPasswordPayload
					return zeroVal, err
				}
				if ec.directives.Session == nil {
					var zeroVal *types.ForgotPasswordPayload
					return zeroVal, errors.New("directive session is not implemented")
				}
				return ec.directives.Session(ctx, nil, directive0, required)
			}

			next = directive1
			return next
		},
		ec.marshalOForgotPasswordPayload2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐForgotPasswordPayload,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_Mutation_forgotPassword(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "success":
				return ec.fieldContext_ForgotPasswordPayload_success(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type ForgotPasswordPayload", field.Name)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Mutation_forgotPassword_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Mutation_resetPassword(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Mutation_resetPassword,
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.resolvers.Mutation().ResetPassword(ctx, fc.Args["input"].(types.ResetPasswordInput))
		},
		func(ctx context.Context, next graphql.Resolver) graphql.Resolver {
			directive0 := next

			directive1 := func(ctx context.Context) (any, error) {
				required, err := ec.unmarshalNSessionRequirement2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋgqlutilsᚋdirectivesᚋsessionᚐSessionRequirement(ctx, "NONE")
				if err != nil {
					var zeroVal *types.ResetPasswordPayload
					return zeroVal, err
				}
				if ec.directives.Session == nil {
					var zeroVal *types.ResetPasswordPayload
					return zeroVal, errors.New("directive session is not implemented")
				}
				return ec.directives.Session(ctx, nil, directive0, required)
			}

			next = directive1
			return next
		},
		ec.marshalOResetPasswordPayload2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐResetPasswordPayload,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_Mutation_resetPassword(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "success":
				return ec.fieldContext_ResetPasswordPayload_success(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type ResetPasswordPayload", field.Name)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Mutation_resetPassword_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Mutation_verifyEmail(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Mutation_verifyEmail,
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.resolvers.Mutation().VerifyEmail(ctx, fc.Args["input"].(types.VerifyEmailInput))
		},
		func(ctx context.Context, next graphql.Resolver) graphql.Resolver {
			directive0 := next

			directive1 := func(ctx context.Context) (any, error) {
				required, err := ec.unmarshalNSessionRequirement2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋgqlutilsᚋdirectivesᚋsessionᚐSessionRequirement(ctx, "OPTIONAL")
				if err != nil {
					var zeroVal *types.VerifyEmailPayload
					return zeroVal, err
				}
				if ec.directives.Session == nil {
					var zeroVal *types.VerifyEmailPayload
					return zeroVal, errors.New("directive session is not implemented")
				}
				return ec.directives.Session(ctx, nil, directive0, required)
			}

			next = directive1
			return next
		},
		ec.marshalOVerifyEmailPayload2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐVerifyEmailPayload,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_Mutation_verifyEmail(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "success":
				return ec.fieldContext_VerifyEmailPayload_success(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type VerifyEmailPayload", field.Name)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Mutation_verifyEmail_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Mutation_changePassword(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Mutation_changePassword,
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.resolvers.Mutation().ChangePassword(ctx, fc.Args["input"].(types.ChangePasswordInput))
		},
		func(ctx context.Context, next graphql.Resolver) graphql.Resolver {
			directive0 := next

			directive1 := func(ctx context.Context) (any, error) {
				required, err := ec.unmarshalNSessionRequirement2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋgqlutilsᚋdirectivesᚋsessionᚐSessionRequirement(ctx, "PRESENT")
				if err != nil {
					var zeroVal *types.ChangePasswordPayload
					return zeroVal, err
				}
				if ec.directives.Session == nil {
					var zeroVal *types.ChangePasswordPayload
					return zeroVal, errors.New("directive session is not implemented")
				}
				return ec.directives.Session(ctx, nil, directive0, required)
			}

			next = directive1
			return next
		},
		ec.marshalOChangePasswordPayload2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐChangePasswordPayload,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_Mutation_changePassword(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "success":
				return ec.fieldContext_ChangePasswordPayload_success(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type ChangePasswordPayload", field.Name)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Mutation_changePassword_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Mutation_changeEmail(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Mutation_changeEmail,
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.resolvers.Mutation().ChangeEmail(ctx, fc.Args["input"].(types.ChangeEmailInput))
		},
		func(ctx context.Context, next graphql.Resolver) graphql.Resolver {
			directive0 := next

			directive1 := func(ctx context.Context) (any, error) {
				required, err := ec.unmarshalNSessionRequirement2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋgqlutilsᚋdirectivesᚋsessionᚐSessionRequirement(ctx, "PRESENT")
				if err != nil {
					var zeroVal *types.ChangeEmailPayload
					return zeroVal, err
				}
				if ec.directives.Session == nil {
					var zeroVal *types.ChangeEmailPayload
					return zeroVal, errors.New("directive session is not implemented")
				}
				return ec.directives.Session(ctx, nil, directive0, required)
			}

			next = directive1
			return next
		},
		ec.marshalOChangeEmailPayload2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐChangeEmailPayload,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_Mutation_changeEmail(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "success":
				return ec.fieldContext_ChangeEmailPayload_success(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type ChangeEmailPayload", field.Name)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Mutation_changeEmail_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Mutation_assumeOrganizationSession(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Mutation_assumeOrganizationSession,
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.resolvers.Mutation().AssumeOrganizationSession(ctx, fc.Args["input"].(types.AssumeOrganizationSessionInput))
		},
		func(ctx context.Context, next graphql.Resolver) graphql.Resolver {
			directive0 := next

			directive1 := func(ctx context.Context) (any, error) {
				required, err := ec.unmarshalNSessionRequirement2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋgqlutilsᚋdirectivesᚋsessionᚐSessionRequirement(ctx, "PRESENT")
				if err != nil {
					var zeroVal *types.AssumeOrganizationSessionPayload
					return zeroVal, err
				}
				if ec.directives.Session == nil {
					var zeroVal *types.AssumeOrganizationSessionPayload
					return zeroVal, errors.New("directive session is not implemented")
				}
				return ec.directives.Session(ctx, nil, directive0, required)
			}

			next = directive1
			return next
		},
		ec.marshalOAssumeOrganizationSessionPayload2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐAssumeOrganizationSessionPayload,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_Mutation_assumeOrganizationSession(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "result":
				return ec.fieldContext_AssumeOrganizationSessionPayload_result(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type AssumeOrganizationSessionPayload", field.Name)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Mutation_assumeOrganizationSession_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Mutation_revokeSession(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Mutation_revokeSession,
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.resolvers.Mutation().RevokeSession(ctx, fc.Args["input"].(types.RevokeSessionInput))
		},
		func(ctx context.Context, next graphql.Resolver) graphql.Resolver {
			directive0 := next

			directive1 := func(ctx context.Context) (any, error) {
				required, err := ec.unmarshalNSessionRequirement2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋgqlutilsᚋdirectivesᚋsessionᚐSessionRequirement(ctx, "PRESENT")
				if err != nil {
					var zeroVal *types.RevokeSessionPayload
					return zeroVal, err
				}
				if ec.directives.Session == nil {
					var zeroVal *types.RevokeSessionPayload
					return zeroVal, errors.New("directive session is not implemented")
				}
				return ec.directives.Session(ctx, nil, directive0, required)
			}

			next = directive1
			return next
		},
		ec.marshalNRevokeSessionPayload2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐRevokeSessionPayload,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_Mutation_revokeSession(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "success":
				return ec.fieldContext_RevokeSessionPayload_success(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type RevokeSessionPayload", field.Name)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Mutation_revokeSession_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Mutation_revokeAllSessions(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Mutation_revokeAllSessions,
		func(ctx context.Context) (any, error) {
			return ec.resolvers.Mutation().RevokeAllSessions(ctx)
		},
		func(ctx context.Context, next graphql.Resolver) graphql.Resolver {
			directive0 := next

			directive1 := func(ctx context.Context) (any, error) {
				required, err := ec.unmarshalNSessionRequirement2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋgqlutilsᚋdirectivesᚋsessionᚐSessionRequirement(ctx, "PRESENT")
				if err != nil {
					var zeroVal *types.RevokeAllSessionsPayload
					return zeroVal, err
				}
				if ec.directives.Session == nil {
					var zeroVal *types.RevokeAllSessionsPayload
					return zeroVal, errors.New("directive session is not implemented")
				}
				return ec.directives.Session(ctx, nil, directive0, required)
			}

			next = directive1
			return next
		},
		ec.marshalORevokeAllSessionsPayload2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐRevokeAllSessionsPayload,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_Mutation_revokeAllSessions(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "revokedCount":
				return ec.fieldContext_RevokeAllSessionsPayload_revokedCount(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type RevokeAllSessionsPayload", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _Mutation_createPersonalAPIKey(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Mutation_createPersonalAPIKey,
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.resolvers.Mutation().CreatePersonalAPIKey(ctx, fc.Args["input"].(types.CreatePersonalAPIKeyInput))
		},
		func(ctx context.Context, next graphql.Resolver) graphql.Resolver {
			directive0 := next

			directive1 := func(ctx context.Context) (any, error) {
				required, err := ec.unmarshalNSessionRequirement2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋgqlutilsᚋdirectivesᚋsessionᚐSessionRequirement(ctx, "PRESENT")
				if err != nil {
					var zeroVal *types.CreatePersonalAPIKeyPayload
					return zeroVal, err
				}
				if ec.directives.Session == nil {
					var zeroVal *types.CreatePersonalAPIKeyPayload
					return zeroVal, errors.New("directive session is not implemented")
				}
				return ec.directives.Session(ctx, nil, directive0, required)
			}

			next = directive1
			return next
		},
		ec.marshalOCreatePersonalAPIKeyPayload2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐCreatePersonalAPIKeyPayload,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_Mutation_createPersonalAPIKey(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "personalAPIKeyEdge":
				return ec.fieldContext_CreatePersonalAPIKeyPayload_personalAPIKeyEdge(ctx, field)
			case "token":
				return ec.fieldContext_CreatePersonalAPIKeyPayload_token(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type CreatePersonalAPIKeyPayload", field.Name)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Mutation_createPersonalAPIKey_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Mutation_revokePersonalAPIKey(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Mutation_revokePersonalAPIKey,
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.resolvers.Mutation().RevokePersonalAPIKey(ctx, fc.Args["input"].(types.RevokePersonalAPIKeyInput))
		},
		func(ctx context.Context, next graphql.Resolver) graphql.Resolver {
			directive0 := next

			directive1 := func(ctx context.Context) (any, error) {
				required, err := ec.unmarshalNSessionRequirement2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋgqlutilsᚋdirectivesᚋsessionᚐSessionRequirement(ctx, "PRESENT")
				if err != nil {
					var zeroVal *types.RevokePersonalAPIKeyPayload
					return zeroVal, err
				}
				if ec.directives.Session == nil {
					var zeroVal *types.RevokePersonalAPIKeyPayload
					return zeroVal, errors.New("directive session is not implemented")
				}
				return ec.directives.Session(ctx, nil, directive0, required)
			}

			next = directive1
			return next
		},
		ec.marshalORevokePersonalAPIKeyPayload2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐRevokePersonalAPIKeyPayload,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_Mutation_revokePersonalAPIKey(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "personalAPIKeyId":
				return ec.fieldContext_RevokePersonalAPIKeyPayload_personalAPIKeyId(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type RevokePersonalAPIKeyPayload", field.Name)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Mutation_revokePersonalAPIKey_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Mutation_createOrganization(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Mutation_createOrganization,
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.resolvers.Mutation().CreateOrganization(ctx, fc.Args["input"].(types.CreateOrganizationInput))
		},
		func(ctx context.Context, next graphql.Resolver) graphql.Resolver {
			directive0 := next

			directive1 := func(ctx context.Context) (any, error) {
				required, err := ec.unmarshalNSessionRequirement2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋgqlutilsᚋdirectivesᚋsessionᚐSessionRequirement(ctx, "PRESENT")
				if err != nil {
					var zeroVal *types.CreateOrganizationPayload
					return zeroVal, err
				}
				if ec.directives.Session == nil {
					var zeroVal *types.CreateOrganizationPayload
					return zeroVal, errors.New("directive session is not implemented")
				}
				return ec.directives.Session(ctx, nil, directive0, required)
			}

			next = directive1
			return next
		},
		ec.marshalOCreateOrganizationPayload2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐCreateOrganizationPayload,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_Mutation_createOrganization(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "organization":
				return ec.fieldContext_CreateOrganizationPayload_organization(ctx, field)
			case "membershipEdge":
				return ec.fieldContext_CreateOrganizationPayload_membershipEdge(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type CreateOrganizationPayload", field.Name)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Mutation_createOrganization_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Mutation_updateOrganization(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Mutation_updateOrganization,
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.resolvers.Mutation().UpdateOrganization(ctx, fc.Args["input"].(types.UpdateOrganizationInput))
		},
		func(ctx context.Context, next graphql.Resolver) graphql.Resolver {
			directive0 := next

			directive1 := func(ctx context.Context) (any, error) {
				required, err := ec.unmarshalNSessionRequirement2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋgqlutilsᚋdirectivesᚋsessionᚐSessionRequirement(ctx, "PRESENT")
				if err != nil {
					var zeroVal *types.UpdateOrganizationPayload
					return zeroVal, err
				}
				if ec.directives.Session == nil {
					var zeroVal *types.UpdateOrganizationPayload
					return zeroVal, errors.New("directive session is not implemented")
				}
				return ec.directives.Session(ctx, nil, directive0, required)
			}

			next = directive1
			return next
		},
		ec.marshalOUpdateOrganizationPayload2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐUpdateOrganizationPayload,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_Mutation_updateOrganization(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "organization":
				return ec.fieldContext_UpdateOrganizationPayload_organization(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type UpdateOrganizationPayload", field.Name)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Mutation_updateOrganization_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Mutation_deleteOrganization(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Mutation_deleteOrganization,
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.resolvers.Mutation().DeleteOrganization(ctx, fc.Args["input"].(types.DeleteOrganizationInput))
		},
		func(ctx context.Context, next graphql.Resolver) graphql.Resolver {
			directive0 := next

			directive1 := func(ctx context.Context) (any, error) {
				required, err := ec.unmarshalNSessionRequirement2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋgqlutilsᚋdirectivesᚋsessionᚐSessionRequirement(ctx, "PRESENT")
				if err != nil {
					var zeroVal *types.DeleteOrganizationPayload
					return zeroVal, err
				}
				if ec.directives.Session == nil {
					var zeroVal *types.DeleteOrganizationPayload
					return zeroVal, errors.New("directive session is not implemented")
				}
				return ec.directives.Session(ctx, nil, directive0, required)
			}

			next = directive1
			return next
		},
		ec.marshalODeleteOrganizationPayload2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐDeleteOrganizationPayload,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_Mutation_deleteOrganization(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "deletedOrganizationId":
				return ec.fieldContext_DeleteOrganizationPayload_deletedOrganizationId(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type DeleteOrganizationPayload", field.Name)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Mutation_deleteOrganization_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Mutation_deleteOrganizationHorizontalLogo(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Mutation_deleteOrganizationHorizontalLogo,
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.resolvers.Mutation().DeleteOrganizationHorizontalLogo(ctx, fc.Args["input"].(types.DeleteOrganizationHorizontalLogoInput))
		},
		func(ctx context.Context, next graphql.Resolver) graphql.Resolver {
			directive0 := next

			directive1 := func(ctx context.Context) (any, error) {
				required, err := ec.unmarshalNSessionRequirement2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋgqlutilsᚋdirectivesᚋsessionᚐSessionRequirement(ctx, "PRESENT")
				if err != nil {
					var zeroVal *types.DeleteOrganizationHorizontalLogoPayload
					return zeroVal, err
				}
				if ec.directives.Session == nil {
					var zeroVal *types.DeleteOrganizationHorizontalLogoPayload
					return zeroVal, errors.New("directive session is not implemented")
				}
				return ec.directives.Session(ctx, nil, directive0, required)
			}

			next = directive1
			return next
		},
		ec.marshalODeleteOrganizationHorizontalLogoPayload2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐDeleteOrganizationHorizontalLogoPayload,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_Mutation_deleteOrganizationHorizontalLogo(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "organization":
				return ec.fieldContext_DeleteOrganizationHorizontalLogoPayload_organization(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type DeleteOrganizationHorizontalLogoPayload", field.Name)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Mutation_deleteOrganizationHorizontalLogo_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Mutation_inviteMember(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Mutation_inviteMember,
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.resolvers.Mutation().InviteMember(ctx, fc.Args["input"].(types.InviteMemberInput))
		},
		func(ctx context.Context, next graphql.Resolver) graphql.Resolver {
			directive0 := next

			directive1 := func(ctx context.Context) (any, error) {
				required, err := ec.unmarshalNSessionRequirement2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋgqlutilsᚋdirectivesᚋsessionᚐSessionRequirement(ctx, "PRESENT")
				if err != nil {
					var zeroVal *types.InviteMemberPayload
					return zeroVal, err
				}
				if ec.directives.Session == nil {
					var zeroVal *types.InviteMemberPayload
					return zeroVal, errors.New("directive session is not implemented")
				}
				return ec.directives.Session(ctx, nil, directive0, required)
			}

			next = directive1
			return next
		},
		ec.marshalOInviteMemberPayload2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐInviteMemberPayload,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_Mutation_inviteMember(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "invitationEdge":
				return ec.fieldContext_InviteMemberPayload_invitationEdge(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type InviteMemberPayload", field.Name)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Mutation_inviteMember_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Mutation_deleteInvitation(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Mutation_deleteInvitation,
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.resolvers.Mutation().DeleteInvitation(ctx, fc.Args["input"].(types.DeleteInvitationInput))
		},
		func(ctx context.Context, next graphql.Resolver) graphql.Resolver {
			directive0 := next

			directive1 := func(ctx context.Context) (any, error) {
				required, err := ec.unmarshalNSessionRequirement2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋgqlutilsᚋdirectivesᚋsessionᚐSessionRequirement(ctx, "PRESENT")
				if err != nil {
					var zeroVal *types.DeleteInvitationPayload
					return zeroVal, err
				}
				if ec.directives.Session == nil {
					var zeroVal *types.DeleteInvitationPayload
					return zeroVal, errors.New("directive session is not implemented")
				}
				return ec.directives.Session(ctx, nil, directive0, required)
			}

			next = directive1
			return next
		},
		ec.marshalODeleteInvitationPayload2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐDeleteInvitationPayload,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_Mutation_deleteInvitation(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "deletedInvitationId":
				return ec.fieldContext_DeleteInvitationPayload_deletedInvitationId(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type DeleteInvitationPayload", field.Name)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Mutation_deleteInvitation_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Mutation_updateProfile(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Mutation_updateProfile,
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.resolvers.Mutation().UpdateProfile(ctx, fc.Args["input"].(types.UpdateProfileInput))
		},
		nil,
		ec.marshalNUpdateProfilePayload2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐUpdateProfilePayload,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_Mutation_updateProfile(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "profile":
				return ec.fieldContext_UpdateProfilePayload_profile(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type UpdateProfilePayload", field.Name)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Mutation_updateProfile_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Mutation_updateMembership(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Mutation_updateMembership,
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.resolvers.Mutation().UpdateMembership(ctx, fc.Args["input"].(types.UpdateMembershipInput))
		},
		nil,
		ec.marshalNUpdateMembershipPayload2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐUpdateMembershipPayload,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_Mutation_updateMembership(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "membership":
				return ec.fieldContext_UpdateMembershipPayload_membership(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type UpdateMembershipPayload", field.Name)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Mutation_updateMembership_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Mutation_removeMember(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Mutation_removeMember,
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.resolvers.Mutation().RemoveMember(ctx, fc.Args["input"].(types.RemoveMemberInput))
		},
		func(ctx context.Context, next graphql.Resolver) graphql.Resolver {
			directive0 := next

			directive1 := func(ctx context.Context) (any, error) {
				required, err := ec.unmarshalNSessionRequirement2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋgqlutilsᚋdirectivesᚋsessionᚐSessionRequirement(ctx, "PRESENT")
				if err != nil {
					var zeroVal *types.RemoveMemberPayload
					return zeroVal, err
				}
				if ec.directives.Session == nil {
					var zeroVal *types.RemoveMemberPayload
					return zeroVal, errors.New("directive session is not implemented")
				}
				return ec.directives.Session(ctx, nil, directive0, required)
			}

			next = directive1
			return next
		},
		ec.marshalORemoveMemberPayload2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐRemoveMemberPayload,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_Mutation_removeMember(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "deletedMembershipId":
				return ec.fieldContext_RemoveMemberPayload_deletedMembershipId(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type RemoveMemberPayload", field.Name)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Mutation_removeMember_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Mutation_acceptInvitation(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Mutation_acceptInvitation,
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.resolvers.Mutation().AcceptInvitation(ctx, fc.Args["input"].(types.AcceptInvitationInput))
		},
		func(ctx context.Context, next graphql.Resolver) graphql.Resolver {
			directive0 := next

			directive1 := func(ctx context.Context) (any, error) {
				required, err := ec.unmarshalNSessionRequirement2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋgqlutilsᚋdirectivesᚋsessionᚐSessionRequirement(ctx, "PRESENT")
				if err != nil {
					var zeroVal *types.AcceptInvitationPayload
					return zeroVal, err
				}
				if ec.directives.Session == nil {
					var zeroVal *types.AcceptInvitationPayload
					return zeroVal, errors.New("directive session is not implemented")
				}
				return ec.directives.Session(ctx, nil, directive0, required)
			}

			next = directive1
			return next
		},
		ec.marshalOAcceptInvitationPayload2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐAcceptInvitationPayload,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_Mutation_acceptInvitation(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "membershipEdge":
				return ec.fieldContext_AcceptInvitationPayload_membershipEdge(ctx, field)
			case "invitation":
				return ec.fieldContext_AcceptInvitationPayload_invitation(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type AcceptInvitationPayload", field.Name)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Mutation_acceptInvitation_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Mutation_createSAMLConfiguration(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Mutation_createSAMLConfiguration,
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.resolvers.Mutation().CreateSAMLConfiguration(ctx, fc.Args["input"].(types.CreateSAMLConfigurationInput))
		},
		func(ctx context.Context, next graphql.Resolver) graphql.Resolver {
			directive0 := next

			directive1 := func(ctx context.Context) (any, error) {
				required, err := ec.unmarshalNSessionRequirement2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋgqlutilsᚋdirectivesᚋsessionᚐSessionRequirement(ctx, "PRESENT")
				if err != nil {
					var zeroVal *types.CreateSAMLConfigurationPayload
					return zeroVal, err
				}
				if ec.directives.Session == nil {
					var zeroVal *types.CreateSAMLConfigurationPayload
					return zeroVal, errors.New("directive session is not implemented")
				}
				return ec.directives.Session(ctx, nil, directive0, required)
			}

			next = directive1
			return next
		},
		ec.marshalOCreateSAMLConfigurationPayload2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐCreateSAMLConfigurationPayload,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_Mutation_createSAMLConfiguration(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "samlConfigurationEdge":
				return ec.fieldContext_CreateSAMLConfigurationPayload_samlConfigurationEdge(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type CreateSAMLConfigurationPayload", field.Name)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Mutation_createSAMLConfiguration_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Mutation_updateSAMLConfiguration(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Mutation_updateSAMLConfiguration,
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.resolvers.Mutation().UpdateSAMLConfiguration(ctx, fc.Args["input"].(types.UpdateSAMLConfigurationInput))
		},
		func(ctx context.Context, next graphql.Resolver) graphql.Resolver {
			directive0 := next

			directive1 := func(ctx context.Context) (any, error) {
				required, err := ec.unmarshalNSessionRequirement2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋgqlutilsᚋdirectivesᚋsessionᚐSessionRequirement(ctx, "PRESENT")
				if err != nil {
					var zeroVal *types.UpdateSAMLConfigurationPayload
					return zeroVal, err
				}
				if ec.directives.Session == nil {
					var zeroVal *types.UpdateSAMLConfigurationPayload
					return zeroVal, errors.New("directive session is not implemented")
				}
				return ec.directives.Session(ctx, nil, directive0, required)
			}

			next = directive1
			return next
		},
		ec.marshalOUpdateSAMLConfigurationPayload2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐUpdateSAMLConfigurationPayload,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_Mutation_updateSAMLConfiguration(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "samlConfiguration":
				return ec.fieldContext_UpdateSAMLConfigurationPayload_samlConfiguration(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type UpdateSAMLConfigurationPayload", field.Name)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Mutation_updateSAMLConfiguration_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Mutation_deleteSAMLConfiguration(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Mutation_deleteSAMLConfiguration,
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.resolvers.Mutation().DeleteSAMLConfiguration(ctx, fc.Args["input"].(types.DeleteSAMLConfigurationInput))
		},
		func(ctx context.Context, next graphql.Resolver) graphql.Resolver {
			directive0 := next

			directive1 := func(ctx context.Context) (any, error) {
				required, err := ec.unmarshalNSessionRequirement2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋgqlutilsᚋdirectivesᚋsessionᚐSessionRequirement(ctx, "PRESENT")
				if err != nil {
					var zeroVal *types.DeleteSAMLConfigurationPayload
					return zeroVal, err
				}
				if ec.directives.Session == nil {
					var zeroVal *types.DeleteSAMLConfigurationPayload
					return zeroVal, errors.New("directive session is not implemented")
				}
				return ec.directives.Session(ctx, nil, directive0, required)
			}

			next = directive1
			return next
		},
		ec.marshalODeleteSAMLConfigurationPayload2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐDeleteSAMLConfigurationPayload,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_Mutation_deleteSAMLConfiguration(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "deletedSamlConfigurationId":
				return ec.fieldContext_DeleteSAMLConfigurationPayload_deletedSamlConfigurationId(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type DeleteSAMLConfigurationPayload", field.Name)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Mutation_deleteSAMLConfiguration_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Mutation_createSCIMConfiguration(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Mutation_createSCIMConfiguration,
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.resolvers.Mutation().CreateSCIMConfiguration(ctx, fc.Args["input"].(types.CreateSCIMConfigurationInput))
		},
		func(ctx context.Context, next graphql.Resolver) graphql.Resolver {
			directive0 := next

			directive1 := func(ctx context.Context) (any, error) {
				required, err := ec.unmarshalNSessionRequirement2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋgqlutilsᚋdirectivesᚋsessionᚐSessionRequirement(ctx, "PRESENT")
				if err != nil {
					var zeroVal *types.CreateSCIMConfigurationPayload
					return zeroVal, err
				}
				if ec.directives.Session == nil {
					var zeroVal *types.CreateSCIMConfigurationPayload
					return zeroVal, errors.New("directive session is not implemented")
				}
				return ec.directives.Session(ctx, nil, directive0, required)
			}

			next = directive1
			return next
		},
		ec.marshalOCreateSCIMConfigurationPayload2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐCreateSCIMConfigurationPayload,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_Mutation_createSCIMConfiguration(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "scimConfiguration":
				return ec.fieldContext_CreateSCIMConfigurationPayload_scimConfiguration(ctx, field)
			case "scimBridge":
				return ec.fieldContext_CreateSCIMConfigurationPayload_scimBridge(ctx, field)
			case "token":
				return ec.fieldContext_CreateSCIMConfigurationPayload_token(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type CreateSCIMConfigurationPayload", field.Name)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Mutation_createSCIMConfiguration_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Mutation_deleteSCIMConfiguration(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Mutation_deleteSCIMConfiguration,
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.resolvers.Mutation().DeleteSCIMConfiguration(ctx, fc.Args["input"].(types.DeleteSCIMConfigurationInput))
		},
		func(ctx context.Context, next graphql.Resolver) graphql.Resolver {
			directive0 := next

			directive1 := func(ctx context.Context) (any, error) {
				required, err := ec.unmarshalNSessionRequirement2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋgqlutilsᚋdirectivesᚋsessionᚐSessionRequirement(ctx, "PRESENT")
				if err != nil {
					var zeroVal *types.DeleteSCIMConfigurationPayload
					return zeroVal, err
				}
				if ec.directives.Session == nil {
					var zeroVal *types.DeleteSCIMConfigurationPayload
					return zeroVal, errors.New("directive session is not implemented")
				}
				return ec.directives.Session(ctx, nil, directive0, required)
			}

			next = directive1
			return next
		},
		ec.marshalODeleteSCIMConfigurationPayload2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐDeleteSCIMConfigurationPayload,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_Mutation_deleteSCIMConfiguration(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "deletedScimConfigurationId":
				return ec.fieldContext_DeleteSCIMConfigurationPayload_deletedScimConfigurationId(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type DeleteSCIMConfigurationPayload", field.Name)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Mutation_deleteSCIMConfiguration_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Mutation_regenerateSCIMToken(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Mutation_regenerateSCIMToken,
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.resolvers.Mutation().RegenerateSCIMToken(ctx, fc.Args["input"].(types.RegenerateSCIMTokenInput))
		},
		func(ctx context.Context, next graphql.Resolver) graphql.Resolver {
			directive0 := next

			directive1 := func(ctx context.Context) (any, error) {
				required, err := ec.unmarshalNSessionRequirement2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋgqlutilsᚋdirectivesᚋsessionᚐSessionRequirement(ctx, "PRESENT")
				if err != nil {
					var zeroVal *types.RegenerateSCIMTokenPayload
					return zeroVal, err
				}
				if ec.directives.Session == nil {
					var zeroVal *types.RegenerateSCIMTokenPayload
					return zeroVal, errors.New("directive session is not implemented")
				}
				return ec.directives.Session(ctx, nil, directive0, required)
			}

			next = directive1
			return next
		},
		ec.marshalORegenerateSCIMTokenPayload2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐRegenerateSCIMTokenPayload,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_Mutation_regenerateSCIMToken(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "scimConfiguration":
				return ec.fieldContext_RegenerateSCIMTokenPayload_scimConfiguration(ctx, field)
			case "token":
				return ec.fieldContext_RegenerateSCIMTokenPayload_token(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type RegenerateSCIMTokenPayload", field.Name)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Mutation_regenerateSCIMToken_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Mutation_updateSCIMBridge(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Mutation_updateSCIMBridge,
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.resolvers.Mutation().UpdateSCIMBridge(ctx, fc.Args["input"].(types.UpdateSCIMBridgeInput))
		},
		func(ctx context.Context, next graphql.Resolver) graphql.Resolver {
			directive0 := next

			directive1 := func(ctx context.Context) (any, error) {
				required, err := ec.unmarshalNSessionRequirement2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋgqlutilsᚋdirectivesᚋsessionᚐSessionRequirement(ctx, "PRESENT")
				if err != nil {
					var zeroVal *types.UpdateSCIMBridgePayload
					return zeroVal, err
				}
				if ec.directives.Session == nil {
					var zeroVal *types.UpdateSCIMBridgePayload
					return zeroVal, errors.New("directive session is not implemented")
				}
				return ec.directives.Session(ctx, nil, directive0, required)
			}

			next = directive1
			return next
		},
		ec.marshalOUpdateSCIMBridgePayload2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐUpdateSCIMBridgePayload,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_Mutation_updateSCIMBridge(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "scimBridge":
				return ec.fieldContext_UpdateSCIMBridgePayload_scimBridge(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type UpdateSCIMBridgePayload", field.Name)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Mutation_updateSCIMBridge_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Organization_id(ctx context.Context, field graphql.CollectedField, obj *types.Organization) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Organization_id,
		func(ctx context.Context) (any, error) {
			return obj.ID, nil
		},
		nil,
		ec.marshalNID2goᚗproboᚗincᚋproboᚋpkgᚋgidᚐGID,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_Organization_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Organization",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type ID does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _Organization_name(ctx context.Context, field graphql.CollectedField, obj *types.Organization) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Organization_name,
		func(ctx context.Context) (any, error) {
			return obj.Name, nil
		},
		nil,
		ec.marshalNString2string,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_Organization_name(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Organization",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _Organization_logoUrl(ctx context.Context, field graphql.CollectedField, obj *types.Organization) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Organization_logoUrl,
		func(ctx context.Context) (any, error) {
			return ec.resolvers.Organization().LogoURL(ctx, obj)
		},
		nil,
		ec.marshalOString2ᚖstring,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_Organization_logoUrl(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Organization",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _Organization_horizontalLogoUrl(ctx context.Context, field graphql.CollectedField, obj *types.Organization) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Organization_horizontalLogoUrl,
		func(ctx context.Context) (any, error) {
			return ec.resolvers.Organization().HorizontalLogoURL(ctx, obj)
		},
		nil,
		ec.marshalOString2ᚖstring,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_Organization_horizontalLogoUrl(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Organization",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _Organization_email(ctx context.Context, field graphql.CollectedField, obj *types.Organization) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Organization_email,
		func(ctx context.Context) (any, error) {
			return obj.Email, nil
		},
		nil,
		ec.marshalOString2ᚖstring,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_Organization_email(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Organization",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _Organization_description(ctx context.Context, field graphql.CollectedField, obj *types.Organization) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Organization_description,
		func(ctx context.Context) (any, error) {
			return obj.Description, nil
		},
		nil,
		ec.marshalOString2ᚖstring,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_Organization_description(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Organization",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _Organization_websiteUrl(ctx context.Context, field graphql.CollectedField, obj *types.Organization) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Organization_websiteUrl,
		func(ctx context.Context) (any, error) {
			return obj.WebsiteURL, nil
		},
		nil,
		ec.marshalOString2ᚖstring,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_Organization_websiteUrl(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Organization",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _Organization_headquarterAddress(ctx context.Context, field graphql.CollectedField, obj *types.Organization) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Organization_headquarterAddress,
		func(ctx context.Context) (any, error) {
			return obj.HeadquarterAddress, nil
		},
		nil,
		ec.marshalOString2ᚖstring,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_Organization_headquarterAddress(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Organization",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _Organization_createdAt(ctx context.Context, field graphql.CollectedField, obj *types.Organization) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Organization_createdAt,
		func(ctx context.Context) (any, error) {
			return obj.CreatedAt, nil
		},
		nil,
		ec.marshalNDatetime2timeᚐTime,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_Organization_createdAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Organization",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Datetime does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _Organization_updatedAt(ctx context.Context, field graphql.CollectedField, obj *types.Organization) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Organization_updatedAt,
		func(ctx context.Context) (any, error) {
			return obj.UpdatedAt, nil
		},
		nil,
		ec.marshalNDatetime2timeᚐTime,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_Organization_updatedAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Organization",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Datetime does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _Organization_members(ctx context.Context, field graphql.CollectedField, obj *types.Organization) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Organization_members,
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.resolvers.Organization().Members(ctx, obj, fc.Args["first"].(*int), fc.Args["after"].(*page.CursorKey), fc.Args["last"].(*int), fc.Args["before"].(*page.CursorKey), fc.Args["orderBy"].(*types.MembershipOrderBy))
		},
		nil,
		ec.marshalOMembershipConnection2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐMembershipConnection,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_Organization_members(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Organization",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "edges":
				return ec.fieldContext_MembershipConnection_edges(ctx, field)
			case "pageInfo":
				return ec.fieldContext_MembershipConnection_pageInfo(ctx, field)
			case "totalCount":
				return ec.fieldContext_MembershipConnection_totalCount(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type MembershipConnection", field.Name)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Organization_members_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Organization_invitations(ctx context.Context, field graphql.CollectedField, obj *types.Organization) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Organization_invitations,
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.resolvers.Organization().Invitations(ctx, obj, fc.Args["first"].(*int), fc.Args["after"].(*page.CursorKey), fc.Args["last"].(*int), fc.Args["before"].(*page.CursorKey), fc.Args["status"].(*coredata.InvitationStatus), fc.Args["orderBy"].(*types.InvitationOrderBy))
		},
		nil,
		ec.marshalOInvitationConnection2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐInvitationConnection,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_Organization_invitations(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Organization",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "edges":
				return ec.fieldContext_InvitationConnection_edges(ctx, field)
			case "pageInfo":
				return ec.fieldContext_InvitationConnection_pageInfo(ctx, field)
			case "totalCount":
				return ec.fieldContext_InvitationConnection_totalCount(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type InvitationConnection", field.Name)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Organization_invitations_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Organization_samlConfigurations(ctx context.Context, field graphql.CollectedField, obj *types.Organization) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Organization_samlConfigurations,
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.resolvers.Organization().SamlConfigurations(ctx, obj, fc.Args["first"].(*int), fc.Args["after"].(*page.CursorKey), fc.Args["last"].(*int), fc.Args["before"].(*page.CursorKey))
		},
		nil,
		ec.marshalOSAMLConfigurationConnection2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐSAMLConfigurationConnection,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_Organization_samlConfigurations(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Organization",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "edges":
				return ec.fieldContext_SAMLConfigurationConnection_edges(ctx, field)
			case "pageInfo":
				return ec.fieldContext_SAMLConfigurationConnection_pageInfo(ctx, field)
			case "totalCount":
				return ec.fieldContext_SAMLConfigurationConnection_totalCount(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type SAMLConfigurationConnection", field.Name)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Organization_samlConfigurations_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Organization_scimConfiguration(ctx context.Context, field graphql.CollectedField, obj *types.Organization) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Organization_scimConfiguration,
		func(ctx context.Context) (any, error) {
			return ec.resolvers.Organization().ScimConfiguration(ctx, obj)
		},
		nil,
		ec.marshalOSCIMConfiguration2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐSCIMConfiguration,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_Organization_scimConfiguration(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Organization",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_SCIMConfiguration_id(ctx, field)
			case "endpointUrl":
				return ec.fieldContext_SCIMConfiguration_endpointUrl(ctx, field)
			case "createdAt":
				return ec.fieldContext_SCIMConfiguration_createdAt(ctx, field)
			case "updatedAt":
				return ec.fieldContext_SCIMConfiguration_updatedAt(ctx, field)
			case "organization":
				return ec.fieldContext_SCIMConfiguration_organization(ctx, field)
			case "bridge":
				return ec.fieldContext_SCIMConfiguration_bridge(ctx, field)
			case "events":
				return ec.fieldContext_SCIMConfiguration_events(ctx, field)
			case "permission":
				return ec.fieldContext_SCIMConfiguration_permission(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type SCIMConfiguration", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _Organization_viewerMembership(ctx context.Context, field graphql.CollectedField, obj *types.Organization) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Organization_viewerMembership,
		func(ctx context.Context) (any, error) {
			return ec.resolvers.Organization().ViewerMembership(ctx, obj)
		},
		nil,
		ec.marshalOMembership2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐMembership,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_Organization_viewerMembership(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Organization",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_Membership_id(ctx, field)
			case "createdAt":
				return ec.fieldContext_Membership_createdAt(ctx, field)
			case "identity":
				return ec.fieldContext_Membership_identity(ctx, field)
			case "profile":
				return ec.fieldContext_Membership_profile(ctx, field)
			case "organization":
				return ec.fieldContext_Membership_organization(ctx, field)
			case "role":
				return ec.fieldContext_Membership_role(ctx, field)
			case "source":
				return ec.fieldContext_Membership_source(ctx, field)
			case "state":
				return ec.fieldContext_Membership_state(ctx, field)
			case "lastSession":
				return ec.fieldContext_Membership_lastSession(ctx, field)
			case "permission":
				return ec.fieldContext_Membership_permission(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type Membership", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _Organization_permission(ctx context.Context, field graphql.CollectedField, obj *types.Organization) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Organization_permission,
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.resolvers.Organization().Permission(ctx, obj, fc.Args["action"].(string))
		},
		func(ctx context.Context, next graphql.Resolver) graphql.Resolver {
			directive0 := next

			directive1 := func(ctx context.Context) (any, error) {
				required, err := ec.unmarshalNSessionRequirement2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋgqlutilsᚋdirectivesᚋsessionᚐSessionRequirement(ctx, "PRESENT")
				if err != nil {
					var zeroVal bool
					return zeroVal, err
				}
				if ec.directives.Session == nil {
					var zeroVal bool
					return zeroVal, errors.New("directive session is not implemented")
				}
				return ec.directives.Session(ctx, obj, directive0, required)
			}

			next = directive1
			return next
		},
		ec.marshalNBoolean2bool,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_Organization_permission(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Organization",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Boolean does not have child fields")
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Organization_permission_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _OrganizationSessionCreated_session(ctx context.Context, field graphql.CollectedField, obj *types.OrganizationSessionCreated) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_OrganizationSessionCreated_session,
		func(ctx context.Context) (any, error) {
			return obj.Session, nil
		},
		nil,
		ec.marshalNSession2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐSession,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_OrganizationSessionCreated_session(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "OrganizationSessionCreated",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_Session_id(ctx, field)
			case "identity":
				return ec.fieldContext_Session_identity(ctx, field)
			case "ipAddress":
				return ec.fieldContext_Session_ipAddress(ctx, field)
			case "userAgent":
				return ec.fieldContext_Session_userAgent(ctx, field)
			case "updatedAt":
				return ec.fieldContext_Session_updatedAt(ctx, field)
			case "createdAt":
				return ec.fieldContext_Session_createdAt(ctx, field)
			case "expiresAt":
				return ec.fieldContext_Session_expiresAt(ctx, field)
			case "permission":
				return ec.fieldContext_Session_permission(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type Session", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _OrganizationSessionCreated_membership(ctx context.Context, field graphql.CollectedField, obj *types.OrganizationSessionCreated) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_OrganizationSessionCreated_membership,
		func(ctx context.Context) (any, error) {
			return obj.Membership, nil
		},
		nil,
		ec.marshalNMembership2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐMembership,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_OrganizationSessionCreated_membership(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "OrganizationSessionCreated",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_Membership_id(ctx, field)
			case "createdAt":
				return ec.fieldContext_Membership_createdAt(ctx, field)
			case "identity":
				return ec.fieldContext_Membership_identity(ctx, field)
			case "profile":
				return ec.fieldContext_Membership_profile(ctx, field)
			case "organization":
				return ec.fieldContext_Membership_organization(ctx, field)
			case "role":
				return ec.fieldContext_Membership_role(ctx, field)
			case "source":
				return ec.fieldContext_Membership_source(ctx, field)
			case "state":
				return ec.fieldContext_Membership_state(ctx, field)
			case "lastSession":
				return ec.fieldContext_Membership_lastSession(ctx, field)
			case "permission":
				return ec.fieldContext_Membership_permission(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type Membership", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _PageInfo_hasNextPage(ctx context.Context, field graphql.CollectedField, obj *types.PageInfo) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_PageInfo_hasNextPage,
		func(ctx context.Context) (any, error) {
			return obj.HasNextPage, nil
		},
		nil,
		ec.marshalNBoolean2bool,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_PageInfo_hasNextPage(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "PageInfo",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Boolean does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _PageInfo_hasPreviousPage(ctx context.Context, field graphql.CollectedField, obj *types.PageInfo) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_PageInfo_hasPreviousPage,
		func(ctx context.Context) (any, error) {
			return obj.HasPreviousPage, nil
		},
		nil,
		ec.marshalNBoolean2bool,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_PageInfo_hasPreviousPage(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "PageInfo",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Boolean does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _PageInfo_startCursor(ctx context.Context, field graphql.CollectedField, obj *types.PageInfo) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_PageInfo_startCursor,
		func(ctx context.Context) (any, error) {
			return obj.StartCursor, nil
		},
		nil,
		ec.marshalOCursorKey2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋpageᚐCursorKey,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_PageInfo_startCursor(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "PageInfo",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type CursorKey does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _PageInfo_endCursor(ctx context.Context, field graphql.CollectedField, obj *types.PageInfo) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_PageInfo_endCursor,
		func(ctx context.Context) (any, error) {
			return obj.EndCursor, nil
		},
		nil,
		ec.marshalOCursorKey2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋpageᚐCursorKey,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_PageInfo_endCursor(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "PageInfo",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type CursorKey does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _PasswordRequired_reason(ctx context.Context, field graphql.CollectedField, obj *types.PasswordRequired) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_PasswordRequired_reason,
		func(ctx context.Context) (any, error) {
			return obj.Reason, nil
		},
		nil,
		ec.marshalNReauthenticationReason2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐReauthenticationReason,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_PasswordRequired_reason(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "PasswordRequired",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type ReauthenticationReason does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _PersonalAPIKey_id(ctx context.Context, field graphql.CollectedField, obj *types.PersonalAPIKey) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_PersonalAPIKey_id,
		func(ctx context.Context) (any, error) {
			return obj.ID, nil
		},
		nil,
		ec.marshalNID2goᚗproboᚗincᚋproboᚋpkgᚋgidᚐGID,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_PersonalAPIKey_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "PersonalAPIKey",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type ID does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _PersonalAPIKey_name(ctx context.Context, field graphql.CollectedField, obj *types.PersonalAPIKey) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_PersonalAPIKey_name,
		func(ctx context.Context) (any, error) {
			return obj.Name, nil
		},
		nil,
		ec.marshalNString2string,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_PersonalAPIKey_name(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "PersonalAPIKey",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _PersonalAPIKey_expiresAt(ctx context.Context, field graphql.CollectedField, obj *types.PersonalAPIKey) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_PersonalAPIKey_expiresAt,
		func(ctx context.Context) (any, error) {
			return obj.ExpiresAt, nil
		},
		nil,
		ec.marshalNDatetime2timeᚐTime,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_PersonalAPIKey_expiresAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "PersonalAPIKey",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Datetime does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _PersonalAPIKey_lastUsedAt(ctx context.Context, field graphql.CollectedField, obj *types.PersonalAPIKey) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_PersonalAPIKey_lastUsedAt,
		func(ctx context.Context) (any, error) {
			return obj.LastUsedAt, nil
		},
		nil,
		ec.marshalODatetime2ᚖtimeᚐTime,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_PersonalAPIKey_lastUsedAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "PersonalAPIKey",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Datetime does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _PersonalAPIKey_createdAt(ctx context.Context, field graphql.CollectedField, obj *types.PersonalAPIKey) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_PersonalAPIKey_createdAt,
		func(ctx context.Context) (any, error) {
			return obj.CreatedAt, nil
		},
		nil,
		ec.marshalNDatetime2timeᚐTime,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_PersonalAPIKey_createdAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "PersonalAPIKey",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Datetime does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _PersonalAPIKey_token(ctx context.Context, field graphql.CollectedField, obj *types.PersonalAPIKey) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_PersonalAPIKey_token,
		func(ctx context.Context) (any, error) {
			return ec.resolvers.PersonalAPIKey().Token(ctx, obj)
		},
		nil,
		ec.marshalOString2ᚖstring,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_PersonalAPIKey_token(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "PersonalAPIKey",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _PersonalAPIKey_permission(ctx context.Context, field graphql.CollectedField, obj *types.PersonalAPIKey) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_PersonalAPIKey_permission,
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.resolvers.PersonalAPIKey().Permission(ctx, obj, fc.Args["action"].(string))
		},
		func(ctx context.Context, next graphql.Resolver) graphql.Resolver {
			directive0 := next

			directive1 := func(ctx context.Context) (any, error) {
				required, err := ec.unmarshalNSessionRequirement2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋgqlutilsᚋdirectivesᚋsessionᚐSessionRequirement(ctx, "PRESENT")
				if err != nil {
					var zeroVal bool
					return zeroVal, err
				}
				if ec.directives.Session == nil {
					var zeroVal bool
					return zeroVal, errors.New("directive session is not implemented")
				}
				return ec.directives.Session(ctx, obj, directive0, required)
			}

			next = directive1
			return next
		},
		ec.marshalNBoolean2bool,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_PersonalAPIKey_permission(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "PersonalAPIKey",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Boolean does not have child fields")
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_PersonalAPIKey_permission_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _PersonalAPIKeyConnection_edges(ctx context.Context, field graphql.CollectedField, obj *types.PersonalAPIKeyConnection) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_PersonalAPIKeyConnection_edges,
		func(ctx context.Context) (any, error) {
			return obj.Edges, nil
		},
		nil,
		ec.marshalNPersonalAPIKeyEdge2ᚕᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐPersonalAPIKeyEdgeᚄ,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_PersonalAPIKeyConnection_edges(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "PersonalAPIKeyConnection",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "node":
				return ec.fieldContext_PersonalAPIKeyEdge_node(ctx, field)
			case "cursor":
				return ec.fieldContext_PersonalAPIKeyEdge_cursor(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type PersonalAPIKeyEdge", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _PersonalAPIKeyConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *types.PersonalAPIKeyConnection) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_PersonalAPIKeyConnection_pageInfo,
		func(ctx context.Context) (any, error) {
			return obj.PageInfo, nil
		},
		nil,
		ec.marshalNPageInfo2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐPageInfo,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_PersonalAPIKeyConnection_pageInfo(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "PersonalAPIKeyConnection",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "hasNextPage":
				return ec.fieldContext_PageInfo_hasNextPage(ctx, field)
			case "hasPreviousPage":
				return ec.fieldContext_PageInfo_hasPreviousPage(ctx, field)
			case "startCursor":
				return ec.fieldContext_PageInfo_startCursor(ctx, field)
			case "endCursor":
				return ec.fieldContext_PageInfo_endCursor(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type PageInfo", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _PersonalAPIKeyConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *types.PersonalAPIKeyConnection) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_PersonalAPIKeyConnection_totalCount,
		func(ctx context.Context) (any, error) {
			return ec.resolvers.PersonalAPIKeyConnection().TotalCount(ctx, obj)
		},
		nil,
		ec.marshalOInt2ᚖint,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_PersonalAPIKeyConnection_totalCount(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "PersonalAPIKeyConnection",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Int does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _PersonalAPIKeyEdge_node(ctx context.Context, field graphql.CollectedField, obj *types.PersonalAPIKeyEdge) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_PersonalAPIKeyEdge_node,
		func(ctx context.Context) (any, error) {
			return obj.Node, nil
		},
		nil,
		ec.marshalNPersonalAPIKey2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐPersonalAPIKey,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_PersonalAPIKeyEdge_node(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "PersonalAPIKeyEdge",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_PersonalAPIKey_id(ctx, field)
			case "name":
				return ec.fieldContext_PersonalAPIKey_name(ctx, field)
			case "expiresAt":
				return ec.fieldContext_PersonalAPIKey_expiresAt(ctx, field)
			case "lastUsedAt":
				return ec.fieldContext_PersonalAPIKey_lastUsedAt(ctx, field)
			case "createdAt":
				return ec.fieldContext_PersonalAPIKey_createdAt(ctx, field)
			case "token":
				return ec.fieldContext_PersonalAPIKey_token(ctx, field)
			case "permission":
				return ec.fieldContext_PersonalAPIKey_permission(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type PersonalAPIKey", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _PersonalAPIKeyEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *types.PersonalAPIKeyEdge) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_PersonalAPIKeyEdge_cursor,
		func(ctx context.Context) (any, error) {
			return obj.Cursor, nil
		},
		nil,
		ec.marshalNCursorKey2goᚗproboᚗincᚋproboᚋpkgᚋpageᚐCursorKey,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_PersonalAPIKeyEdge_cursor(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "PersonalAPIKeyEdge",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type CursorKey does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _Query_node(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Query_node,
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.resolvers.Query().Node(ctx, fc.Args["id"].(gid.GID))
		},
		func(ctx context.Context, next graphql.Resolver) graphql.Resolver {
			directive0 := next

			directive1 := func(ctx context.Context) (any, error) {
				required, err := ec.unmarshalNSessionRequirement2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋgqlutilsᚋdirectivesᚋsessionᚐSessionRequirement(ctx, "PRESENT")
				if err != nil {
					var zeroVal types.Node
					return zeroVal, err
				}
				if ec.directives.Session == nil {
					var zeroVal types.Node
					return zeroVal, errors.New("directive session is not implemented")
				}
				return ec.directives.Session(ctx, nil, directive0, required)
			}

			next = directive1
			return next
		},
		ec.marshalONode2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐNode,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_Query_node(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Query",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("FieldContext.Child cannot be called on type INTERFACE")
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Query_node_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Query_viewer(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Query_viewer,
		func(ctx context.Context) (any, error) {
			return ec.resolvers.Query().Viewer(ctx)
		},
		func(ctx context.Context, next graphql.Resolver) graphql.Resolver {
			directive0 := next

			directive1 := func(ctx context.Context) (any, error) {
				required, err := ec.unmarshalNSessionRequirement2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋgqlutilsᚋdirectivesᚋsessionᚐSessionRequirement(ctx, "PRESENT")
				if err != nil {
					var zeroVal *types.Identity
					return zeroVal, err
				}
				if ec.directives.Session == nil {
					var zeroVal *types.Identity
					return zeroVal, errors.New("directive session is not implemented")
				}
				return ec.directives.Session(ctx, nil, directive0, required)
			}

			next = directive1
			return next
		},
		ec.marshalOIdentity2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐIdentity,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_Query_viewer(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Query",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_Identity_id(ctx, field)
			case "email":
				return ec.fieldContext_Identity_email(ctx, field)
			case "fullName":
				return ec.fieldContext_Identity_fullName(ctx, field)
			case "emailVerified":
				return ec.fieldContext_Identity_emailVerified(ctx, field)
			case "createdAt":
				return ec.fieldContext_Identity_createdAt(ctx, field)
			case "updatedAt":
				return ec.fieldContext_Identity_updatedAt(ctx, field)
			case "memberships":
				return ec.fieldContext_Identity_memberships(ctx, field)
			case "pendingInvitations":
				return ec.fieldContext_Identity_pendingInvitations(ctx, field)
			case "sessions":
				return ec.fieldContext_Identity_sessions(ctx, field)
			case "personalAPIKeys":
				return ec.fieldContext_Identity_personalAPIKeys(ctx, field)
			case "permission":
				return ec.fieldContext_Identity_permission(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type Identity", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _Query_ssoLoginURL(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Query_ssoLoginURL,
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.resolvers.Query().SsoLoginURL(ctx, fc.Args["email"].(mail.Addr))
		},
		func(ctx context.Context, next graphql.Resolver) graphql.Resolver {
			directive0 := next

			directive1 := func(ctx context.Context) (any, error) {
				required, err := ec.unmarshalNSessionRequirement2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋgqlutilsᚋdirectivesᚋsessionᚐSessionRequirement(ctx, "OPTIONAL")
				if err != nil {
					var zeroVal *string
					return zeroVal, err
				}
				if ec.directives.Session == nil {
					var zeroVal *string
					return zeroVal, errors.New("directive session is not implemented")
				}
				return ec.directives.Session(ctx, nil, directive0, required)
			}

			next = directive1
			return next
		},
		ec.marshalOString2ᚖstring,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_Query_ssoLoginURL(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Query",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Query_ssoLoginURL_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Query___type(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Query___type,
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.introspectType(fc.Args["name"].(string))
		},
		nil,
		ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_Query___type(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Query",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "kind":
				return ec.fieldContext___Type_kind(ctx, field)
			case "name":
				return ec.fieldContext___Type_name(ctx, field)
			case "description":
				return ec.fieldContext___Type_description(ctx, field)
			case "specifiedByURL":
				return ec.fieldContext___Type_specifiedByURL(ctx, field)
			case "fields":
				return ec.fieldContext___Type_fields(ctx, field)
			case "interfaces":
				return ec.fieldContext___Type_interfaces(ctx, field)
			case "possibleTypes":
				return ec.fieldContext___Type_possibleTypes(ctx, field)
			case "enumValues":
				return ec.fieldContext___Type_enumValues(ctx, field)
			case "inputFields":
				return ec.fieldContext___Type_inputFields(ctx, field)
			case "ofType":
				return ec.fieldContext___Type_ofType(ctx, field)
			case "isOneOf":
				return ec.fieldContext___Type_isOneOf(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Query___type_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Query___schema(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Query___schema,
		func(ctx context.Context) (any, error) {
			return ec.introspectSchema()
		},
		nil,
		ec.marshalO__Schema2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_Query___schema(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Query",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "description":
				return ec.fieldContext___Schema_description(ctx, field)
			case "types":
				return ec.fieldContext___Schema_types(ctx, field)
			case "queryType":
				return ec.fieldContext___Schema_queryType(ctx, field)
			case "mutationType":
				return ec.fieldContext___Schema_mutationType(ctx, field)
			case "subscriptionType":
				return ec.fieldContext___Schema_subscriptionType(ctx, field)
			case "directives":
				return ec.fieldContext___Schema_directives(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type __Schema", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _RegenerateSCIMTokenPayload_scimConfiguration(ctx context.Context, field graphql.CollectedField, obj *types.RegenerateSCIMTokenPayload) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_RegenerateSCIMTokenPayload_scimConfiguration,
		func(ctx context.Context) (any, error) {
			return obj.ScimConfiguration, nil
		},
		nil,
		ec.marshalNSCIMConfiguration2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐSCIMConfiguration,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_RegenerateSCIMTokenPayload_scimConfiguration(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "RegenerateSCIMTokenPayload",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_SCIMConfiguration_id(ctx, field)
			case "endpointUrl":
				return ec.fieldContext_SCIMConfiguration_endpointUrl(ctx, field)
			case "createdAt":
				return ec.fieldContext_SCIMConfiguration_createdAt(ctx, field)
			case "updatedAt":
				return ec.fieldContext_SCIMConfiguration_updatedAt(ctx, field)
			case "organization":
				return ec.fieldContext_SCIMConfiguration_organization(ctx, field)
			case "bridge":
				return ec.fieldContext_SCIMConfiguration_bridge(ctx, field)
			case "events":
				return ec.fieldContext_SCIMConfiguration_events(ctx, field)
			case "permission":
				return ec.fieldContext_SCIMConfiguration_permission(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type SCIMConfiguration", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _RegenerateSCIMTokenPayload_token(ctx context.Context, field graphql.CollectedField, obj *types.RegenerateSCIMTokenPayload) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_RegenerateSCIMTokenPayload_token,
		func(ctx context.Context) (any, error) {
			return obj.Token, nil
		},
		nil,
		ec.marshalNString2string,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_RegenerateSCIMTokenPayload_token(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "RegenerateSCIMTokenPayload",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _RemoveMemberPayload_deletedMembershipId(ctx context.Context, field graphql.CollectedField, obj *types.RemoveMemberPayload) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_RemoveMemberPayload_deletedMembershipId,
		func(ctx context.Context) (any, error) {
			return obj.DeletedMembershipID, nil
		},
		nil,
		ec.marshalNID2goᚗproboᚗincᚋproboᚋpkgᚋgidᚐGID,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_RemoveMemberPayload_deletedMembershipId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "RemoveMemberPayload",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type ID does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _ResetPasswordPayload_success(ctx context.Context, field graphql.CollectedField, obj *types.ResetPasswordPayload) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_ResetPasswordPayload_success,
		func(ctx context.Context) (any, error) {
			return obj.Success, nil
		},
		nil,
		ec.marshalNBoolean2bool,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_ResetPasswordPayload_success(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "ResetPasswordPayload",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Boolean does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _RevokeAllSessionsPayload_revokedCount(ctx context.Context, field graphql.CollectedField, obj *types.RevokeAllSessionsPayload) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_RevokeAllSessionsPayload_revokedCount,
		func(ctx context.Context) (any, error) {
			return obj.RevokedCount, nil
		},
		nil,
		ec.marshalNInt2int,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_RevokeAllSessionsPayload_revokedCount(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "RevokeAllSessionsPayload",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Int does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _RevokePersonalAPIKeyPayload_personalAPIKeyId(ctx context.Context, field graphql.CollectedField, obj *types.RevokePersonalAPIKeyPayload) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_RevokePersonalAPIKeyPayload_personalAPIKeyId,
		func(ctx context.Context) (any, error) {
			return obj.PersonalAPIKeyID, nil
		},
		nil,
		ec.marshalNID2goᚗproboᚗincᚋproboᚋpkgᚋgidᚐGID,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_RevokePersonalAPIKeyPayload_personalAPIKeyId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "RevokePersonalAPIKeyPayload",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type ID does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _RevokeSessionPayload_success(ctx context.Context, field graphql.CollectedField, obj *types.RevokeSessionPayload) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_RevokeSessionPayload_success,
		func(ctx context.Context) (any, error) {
			return obj.Success, nil
		},
		nil,
		ec.marshalNBoolean2bool,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_RevokeSessionPayload_success(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "RevokeSessionPayload",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Boolean does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _SAMLAttributeMappings_email(ctx context.Context, field graphql.CollectedField, obj *types.SAMLAttributeMappings) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SAMLAttributeMappings_email,
		func(ctx context.Context) (any, error) {
			return obj.Email, nil
		},
		nil,
		ec.marshalNString2string,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_SAMLAttributeMappings_email(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SAMLAttributeMappings",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _SAMLAttributeMappings_firstName(ctx context.Context, field graphql.CollectedField, obj *types.SAMLAttributeMappings) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SAMLAttributeMappings_firstName,
		func(ctx context.Context) (any, error) {
			return obj.FirstName, nil
		},
		nil,
		ec.marshalNString2string,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_SAMLAttributeMappings_firstName(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SAMLAttributeMappings",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _SAMLAttributeMappings_lastName(ctx context.Context, field graphql.CollectedField, obj *types.SAMLAttributeMappings) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SAMLAttributeMappings_lastName,
		func(ctx context.Context) (any, error) {
			return obj.LastName, nil
		},
		nil,
		ec.marshalNString2string,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_SAMLAttributeMappings_lastName(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SAMLAttributeMappings",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _SAMLAttributeMappings_role(ctx context.Context, field graphql.CollectedField, obj *types.SAMLAttributeMappings) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SAMLAttributeMappings_role,
		func(ctx context.Context) (any, error) {
			return obj.Role, nil
		},
		nil,
		ec.marshalNString2string,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_SAMLAttributeMappings_role(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SAMLAttributeMappings",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _SAMLAuthenticationRequired_reason(ctx context.Context, field graphql.CollectedField, obj *types.SAMLAuthenticationRequired) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SAMLAuthenticationRequired_reason,
		func(ctx context.Context) (any, error) {
			return obj.Reason, nil
		},
		nil,
		ec.marshalNReauthenticationReason2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐReauthenticationReason,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_SAMLAuthenticationRequired_reason(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SAMLAuthenticationRequired",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type ReauthenticationReason does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _SAMLAuthenticationRequired_redirectUrl(ctx context.Context, field graphql.CollectedField, obj *types.SAMLAuthenticationRequired) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SAMLAuthenticationRequired_redirectUrl,
		func(ctx context.Context) (any, error) {
			return obj.RedirectURL, nil
		},
		nil,
		ec.marshalNString2string,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_SAMLAuthenticationRequired_redirectUrl(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SAMLAuthenticationRequired",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _SAMLConfiguration_id(ctx context.Context, field graphql.CollectedField, obj *types.SAMLConfiguration) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SAMLConfiguration_id,
		func(ctx context.Context) (any, error) {
			return obj.ID, nil
		},
		nil,
		ec.marshalNID2goᚗproboᚗincᚋproboᚋpkgᚋgidᚐGID,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_SAMLConfiguration_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SAMLConfiguration",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type ID does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _SAMLConfiguration_emailDomain(ctx context.Context, field graphql.CollectedField, obj *types.SAMLConfiguration) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SAMLConfiguration_emailDomain,
		func(ctx context.Context) (any, error) {
			return obj.EmailDomain, nil
		},
		nil,
		ec.marshalNString2string,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_SAMLConfiguration_emailDomain(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SAMLConfiguration",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _SAMLConfiguration_enforcementPolicy(ctx context.Context, field graphql.CollectedField, obj *types.SAMLConfiguration) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SAMLConfiguration_enforcementPolicy,
		func(ctx context.Context) (any, error) {
			return obj.EnforcementPolicy, nil
		},
		nil,
		ec.marshalNSAMLEnforcementPolicy2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐSAMLEnforcementPolicy,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_SAMLConfiguration_enforcementPolicy(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SAMLConfiguration",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type SAMLEnforcementPolicy does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _SAMLConfiguration_domainVerifiedAt(ctx context.Context, field graphql.CollectedField, obj *types.SAMLConfiguration) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SAMLConfiguration_domainVerifiedAt,
		func(ctx context.Context) (any, error) {
			return obj.DomainVerifiedAt, nil
		},
		nil,
		ec.marshalODatetime2ᚖtimeᚐTime,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_SAMLConfiguration_domainVerifiedAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SAMLConfiguration",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Datetime does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _SAMLConfiguration_domainVerificationToken(ctx context.Context, field graphql.CollectedField, obj *types.SAMLConfiguration) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SAMLConfiguration_domainVerificationToken,
		func(ctx context.Context) (any, error) {
			return obj.DomainVerificationToken, nil
		},
		nil,
		ec.marshalOString2ᚖstring,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_SAMLConfiguration_domainVerificationToken(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SAMLConfiguration",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _SAMLConfiguration_idpEntityId(ctx context.Context, field graphql.CollectedField, obj *types.SAMLConfiguration) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SAMLConfiguration_idpEntityId,
		func(ctx context.Context) (any, error) {
			return obj.IdpEntityID, nil
		},
		nil,
		ec.marshalNString2string,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_SAMLConfiguration_idpEntityId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SAMLConfiguration",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _SAMLConfiguration_idpSsoUrl(ctx context.Context, field graphql.CollectedField, obj *types.SAMLConfiguration) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SAMLConfiguration_idpSsoUrl,
		func(ctx context.Context) (any, error) {
			return obj.IdpSsoURL, nil
		},
		nil,
		ec.marshalNString2string,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_SAMLConfiguration_idpSsoUrl(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SAMLConfiguration",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _SAMLConfiguration_idpCertificate(ctx context.Context, field graphql.CollectedField, obj *types.SAMLConfiguration) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SAMLConfiguration_idpCertificate,
		func(ctx context.Context) (any, error) {
			return obj.IdpCertificate, nil
		},
		nil,
		ec.marshalNString2string,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_SAMLConfiguration_idpCertificate(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SAMLConfiguration",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _SAMLConfiguration_autoSignupEnabled(ctx context.Context, field graphql.CollectedField, obj *types.SAMLConfiguration) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SAMLConfiguration_autoSignupEnabled,
		func(ctx context.Context) (any, error) {
			return obj.AutoSignupEnabled, nil
		},
		nil,
		ec.marshalNBoolean2bool,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_SAMLConfiguration_autoSignupEnabled(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SAMLConfiguration",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Boolean does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _SAMLConfiguration_createdAt(ctx context.Context, field graphql.CollectedField, obj *types.SAMLConfiguration) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SAMLConfiguration_createdAt,
		func(ctx context.Context) (any, error) {
			return obj.CreatedAt, nil
		},
		nil,
		ec.marshalNDatetime2timeᚐTime,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_SAMLConfiguration_createdAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SAMLConfiguration",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Datetime does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _SAMLConfiguration_updatedAt(ctx context.Context, field graphql.CollectedField, obj *types.SAMLConfiguration) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SAMLConfiguration_updatedAt,
		func(ctx context.Context) (any, error) {
			return obj.UpdatedAt, nil
		},
		nil,
		ec.marshalNDatetime2timeᚐTime,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_SAMLConfiguration_updatedAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SAMLConfiguration",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Datetime does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _SAMLConfiguration_testLoginUrl(ctx context.Context, field graphql.CollectedField, obj *types.SAMLConfiguration) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SAMLConfiguration_testLoginUrl,
		func(ctx context.Context) (any, error) {
			return ec.resolvers.SAMLConfiguration().TestLoginURL(ctx, obj)
		},
		nil,
		ec.marshalNString2string,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_SAMLConfiguration_testLoginUrl(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SAMLConfiguration",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _SAMLConfiguration_attributeMappings(ctx context.Context, field graphql.CollectedField, obj *types.SAMLConfiguration) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SAMLConfiguration_attributeMappings,
		func(ctx context.Context) (any, error) {
			return obj.AttributeMappings, nil
		},
		nil,
		ec.marshalNSAMLAttributeMappings2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐSAMLAttributeMappings,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_SAMLConfiguration_attributeMappings(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SAMLConfiguration",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "email":
				return ec.fieldContext_SAMLAttributeMappings_email(ctx, field)
			case "firstName":
				return ec.fieldContext_SAMLAttributeMappings_firstName(ctx, field)
			case "lastName":
				return ec.fieldContext_SAMLAttributeMappings_lastName(ctx, field)
			case "role":
				return ec.fieldContext_SAMLAttributeMappings_role(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type SAMLAttributeMappings", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _SAMLConfiguration_permission(ctx context.Context, field graphql.CollectedField, obj *types.SAMLConfiguration) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SAMLConfiguration_permission,
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.resolvers.SAMLConfiguration().Permission(ctx, obj, fc.Args["action"].(string))
		},
		func(ctx context.Context, next graphql.Resolver) graphql.Resolver {
			directive0 := next

			directive1 := func(ctx context.Context) (any, error) {
				required, err := ec.unmarshalNSessionRequirement2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋgqlutilsᚋdirectivesᚋsessionᚐSessionRequirement(ctx, "PRESENT")
				if err != nil {
					var zeroVal bool
					return zeroVal, err
				}
				if ec.directives.Session == nil {
					var zeroVal bool
					return zeroVal, errors.New("directive session is not implemented")
				}
				return ec.directives.Session(ctx, obj, directive0, required)
			}

			next = directive1
			return next
		},
		ec.marshalNBoolean2bool,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_SAMLConfiguration_permission(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SAMLConfiguration",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Boolean does not have child fields")
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_SAMLConfiguration_permission_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _SAMLConfigurationConnection_edges(ctx context.Context, field graphql.CollectedField, obj *types.SAMLConfigurationConnection) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SAMLConfigurationConnection_edges,
		func(ctx context.Context) (any, error) {
			return obj.Edges, nil
		},
		nil,
		ec.marshalNSAMLConfigurationEdge2ᚕᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐSAMLConfigurationEdgeᚄ,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_SAMLConfigurationConnection_edges(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SAMLConfigurationConnection",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "node":
				return ec.fieldContext_SAMLConfigurationEdge_node(ctx, field)
			case "cursor":
				return ec.fieldContext_SAMLConfigurationEdge_cursor(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type SAMLConfigurationEdge", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _SAMLConfigurationConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *types.SAMLConfigurationConnection) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SAMLConfigurationConnection_pageInfo,
		func(ctx context.Context) (any, error) {
			return obj.PageInfo, nil
		},
		nil,
		ec.marshalNPageInfo2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐPageInfo,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_SAMLConfigurationConnection_pageInfo(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SAMLConfigurationConnection",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "hasNextPage":
				return ec.fieldContext_PageInfo_hasNextPage(ctx, field)
			case "hasPreviousPage":
				return ec.fieldContext_PageInfo_hasPreviousPage(ctx, field)
			case "startCursor":
				return ec.fieldContext_PageInfo_startCursor(ctx, field)
			case "endCursor":
				return ec.fieldContext_PageInfo_endCursor(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type PageInfo", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _SAMLConfigurationConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *types.SAMLConfigurationConnection) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SAMLConfigurationConnection_totalCount,
		func(ctx context.Context) (any, error) {
			return ec.resolvers.SAMLConfigurationConnection().TotalCount(ctx, obj)
		},
		nil,
		ec.marshalOInt2ᚖint,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_SAMLConfigurationConnection_totalCount(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SAMLConfigurationConnection",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Int does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _SAMLConfigurationEdge_node(ctx context.Context, field graphql.CollectedField, obj *types.SAMLConfigurationEdge) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SAMLConfigurationEdge_node,
		func(ctx context.Context) (any, error) {
			return obj.Node, nil
		},
		nil,
		ec.marshalNSAMLConfiguration2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐSAMLConfiguration,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_SAMLConfigurationEdge_node(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SAMLConfigurationEdge",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_SAMLConfiguration_id(ctx, field)
			case "emailDomain":
				return ec.fieldContext_SAMLConfiguration_emailDomain(ctx, field)
			case "enforcementPolicy":
				return ec.fieldContext_SAMLConfiguration_enforcementPolicy(ctx, field)
			case "domainVerifiedAt":
				return ec.fieldContext_SAMLConfiguration_domainVerifiedAt(ctx, field)
			case "domainVerificationToken":
				return ec.fieldContext_SAMLConfiguration_domainVerificationToken(ctx, field)
			case "idpEntityId":
				return ec.fieldContext_SAMLConfiguration_idpEntityId(ctx, field)
			case "idpSsoUrl":
				return ec.fieldContext_SAMLConfiguration_idpSsoUrl(ctx, field)
			case "idpCertificate":
				return ec.fieldContext_SAMLConfiguration_idpCertificate(ctx, field)
			case "autoSignupEnabled":
				return ec.fieldContext_SAMLConfiguration_autoSignupEnabled(ctx, field)
			case "createdAt":
				return ec.fieldContext_SAMLConfiguration_createdAt(ctx, field)
			case "updatedAt":
				return ec.fieldContext_SAMLConfiguration_updatedAt(ctx, field)
			case "testLoginUrl":
				return ec.fieldContext_SAMLConfiguration_testLoginUrl(ctx, field)
			case "attributeMappings":
				return ec.fieldContext_SAMLConfiguration_attributeMappings(ctx, field)
			case "permission":
				return ec.fieldContext_SAMLConfiguration_permission(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type SAMLConfiguration", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _SAMLConfigurationEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *types.SAMLConfigurationEdge) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SAMLConfigurationEdge_cursor,
		func(ctx context.Context) (any, error) {
			return obj.Cursor, nil
		},
		nil,
		ec.marshalNCursorKey2goᚗproboᚗincᚋproboᚋpkgᚋpageᚐCursorKey,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_SAMLConfigurationEdge_cursor(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SAMLConfigurationEdge",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type CursorKey does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _SCIMBridge_id(ctx context.Context, field graphql.CollectedField, obj *types.SCIMBridge) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SCIMBridge_id,
		func(ctx context.Context) (any, error) {
			return obj.ID, nil
		},
		nil,
		ec.marshalNID2goᚗproboᚗincᚋproboᚋpkgᚋgidᚐGID,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_SCIMBridge_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SCIMBridge",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type ID does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _SCIMBridge_state(ctx context.Context, field graphql.CollectedField, obj *types.SCIMBridge) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SCIMBridge_state,
		func(ctx context.Context) (any, error) {
			return obj.State, nil
		},
		nil,
		ec.marshalNSCIMBridgeState2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐSCIMBridgeState,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_SCIMBridge_state(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SCIMBridge",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type SCIMBridgeState does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _SCIMBridge_scimConfiguration(ctx context.Context, field graphql.CollectedField, obj *types.SCIMBridge) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SCIMBridge_scimConfiguration,
		func(ctx context.Context) (any, error) {
			return ec.resolvers.SCIMBridge().ScimConfiguration(ctx, obj)
		},
		nil,
		ec.marshalOSCIMConfiguration2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐSCIMConfiguration,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_SCIMBridge_scimConfiguration(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SCIMBridge",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_SCIMConfiguration_id(ctx, field)
			case "endpointUrl":
				return ec.fieldContext_SCIMConfiguration_endpointUrl(ctx, field)
			case "createdAt":
				return ec.fieldContext_SCIMConfiguration_createdAt(ctx, field)
			case "updatedAt":
				return ec.fieldContext_SCIMConfiguration_updatedAt(ctx, field)
			case "organization":
				return ec.fieldContext_SCIMConfiguration_organization(ctx, field)
			case "bridge":
				return ec.fieldContext_SCIMConfiguration_bridge(ctx, field)
			case "events":
				return ec.fieldContext_SCIMConfiguration_events(ctx, field)
			case "permission":
				return ec.fieldContext_SCIMConfiguration_permission(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type SCIMConfiguration", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _SCIMBridge_connector(ctx context.Context, field graphql.CollectedField, obj *types.SCIMBridge) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SCIMBridge_connector,
		func(ctx context.Context) (any, error) {
			return ec.resolvers.SCIMBridge().Connector(ctx, obj)
		},
		nil,
		ec.marshalOConnector2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐConnector,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_SCIMBridge_connector(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SCIMBridge",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_Connector_id(ctx, field)
			case "provider":
				return ec.fieldContext_Connector_provider(ctx, field)
			case "createdAt":
				return ec.fieldContext_Connector_createdAt(ctx, field)
			case "updatedAt":
				return ec.fieldContext_Connector_updatedAt(ctx, field)
			case "permission":
				return ec.fieldContext_Connector_permission(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type Connector", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _SCIMBridge_type(ctx context.Context, field graphql.CollectedField, obj *types.SCIMBridge) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SCIMBridge_type,
		func(ctx context.Context) (any, error) {
			return obj.Type, nil
		},
		nil,
		ec.marshalNSCIMBridgeType2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐSCIMBridgeType,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_SCIMBridge_type(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SCIMBridge",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type SCIMBridgeType does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _SCIMBridge_excludedUserNames(ctx context.Context, field graphql.CollectedField, obj *types.SCIMBridge) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SCIMBridge_excludedUserNames,
		func(ctx context.Context) (any, error) {
			return obj.ExcludedUserNames, nil
		},
		nil,
		ec.marshalNString2ᚕstringᚄ,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_SCIMBridge_excludedUserNames(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SCIMBridge",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _SCIMBridge_createdAt(ctx context.Context, field graphql.CollectedField, obj *types.SCIMBridge) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SCIMBridge_createdAt,
		func(ctx context.Context) (any, error) {
			return obj.CreatedAt, nil
		},
		nil,
		ec.marshalNDatetime2timeᚐTime,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_SCIMBridge_createdAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SCIMBridge",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Datetime does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _SCIMBridge_updatedAt(ctx context.Context, field graphql.CollectedField, obj *types.SCIMBridge) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SCIMBridge_updatedAt,
		func(ctx context.Context) (any, error) {
			return obj.UpdatedAt, nil
		},
		nil,
		ec.marshalNDatetime2timeᚐTime,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_SCIMBridge_updatedAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SCIMBridge",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Datetime does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _SCIMBridge_permission(ctx context.Context, field graphql.CollectedField, obj *types.SCIMBridge) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SCIMBridge_permission,
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.resolvers.SCIMBridge().Permission(ctx, obj, fc.Args["action"].(string))
		},
		func(ctx context.Context, next graphql.Resolver) graphql.Resolver {
			directive0 := next

			directive1 := func(ctx context.Context) (any, error) {
				required, err := ec.unmarshalNSessionRequirement2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋgqlutilsᚋdirectivesᚋsessionᚐSessionRequirement(ctx, "PRESENT")
				if err != nil {
					var zeroVal bool
					return zeroVal, err
				}
				if ec.directives.Session == nil {
					var zeroVal bool
					return zeroVal, errors.New("directive session is not implemented")
				}
				return ec.directives.Session(ctx, obj, directive0, required)
			}

			next = directive1
			return next
		},
		ec.marshalNBoolean2bool,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_SCIMBridge_permission(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SCIMBridge",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Boolean does not have child fields")
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_SCIMBridge_permission_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _SCIMConfiguration_id(ctx context.Context, field graphql.CollectedField, obj *types.SCIMConfiguration) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SCIMConfiguration_id,
		func(ctx context.Context) (any, error) {
			return obj.ID, nil
		},
		nil,
		ec.marshalNID2goᚗproboᚗincᚋproboᚋpkgᚋgidᚐGID,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_SCIMConfiguration_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SCIMConfiguration",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type ID does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _SCIMConfiguration_endpointUrl(ctx context.Context, field graphql.CollectedField, obj *types.SCIMConfiguration) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SCIMConfiguration_endpointUrl,
		func(ctx context.Context) (any, error) {
			return ec.resolvers.SCIMConfiguration().EndpointURL(ctx, obj)
		},
		nil,
		ec.marshalNString2string,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_SCIMConfiguration_endpointUrl(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SCIMConfiguration",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _SCIMConfiguration_createdAt(ctx context.Context, field graphql.CollectedField, obj *types.SCIMConfiguration) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SCIMConfiguration_createdAt,
		func(ctx context.Context) (any, error) {
			return obj.CreatedAt, nil
		},
		nil,
		ec.marshalNDatetime2timeᚐTime,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_SCIMConfiguration_createdAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SCIMConfiguration",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Datetime does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _SCIMConfiguration_updatedAt(ctx context.Context, field graphql.CollectedField, obj *types.SCIMConfiguration) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SCIMConfiguration_updatedAt,
		func(ctx context.Context) (any, error) {
			return obj.UpdatedAt, nil
		},
		nil,
		ec.marshalNDatetime2timeᚐTime,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_SCIMConfiguration_updatedAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SCIMConfiguration",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Datetime does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _SCIMConfiguration_organization(ctx context.Context, field graphql.CollectedField, obj *types.SCIMConfiguration) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SCIMConfiguration_organization,
		func(ctx context.Context) (any, error) {
			return ec.resolvers.SCIMConfiguration().Organization(ctx, obj)
		},
		nil,
		ec.marshalOOrganization2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐOrganization,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_SCIMConfiguration_organization(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SCIMConfiguration",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_Organization_id(ctx, field)
			case "name":
				return ec.fieldContext_Organization_name(ctx, field)
			case "logoUrl":
				return ec.fieldContext_Organization_logoUrl(ctx, field)
			case "horizontalLogoUrl":
				return ec.fieldContext_Organization_horizontalLogoUrl(ctx, field)
			case "email":
				return ec.fieldContext_Organization_email(ctx, field)
			case "description":
				return ec.fieldContext_Organization_description(ctx, field)
			case "websiteUrl":
				return ec.fieldContext_Organization_websiteUrl(ctx, field)
			case "headquarterAddress":
				return ec.fieldContext_Organization_headquarterAddress(ctx, field)
			case "createdAt":
				return ec.fieldContext_Organization_createdAt(ctx, field)
			case "updatedAt":
				return ec.fieldContext_Organization_updatedAt(ctx, field)
			case "members":
				return ec.fieldContext_Organization_members(ctx, field)
			case "invitations":
				return ec.fieldContext_Organization_invitations(ctx, field)
			case "samlConfigurations":
				return ec.fieldContext_Organization_samlConfigurations(ctx, field)
			case "scimConfiguration":
				return ec.fieldContext_Organization_scimConfiguration(ctx, field)
			case "viewerMembership":
				return ec.fieldContext_Organization_viewerMembership(ctx, field)
			case "permission":
				return ec.fieldContext_Organization_permission(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type Organization", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _SCIMConfiguration_bridge(ctx context.Context, field graphql.CollectedField, obj *types.SCIMConfiguration) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SCIMConfiguration_bridge,
		func(ctx context.Context) (any, error) {
			return ec.resolvers.SCIMConfiguration().Bridge(ctx, obj)
		},
		nil,
		ec.marshalOSCIMBridge2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐSCIMBridge,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_SCIMConfiguration_bridge(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SCIMConfiguration",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_SCIMBridge_id(ctx, field)
			case "state":
				return ec.fieldContext_SCIMBridge_state(ctx, field)
			case "scimConfiguration":
				return ec.fieldContext_SCIMBridge_scimConfiguration(ctx, field)
			case "connector":
				return ec.fieldContext_SCIMBridge_connector(ctx, field)
			case "type":
				return ec.fieldContext_SCIMBridge_type(ctx, field)
			case "excludedUserNames":
				return ec.fieldContext_SCIMBridge_excludedUserNames(ctx, field)
			case "createdAt":
				return ec.fieldContext_SCIMBridge_createdAt(ctx, field)
			case "updatedAt":
				return ec.fieldContext_SCIMBridge_updatedAt(ctx, field)
			case "permission":
				return ec.fieldContext_SCIMBridge_permission(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type SCIMBridge", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _SCIMConfiguration_events(ctx context.Context, field graphql.CollectedField, obj *types.SCIMConfiguration) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SCIMConfiguration_events,
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.resolvers.SCIMConfiguration().Events(ctx, obj, fc.Args["first"].(*int), fc.Args["after"].(*page.CursorKey), fc.Args["last"].(*int), fc.Args["before"].(*page.CursorKey), fc.Args["orderBy"].(*types.SCIMEventOrderBy))
		},
		nil,
		ec.marshalOSCIMEventConnection2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐSCIMEventConnection,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_SCIMConfiguration_events(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SCIMConfiguration",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "edges":
				return ec.fieldContext_SCIMEventConnection_edges(ctx, field)
			case "pageInfo":
				return ec.fieldContext_SCIMEventConnection_pageInfo(ctx, field)
			case "totalCount":
				return ec.fieldContext_SCIMEventConnection_totalCount(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type SCIMEventConnection", field.Name)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_SCIMConfiguration_events_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _SCIMConfiguration_permission(ctx context.Context, field graphql.CollectedField, obj *types.SCIMConfiguration) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SCIMConfiguration_permission,
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.resolvers.SCIMConfiguration().Permission(ctx, obj, fc.Args["action"].(string))
		},
		func(ctx context.Context, next graphql.Resolver) graphql.Resolver {
			directive0 := next

			directive1 := func(ctx context.Context) (any, error) {
				required, err := ec.unmarshalNSessionRequirement2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋgqlutilsᚋdirectivesᚋsessionᚐSessionRequirement(ctx, "PRESENT")
				if err != nil {
					var zeroVal bool
					return zeroVal, err
				}
				if ec.directives.Session == nil {
					var zeroVal bool
					return zeroVal, errors.New("directive session is not implemented")
				}
				return ec.directives.Session(ctx, obj, directive0, required)
			}

			next = directive1
			return next
		},
		ec.marshalNBoolean2bool,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_SCIMConfiguration_permission(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SCIMConfiguration",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Boolean does not have child fields")
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_SCIMConfiguration_permission_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _SCIMEvent_id(ctx context.Context, field graphql.CollectedField, obj *types.SCIMEvent) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SCIMEvent_id,
		func(ctx context.Context) (any, error) {
			return obj.ID, nil
		},
		nil,
		ec.marshalNID2goᚗproboᚗincᚋproboᚋpkgᚋgidᚐGID,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_SCIMEvent_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SCIMEvent",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type ID does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _SCIMEvent_method(ctx context.Context, field graphql.CollectedField, obj *types.SCIMEvent) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SCIMEvent_method,
		func(ctx context.Context) (any, error) {
			return obj.Method, nil
		},
		nil,
		ec.marshalNString2string,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_SCIMEvent_method(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SCIMEvent",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _SCIMEvent_path(ctx context.Context, field graphql.CollectedField, obj *types.SCIMEvent) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SCIMEvent_path,
		func(ctx context.Context) (any, error) {
			return obj.Path, nil
		},
		nil,
		ec.marshalNString2string,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_SCIMEvent_path(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SCIMEvent",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _SCIMEvent_statusCode(ctx context.Context, field graphql.CollectedField, obj *types.SCIMEvent) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SCIMEvent_statusCode,
		func(ctx context.Context) (any, error) {
			return obj.StatusCode, nil
		},
		nil,
		ec.marshalNInt2int,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_SCIMEvent_statusCode(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SCIMEvent",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Int does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _SCIMEvent_requestBody(ctx context.Context, field graphql.CollectedField, obj *types.SCIMEvent) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SCIMEvent_requestBody,
		func(ctx context.Context) (any, error) {
			return obj.RequestBody, nil
		},
		nil,
		ec.marshalOString2ᚖstring,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_SCIMEvent_requestBody(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SCIMEvent",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _SCIMEvent_responseBody(ctx context.Context, field graphql.CollectedField, obj *types.SCIMEvent) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SCIMEvent_responseBody,
		func(ctx context.Context) (any, error) {
			return obj.ResponseBody, nil
		},
		nil,
		ec.marshalOString2ᚖstring,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_SCIMEvent_responseBody(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SCIMEvent",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _SCIMEvent_errorMessage(ctx context.Context, field graphql.CollectedField, obj *types.SCIMEvent) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SCIMEvent_errorMessage,
		func(ctx context.Context) (any, error) {
			return obj.ErrorMessage, nil
		},
		nil,
		ec.marshalOString2ᚖstring,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_SCIMEvent_errorMessage(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SCIMEvent",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _SCIMEvent_membership(ctx context.Context, field graphql.CollectedField, obj *types.SCIMEvent) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SCIMEvent_membership,
		func(ctx context.Context) (any, error) {
			return ec.resolvers.SCIMEvent().Membership(ctx, obj)
		},
		nil,
		ec.marshalOMembership2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐMembership,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_SCIMEvent_membership(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SCIMEvent",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_Membership_id(ctx, field)
			case "createdAt":
				return ec.fieldContext_Membership_createdAt(ctx, field)
			case "identity":
				return ec.fieldContext_Membership_identity(ctx, field)
			case "profile":
				return ec.fieldContext_Membership_profile(ctx, field)
			case "organization":
				return ec.fieldContext_Membership_organization(ctx, field)
			case "role":
				return ec.fieldContext_Membership_role(ctx, field)
			case "source":
				return ec.fieldContext_Membership_source(ctx, field)
			case "state":
				return ec.fieldContext_Membership_state(ctx, field)
			case "lastSession":
				return ec.fieldContext_Membership_lastSession(ctx, field)
			case "permission":
				return ec.fieldContext_Membership_permission(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type Membership", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _SCIMEvent_ipAddress(ctx context.Context, field graphql.CollectedField, obj *types.SCIMEvent) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SCIMEvent_ipAddress,
		func(ctx context.Context) (any, error) {
			return obj.IPAddress, nil
		},
		nil,
		ec.marshalNString2string,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_SCIMEvent_ipAddress(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SCIMEvent",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _SCIMEvent_createdAt(ctx context.Context, field graphql.CollectedField, obj *types.SCIMEvent) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SCIMEvent_createdAt,
		func(ctx context.Context) (any, error) {
			return obj.CreatedAt, nil
		},
		nil,
		ec.marshalNDatetime2timeᚐTime,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_SCIMEvent_createdAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SCIMEvent",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Datetime does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _SCIMEvent_permission(ctx context.Context, field graphql.CollectedField, obj *types.SCIMEvent) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SCIMEvent_permission,
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.resolvers.SCIMEvent().Permission(ctx, obj, fc.Args["action"].(string))
		},
		func(ctx context.Context, next graphql.Resolver) graphql.Resolver {
			directive0 := next

			directive1 := func(ctx context.Context) (any, error) {
				required, err := ec.unmarshalNSessionRequirement2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋgqlutilsᚋdirectivesᚋsessionᚐSessionRequirement(ctx, "PRESENT")
				if err != nil {
					var zeroVal bool
					return zeroVal, err
				}
				if ec.directives.Session == nil {
					var zeroVal bool
					return zeroVal, errors.New("directive session is not implemented")
				}
				return ec.directives.Session(ctx, obj, directive0, required)
			}

			next = directive1
			return next
		},
		ec.marshalNBoolean2bool,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_SCIMEvent_permission(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SCIMEvent",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Boolean does not have child fields")
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_SCIMEvent_permission_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _SCIMEventConnection_edges(ctx context.Context, field graphql.CollectedField, obj *types.SCIMEventConnection) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SCIMEventConnection_edges,
		func(ctx context.Context) (any, error) {
			return obj.Edges, nil
		},
		nil,
		ec.marshalNSCIMEventEdge2ᚕᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐSCIMEventEdgeᚄ,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_SCIMEventConnection_edges(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SCIMEventConnection",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "node":
				return ec.fieldContext_SCIMEventEdge_node(ctx, field)
			case "cursor":
				return ec.fieldContext_SCIMEventEdge_cursor(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type SCIMEventEdge", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _SCIMEventConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *types.SCIMEventConnection) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SCIMEventConnection_pageInfo,
		func(ctx context.Context) (any, error) {
			return obj.PageInfo, nil
		},
		nil,
		ec.marshalNPageInfo2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐPageInfo,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_SCIMEventConnection_pageInfo(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SCIMEventConnection",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "hasNextPage":
				return ec.fieldContext_PageInfo_hasNextPage(ctx, field)
			case "hasPreviousPage":
				return ec.fieldContext_PageInfo_hasPreviousPage(ctx, field)
			case "startCursor":
				return ec.fieldContext_PageInfo_startCursor(ctx, field)
			case "endCursor":
				return ec.fieldContext_PageInfo_endCursor(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type PageInfo", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _SCIMEventConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *types.SCIMEventConnection) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SCIMEventConnection_totalCount,
		func(ctx context.Context) (any, error) {
			return ec.resolvers.SCIMEventConnection().TotalCount(ctx, obj)
		},
		nil,
		ec.marshalOInt2ᚖint,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_SCIMEventConnection_totalCount(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SCIMEventConnection",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Int does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _SCIMEventEdge_node(ctx context.Context, field graphql.CollectedField, obj *types.SCIMEventEdge) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SCIMEventEdge_node,
		func(ctx context.Context) (any, error) {
			return obj.Node, nil
		},
		nil,
		ec.marshalNSCIMEvent2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐSCIMEvent,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_SCIMEventEdge_node(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SCIMEventEdge",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_SCIMEvent_id(ctx, field)
			case "method":
				return ec.fieldContext_SCIMEvent_method(ctx, field)
			case "path":
				return ec.fieldContext_SCIMEvent_path(ctx, field)
			case "statusCode":
				return ec.fieldContext_SCIMEvent_statusCode(ctx, field)
			case "requestBody":
				return ec.fieldContext_SCIMEvent_requestBody(ctx, field)
			case "responseBody":
				return ec.fieldContext_SCIMEvent_responseBody(ctx, field)
			case "errorMessage":
				return ec.fieldContext_SCIMEvent_errorMessage(ctx, field)
			case "membership":
				return ec.fieldContext_SCIMEvent_membership(ctx, field)
			case "ipAddress":
				return ec.fieldContext_SCIMEvent_ipAddress(ctx, field)
			case "createdAt":
				return ec.fieldContext_SCIMEvent_createdAt(ctx, field)
			case "permission":
				return ec.fieldContext_SCIMEvent_permission(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type SCIMEvent", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _SCIMEventEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *types.SCIMEventEdge) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SCIMEventEdge_cursor,
		func(ctx context.Context) (any, error) {
			return obj.Cursor, nil
		},
		nil,
		ec.marshalNCursorKey2goᚗproboᚗincᚋproboᚋpkgᚋpageᚐCursorKey,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_SCIMEventEdge_cursor(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SCIMEventEdge",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type CursorKey does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _Session_id(ctx context.Context, field graphql.CollectedField, obj *types.Session) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Session_id,
		func(ctx context.Context) (any, error) {
			return obj.ID, nil
		},
		nil,
		ec.marshalNID2goᚗproboᚗincᚋproboᚋpkgᚋgidᚐGID,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_Session_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Session",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type ID does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _Session_identity(ctx context.Context, field graphql.CollectedField, obj *types.Session) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Session_identity,
		func(ctx context.Context) (any, error) {
			return ec.resolvers.Session().Identity(ctx, obj)
		},
		nil,
		ec.marshalOIdentity2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐIdentity,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_Session_identity(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Session",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_Identity_id(ctx, field)
			case "email":
				return ec.fieldContext_Identity_email(ctx, field)
			case "fullName":
				return ec.fieldContext_Identity_fullName(ctx, field)
			case "emailVerified":
				return ec.fieldContext_Identity_emailVerified(ctx, field)
			case "createdAt":
				return ec.fieldContext_Identity_createdAt(ctx, field)
			case "updatedAt":
				return ec.fieldContext_Identity_updatedAt(ctx, field)
			case "memberships":
				return ec.fieldContext_Identity_memberships(ctx, field)
			case "pendingInvitations":
				return ec.fieldContext_Identity_pendingInvitations(ctx, field)
			case "sessions":
				return ec.fieldContext_Identity_sessions(ctx, field)
			case "personalAPIKeys":
				return ec.fieldContext_Identity_personalAPIKeys(ctx, field)
			case "permission":
				return ec.fieldContext_Identity_permission(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type Identity", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _Session_ipAddress(ctx context.Context, field graphql.CollectedField, obj *types.Session) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Session_ipAddress,
		func(ctx context.Context) (any, error) {
			return obj.IPAddress, nil
		},
		nil,
		ec.marshalNString2string,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_Session_ipAddress(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Session",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _Session_userAgent(ctx context.Context, field graphql.CollectedField, obj *types.Session) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Session_userAgent,
		func(ctx context.Context) (any, error) {
			return obj.UserAgent, nil
		},
		nil,
		ec.marshalNString2string,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_Session_userAgent(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Session",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _Session_updatedAt(ctx context.Context, field graphql.CollectedField, obj *types.Session) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Session_updatedAt,
		func(ctx context.Context) (any, error) {
			return obj.UpdatedAt, nil
		},
		nil,
		ec.marshalNDatetime2timeᚐTime,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_Session_updatedAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Session",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Datetime does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _Session_createdAt(ctx context.Context, field graphql.CollectedField, obj *types.Session) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Session_createdAt,
		func(ctx context.Context) (any, error) {
			return obj.CreatedAt, nil
		},
		nil,
		ec.marshalNDatetime2timeᚐTime,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_Session_createdAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Session",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Datetime does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _Session_expiresAt(ctx context.Context, field graphql.CollectedField, obj *types.Session) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Session_expiresAt,
		func(ctx context.Context) (any, error) {
			return obj.ExpiresAt, nil
		},
		nil,
		ec.marshalNDatetime2timeᚐTime,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_Session_expiresAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Session",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Datetime does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _Session_permission(ctx context.Context, field graphql.CollectedField, obj *types.Session) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Session_permission,
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.resolvers.Session().Permission(ctx, obj, fc.Args["action"].(string))
		},
		func(ctx context.Context, next graphql.Resolver) graphql.Resolver {
			directive0 := next

			directive1 := func(ctx context.Context) (any, error) {
				required, err := ec.unmarshalNSessionRequirement2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋgqlutilsᚋdirectivesᚋsessionᚐSessionRequirement(ctx, "PRESENT")
				if err != nil {
					var zeroVal bool
					return zeroVal, err
				}
				if ec.directives.Session == nil {
					var zeroVal bool
					return zeroVal, errors.New("directive session is not implemented")
				}
				return ec.directives.Session(ctx, obj, directive0, required)
			}

			next = directive1
			return next
		},
		ec.marshalNBoolean2bool,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_Session_permission(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Session",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Boolean does not have child fields")
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Session_permission_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _SessionConnection_edges(ctx context.Context, field graphql.CollectedField, obj *types.SessionConnection) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SessionConnection_edges,
		func(ctx context.Context) (any, error) {
			return obj.Edges, nil
		},
		nil,
		ec.marshalNSessionEdge2ᚕᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐSessionEdgeᚄ,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_SessionConnection_edges(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SessionConnection",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "node":
				return ec.fieldContext_SessionEdge_node(ctx, field)
			case "cursor":
				return ec.fieldContext_SessionEdge_cursor(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type SessionEdge", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _SessionConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *types.SessionConnection) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SessionConnection_pageInfo,
		func(ctx context.Context) (any, error) {
			return obj.PageInfo, nil
		},
		nil,
		ec.marshalNPageInfo2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐPageInfo,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_SessionConnection_pageInfo(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SessionConnection",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "hasNextPage":
				return ec.fieldContext_PageInfo_hasNextPage(ctx, field)
			case "hasPreviousPage":
				return ec.fieldContext_PageInfo_hasPreviousPage(ctx, field)
			case "startCursor":
				return ec.fieldContext_PageInfo_startCursor(ctx, field)
			case "endCursor":
				return ec.fieldContext_PageInfo_endCursor(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type PageInfo", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _SessionConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *types.SessionConnection) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SessionConnection_totalCount,
		func(ctx context.Context) (any, error) {
			return ec.resolvers.SessionConnection().TotalCount(ctx, obj)
		},
		nil,
		ec.marshalOInt2ᚖint,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_SessionConnection_totalCount(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SessionConnection",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Int does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _SessionEdge_node(ctx context.Context, field graphql.CollectedField, obj *types.SessionEdge) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SessionEdge_node,
		func(ctx context.Context) (any, error) {
			return obj.Node, nil
		},
		nil,
		ec.marshalNSession2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐSession,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_SessionEdge_node(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SessionEdge",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_Session_id(ctx, field)
			case "identity":
				return ec.fieldContext_Session_identity(ctx, field)
			case "ipAddress":
				return ec.fieldContext_Session_ipAddress(ctx, field)
			case "userAgent":
				return ec.fieldContext_Session_userAgent(ctx, field)
			case "updatedAt":
				return ec.fieldContext_Session_updatedAt(ctx, field)
			case "createdAt":
				return ec.fieldContext_Session_createdAt(ctx, field)
			case "expiresAt":
				return ec.fieldContext_Session_expiresAt(ctx, field)
			case "permission":
				return ec.fieldContext_Session_permission(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type Session", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _SessionEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *types.SessionEdge) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SessionEdge_cursor,
		func(ctx context.Context) (any, error) {
			return obj.Cursor, nil
		},
		nil,
		ec.marshalNCursorKey2goᚗproboᚗincᚋproboᚋpkgᚋpageᚐCursorKey,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_SessionEdge_cursor(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SessionEdge",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type CursorKey does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _SignInPayload_identity(ctx context.Context, field graphql.CollectedField, obj *types.SignInPayload) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SignInPayload_identity,
		func(ctx context.Context) (any, error) {
			return obj.Identity, nil
		},
		nil,
		ec.marshalOIdentity2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐIdentity,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_SignInPayload_identity(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SignInPayload",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_Identity_id(ctx, field)
			case "email":
				return ec.fieldContext_Identity_email(ctx, field)
			case "fullName":
				return ec.fieldContext_Identity_fullName(ctx, field)
			case "emailVerified":
				return ec.fieldContext_Identity_emailVerified(ctx, field)
			case "createdAt":
				return ec.fieldContext_Identity_createdAt(ctx, field)
			case "updatedAt":
				return ec.fieldContext_Identity_updatedAt(ctx, field)
			case "memberships":
				return ec.fieldContext_Identity_memberships(ctx, field)
			case "pendingInvitations":
				return ec.fieldContext_Identity_pendingInvitations(ctx, field)
			case "sessions":
				return ec.fieldContext_Identity_sessions(ctx, field)
			case "personalAPIKeys":
				return ec.fieldContext_Identity_personalAPIKeys(ctx, field)
			case "permission":
				return ec.fieldContext_Identity_permission(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type Identity", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _SignInPayload_session(ctx context.Context, field graphql.CollectedField, obj *types.SignInPayload) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SignInPayload_session,
		func(ctx context.Context) (any, error) {
			return obj.Session, nil
		},
		nil,
		ec.marshalOSession2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐSession,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_SignInPayload_session(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SignInPayload",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_Session_id(ctx, field)
			case "identity":
				return ec.fieldContext_Session_identity(ctx, field)
			case "ipAddress":
				return ec.fieldContext_Session_ipAddress(ctx, field)
			case "userAgent":
				return ec.fieldContext_Session_userAgent(ctx, field)
			case "updatedAt":
				return ec.fieldContext_Session_updatedAt(ctx, field)
			case "createdAt":
				return ec.fieldContext_Session_createdAt(ctx, field)
			case "expiresAt":
				return ec.fieldContext_Session_expiresAt(ctx, field)
			case "permission":
				return ec.fieldContext_Session_permission(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type Session", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _SignOutPayload_success(ctx context.Context, field graphql.CollectedField, obj *types.SignOutPayload) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SignOutPayload_success,
		func(ctx context.Context) (any, error) {
			return obj.Success, nil
		},
		nil,
		ec.marshalNBoolean2bool,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_SignOutPayload_success(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SignOutPayload",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Boolean does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _SignUpFromInvitationPayload_identity(ctx context.Context, field graphql.CollectedField, obj *types.SignUpFromInvitationPayload) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SignUpFromInvitationPayload_identity,
		func(ctx context.Context) (any, error) {
			return obj.Identity, nil
		},
		nil,
		ec.marshalOIdentity2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐIdentity,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_SignUpFromInvitationPayload_identity(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SignUpFromInvitationPayload",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_Identity_id(ctx, field)
			case "email":
				return ec.fieldContext_Identity_email(ctx, field)
			case "fullName":
				return ec.fieldContext_Identity_fullName(ctx, field)
			case "emailVerified":
				return ec.fieldContext_Identity_emailVerified(ctx, field)
			case "createdAt":
				return ec.fieldContext_Identity_createdAt(ctx, field)
			case "updatedAt":
				return ec.fieldContext_Identity_updatedAt(ctx, field)
			case "memberships":
				return ec.fieldContext_Identity_memberships(ctx, field)
			case "pendingInvitations":
				return ec.fieldContext_Identity_pendingInvitations(ctx, field)
			case "sessions":
				return ec.fieldContext_Identity_sessions(ctx, field)
			case "personalAPIKeys":
				return ec.fieldContext_Identity_personalAPIKeys(ctx, field)
			case "permission":
				return ec.fieldContext_Identity_permission(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type Identity", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _SignUpPayload_identity(ctx context.Context, field graphql.CollectedField, obj *types.SignUpPayload) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SignUpPayload_identity,
		func(ctx context.Context) (any, error) {
			return obj.Identity, nil
		},
		nil,
		ec.marshalOIdentity2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐIdentity,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_SignUpPayload_identity(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SignUpPayload",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_Identity_id(ctx, field)
			case "email":
				return ec.fieldContext_Identity_email(ctx, field)
			case "fullName":
				return ec.fieldContext_Identity_fullName(ctx, field)
			case "emailVerified":
				return ec.fieldContext_Identity_emailVerified(ctx, field)
			case "createdAt":
				return ec.fieldContext_Identity_createdAt(ctx, field)
			case "updatedAt":
				return ec.fieldContext_Identity_updatedAt(ctx, field)
			case "memberships":
				return ec.fieldContext_Identity_memberships(ctx, field)
			case "pendingInvitations":
				return ec.fieldContext_Identity_pendingInvitations(ctx, field)
			case "sessions":
				return ec.fieldContext_Identity_sessions(ctx, field)
			case "personalAPIKeys":
				return ec.fieldContext_Identity_personalAPIKeys(ctx, field)
			case "permission":
				return ec.fieldContext_Identity_permission(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type Identity", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _UpdateMembershipPayload_membership(ctx context.Context, field graphql.CollectedField, obj *types.UpdateMembershipPayload) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_UpdateMembershipPayload_membership,
		func(ctx context.Context) (any, error) {
			return obj.Membership, nil
		},
		nil,
		ec.marshalNMembership2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐMembership,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_UpdateMembershipPayload_membership(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "UpdateMembershipPayload",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_Membership_id(ctx, field)
			case "createdAt":
				return ec.fieldContext_Membership_createdAt(ctx, field)
			case "identity":
				return ec.fieldContext_Membership_identity(ctx, field)
			case "profile":
				return ec.fieldContext_Membership_profile(ctx, field)
			case "organization":
				return ec.fieldContext_Membership_organization(ctx, field)
			case "role":
				return ec.fieldContext_Membership_role(ctx, field)
			case "source":
				return ec.fieldContext_Membership_source(ctx, field)
			case "state":
				return ec.fieldContext_Membership_state(ctx, field)
			case "lastSession":
				return ec.fieldContext_Membership_lastSession(ctx, field)
			case "permission":
				return ec.fieldContext_Membership_permission(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type Membership", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _UpdateOrganizationPayload_organization(ctx context.Context, field graphql.CollectedField, obj *types.UpdateOrganizationPayload) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_UpdateOrganizationPayload_organization,
		func(ctx context.Context) (any, error) {
			return obj.Organization, nil
		},
		nil,
		ec.marshalOOrganization2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐOrganization,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_UpdateOrganizationPayload_organization(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "UpdateOrganizationPayload",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_Organization_id(ctx, field)
			case "name":
				return ec.fieldContext_Organization_name(ctx, field)
			case "logoUrl":
				return ec.fieldContext_Organization_logoUrl(ctx, field)
			case "horizontalLogoUrl":
				return ec.fieldContext_Organization_horizontalLogoUrl(ctx, field)
			case "email":
				return ec.fieldContext_Organization_email(ctx, field)
			case "description":
				return ec.fieldContext_Organization_description(ctx, field)
			case "websiteUrl":
				return ec.fieldContext_Organization_websiteUrl(ctx, field)
			case "headquarterAddress":
				return ec.fieldContext_Organization_headquarterAddress(ctx, field)
			case "createdAt":
				return ec.fieldContext_Organization_createdAt(ctx, field)
			case "updatedAt":
				return ec.fieldContext_Organization_updatedAt(ctx, field)
			case "members":
				return ec.fieldContext_Organization_members(ctx, field)
			case "invitations":
				return ec.fieldContext_Organization_invitations(ctx, field)
			case "samlConfigurations":
				return ec.fieldContext_Organization_samlConfigurations(ctx, field)
			case "scimConfiguration":
				return ec.fieldContext_Organization_scimConfiguration(ctx, field)
			case "viewerMembership":
				return ec.fieldContext_Organization_viewerMembership(ctx, field)
			case "permission":
				return ec.fieldContext_Organization_permission(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type Organization", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _UpdateProfilePayload_profile(ctx context.Context, field graphql.CollectedField, obj *types.UpdateProfilePayload) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_UpdateProfilePayload_profile,
		func(ctx context.Context) (any, error) {
			return obj.Profile, nil
		},
		nil,
		ec.marshalNMembershipProfile2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐMembershipProfile,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_UpdateProfilePayload_profile(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "UpdateProfilePayload",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_MembershipProfile_id(ctx, field)
			case "fullName":
				return ec.fieldContext_MembershipProfile_fullName(ctx, field)
			case "additionalEmailAddresses":
				return ec.fieldContext_MembershipProfile_additionalEmailAddresses(ctx, field)
			case "kind":
				return ec.fieldContext_MembershipProfile_kind(ctx, field)
			case "position":
				return ec.fieldContext_MembershipProfile_position(ctx, field)
			case "contractStartDate":
				return ec.fieldContext_MembershipProfile_contractStartDate(ctx, field)
			case "contractEndDate":
				return ec.fieldContext_MembershipProfile_contractEndDate(ctx, field)
			case "createdAt":
				return ec.fieldContext_MembershipProfile_createdAt(ctx, field)
			case "updatedAt":
				return ec.fieldContext_MembershipProfile_updatedAt(ctx, field)
			case "identity":
				return ec.fieldContext_MembershipProfile_identity(ctx, field)
			case "organization":
				return ec.fieldContext_MembershipProfile_organization(ctx, field)
			case "membershipId":
				return ec.fieldContext_MembershipProfile_membershipId(ctx, field)
			case "permission":
				return ec.fieldContext_MembershipProfile_permission(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type MembershipProfile", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _UpdateSAMLConfigurationPayload_samlConfiguration(ctx context.Context, field graphql.CollectedField, obj *types.UpdateSAMLConfigurationPayload) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_UpdateSAMLConfigurationPayload_samlConfiguration,
		func(ctx context.Context) (any, error) {
			return obj.SamlConfiguration, nil
		},
		nil,
		ec.marshalOSAMLConfiguration2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐSAMLConfiguration,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_UpdateSAMLConfigurationPayload_samlConfiguration(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "UpdateSAMLConfigurationPayload",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_SAMLConfiguration_id(ctx, field)
			case "emailDomain":
				return ec.fieldContext_SAMLConfiguration_emailDomain(ctx, field)
			case "enforcementPolicy":
				return ec.fieldContext_SAMLConfiguration_enforcementPolicy(ctx, field)
			case "domainVerifiedAt":
				return ec.fieldContext_SAMLConfiguration_domainVerifiedAt(ctx, field)
			case "domainVerificationToken":
				return ec.fieldContext_SAMLConfiguration_domainVerificationToken(ctx, field)
			case "idpEntityId":
				return ec.fieldContext_SAMLConfiguration_idpEntityId(ctx, field)
			case "idpSsoUrl":
				return ec.fieldContext_SAMLConfiguration_idpSsoUrl(ctx, field)
			case "idpCertificate":
				return ec.fieldContext_SAMLConfiguration_idpCertificate(ctx, field)
			case "autoSignupEnabled":
				return ec.fieldContext_SAMLConfiguration_autoSignupEnabled(ctx, field)
			case "createdAt":
				return ec.fieldContext_SAMLConfiguration_createdAt(ctx, field)
			case "updatedAt":
				return ec.fieldContext_SAMLConfiguration_updatedAt(ctx, field)
			case "testLoginUrl":
				return ec.fieldContext_SAMLConfiguration_testLoginUrl(ctx, field)
			case "attributeMappings":
				return ec.fieldContext_SAMLConfiguration_attributeMappings(ctx, field)
			case "permission":
				return ec.fieldContext_SAMLConfiguration_permission(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type SAMLConfiguration", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _UpdateSCIMBridgePayload_scimBridge(ctx context.Context, field graphql.CollectedField, obj *types.UpdateSCIMBridgePayload) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_UpdateSCIMBridgePayload_scimBridge,
		func(ctx context.Context) (any, error) {
			return obj.ScimBridge, nil
		},
		nil,
		ec.marshalNSCIMBridge2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐSCIMBridge,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_UpdateSCIMBridgePayload_scimBridge(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "UpdateSCIMBridgePayload",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_SCIMBridge_id(ctx, field)
			case "state":
				return ec.fieldContext_SCIMBridge_state(ctx, field)
			case "scimConfiguration":
				return ec.fieldContext_SCIMBridge_scimConfiguration(ctx, field)
			case "connector":
				return ec.fieldContext_SCIMBridge_connector(ctx, field)
			case "type":
				return ec.fieldContext_SCIMBridge_type(ctx, field)
			case "excludedUserNames":
				return ec.fieldContext_SCIMBridge_excludedUserNames(ctx, field)
			case "createdAt":
				return ec.fieldContext_SCIMBridge_createdAt(ctx, field)
			case "updatedAt":
				return ec.fieldContext_SCIMBridge_updatedAt(ctx, field)
			case "permission":
				return ec.fieldContext_SCIMBridge_permission(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type SCIMBridge", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _VerifyEmailPayload_success(ctx context.Context, field graphql.CollectedField, obj *types.VerifyEmailPayload) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_VerifyEmailPayload_success,
		func(ctx context.Context) (any, error) {
			return obj.Success, nil
		},
		nil,
		ec.marshalNBoolean2bool,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_VerifyEmailPayload_success(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "VerifyEmailPayload",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Boolean does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) ___Directive_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext___Directive_name,
		func(ctx context.Context) (any, error) {
			return obj.Name, nil
		},
		nil,
		ec.marshalNString2string,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext___Directive_name(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__Directive",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) ___Directive_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext___Directive_description,
		func(ctx context.Context) (any, error) {
			return obj.Description(), nil
		},
		nil,
		ec.marshalOString2ᚖstring,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext___Directive_description(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__Directive",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) ___Directive_isRepeatable(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext___Directive_isRepeatable,
		func(ctx context.Context) (any, error) {
			return obj.IsRepeatable, nil
		},
		nil,
		ec.marshalNBoolean2bool,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext___Directive_isRepeatable(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__Directive",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Boolean does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) ___Directive_locations(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext___Directive_locations,
		func(ctx context.Context) (any, error) {
			return obj.Locations, nil
		},
		nil,
		ec.marshalN__DirectiveLocation2ᚕstringᚄ,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext___Directive_locations(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__Directive",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type __DirectiveLocation does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext___Directive_args,
		func(ctx context.Context) (any, error) {
			return obj.Args, nil
		},
		nil,
		ec.marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext___Directive_args(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__Directive",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "name":
				return ec.fieldContext___InputValue_name(ctx, field)
			case "description":
				return ec.fieldContext___InputValue_description(ctx, field)
			case "type":
				return ec.fieldContext___InputValue_type(ctx, field)
			case "defaultValue":
				return ec.fieldContext___InputValue_defaultValue(ctx, field)
			case "isDeprecated":
				return ec.fieldContext___InputValue_isDeprecated(ctx, field)
			case "deprecationReason":
				return ec.fieldContext___InputValue_deprecationReason(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type __InputValue", field.Name)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field___Directive_args_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) ___EnumValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext___EnumValue_name,
		func(ctx context.Context) (any, error) {
			return obj.Name, nil
		},
		nil,
		ec.marshalNString2string,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext___EnumValue_name(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__EnumValue",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) ___EnumValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext___EnumValue_description,
		func(ctx context.Context) (any, error) {
			return obj.Description(), nil
		},
		nil,
		ec.marshalOString2ᚖstring,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext___EnumValue_description(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__EnumValue",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) ___EnumValue_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext___EnumValue_isDeprecated,
		func(ctx context.Context) (any, error) {
			return obj.IsDeprecated(), nil
		},
		nil,
		ec.marshalNBoolean2bool,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext___EnumValue_isDeprecated(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__EnumValue",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Boolean does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) ___EnumValue_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext___EnumValue_deprecationReason,
		func(ctx context.Context) (any, error) {
			return obj.DeprecationReason(), nil
		},
		nil,
		ec.marshalOString2ᚖstring,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext___EnumValue_deprecationReason(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__EnumValue",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) ___Field_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext___Field_name,
		func(ctx context.Context) (any, error) {
			return obj.Name, nil
		},
		nil,
		ec.marshalNString2string,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext___Field_name(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__Field",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) ___Field_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext___Field_description,
		func(ctx context.Context) (any, error) {
			return obj.Description(), nil
		},
		nil,
		ec.marshalOString2ᚖstring,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext___Field_description(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__Field",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext___Field_args,
		func(ctx context.Context) (any, error) {
			return obj.Args, nil
		},
		nil,
		ec.marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext___Field_args(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__Field",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "name":
				return ec.fieldContext___InputValue_name(ctx, field)
			case "description":
				return ec.fieldContext___InputValue_description(ctx, field)
			case "type":
				return ec.fieldContext___InputValue_type(ctx, field)
			case "defaultValue":
				return ec.fieldContext___InputValue_defaultValue(ctx, field)
			case "isDeprecated":
				return ec.fieldContext___InputValue_isDeprecated(ctx, field)
			case "deprecationReason":
				return ec.fieldContext___InputValue_deprecationReason(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type __InputValue", field.Name)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field___Field_args_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) ___Field_type(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext___Field_type,
		func(ctx context.Context) (any, error) {
			return obj.Type, nil
		},
		nil,
		ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext___Field_type(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__Field",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "kind":
				return ec.fieldContext___Type_kind(ctx, field)
			case "name":
				return ec.fieldContext___Type_name(ctx, field)
			case "description":
				return ec.fieldContext___Type_description(ctx, field)
			case "specifiedByURL":
				return ec.fieldContext___Type_specifiedByURL(ctx, field)
			case "fields":
				return ec.fieldContext___Type_fields(ctx, field)
			case "interfaces":
				return ec.fieldContext___Type_interfaces(ctx, field)
			case "possibleTypes":
				return ec.fieldContext___Type_possibleTypes(ctx, field)
			case "enumValues":
				return ec.fieldContext___Type_enumValues(ctx, field)
			case "inputFields":
				return ec.fieldContext___Type_inputFields(ctx, field)
			case "ofType":
				return ec.fieldContext___Type_ofType(ctx, field)
			case "isOneOf":
				return ec.fieldContext___Type_isOneOf(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) ___Field_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext___Field_isDeprecated,
		func(ctx context.Context) (any, error) {
			return obj.IsDeprecated(), nil
		},
		nil,
		ec.marshalNBoolean2bool,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext___Field_isDeprecated(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__Field",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Boolean does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) ___Field_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext___Field_deprecationReason,
		func(ctx context.Context) (any, error) {
			return obj.DeprecationReason(), nil
		},
		nil,
		ec.marshalOString2ᚖstring,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext___Field_deprecationReason(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__Field",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) ___InputValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext___InputValue_name,
		func(ctx context.Context) (any, error) {
			return obj.Name, nil
		},
		nil,
		ec.marshalNString2string,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext___InputValue_name(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__InputValue",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) ___InputValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext___InputValue_description,
		func(ctx context.Context) (any, error) {
			return obj.Description(), nil
		},
		nil,
		ec.marshalOString2ᚖstring,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext___InputValue_description(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__InputValue",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) ___InputValue_type(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext___InputValue_type,
		func(ctx context.Context) (any, error) {
			return obj.Type, nil
		},
		nil,
		ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext___InputValue_type(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__InputValue",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "kind":
				return ec.fieldContext___Type_kind(ctx, field)
			case "name":
				return ec.fieldContext___Type_name(ctx, field)
			case "description":
				return ec.fieldContext___Type_description(ctx, field)
			case "specifiedByURL":
				return ec.fieldContext___Type_specifiedByURL(ctx, field)
			case "fields":
				return ec.fieldContext___Type_fields(ctx, field)
			case "interfaces":
				return ec.fieldContext___Type_interfaces(ctx, field)
			case "possibleTypes":
				return ec.fieldContext___Type_possibleTypes(ctx, field)
			case "enumValues":
				return ec.fieldContext___Type_enumValues(ctx, field)
			case "inputFields":
				return ec.fieldContext___Type_inputFields(ctx, field)
			case "ofType":
				return ec.fieldContext___Type_ofType(ctx, field)
			case "isOneOf":
				return ec.fieldContext___Type_isOneOf(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) ___InputValue_defaultValue(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext___InputValue_defaultValue,
		func(ctx context.Context) (any, error) {
			return obj.DefaultValue, nil
		},
		nil,
		ec.marshalOString2ᚖstring,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext___InputValue_defaultValue(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__InputValue",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) ___InputValue_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext___InputValue_isDeprecated,
		func(ctx context.Context) (any, error) {
			return obj.IsDeprecated(), nil
		},
		nil,
		ec.marshalNBoolean2bool,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext___InputValue_isDeprecated(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__InputValue",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Boolean does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) ___InputValue_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext___InputValue_deprecationReason,
		func(ctx context.Context) (any, error) {
			return obj.DeprecationReason(), nil
		},
		nil,
		ec.marshalOString2ᚖstring,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext___InputValue_deprecationReason(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__InputValue",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) ___Schema_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext___Schema_description,
		func(ctx context.Context) (any, error) {
			return obj.Description(), nil
		},
		nil,
		ec.marshalOString2ᚖstring,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext___Schema_description(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__Schema",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext___Schema_types,
		func(ctx context.Context) (any, error) {
			return obj.Types(), nil
		},
		nil,
		ec.marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext___Schema_types(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__Schema",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "kind":
				return ec.fieldContext___Type_kind(ctx, field)
			case "name":
				return ec.fieldContext___Type_name(ctx, field)
			case "description":
				return ec.fieldContext___Type_description(ctx, field)
			case "specifiedByURL":
				return ec.fieldContext___Type_specifiedByURL(ctx, field)
			case "fields":
				return ec.fieldContext___Type_fields(ctx, field)
			case "interfaces":
				return ec.fieldContext___Type_interfaces(ctx, field)
			case "possibleTypes":
				return ec.fieldContext___Type_possibleTypes(ctx, field)
			case "enumValues":
				return ec.fieldContext___Type_enumValues(ctx, field)
			case "inputFields":
				return ec.fieldContext___Type_inputFields(ctx, field)
			case "ofType":
				return ec.fieldContext___Type_ofType(ctx, field)
			case "isOneOf":
				return ec.fieldContext___Type_isOneOf(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) ___Schema_queryType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext___Schema_queryType,
		func(ctx context.Context) (any, error) {
			return obj.QueryType(), nil
		},
		nil,
		ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext___Schema_queryType(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__Schema",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "kind":
				return ec.fieldContext___Type_kind(ctx, field)
			case "name":
				return ec.fieldContext___Type_name(ctx, field)
			case "description":
				return ec.fieldContext___Type_description(ctx, field)
			case "specifiedByURL":
				return ec.fieldContext___Type_specifiedByURL(ctx, field)
			case "fields":
				return ec.fieldContext___Type_fields(ctx, field)
			case "interfaces":
				return ec.fieldContext___Type_interfaces(ctx, field)
			case "possibleTypes":
				return ec.fieldContext___Type_possibleTypes(ctx, field)
			case "enumValues":
				return ec.fieldContext___Type_enumValues(ctx, field)
			case "inputFields":
				return ec.fieldContext___Type_inputFields(ctx, field)
			case "ofType":
				return ec.fieldContext___Type_ofType(ctx, field)
			case "isOneOf":
				return ec.fieldContext___Type_isOneOf(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) ___Schema_mutationType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext___Schema_mutationType,
		func(ctx context.Context) (any, error) {
			return obj.MutationType(), nil
		},
		nil,
		ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext___Schema_mutationType(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__Schema",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "kind":
				return ec.fieldContext___Type_kind(ctx, field)
			case "name":
				return ec.fieldContext___Type_name(ctx, field)
			case "description":
				return ec.fieldContext___Type_description(ctx, field)
			case "specifiedByURL":
				return ec.fieldContext___Type_specifiedByURL(ctx, field)
			case "fields":
				return ec.fieldContext___Type_fields(ctx, field)
			case "interfaces":
				return ec.fieldContext___Type_interfaces(ctx, field)
			case "possibleTypes":
				return ec.fieldContext___Type_possibleTypes(ctx, field)
			case "enumValues":
				return ec.fieldContext___Type_enumValues(ctx, field)
			case "inputFields":
				return ec.fieldContext___Type_inputFields(ctx, field)
			case "ofType":
				return ec.fieldContext___Type_ofType(ctx, field)
			case "isOneOf":
				return ec.fieldContext___Type_isOneOf(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) ___Schema_subscriptionType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext___Schema_subscriptionType,
		func(ctx context.Context) (any, error) {
			return obj.SubscriptionType(), nil
		},
		nil,
		ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext___Schema_subscriptionType(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__Schema",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "kind":
				return ec.fieldContext___Type_kind(ctx, field)
			case "name":
				return ec.fieldContext___Type_name(ctx, field)
			case "description":
				return ec.fieldContext___Type_description(ctx, field)
			case "specifiedByURL":
				return ec.fieldContext___Type_specifiedByURL(ctx, field)
			case "fields":
				return ec.fieldContext___Type_fields(ctx, field)
			case "interfaces":
				return ec.fieldContext___Type_interfaces(ctx, field)
			case "possibleTypes":
				return ec.fieldContext___Type_possibleTypes(ctx, field)
			case "enumValues":
				return ec.fieldContext___Type_enumValues(ctx, field)
			case "inputFields":
				return ec.fieldContext___Type_inputFields(ctx, field)
			case "ofType":
				return ec.fieldContext___Type_ofType(ctx, field)
			case "isOneOf":
				return ec.fieldContext___Type_isOneOf(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) ___Schema_directives(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext___Schema_directives,
		func(ctx context.Context) (any, error) {
			return obj.Directives(), nil
		},
		nil,
		ec.marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirectiveᚄ,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext___Schema_directives(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__Schema",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "name":
				return ec.fieldContext___Directive_name(ctx, field)
			case "description":
				return ec.fieldContext___Directive_description(ctx, field)
			case "isRepeatable":
				return ec.fieldContext___Directive_isRepeatable(ctx, field)
			case "locations":
				return ec.fieldContext___Directive_locations(ctx, field)
			case "args":
				return ec.fieldContext___Directive_args(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type __Directive", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) ___Type_kind(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext___Type_kind,
		func(ctx context.Context) (any, error) {
			return obj.Kind(), nil
		},
		nil,
		ec.marshalN__TypeKind2string,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext___Type_kind(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__Type",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type __TypeKind does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) ___Type_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext___Type_name,
		func(ctx context.Context) (any, error) {
			return obj.Name(), nil
		},
		nil,
		ec.marshalOString2ᚖstring,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext___Type_name(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__Type",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) ___Type_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext___Type_description,
		func(ctx context.Context) (any, error) {
			return obj.Description(), nil
		},
		nil,
		ec.marshalOString2ᚖstring,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext___Type_description(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__Type",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) ___Type_specifiedByURL(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext___Type_specifiedByURL,
		func(ctx context.Context) (any, error) {
			return obj.SpecifiedByURL(), nil
		},
		nil,
		ec.marshalOString2ᚖstring,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext___Type_specifiedByURL(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__Type",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext___Type_fields,
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return obj.Fields(fc.Args["includeDeprecated"].(bool)), nil
		},
		nil,
		ec.marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐFieldᚄ,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext___Type_fields(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__Type",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "name":
				return ec.fieldContext___Field_name(ctx, field)
			case "description":
				return ec.fieldContext___Field_description(ctx, field)
			case "args":
				return ec.fieldContext___Field_args(ctx, field)
			case "type":
				return ec.fieldContext___Field_type(ctx, field)
			case "isDeprecated":
				return ec.fieldContext___Field_isDeprecated(ctx, field)
			case "deprecationReason":
				return ec.fieldContext___Field_deprecationReason(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type __Field", field.Name)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field___Type_fields_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext___Type_interfaces,
		func(ctx context.Context) (any, error) {
			return obj.Interfaces(), nil
		},
		nil,
		ec.marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext___Type_interfaces(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__Type",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "kind":
				return ec.fieldContext___Type_kind(ctx, field)
			case "name":
				return ec.fieldContext___Type_name(ctx, field)
			case "description":
				return ec.fieldContext___Type_description(ctx, field)
			case "specifiedByURL":
				return ec.fieldContext___Type_specifiedByURL(ctx, field)
			case "fields":
				return ec.fieldContext___Type_fields(ctx, field)
			case "interfaces":
				return ec.fieldContext___Type_interfaces(ctx, field)
			case "possibleTypes":
				return ec.fieldContext___Type_possibleTypes(ctx, field)
			case "enumValues":
				return ec.fieldContext___Type_enumValues(ctx, field)
			case "inputFields":
				return ec.fieldContext___Type_inputFields(ctx, field)
			case "ofType":
				return ec.fieldContext___Type_ofType(ctx, field)
			case "isOneOf":
				return ec.fieldContext___Type_isOneOf(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext___Type_possibleTypes,
		func(ctx context.Context) (any, error) {
			return obj.PossibleTypes(), nil
		},
		nil,
		ec.marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext___Type_possibleTypes(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__Type",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "kind":
				return ec.fieldContext___Type_kind(ctx, field)
			case "name":
				return ec.fieldContext___Type_name(ctx, field)
			case "description":
				return ec.fieldContext___Type_description(ctx, field)
			case "specifiedByURL":
				return ec.fieldContext___Type_specifiedByURL(ctx, field)
			case "fields":
				return ec.fieldContext___Type_fields(ctx, field)
			case "interfaces":
				return ec.fieldContext___Type_interfaces(ctx, field)
			case "possibleTypes":
				return ec.fieldContext___Type_possibleTypes(ctx, field)
			case "enumValues":
				return ec.fieldContext___Type_enumValues(ctx, field)
			case "inputFields":
				return ec.fieldContext___Type_inputFields(ctx, field)
			case "ofType":
				return ec.fieldContext___Type_ofType(ctx, field)
			case "isOneOf":
				return ec.fieldContext___Type_isOneOf(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext___Type_enumValues,
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return obj.EnumValues(fc.Args["includeDeprecated"].(bool)), nil
		},
		nil,
		ec.marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValueᚄ,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext___Type_enumValues(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__Type",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "name":
				return ec.fieldContext___EnumValue_name(ctx, field)
			case "description":
				return ec.fieldContext___EnumValue_description(ctx, field)
			case "isDeprecated":
				return ec.fieldContext___EnumValue_isDeprecated(ctx, field)
			case "deprecationReason":
				return ec.fieldContext___EnumValue_deprecationReason(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type __EnumValue", field.Name)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field___Type_enumValues_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext___Type_inputFields,
		func(ctx context.Context) (any, error) {
			return obj.InputFields(), nil
		},
		nil,
		ec.marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext___Type_inputFields(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__Type",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "name":
				return ec.fieldContext___InputValue_name(ctx, field)
			case "description":
				return ec.fieldContext___InputValue_description(ctx, field)
			case "type":
				return ec.fieldContext___InputValue_type(ctx, field)
			case "defaultValue":
				return ec.fieldContext___InputValue_defaultValue(ctx, field)
			case "isDeprecated":
				return ec.fieldContext___InputValue_isDeprecated(ctx, field)
			case "deprecationReason":
				return ec.fieldContext___InputValue_deprecationReason(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type __InputValue", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) ___Type_ofType(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext___Type_ofType,
		func(ctx context.Context) (any, error) {
			return obj.OfType(), nil
		},
		nil,
		ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext___Type_ofType(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__Type",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "kind":
				return ec.fieldContext___Type_kind(ctx, field)
			case "name":
				return ec.fieldContext___Type_name(ctx, field)
			case "description":
				return ec.fieldContext___Type_description(ctx, field)
			case "specifiedByURL":
				return ec.fieldContext___Type_specifiedByURL(ctx, field)
			case "fields":
				return ec.fieldContext___Type_fields(ctx, field)
			case "interfaces":
				return ec.fieldContext___Type_interfaces(ctx, field)
			case "possibleTypes":
				return ec.fieldContext___Type_possibleTypes(ctx, field)
			case "enumValues":
				return ec.fieldContext___Type_enumValues(ctx, field)
			case "inputFields":
				return ec.fieldContext___Type_inputFields(ctx, field)
			case "ofType":
				return ec.fieldContext___Type_ofType(ctx, field)
			case "isOneOf":
				return ec.fieldContext___Type_isOneOf(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) ___Type_isOneOf(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext___Type_isOneOf,
		func(ctx context.Context) (any, error) {
			return obj.IsOneOf(), nil
		},
		nil,
		ec.marshalOBoolean2bool,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext___Type_isOneOf(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__Type",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Boolean does not have child fields")
		},
	}
	return fc, nil
}

// endregion **************************** field.gotpl *****************************

// region    **************************** input.gotpl *****************************

func (ec *executionContext) unmarshalInputAcceptInvitationInput(ctx context.Context, obj any) (types.AcceptInvitationInput, error) {
	var it types.AcceptInvitationInput
	asMap := map[string]any{}
	for k, v := range obj.(map[string]any) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"invitationId"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "invitationId":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("invitationId"))
			data, err := ec.unmarshalNID2goᚗproboᚗincᚋproboᚋpkgᚋgidᚐGID(ctx, v)
			if err != nil {
				return it, err
			}
			it.InvitationID = data
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputAssumeOrganizationSessionInput(ctx context.Context, obj any) (types.AssumeOrganizationSessionInput, error) {
	var it types.AssumeOrganizationSessionInput
	asMap := map[string]any{}
	for k, v := range obj.(map[string]any) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"organizationId", "continue"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "organizationId":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("organizationId"))
			data, err := ec.unmarshalNID2goᚗproboᚗincᚋproboᚋpkgᚋgidᚐGID(ctx, v)
			if err != nil {
				return it, err
			}
			it.OrganizationID = data
		case "continue":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("continue"))
			data, err := ec.unmarshalNString2string(ctx, v)
			if err != nil {
				return it, err
			}
			it.Continue = data
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputChangeEmailInput(ctx context.Context, obj any) (types.ChangeEmailInput, error) {
	var it types.ChangeEmailInput
	asMap := map[string]any{}
	for k, v := range obj.(map[string]any) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"newEmail", "password"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "newEmail":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("newEmail"))
			data, err := ec.unmarshalNEmailAddr2goᚗproboᚗincᚋproboᚋpkgᚋmailᚐAddr(ctx, v)
			if err != nil {
				return it, err
			}
			it.NewEmail = data
		case "password":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("password"))
			data, err := ec.unmarshalNString2string(ctx, v)
			if err != nil {
				return it, err
			}
			it.Password = data
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputChangePasswordInput(ctx context.Context, obj any) (types.ChangePasswordInput, error) {
	var it types.ChangePasswordInput
	asMap := map[string]any{}
	for k, v := range obj.(map[string]any) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"currentPassword", "newPassword"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "currentPassword":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("currentPassword"))
			data, err := ec.unmarshalNString2string(ctx, v)
			if err != nil {
				return it, err
			}
			it.CurrentPassword = data
		case "newPassword":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("newPassword"))
			data, err := ec.unmarshalNString2string(ctx, v)
			if err != nil {
				return it, err
			}
			it.NewPassword = data
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputCreateOrganizationInput(ctx context.Context, obj any) (types.CreateOrganizationInput, error) {
	var it types.CreateOrganizationInput
	asMap := map[string]any{}
	for k, v := range obj.(map[string]any) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"name", "logoFile", "horizontalLogoFile"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "name":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name"))
			data, err := ec.unmarshalNString2string(ctx, v)
			if err != nil {
				return it, err
			}
			it.Name = data
		case "logoFile":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("logoFile"))
			data, err := ec.unmarshalOUpload2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚐUpload(ctx, v)
			if err != nil {
				return it, err
			}
			it.LogoFile = data
		case "horizontalLogoFile":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("horizontalLogoFile"))
			data, err := ec.unmarshalOUpload2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚐUpload(ctx, v)
			if err != nil {
				return it, err
			}
			it.HorizontalLogoFile = data
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputCreatePersonalAPIKeyInput(ctx context.Context, obj any) (types.CreatePersonalAPIKeyInput, error) {
	var it types.CreatePersonalAPIKeyInput
	asMap := map[string]any{}
	for k, v := range obj.(map[string]any) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"name", "expiresAt"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "name":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name"))
			data, err := ec.unmarshalNString2string(ctx, v)
			if err != nil {
				return it, err
			}
			it.Name = data
		case "expiresAt":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("expiresAt"))
			data, err := ec.unmarshalNDatetime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
			it.ExpiresAt = data
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputCreateSAMLConfigurationInput(ctx context.Context, obj any) (types.CreateSAMLConfigurationInput, error) {
	var it types.CreateSAMLConfigurationInput
	asMap := map[string]any{}
	for k, v := range obj.(map[string]any) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"organizationId", "emailDomain", "idpEntityId", "idpSsoUrl", "idpCertificate", "autoSignupEnabled", "attributeMappings"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "organizationId":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("organizationId"))
			data, err := ec.unmarshalNID2goᚗproboᚗincᚋproboᚋpkgᚋgidᚐGID(ctx, v)
			if err != nil {
				return it, err
			}
			it.OrganizationID = data
		case "emailDomain":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("emailDomain"))
			data, err := ec.unmarshalNString2string(ctx, v)
			if err != nil {
				return it, err
			}
			it.EmailDomain = data
		case "idpEntityId":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idpEntityId"))
			data, err := ec.unmarshalNString2string(ctx, v)
			if err != nil {
				return it, err
			}
			it.IdpEntityID = data
		case "idpSsoUrl":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idpSsoUrl"))
			data, err := ec.unmarshalNString2string(ctx, v)
			if err != nil {
				return it, err
			}
			it.IdpSsoURL = data
		case "idpCertificate":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idpCertificate"))
			data, err := ec.unmarshalNString2string(ctx, v)
			if err != nil {
				return it, err
			}
			it.IdpCertificate = data
		case "autoSignupEnabled":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("autoSignupEnabled"))
			data, err := ec.unmarshalNBoolean2bool(ctx, v)
			if err != nil {
				return it, err
			}
			it.AutoSignupEnabled = data
		case "attributeMappings":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("attributeMappings"))
			data, err := ec.unmarshalOSAMLAttributeMappingsInput2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐSAMLAttributeMappingsInput(ctx, v)
			if err != nil {
				return it, err
			}
			it.AttributeMappings = data
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputCreateSCIMConfigurationInput(ctx context.Context, obj any) (types.CreateSCIMConfigurationInput, error) {
	var it types.CreateSCIMConfigurationInput
	asMap := map[string]any{}
	for k, v := range obj.(map[string]any) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"organizationId", "connectorId"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "organizationId":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("organizationId"))
			data, err := ec.unmarshalNID2goᚗproboᚗincᚋproboᚋpkgᚋgidᚐGID(ctx, v)
			if err != nil {
				return it, err
			}
			it.OrganizationID = data
		case "connectorId":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("connectorId"))
			data, err := ec.unmarshalOID2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋgidᚐGID(ctx, v)
			if err != nil {
				return it, err
			}
			it.ConnectorID = data
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputDeleteInvitationInput(ctx context.Context, obj any) (types.DeleteInvitationInput, error) {
	var it types.DeleteInvitationInput
	asMap := map[string]any{}
	for k, v := range obj.(map[string]any) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"organizationId", "invitationId"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "organizationId":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("organizationId"))
			data, err := ec.unmarshalNID2goᚗproboᚗincᚋproboᚋpkgᚋgidᚐGID(ctx, v)
			if err != nil {
				return it, err
			}
			it.OrganizationID = data
		case "invitationId":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("invitationId"))
			data, err := ec.unmarshalNID2goᚗproboᚗincᚋproboᚋpkgᚋgidᚐGID(ctx, v)
			if err != nil {
				return it, err
			}
			it.InvitationID = data
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputDeleteOrganizationHorizontalLogoInput(ctx context.Context, obj any) (types.DeleteOrganizationHorizontalLogoInput, error) {
	var it types.DeleteOrganizationHorizontalLogoInput
	asMap := map[string]any{}
	for k, v := range obj.(map[string]any) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"organizationId"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "organizationId":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("organizationId"))
			data, err := ec.unmarshalNID2goᚗproboᚗincᚋproboᚋpkgᚋgidᚐGID(ctx, v)
			if err != nil {
				return it, err
			}
			it.OrganizationID = data
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputDeleteOrganizationInput(ctx context.Context, obj any) (types.DeleteOrganizationInput, error) {
	var it types.DeleteOrganizationInput
	asMap := map[string]any{}
	for k, v := range obj.(map[string]any) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"organizationId"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "organizationId":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("organizationId"))
			data, err := ec.unmarshalNID2goᚗproboᚗincᚋproboᚋpkgᚋgidᚐGID(ctx, v)
			if err != nil {
				return it, err
			}
			it.OrganizationID = data
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputDeleteSAMLConfigurationInput(ctx context.Context, obj any) (types.DeleteSAMLConfigurationInput, error) {
	var it types.DeleteSAMLConfigurationInput
	asMap := map[string]any{}
	for k, v := range obj.(map[string]any) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"organizationId", "samlConfigurationId"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "organizationId":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("organizationId"))
			data, err := ec.unmarshalNID2goᚗproboᚗincᚋproboᚋpkgᚋgidᚐGID(ctx, v)
			if err != nil {
				return it, err
			}
			it.OrganizationID = data
		case "samlConfigurationId":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("samlConfigurationId"))
			data, err := ec.unmarshalNID2goᚗproboᚗincᚋproboᚋpkgᚋgidᚐGID(ctx, v)
			if err != nil {
				return it, err
			}
			it.SamlConfigurationID = data
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputDeleteSCIMConfigurationInput(ctx context.Context, obj any) (types.DeleteSCIMConfigurationInput, error) {
	var it types.DeleteSCIMConfigurationInput
	asMap := map[string]any{}
	for k, v := range obj.(map[string]any) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"organizationId", "scimConfigurationId"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "organizationId":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("organizationId"))
			data, err := ec.unmarshalNID2goᚗproboᚗincᚋproboᚋpkgᚋgidᚐGID(ctx, v)
			if err != nil {
				return it, err
			}
			it.OrganizationID = data
		case "scimConfigurationId":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scimConfigurationId"))
			data, err := ec.unmarshalNID2goᚗproboᚗincᚋproboᚋpkgᚋgidᚐGID(ctx, v)
			if err != nil {
				return it, err
			}
			it.ScimConfigurationID = data
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputForgotPasswordInput(ctx context.Context, obj any) (types.ForgotPasswordInput, error) {
	var it types.ForgotPasswordInput
	asMap := map[string]any{}
	for k, v := range obj.(map[string]any) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"email"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "email":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("email"))
			data, err := ec.unmarshalNEmailAddr2goᚗproboᚗincᚋproboᚋpkgᚋmailᚐAddr(ctx, v)
			if err != nil {
				return it, err
			}
			it.Email = data
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputInvitationOrder(ctx context.Context, obj any) (types.InvitationOrderBy, error) {
	var it types.InvitationOrderBy
	asMap := map[string]any{}
	for k, v := range obj.(map[string]any) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"direction", "field"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "direction":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("direction"))
			data, err := ec.unmarshalNOrderDirection2goᚗproboᚗincᚋproboᚋpkgᚋpageᚐOrderDirection(ctx, v)
			if err != nil {
				return it, err
			}
			it.Direction = data
		case "field":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("field"))
			data, err := ec.unmarshalNInvitationOrderField2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐInvitationOrderField(ctx, v)
			if err != nil {
				return it, err
			}
			it.Field = data
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputInviteMemberInput(ctx context.Context, obj any) (types.InviteMemberInput, error) {
	var it types.InviteMemberInput
	asMap := map[string]any{}
	for k, v := range obj.(map[string]any) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"organizationId", "email", "fullName", "role"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "organizationId":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("organizationId"))
			data, err := ec.unmarshalNID2goᚗproboᚗincᚋproboᚋpkgᚋgidᚐGID(ctx, v)
			if err != nil {
				return it, err
			}
			it.OrganizationID = data
		case "email":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("email"))
			data, err := ec.unmarshalNEmailAddr2goᚗproboᚗincᚋproboᚋpkgᚋmailᚐAddr(ctx, v)
			if err != nil {
				return it, err
			}
			it.Email = data
		case "fullName":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("fullName"))
			data, err := ec.unmarshalNString2string(ctx, v)
			if err != nil {
				return it, err
			}
			it.FullName = data
		case "role":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("role"))
			data, err := ec.unmarshalNMembershipRole2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐMembershipRole(ctx, v)
			if err != nil {
				return it, err
			}
			it.Role = data
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputMembershipOrder(ctx context.Context, obj any) (types.MembershipOrderBy, error) {
	var it types.MembershipOrderBy
	asMap := map[string]any{}
	for k, v := range obj.(map[string]any) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"direction", "field"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "direction":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("direction"))
			data, err := ec.unmarshalNOrderDirection2goᚗproboᚗincᚋproboᚋpkgᚋpageᚐOrderDirection(ctx, v)
			if err != nil {
				return it, err
			}
			it.Direction = data
		case "field":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("field"))
			data, err := ec.unmarshalNMembershipOrderField2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐMembershipOrderField(ctx, v)
			if err != nil {
				return it, err
			}
			it.Field = data
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputRegenerateSCIMTokenInput(ctx context.Context, obj any) (types.RegenerateSCIMTokenInput, error) {
	var it types.RegenerateSCIMTokenInput
	asMap := map[string]any{}
	for k, v := range obj.(map[string]any) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"organizationId", "scimConfigurationId"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "organizationId":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("organizationId"))
			data, err := ec.unmarshalNID2goᚗproboᚗincᚋproboᚋpkgᚋgidᚐGID(ctx, v)
			if err != nil {
				return it, err
			}
			it.OrganizationID = data
		case "scimConfigurationId":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scimConfigurationId"))
			data, err := ec.unmarshalNID2goᚗproboᚗincᚋproboᚋpkgᚋgidᚐGID(ctx, v)
			if err != nil {
				return it, err
			}
			it.ScimConfigurationID = data
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputRemoveMemberInput(ctx context.Context, obj any) (types.RemoveMemberInput, error) {
	var it types.RemoveMemberInput
	asMap := map[string]any{}
	for k, v := range obj.(map[string]any) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"organizationId", "membershipId"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "organizationId":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("organizationId"))
			data, err := ec.unmarshalNID2goᚗproboᚗincᚋproboᚋpkgᚋgidᚐGID(ctx, v)
			if err != nil {
				return it, err
			}
			it.OrganizationID = data
		case "membershipId":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("membershipId"))
			data, err := ec.unmarshalNID2goᚗproboᚗincᚋproboᚋpkgᚋgidᚐGID(ctx, v)
			if err != nil {
				return it, err
			}
			it.MembershipID = data
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputResetPasswordInput(ctx context.Context, obj any) (types.ResetPasswordInput, error) {
	var it types.ResetPasswordInput
	asMap := map[string]any{}
	for k, v := range obj.(map[string]any) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"token", "password"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "token":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("token"))
			data, err := ec.unmarshalNString2string(ctx, v)
			if err != nil {
				return it, err
			}
			it.Token = data
		case "password":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("password"))
			data, err := ec.unmarshalNString2string(ctx, v)
			if err != nil {
				return it, err
			}
			it.Password = data
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputRevokePersonalAPIKeyInput(ctx context.Context, obj any) (types.RevokePersonalAPIKeyInput, error) {
	var it types.RevokePersonalAPIKeyInput
	asMap := map[string]any{}
	for k, v := range obj.(map[string]any) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"personalAPIKeyId"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "personalAPIKeyId":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("personalAPIKeyId"))
			data, err := ec.unmarshalNID2goᚗproboᚗincᚋproboᚋpkgᚋgidᚐGID(ctx, v)
			if err != nil {
				return it, err
			}
			it.PersonalAPIKeyID = data
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputRevokeSessionInput(ctx context.Context, obj any) (types.RevokeSessionInput, error) {
	var it types.RevokeSessionInput
	asMap := map[string]any{}
	for k, v := range obj.(map[string]any) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"sessionId"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "sessionId":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("sessionId"))
			data, err := ec.unmarshalNID2goᚗproboᚗincᚋproboᚋpkgᚋgidᚐGID(ctx, v)
			if err != nil {
				return it, err
			}
			it.SessionID = data
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputSAMLAttributeMappingsInput(ctx context.Context, obj any) (types.SAMLAttributeMappingsInput, error) {
	var it types.SAMLAttributeMappingsInput
	asMap := map[string]any{}
	for k, v := range obj.(map[string]any) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"email", "firstName", "lastName", "role"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "email":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("email"))
			data, err := ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
			it.Email = data
		case "firstName":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("firstName"))
			data, err := ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
			it.FirstName = data
		case "lastName":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("lastName"))
			data, err := ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
			it.LastName = data
		case "role":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("role"))
			data, err := ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
			it.Role = data
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputSCIMEventOrder(ctx context.Context, obj any) (types.SCIMEventOrderBy, error) {
	var it types.SCIMEventOrderBy
	asMap := map[string]any{}
	for k, v := range obj.(map[string]any) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"direction", "field"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "direction":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("direction"))
			data, err := ec.unmarshalNOrderDirection2goᚗproboᚗincᚋproboᚋpkgᚋpageᚐOrderDirection(ctx, v)
			if err != nil {
				return it, err
			}
			it.Direction = data
		case "field":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("field"))
			data, err := ec.unmarshalNSCIMEventOrderField2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐSCIMEventOrderField(ctx, v)
			if err != nil {
				return it, err
			}
			it.Field = data
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputSessionOrder(ctx context.Context, obj any) (types.SessionOrder, error) {
	var it types.SessionOrder
	asMap := map[string]any{}
	for k, v := range obj.(map[string]any) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"direction", "field"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "direction":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("direction"))
			data, err := ec.unmarshalNOrderDirection2goᚗproboᚗincᚋproboᚋpkgᚋpageᚐOrderDirection(ctx, v)
			if err != nil {
				return it, err
			}
			it.Direction = data
		case "field":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("field"))
			data, err := ec.unmarshalNSessionOrderField2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐSessionOrderField(ctx, v)
			if err != nil {
				return it, err
			}
			it.Field = data
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputSignInInput(ctx context.Context, obj any) (types.SignInInput, error) {
	var it types.SignInInput
	asMap := map[string]any{}
	for k, v := range obj.(map[string]any) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"organizationId", "email", "password"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "organizationId":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("organizationId"))
			data, err := ec.unmarshalOID2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋgidᚐGID(ctx, v)
			if err != nil {
				return it, err
			}
			it.OrganizationID = data
		case "email":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("email"))
			data, err := ec.unmarshalNEmailAddr2goᚗproboᚗincᚋproboᚋpkgᚋmailᚐAddr(ctx, v)
			if err != nil {
				return it, err
			}
			it.Email = data
		case "password":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("password"))
			data, err := ec.unmarshalNString2string(ctx, v)
			if err != nil {
				return it, err
			}
			it.Password = data
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputSignUpFromInvitationInput(ctx context.Context, obj any) (types.SignUpFromInvitationInput, error) {
	var it types.SignUpFromInvitationInput
	asMap := map[string]any{}
	for k, v := range obj.(map[string]any) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"token", "password", "fullName"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "token":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("token"))
			data, err := ec.unmarshalNString2string(ctx, v)
			if err != nil {
				return it, err
			}
			it.Token = data
		case "password":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("password"))
			data, err := ec.unmarshalNString2string(ctx, v)
			if err != nil {
				return it, err
			}
			it.Password = data
		case "fullName":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("fullName"))
			data, err := ec.unmarshalNString2string(ctx, v)
			if err != nil {
				return it, err
			}
			it.FullName = data
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputSignUpInput(ctx context.Context, obj any) (types.SignUpInput, error) {
	var it types.SignUpInput
	asMap := map[string]any{}
	for k, v := range obj.(map[string]any) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"email", "password", "fullName"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "email":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("email"))
			data, err := ec.unmarshalNEmailAddr2goᚗproboᚗincᚋproboᚋpkgᚋmailᚐAddr(ctx, v)
			if err != nil {
				return it, err
			}
			it.Email = data
		case "password":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("password"))
			data, err := ec.unmarshalNString2string(ctx, v)
			if err != nil {
				return it, err
			}
			it.Password = data
		case "fullName":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("fullName"))
			data, err := ec.unmarshalNString2string(ctx, v)
			if err != nil {
				return it, err
			}
			it.FullName = data
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputUpdateMembershipInput(ctx context.Context, obj any) (types.UpdateMembershipInput, error) {
	var it types.UpdateMembershipInput
	asMap := map[string]any{}
	for k, v := range obj.(map[string]any) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"organizationId", "membershipId", "role"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "organizationId":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("organizationId"))
			data, err := ec.unmarshalNID2goᚗproboᚗincᚋproboᚋpkgᚋgidᚐGID(ctx, v)
			if err != nil {
				return it, err
			}
			it.OrganizationID = data
		case "membershipId":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("membershipId"))
			data, err := ec.unmarshalNID2goᚗproboᚗincᚋproboᚋpkgᚋgidᚐGID(ctx, v)
			if err != nil {
				return it, err
			}
			it.MembershipID = data
		case "role":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("role"))
			data, err := ec.unmarshalNMembershipRole2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐMembershipRole(ctx, v)
			if err != nil {
				return it, err
			}
			it.Role = data
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputUpdateOrganizationInput(ctx context.Context, obj any) (types.UpdateOrganizationInput, error) {
	var it types.UpdateOrganizationInput
	asMap := map[string]any{}
	for k, v := range obj.(map[string]any) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"organizationId", "name", "logoFile", "horizontalLogoFile", "description", "websiteUrl", "email", "headquarterAddress"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "organizationId":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("organizationId"))
			data, err := ec.unmarshalNID2goᚗproboᚗincᚋproboᚋpkgᚋgidᚐGID(ctx, v)
			if err != nil {
				return it, err
			}
			it.OrganizationID = data
		case "name":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name"))
			data, err := ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
			it.Name = data
		case "logoFile":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("logoFile"))
			data, err := ec.unmarshalOUpload2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚐUpload(ctx, v)
			if err != nil {
				return it, err
			}
			it.LogoFile = data
		case "horizontalLogoFile":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("horizontalLogoFile"))
			data, err := ec.unmarshalOUpload2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚐUpload(ctx, v)
			if err != nil {
				return it, err
			}
			it.HorizontalLogoFile = data
		case "description":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("description"))
			data, err := ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
			it.Description = graphql.OmittableOf(data)
		case "websiteUrl":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("websiteUrl"))
			data, err := ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
			it.WebsiteURL = graphql.OmittableOf(data)
		case "email":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("email"))
			data, err := ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
			it.Email = graphql.OmittableOf(data)
		case "headquarterAddress":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("headquarterAddress"))
			data, err := ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
			it.HeadquarterAddress = graphql.OmittableOf(data)
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputUpdateProfileInput(ctx context.Context, obj any) (types.UpdateProfileInput, error) {
	var it types.UpdateProfileInput
	asMap := map[string]any{}
	for k, v := range obj.(map[string]any) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"id", "fullName", "additionalEmailAddresses", "kind", "position", "contractStartDate", "contractEndDate"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "id":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
			data, err := ec.unmarshalNID2goᚗproboᚗincᚋproboᚋpkgᚋgidᚐGID(ctx, v)
			if err != nil {
				return it, err
			}
			it.ID = data
		case "fullName":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("fullName"))
			data, err := ec.unmarshalNString2string(ctx, v)
			if err != nil {
				return it, err
			}
			it.FullName = data
		case "additionalEmailAddresses":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("additionalEmailAddresses"))
			data, err := ec.unmarshalOEmailAddr2ᚕgoᚗproboᚗincᚋproboᚋpkgᚋmailᚐAddrᚄ(ctx, v)
			if err != nil {
				return it, err
			}
			it.AdditionalEmailAddresses = data
		case "kind":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("kind"))
			data, err := ec.unmarshalNProfileKind2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐMembershipProfileKind(ctx, v)
			if err != nil {
				return it, err
			}
			it.Kind = data
		case "position":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("position"))
			data, err := ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
			it.Position = graphql.OmittableOf(data)
		case "contractStartDate":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("contractStartDate"))
			data, err := ec.unmarshalODatetime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
			it.ContractStartDate = graphql.OmittableOf(data)
		case "contractEndDate":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("contractEndDate"))
			data, err := ec.unmarshalODatetime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
			it.ContractEndDate = graphql.OmittableOf(data)
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputUpdateSAMLConfigurationInput(ctx context.Context, obj any) (types.UpdateSAMLConfigurationInput, error) {
	var it types.UpdateSAMLConfigurationInput
	asMap := map[string]any{}
	for k, v := range obj.(map[string]any) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"organizationId", "samlConfigurationId", "idpEntityId", "idpSsoUrl", "idpCertificate", "autoSignupEnabled", "enforcementPolicy", "attributeMappings"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "organizationId":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("organizationId"))
			data, err := ec.unmarshalNID2goᚗproboᚗincᚋproboᚋpkgᚋgidᚐGID(ctx, v)
			if err != nil {
				return it, err
			}
			it.OrganizationID = data
		case "samlConfigurationId":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("samlConfigurationId"))
			data, err := ec.unmarshalNID2goᚗproboᚗincᚋproboᚋpkgᚋgidᚐGID(ctx, v)
			if err != nil {
				return it, err
			}
			it.SamlConfigurationID = data
		case "idpEntityId":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idpEntityId"))
			data, err := ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
			it.IdpEntityID = data
		case "idpSsoUrl":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idpSsoUrl"))
			data, err := ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
			it.IdpSsoURL = data
		case "idpCertificate":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idpCertificate"))
			data, err := ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
			it.IdpCertificate = data
		case "autoSignupEnabled":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("autoSignupEnabled"))
			data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v)
			if err != nil {
				return it, err
			}
			it.AutoSignupEnabled = data
		case "enforcementPolicy":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("enforcementPolicy"))
			data, err := ec.unmarshalNSAMLEnforcementPolicy2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐSAMLEnforcementPolicy(ctx, v)
			if err != nil {
				return it, err
			}
			it.EnforcementPolicy = data
		case "attributeMappings":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("attributeMappings"))
			data, err := ec.unmarshalOSAMLAttributeMappingsInput2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐSAMLAttributeMappingsInput(ctx, v)
			if err != nil {
				return it, err
			}
			it.AttributeMappings = data
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputUpdateSCIMBridgeInput(ctx context.Context, obj any) (types.UpdateSCIMBridgeInput, error) {
	var it types.UpdateSCIMBridgeInput
	asMap := map[string]any{}
	for k, v := range obj.(map[string]any) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"organizationId", "scimBridgeId", "excludedUserNames"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "organizationId":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("organizationId"))
			data, err := ec.unmarshalNID2goᚗproboᚗincᚋproboᚋpkgᚋgidᚐGID(ctx, v)
			if err != nil {
				return it, err
			}
			it.OrganizationID = data
		case "scimBridgeId":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scimBridgeId"))
			data, err := ec.unmarshalNID2goᚗproboᚗincᚋproboᚋpkgᚋgidᚐGID(ctx, v)
			if err != nil {
				return it, err
			}
			it.ScimBridgeID = data
		case "excludedUserNames":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("excludedUserNames"))
			data, err := ec.unmarshalNString2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
			it.ExcludedUserNames = data
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputVerifyEmailInput(ctx context.Context, obj any) (types.VerifyEmailInput, error) {
	var it types.VerifyEmailInput
	asMap := map[string]any{}
	for k, v := range obj.(map[string]any) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"token"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "token":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("token"))
			data, err := ec.unmarshalNString2string(ctx, v)
			if err != nil {
				return it, err
			}
			it.Token = data
		}
	}

	return it, nil
}

// endregion **************************** input.gotpl *****************************

// region    ************************** interface.gotpl ***************************

func (ec *executionContext) _AssumeOrganizationSessionResult(ctx context.Context, sel ast.SelectionSet, obj types.AssumeOrganizationSessionResult) graphql.Marshaler {
	switch obj := (obj).(type) {
	case nil:
		return graphql.Null
	case types.SAMLAuthenticationRequired:
		return ec._SAMLAuthenticationRequired(ctx, sel, &obj)
	case *types.SAMLAuthenticationRequired:
		if obj == nil {
			return graphql.Null
		}
		return ec._SAMLAuthenticationRequired(ctx, sel, obj)
	case types.PasswordRequired:
		return ec._PasswordRequired(ctx, sel, &obj)
	case *types.PasswordRequired:
		if obj == nil {
			return graphql.Null
		}
		return ec._PasswordRequired(ctx, sel, obj)
	case types.OrganizationSessionCreated:
		return ec._OrganizationSessionCreated(ctx, sel, &obj)
	case *types.OrganizationSessionCreated:
		if obj == nil {
			return graphql.Null
		}
		return ec._OrganizationSessionCreated(ctx, sel, obj)
	default:
		if typedObj, ok := obj.(graphql.Marshaler); ok {
			return typedObj
		} else {
			panic(fmt.Errorf("unexpected type %T; non-generated variants of AssumeOrganizationSessionResult must implement graphql.Marshaler", obj))
		}
	}
}

func (ec *executionContext) _Node(ctx context.Context, sel ast.SelectionSet, obj types.Node) graphql.Marshaler {
	switch obj := (obj).(type) {
	case nil:
		return graphql.Null
	case types.Session:
		return ec._Session(ctx, sel, &obj)
	case *types.Session:
		if obj == nil {
			return graphql.Null
		}
		return ec._Session(ctx, sel, obj)
	case types.SCIMEvent:
		return ec._SCIMEvent(ctx, sel, &obj)
	case *types.SCIMEvent:
		if obj == nil {
			return graphql.Null
		}
		return ec._SCIMEvent(ctx, sel, obj)
	case types.SCIMConfiguration:
		return ec._SCIMConfiguration(ctx, sel, &obj)
	case *types.SCIMConfiguration:
		if obj == nil {
			return graphql.Null
		}
		return ec._SCIMConfiguration(ctx, sel, obj)
	case types.SCIMBridge:
		return ec._SCIMBridge(ctx, sel, &obj)
	case *types.SCIMBridge:
		if obj == nil {
			return graphql.Null
		}
		return ec._SCIMBridge(ctx, sel, obj)
	case types.SAMLConfiguration:
		return ec._SAMLConfiguration(ctx, sel, &obj)
	case *types.SAMLConfiguration:
		if obj == nil {
			return graphql.Null
		}
		return ec._SAMLConfiguration(ctx, sel, obj)
	case types.PersonalAPIKey:
		return ec._PersonalAPIKey(ctx, sel, &obj)
	case *types.PersonalAPIKey:
		if obj == nil {
			return graphql.Null
		}
		return ec._PersonalAPIKey(ctx, sel, obj)
	case types.Organization:
		return ec._Organization(ctx, sel, &obj)
	case *types.Organization:
		if obj == nil {
			return graphql.Null
		}
		return ec._Organization(ctx, sel, obj)
	case types.MembershipProfile:
		return ec._MembershipProfile(ctx, sel, &obj)
	case *types.MembershipProfile:
		if obj == nil {
			return graphql.Null
		}
		return ec._MembershipProfile(ctx, sel, obj)
	case types.Membership:
		return ec._Membership(ctx, sel, &obj)
	case *types.Membership:
		if obj == nil {
			return graphql.Null
		}
		return ec._Membership(ctx, sel, obj)
	case types.Invitation:
		return ec._Invitation(ctx, sel, &obj)
	case *types.Invitation:
		if obj == nil {
			return graphql.Null
		}
		return ec._Invitation(ctx, sel, obj)
	case types.Identity:
		return ec._Identity(ctx, sel, &obj)
	case *types.Identity:
		if obj == nil {
			return graphql.Null
		}
		return ec._Identity(ctx, sel, obj)
	case types.Connector:
		return ec._Connector(ctx, sel, &obj)
	case *types.Connector:
		if obj == nil {
			return graphql.Null
		}
		return ec._Connector(ctx, sel, obj)
	default:
		if typedObj, ok := obj.(graphql.Marshaler); ok {
			return typedObj
		} else {
			panic(fmt.Errorf("unexpected type %T; non-generated variants of Node must implement graphql.Marshaler", obj))
		}
	}
}

// endregion ************************** interface.gotpl ***************************

// region    **************************** object.gotpl ****************************

var acceptInvitationPayloadImplementors = []string{"AcceptInvitationPayload"}

func (ec *executionContext) _AcceptInvitationPayload(ctx context.Context, sel ast.SelectionSet, obj *types.AcceptInvitationPayload) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, acceptInvitationPayloadImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("AcceptInvitationPayload")
		case "membershipEdge":
			out.Values[i] = ec._AcceptInvitationPayload_membershipEdge(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "invitation":
			out.Values[i] = ec._AcceptInvitationPayload_invitation(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var assumeOrganizationSessionPayloadImplementors = []string{"AssumeOrganizationSessionPayload"}

func (ec *executionContext) _AssumeOrganizationSessionPayload(ctx context.Context, sel ast.SelectionSet, obj *types.AssumeOrganizationSessionPayload) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, assumeOrganizationSessionPayloadImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("AssumeOrganizationSessionPayload")
		case "result":
			out.Values[i] = ec._AssumeOrganizationSessionPayload_result(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var changeEmailPayloadImplementors = []string{"ChangeEmailPayload"}

func (ec *executionContext) _ChangeEmailPayload(ctx context.Context, sel ast.SelectionSet, obj *types.ChangeEmailPayload) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, changeEmailPayloadImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("ChangeEmailPayload")
		case "success":
			out.Values[i] = ec._ChangeEmailPayload_success(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var changePasswordPayloadImplementors = []string{"ChangePasswordPayload"}

func (ec *executionContext) _ChangePasswordPayload(ctx context.Context, sel ast.SelectionSet, obj *types.ChangePasswordPayload) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, changePasswordPayloadImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("ChangePasswordPayload")
		case "success":
			out.Values[i] = ec._ChangePasswordPayload_success(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var connectorImplementors = []string{"Connector", "Node"}

func (ec *executionContext) _Connector(ctx context.Context, sel ast.SelectionSet, obj *types.Connector) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, connectorImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("Connector")
		case "id":
			out.Values[i] = ec._Connector_id(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "provider":
			out.Values[i] = ec._Connector_provider(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "createdAt":
			out.Values[i] = ec._Connector_createdAt(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "updatedAt":
			out.Values[i] = ec._Connector_updatedAt(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "permission":
			field := field

			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Connector_permission(ctx, field, obj)
				if res == graphql.Null {
					atomic.AddUint32(&fs.Invalids, 1)
				}
				return res
			}

			if field.Deferrable != nil {
				dfs, ok := deferred[field.Deferrable.Label]
				di := 0
				if ok {
					dfs.AddField(field)
					di = len(dfs.Values) - 1
				} else {
					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
					deferred[field.Deferrable.Label] = dfs
				}
				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
					return innerFunc(ctx, dfs)
				})

				// don't run the out.Concurrently() call below
				out.Values[i] = graphql.Null
				continue
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var createOrganizationPayloadImplementors = []string{"CreateOrganizationPayload"}

func (ec *executionContext) _CreateOrganizationPayload(ctx context.Context, sel ast.SelectionSet, obj *types.CreateOrganizationPayload) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, createOrganizationPayloadImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("CreateOrganizationPayload")
		case "organization":
			out.Values[i] = ec._CreateOrganizationPayload_organization(ctx, field, obj)
		case "membershipEdge":
			out.Values[i] = ec._CreateOrganizationPayload_membershipEdge(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var createPersonalAPIKeyPayloadImplementors = []string{"CreatePersonalAPIKeyPayload"}

func (ec *executionContext) _CreatePersonalAPIKeyPayload(ctx context.Context, sel ast.SelectionSet, obj *types.CreatePersonalAPIKeyPayload) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, createPersonalAPIKeyPayloadImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("CreatePersonalAPIKeyPayload")
		case "personalAPIKeyEdge":
			out.Values[i] = ec._CreatePersonalAPIKeyPayload_personalAPIKeyEdge(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "token":
			out.Values[i] = ec._CreatePersonalAPIKeyPayload_token(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var createSAMLConfigurationPayloadImplementors = []string{"CreateSAMLConfigurationPayload"}

func (ec *executionContext) _CreateSAMLConfigurationPayload(ctx context.Context, sel ast.SelectionSet, obj *types.CreateSAMLConfigurationPayload) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, createSAMLConfigurationPayloadImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("CreateSAMLConfigurationPayload")
		case "samlConfigurationEdge":
			out.Values[i] = ec._CreateSAMLConfigurationPayload_samlConfigurationEdge(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var createSCIMConfigurationPayloadImplementors = []string{"CreateSCIMConfigurationPayload"}

func (ec *executionContext) _CreateSCIMConfigurationPayload(ctx context.Context, sel ast.SelectionSet, obj *types.CreateSCIMConfigurationPayload) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, createSCIMConfigurationPayloadImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("CreateSCIMConfigurationPayload")
		case "scimConfiguration":
			out.Values[i] = ec._CreateSCIMConfigurationPayload_scimConfiguration(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "scimBridge":
			out.Values[i] = ec._CreateSCIMConfigurationPayload_scimBridge(ctx, field, obj)
		case "token":
			out.Values[i] = ec._CreateSCIMConfigurationPayload_token(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var deleteInvitationPayloadImplementors = []string{"DeleteInvitationPayload"}

func (ec *executionContext) _DeleteInvitationPayload(ctx context.Context, sel ast.SelectionSet, obj *types.DeleteInvitationPayload) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, deleteInvitationPayloadImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("DeleteInvitationPayload")
		case "deletedInvitationId":
			out.Values[i] = ec._DeleteInvitationPayload_deletedInvitationId(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var deleteOrganizationHorizontalLogoPayloadImplementors = []string{"DeleteOrganizationHorizontalLogoPayload"}

func (ec *executionContext) _DeleteOrganizationHorizontalLogoPayload(ctx context.Context, sel ast.SelectionSet, obj *types.DeleteOrganizationHorizontalLogoPayload) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, deleteOrganizationHorizontalLogoPayloadImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("DeleteOrganizationHorizontalLogoPayload")
		case "organization":
			out.Values[i] = ec._DeleteOrganizationHorizontalLogoPayload_organization(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var deleteOrganizationPayloadImplementors = []string{"DeleteOrganizationPayload"}

func (ec *executionContext) _DeleteOrganizationPayload(ctx context.Context, sel ast.SelectionSet, obj *types.DeleteOrganizationPayload) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, deleteOrganizationPayloadImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("DeleteOrganizationPayload")
		case "deletedOrganizationId":
			out.Values[i] = ec._DeleteOrganizationPayload_deletedOrganizationId(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var deleteSAMLConfigurationPayloadImplementors = []string{"DeleteSAMLConfigurationPayload"}

func (ec *executionContext) _DeleteSAMLConfigurationPayload(ctx context.Context, sel ast.SelectionSet, obj *types.DeleteSAMLConfigurationPayload) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, deleteSAMLConfigurationPayloadImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("DeleteSAMLConfigurationPayload")
		case "deletedSamlConfigurationId":
			out.Values[i] = ec._DeleteSAMLConfigurationPayload_deletedSamlConfigurationId(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var deleteSCIMConfigurationPayloadImplementors = []string{"DeleteSCIMConfigurationPayload"}

func (ec *executionContext) _DeleteSCIMConfigurationPayload(ctx context.Context, sel ast.SelectionSet, obj *types.DeleteSCIMConfigurationPayload) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, deleteSCIMConfigurationPayloadImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("DeleteSCIMConfigurationPayload")
		case "deletedScimConfigurationId":
			out.Values[i] = ec._DeleteSCIMConfigurationPayload_deletedScimConfigurationId(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var forgotPasswordPayloadImplementors = []string{"ForgotPasswordPayload"}

func (ec *executionContext) _ForgotPasswordPayload(ctx context.Context, sel ast.SelectionSet, obj *types.ForgotPasswordPayload) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, forgotPasswordPayloadImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("ForgotPasswordPayload")
		case "success":
			out.Values[i] = ec._ForgotPasswordPayload_success(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var identityImplementors = []string{"Identity", "Node"}

func (ec *executionContext) _Identity(ctx context.Context, sel ast.SelectionSet, obj *types.Identity) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, identityImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("Identity")
		case "id":
			out.Values[i] = ec._Identity_id(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "email":
			out.Values[i] = ec._Identity_email(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "fullName":
			out.Values[i] = ec._Identity_fullName(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "emailVerified":
			out.Values[i] = ec._Identity_emailVerified(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "createdAt":
			out.Values[i] = ec._Identity_createdAt(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "updatedAt":
			out.Values[i] = ec._Identity_updatedAt(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "memberships":
			field := field

			innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Identity_memberships(ctx, field, obj)
				return res
			}

			if field.Deferrable != nil {
				dfs, ok := deferred[field.Deferrable.Label]
				di := 0
				if ok {
					dfs.AddField(field)
					di = len(dfs.Values) - 1
				} else {
					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
					deferred[field.Deferrable.Label] = dfs
				}
				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
					return innerFunc(ctx, dfs)
				})

				// don't run the out.Concurrently() call below
				out.Values[i] = graphql.Null
				continue
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
		case "pendingInvitations":
			field := field

			innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Identity_pendingInvitations(ctx, field, obj)
				return res
			}

			if field.Deferrable != nil {
				dfs, ok := deferred[field.Deferrable.Label]
				di := 0
				if ok {
					dfs.AddField(field)
					di = len(dfs.Values) - 1
				} else {
					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
					deferred[field.Deferrable.Label] = dfs
				}
				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
					return innerFunc(ctx, dfs)
				})

				// don't run the out.Concurrently() call below
				out.Values[i] = graphql.Null
				continue
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
		case "sessions":
			field := field

			innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Identity_sessions(ctx, field, obj)
				return res
			}

			if field.Deferrable != nil {
				dfs, ok := deferred[field.Deferrable.Label]
				di := 0
				if ok {
					dfs.AddField(field)
					di = len(dfs.Values) - 1
				} else {
					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
					deferred[field.Deferrable.Label] = dfs
				}
				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
					return innerFunc(ctx, dfs)
				})

				// don't run the out.Concurrently() call below
				out.Values[i] = graphql.Null
				continue
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
		case "personalAPIKeys":
			field := field

			innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Identity_personalAPIKeys(ctx, field, obj)
				return res
			}

			if field.Deferrable != nil {
				dfs, ok := deferred[field.Deferrable.Label]
				di := 0
				if ok {
					dfs.AddField(field)
					di = len(dfs.Values) - 1
				} else {
					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
					deferred[field.Deferrable.Label] = dfs
				}
				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
					return innerFunc(ctx, dfs)
				})

				// don't run the out.Concurrently() call below
				out.Values[i] = graphql.Null
				continue
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
		case "permission":
			field := field

			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Identity_permission(ctx, field, obj)
				if res == graphql.Null {
					atomic.AddUint32(&fs.Invalids, 1)
				}
				return res
			}

			if field.Deferrable != nil {
				dfs, ok := deferred[field.Deferrable.Label]
				di := 0
				if ok {
					dfs.AddField(field)
					di = len(dfs.Values) - 1
				} else {
					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
					deferred[field.Deferrable.Label] = dfs
				}
				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
					return innerFunc(ctx, dfs)
				})

				// don't run the out.Concurrently() call below
				out.Values[i] = graphql.Null
				continue
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var invitationImplementors = []string{"Invitation", "Node"}

func (ec *executionContext) _Invitation(ctx context.Context, sel ast.SelectionSet, obj *types.Invitation) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, invitationImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("Invitation")
		case "id":
			out.Values[i] = ec._Invitation_id(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "email":
			out.Values[i] = ec._Invitation_email(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "fullName":
			out.Values[i] = ec._Invitation_fullName(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "role":
			out.Values[i] = ec._Invitation_role(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "expiresAt":
			out.Values[i] = ec._Invitation_expiresAt(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "acceptedAt":
			out.Values[i] = ec._Invitation_acceptedAt(ctx, field, obj)
		case "createdAt":
			out.Values[i] = ec._Invitation_createdAt(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "status":
			out.Values[i] = ec._Invitation_status(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "organization":
			field := field

			innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Invitation_organization(ctx, field, obj)
				return res
			}

			if field.Deferrable != nil {
				dfs, ok := deferred[field.Deferrable.Label]
				di := 0
				if ok {
					dfs.AddField(field)
					di = len(dfs.Values) - 1
				} else {
					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
					deferred[field.Deferrable.Label] = dfs
				}
				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
					return innerFunc(ctx, dfs)
				})

				// don't run the out.Concurrently() call below
				out.Values[i] = graphql.Null
				continue
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
		case "permission":
			field := field

			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Invitation_permission(ctx, field, obj)
				if res == graphql.Null {
					atomic.AddUint32(&fs.Invalids, 1)
				}
				return res
			}

			if field.Deferrable != nil {
				dfs, ok := deferred[field.Deferrable.Label]
				di := 0
				if ok {
					dfs.AddField(field)
					di = len(dfs.Values) - 1
				} else {
					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
					deferred[field.Deferrable.Label] = dfs
				}
				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
					return innerFunc(ctx, dfs)
				})

				// don't run the out.Concurrently() call below
				out.Values[i] = graphql.Null
				continue
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var invitationConnectionImplementors = []string{"InvitationConnection"}

func (ec *executionContext) _InvitationConnection(ctx context.Context, sel ast.SelectionSet, obj *types.InvitationConnection) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, invitationConnectionImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("InvitationConnection")
		case "edges":
			out.Values[i] = ec._InvitationConnection_edges(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "pageInfo":
			out.Values[i] = ec._InvitationConnection_pageInfo(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "totalCount":
			field := field

			innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._InvitationConnection_totalCount(ctx, field, obj)
				return res
			}

			if field.Deferrable != nil {
				dfs, ok := deferred[field.Deferrable.Label]
				di := 0
				if ok {
					dfs.AddField(field)
					di = len(dfs.Values) - 1
				} else {
					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
					deferred[field.Deferrable.Label] = dfs
				}
				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
					return innerFunc(ctx, dfs)
				})

				// don't run the out.Concurrently() call below
				out.Values[i] = graphql.Null
				continue
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var invitationEdgeImplementors = []string{"InvitationEdge"}

func (ec *executionContext) _InvitationEdge(ctx context.Context, sel ast.SelectionSet, obj *types.InvitationEdge) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, invitationEdgeImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("InvitationEdge")
		case "node":
			out.Values[i] = ec._InvitationEdge_node(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "cursor":
			out.Values[i] = ec._InvitationEdge_cursor(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var inviteMemberPayloadImplementors = []string{"InviteMemberPayload"}

func (ec *executionContext) _InviteMemberPayload(ctx context.Context, sel ast.SelectionSet, obj *types.InviteMemberPayload) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, inviteMemberPayloadImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("InviteMemberPayload")
		case "invitationEdge":
			out.Values[i] = ec._InviteMemberPayload_invitationEdge(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var membershipImplementors = []string{"Membership", "Node"}

func (ec *executionContext) _Membership(ctx context.Context, sel ast.SelectionSet, obj *types.Membership) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, membershipImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("Membership")
		case "id":
			out.Values[i] = ec._Membership_id(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "createdAt":
			out.Values[i] = ec._Membership_createdAt(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "identity":
			field := field

			innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Membership_identity(ctx, field, obj)
				return res
			}

			if field.Deferrable != nil {
				dfs, ok := deferred[field.Deferrable.Label]
				di := 0
				if ok {
					dfs.AddField(field)
					di = len(dfs.Values) - 1
				} else {
					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
					deferred[field.Deferrable.Label] = dfs
				}
				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
					return innerFunc(ctx, dfs)
				})

				// don't run the out.Concurrently() call below
				out.Values[i] = graphql.Null
				continue
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
		case "profile":
			field := field

			innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Membership_profile(ctx, field, obj)
				return res
			}

			if field.Deferrable != nil {
				dfs, ok := deferred[field.Deferrable.Label]
				di := 0
				if ok {
					dfs.AddField(field)
					di = len(dfs.Values) - 1
				} else {
					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
					deferred[field.Deferrable.Label] = dfs
				}
				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
					return innerFunc(ctx, dfs)
				})

				// don't run the out.Concurrently() call below
				out.Values[i] = graphql.Null
				continue
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
		case "organization":
			field := field

			innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Membership_organization(ctx, field, obj)
				return res
			}

			if field.Deferrable != nil {
				dfs, ok := deferred[field.Deferrable.Label]
				di := 0
				if ok {
					dfs.AddField(field)
					di = len(dfs.Values) - 1
				} else {
					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
					deferred[field.Deferrable.Label] = dfs
				}
				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
					return innerFunc(ctx, dfs)
				})

				// don't run the out.Concurrently() call below
				out.Values[i] = graphql.Null
				continue
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
		case "role":
			out.Values[i] = ec._Membership_role(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "source":
			out.Values[i] = ec._Membership_source(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "state":
			out.Values[i] = ec._Membership_state(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "lastSession":
			field := field

			innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Membership_lastSession(ctx, field, obj)
				return res
			}

			if field.Deferrable != nil {
				dfs, ok := deferred[field.Deferrable.Label]
				di := 0
				if ok {
					dfs.AddField(field)
					di = len(dfs.Values) - 1
				} else {
					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
					deferred[field.Deferrable.Label] = dfs
				}
				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
					return innerFunc(ctx, dfs)
				})

				// don't run the out.Concurrently() call below
				out.Values[i] = graphql.Null
				continue
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
		case "permission":
			field := field

			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Membership_permission(ctx, field, obj)
				if res == graphql.Null {
					atomic.AddUint32(&fs.Invalids, 1)
				}
				return res
			}

			if field.Deferrable != nil {
				dfs, ok := deferred[field.Deferrable.Label]
				di := 0
				if ok {
					dfs.AddField(field)
					di = len(dfs.Values) - 1
				} else {
					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
					deferred[field.Deferrable.Label] = dfs
				}
				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
					return innerFunc(ctx, dfs)
				})

				// don't run the out.Concurrently() call below
				out.Values[i] = graphql.Null
				continue
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var membershipConnectionImplementors = []string{"MembershipConnection"}

func (ec *executionContext) _MembershipConnection(ctx context.Context, sel ast.SelectionSet, obj *types.MembershipConnection) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, membershipConnectionImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("MembershipConnection")
		case "edges":
			out.Values[i] = ec._MembershipConnection_edges(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "pageInfo":
			out.Values[i] = ec._MembershipConnection_pageInfo(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "totalCount":
			field := field

			innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._MembershipConnection_totalCount(ctx, field, obj)
				return res
			}

			if field.Deferrable != nil {
				dfs, ok := deferred[field.Deferrable.Label]
				di := 0
				if ok {
					dfs.AddField(field)
					di = len(dfs.Values) - 1
				} else {
					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
					deferred[field.Deferrable.Label] = dfs
				}
				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
					return innerFunc(ctx, dfs)
				})

				// don't run the out.Concurrently() call below
				out.Values[i] = graphql.Null
				continue
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var membershipEdgeImplementors = []string{"MembershipEdge"}

func (ec *executionContext) _MembershipEdge(ctx context.Context, sel ast.SelectionSet, obj *types.MembershipEdge) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, membershipEdgeImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("MembershipEdge")
		case "node":
			out.Values[i] = ec._MembershipEdge_node(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "cursor":
			out.Values[i] = ec._MembershipEdge_cursor(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var membershipProfileImplementors = []string{"MembershipProfile", "Node"}

func (ec *executionContext) _MembershipProfile(ctx context.Context, sel ast.SelectionSet, obj *types.MembershipProfile) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, membershipProfileImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("MembershipProfile")
		case "id":
			out.Values[i] = ec._MembershipProfile_id(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "fullName":
			out.Values[i] = ec._MembershipProfile_fullName(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "additionalEmailAddresses":
			out.Values[i] = ec._MembershipProfile_additionalEmailAddresses(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "kind":
			out.Values[i] = ec._MembershipProfile_kind(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "position":
			out.Values[i] = ec._MembershipProfile_position(ctx, field, obj)
		case "contractStartDate":
			out.Values[i] = ec._MembershipProfile_contractStartDate(ctx, field, obj)
		case "contractEndDate":
			out.Values[i] = ec._MembershipProfile_contractEndDate(ctx, field, obj)
		case "createdAt":
			out.Values[i] = ec._MembershipProfile_createdAt(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "updatedAt":
			out.Values[i] = ec._MembershipProfile_updatedAt(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "identity":
			field := field

			innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._MembershipProfile_identity(ctx, field, obj)
				return res
			}

			if field.Deferrable != nil {
				dfs, ok := deferred[field.Deferrable.Label]
				di := 0
				if ok {
					dfs.AddField(field)
					di = len(dfs.Values) - 1
				} else {
					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
					deferred[field.Deferrable.Label] = dfs
				}
				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
					return innerFunc(ctx, dfs)
				})

				// don't run the out.Concurrently() call below
				out.Values[i] = graphql.Null
				continue
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
		case "organization":
			field := field

			innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._MembershipProfile_organization(ctx, field, obj)
				return res
			}

			if field.Deferrable != nil {
				dfs, ok := deferred[field.Deferrable.Label]
				di := 0
				if ok {
					dfs.AddField(field)
					di = len(dfs.Values) - 1
				} else {
					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
					deferred[field.Deferrable.Label] = dfs
				}
				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
					return innerFunc(ctx, dfs)
				})

				// don't run the out.Concurrently() call below
				out.Values[i] = graphql.Null
				continue
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
		case "membershipId":
			out.Values[i] = ec._MembershipProfile_membershipId(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "permission":
			field := field

			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._MembershipProfile_permission(ctx, field, obj)
				if res == graphql.Null {
					atomic.AddUint32(&fs.Invalids, 1)
				}
				return res
			}

			if field.Deferrable != nil {
				dfs, ok := deferred[field.Deferrable.Label]
				di := 0
				if ok {
					dfs.AddField(field)
					di = len(dfs.Values) - 1
				} else {
					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
					deferred[field.Deferrable.Label] = dfs
				}
				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
					return innerFunc(ctx, dfs)
				})

				// don't run the out.Concurrently() call below
				out.Values[i] = graphql.Null
				continue
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var mutationImplementors = []string{"Mutation"}

func (ec *executionContext) _Mutation(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, mutationImplementors)
	ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{
		Object: "Mutation",
	})

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		innerCtx := graphql.WithRootFieldContext(ctx, &graphql.RootFieldContext{
			Object: field.Name,
			Field:  field,
		})

		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("Mutation")
		case "signIn":
			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
				return ec._Mutation_signIn(ctx, field)
			})
		case "signUp":
			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
				return ec._Mutation_signUp(ctx, field)
			})
		case "signOut":
			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
				return ec._Mutation_signOut(ctx, field)
			})
		case "signUpFromInvitation":
			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
				return ec._Mutation_signUpFromInvitation(ctx, field)
			})
		case "forgotPassword":
			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
				return ec._Mutation_forgotPassword(ctx, field)
			})
		case "resetPassword":
			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
				return ec._Mutation_resetPassword(ctx, field)
			})
		case "verifyEmail":
			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
				return ec._Mutation_verifyEmail(ctx, field)
			})
		case "changePassword":
			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
				return ec._Mutation_changePassword(ctx, field)
			})
		case "changeEmail":
			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
				return ec._Mutation_changeEmail(ctx, field)
			})
		case "assumeOrganizationSession":
			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
				return ec._Mutation_assumeOrganizationSession(ctx, field)
			})
		case "revokeSession":
			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
				return ec._Mutation_revokeSession(ctx, field)
			})
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "revokeAllSessions":
			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
				return ec._Mutation_revokeAllSessions(ctx, field)
			})
		case "createPersonalAPIKey":
			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
				return ec._Mutation_createPersonalAPIKey(ctx, field)
			})
		case "revokePersonalAPIKey":
			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
				return ec._Mutation_revokePersonalAPIKey(ctx, field)
			})
		case "createOrganization":
			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
				return ec._Mutation_createOrganization(ctx, field)
			})
		case "updateOrganization":
			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
				return ec._Mutation_updateOrganization(ctx, field)
			})
		case "deleteOrganization":
			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
				return ec._Mutation_deleteOrganization(ctx, field)
			})
		case "deleteOrganizationHorizontalLogo":
			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
				return ec._Mutation_deleteOrganizationHorizontalLogo(ctx, field)
			})
		case "inviteMember":
			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
				return ec._Mutation_inviteMember(ctx, field)
			})
		case "deleteInvitation":
			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
				return ec._Mutation_deleteInvitation(ctx, field)
			})
		case "updateProfile":
			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
				return ec._Mutation_updateProfile(ctx, field)
			})
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "updateMembership":
			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
				return ec._Mutation_updateMembership(ctx, field)
			})
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "removeMember":
			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
				return ec._Mutation_removeMember(ctx, field)
			})
		case "acceptInvitation":
			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
				return ec._Mutation_acceptInvitation(ctx, field)
			})
		case "createSAMLConfiguration":
			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
				return ec._Mutation_createSAMLConfiguration(ctx, field)
			})
		case "updateSAMLConfiguration":
			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
				return ec._Mutation_updateSAMLConfiguration(ctx, field)
			})
		case "deleteSAMLConfiguration":
			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
				return ec._Mutation_deleteSAMLConfiguration(ctx, field)
			})
		case "createSCIMConfiguration":
			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
				return ec._Mutation_createSCIMConfiguration(ctx, field)
			})
		case "deleteSCIMConfiguration":
			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
				return ec._Mutation_deleteSCIMConfiguration(ctx, field)
			})
		case "regenerateSCIMToken":
			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
				return ec._Mutation_regenerateSCIMToken(ctx, field)
			})
		case "updateSCIMBridge":
			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
				return ec._Mutation_updateSCIMBridge(ctx, field)
			})
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var organizationImplementors = []string{"Organization", "Node"}

func (ec *executionContext) _Organization(ctx context.Context, sel ast.SelectionSet, obj *types.Organization) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, organizationImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("Organization")
		case "id":
			out.Values[i] = ec._Organization_id(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "name":
			out.Values[i] = ec._Organization_name(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "logoUrl":
			field := field

			innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Organization_logoUrl(ctx, field, obj)
				return res
			}

			if field.Deferrable != nil {
				dfs, ok := deferred[field.Deferrable.Label]
				di := 0
				if ok {
					dfs.AddField(field)
					di = len(dfs.Values) - 1
				} else {
					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
					deferred[field.Deferrable.Label] = dfs
				}
				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
					return innerFunc(ctx, dfs)
				})

				// don't run the out.Concurrently() call below
				out.Values[i] = graphql.Null
				continue
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
		case "horizontalLogoUrl":
			field := field

			innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Organization_horizontalLogoUrl(ctx, field, obj)
				return res
			}

			if field.Deferrable != nil {
				dfs, ok := deferred[field.Deferrable.Label]
				di := 0
				if ok {
					dfs.AddField(field)
					di = len(dfs.Values) - 1
				} else {
					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
					deferred[field.Deferrable.Label] = dfs
				}
				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
					return innerFunc(ctx, dfs)
				})

				// don't run the out.Concurrently() call below
				out.Values[i] = graphql.Null
				continue
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
		case "email":
			out.Values[i] = ec._Organization_email(ctx, field, obj)
		case "description":
			out.Values[i] = ec._Organization_description(ctx, field, obj)
		case "websiteUrl":
			out.Values[i] = ec._Organization_websiteUrl(ctx, field, obj)
		case "headquarterAddress":
			out.Values[i] = ec._Organization_headquarterAddress(ctx, field, obj)
		case "createdAt":
			out.Values[i] = ec._Organization_createdAt(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "updatedAt":
			out.Values[i] = ec._Organization_updatedAt(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "members":
			field := field

			innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Organization_members(ctx, field, obj)
				return res
			}

			if field.Deferrable != nil {
				dfs, ok := deferred[field.Deferrable.Label]
				di := 0
				if ok {
					dfs.AddField(field)
					di = len(dfs.Values) - 1
				} else {
					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
					deferred[field.Deferrable.Label] = dfs
				}
				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
					return innerFunc(ctx, dfs)
				})

				// don't run the out.Concurrently() call below
				out.Values[i] = graphql.Null
				continue
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
		case "invitations":
			field := field

			innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Organization_invitations(ctx, field, obj)
				return res
			}

			if field.Deferrable != nil {
				dfs, ok := deferred[field.Deferrable.Label]
				di := 0
				if ok {
					dfs.AddField(field)
					di = len(dfs.Values) - 1
				} else {
					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
					deferred[field.Deferrable.Label] = dfs
				}
				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
					return innerFunc(ctx, dfs)
				})

				// don't run the out.Concurrently() call below
				out.Values[i] = graphql.Null
				continue
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
		case "samlConfigurations":
			field := field

			innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Organization_samlConfigurations(ctx, field, obj)
				return res
			}

			if field.Deferrable != nil {
				dfs, ok := deferred[field.Deferrable.Label]
				di := 0
				if ok {
					dfs.AddField(field)
					di = len(dfs.Values) - 1
				} else {
					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
					deferred[field.Deferrable.Label] = dfs
				}
				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
					return innerFunc(ctx, dfs)
				})

				// don't run the out.Concurrently() call below
				out.Values[i] = graphql.Null
				continue
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
		case "scimConfiguration":
			field := field

			innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Organization_scimConfiguration(ctx, field, obj)
				return res
			}

			if field.Deferrable != nil {
				dfs, ok := deferred[field.Deferrable.Label]
				di := 0
				if ok {
					dfs.AddField(field)
					di = len(dfs.Values) - 1
				} else {
					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
					deferred[field.Deferrable.Label] = dfs
				}
				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
					return innerFunc(ctx, dfs)
				})

				// don't run the out.Concurrently() call below
				out.Values[i] = graphql.Null
				continue
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
		case "viewerMembership":
			field := field

			innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Organization_viewerMembership(ctx, field, obj)
				return res
			}

			if field.Deferrable != nil {
				dfs, ok := deferred[field.Deferrable.Label]
				di := 0
				if ok {
					dfs.AddField(field)
					di = len(dfs.Values) - 1
				} else {
					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
					deferred[field.Deferrable.Label] = dfs
				}
				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
					return innerFunc(ctx, dfs)
				})

				// don't run the out.Concurrently() call below
				out.Values[i] = graphql.Null
				continue
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
		case "permission":
			field := field

			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Organization_permission(ctx, field, obj)
				if res == graphql.Null {
					atomic.AddUint32(&fs.Invalids, 1)
				}
				return res
			}

			if field.Deferrable != nil {
				dfs, ok := deferred[field.Deferrable.Label]
				di := 0
				if ok {
					dfs.AddField(field)
					di = len(dfs.Values) - 1
				} else {
					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
					deferred[field.Deferrable.Label] = dfs
				}
				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
					return innerFunc(ctx, dfs)
				})

				// don't run the out.Concurrently() call below
				out.Values[i] = graphql.Null
				continue
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var organizationSessionCreatedImplementors = []string{"OrganizationSessionCreated", "AssumeOrganizationSessionResult"}

func (ec *executionContext) _OrganizationSessionCreated(ctx context.Context, sel ast.SelectionSet, obj *types.OrganizationSessionCreated) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, organizationSessionCreatedImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("OrganizationSessionCreated")
		case "session":
			out.Values[i] = ec._OrganizationSessionCreated_session(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "membership":
			out.Values[i] = ec._OrganizationSessionCreated_membership(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var pageInfoImplementors = []string{"PageInfo"}

func (ec *executionContext) _PageInfo(ctx context.Context, sel ast.SelectionSet, obj *types.PageInfo) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, pageInfoImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("PageInfo")
		case "hasNextPage":
			out.Values[i] = ec._PageInfo_hasNextPage(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "hasPreviousPage":
			out.Values[i] = ec._PageInfo_hasPreviousPage(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "startCursor":
			out.Values[i] = ec._PageInfo_startCursor(ctx, field, obj)
		case "endCursor":
			out.Values[i] = ec._PageInfo_endCursor(ctx, field, obj)
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var passwordRequiredImplementors = []string{"PasswordRequired", "AssumeOrganizationSessionResult"}

func (ec *executionContext) _PasswordRequired(ctx context.Context, sel ast.SelectionSet, obj *types.PasswordRequired) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, passwordRequiredImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("PasswordRequired")
		case "reason":
			out.Values[i] = ec._PasswordRequired_reason(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var personalAPIKeyImplementors = []string{"PersonalAPIKey", "Node"}

func (ec *executionContext) _PersonalAPIKey(ctx context.Context, sel ast.SelectionSet, obj *types.PersonalAPIKey) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, personalAPIKeyImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("PersonalAPIKey")
		case "id":
			out.Values[i] = ec._PersonalAPIKey_id(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "name":
			out.Values[i] = ec._PersonalAPIKey_name(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "expiresAt":
			out.Values[i] = ec._PersonalAPIKey_expiresAt(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "lastUsedAt":
			out.Values[i] = ec._PersonalAPIKey_lastUsedAt(ctx, field, obj)
		case "createdAt":
			out.Values[i] = ec._PersonalAPIKey_createdAt(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "token":
			field := field

			innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._PersonalAPIKey_token(ctx, field, obj)
				return res
			}

			if field.Deferrable != nil {
				dfs, ok := deferred[field.Deferrable.Label]
				di := 0
				if ok {
					dfs.AddField(field)
					di = len(dfs.Values) - 1
				} else {
					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
					deferred[field.Deferrable.Label] = dfs
				}
				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
					return innerFunc(ctx, dfs)
				})

				// don't run the out.Concurrently() call below
				out.Values[i] = graphql.Null
				continue
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
		case "permission":
			field := field

			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._PersonalAPIKey_permission(ctx, field, obj)
				if res == graphql.Null {
					atomic.AddUint32(&fs.Invalids, 1)
				}
				return res
			}

			if field.Deferrable != nil {
				dfs, ok := deferred[field.Deferrable.Label]
				di := 0
				if ok {
					dfs.AddField(field)
					di = len(dfs.Values) - 1
				} else {
					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
					deferred[field.Deferrable.Label] = dfs
				}
				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
					return innerFunc(ctx, dfs)
				})

				// don't run the out.Concurrently() call below
				out.Values[i] = graphql.Null
				continue
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var personalAPIKeyConnectionImplementors = []string{"PersonalAPIKeyConnection"}

func (ec *executionContext) _PersonalAPIKeyConnection(ctx context.Context, sel ast.SelectionSet, obj *types.PersonalAPIKeyConnection) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, personalAPIKeyConnectionImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("PersonalAPIKeyConnection")
		case "edges":
			out.Values[i] = ec._PersonalAPIKeyConnection_edges(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "pageInfo":
			out.Values[i] = ec._PersonalAPIKeyConnection_pageInfo(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "totalCount":
			field := field

			innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._PersonalAPIKeyConnection_totalCount(ctx, field, obj)
				return res
			}

			if field.Deferrable != nil {
				dfs, ok := deferred[field.Deferrable.Label]
				di := 0
				if ok {
					dfs.AddField(field)
					di = len(dfs.Values) - 1
				} else {
					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
					deferred[field.Deferrable.Label] = dfs
				}
				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
					return innerFunc(ctx, dfs)
				})

				// don't run the out.Concurrently() call below
				out.Values[i] = graphql.Null
				continue
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var personalAPIKeyEdgeImplementors = []string{"PersonalAPIKeyEdge"}

func (ec *executionContext) _PersonalAPIKeyEdge(ctx context.Context, sel ast.SelectionSet, obj *types.PersonalAPIKeyEdge) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, personalAPIKeyEdgeImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("PersonalAPIKeyEdge")
		case "node":
			out.Values[i] = ec._PersonalAPIKeyEdge_node(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "cursor":
			out.Values[i] = ec._PersonalAPIKeyEdge_cursor(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var queryImplementors = []string{"Query"}

func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, queryImplementors)
	ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{
		Object: "Query",
	})

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		innerCtx := graphql.WithRootFieldContext(ctx, &graphql.RootFieldContext{
			Object: field.Name,
			Field:  field,
		})

		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("Query")
		case "node":
			field := field

			innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Query_node(ctx, field)
				return res
			}

			rrm := func(ctx context.Context) graphql.Marshaler {
				return ec.OperationContext.RootResolverMiddleware(ctx,
					func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
		case "viewer":
			field := field

			innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Query_viewer(ctx, field)
				return res
			}

			rrm := func(ctx context.Context) graphql.Marshaler {
				return ec.OperationContext.RootResolverMiddleware(ctx,
					func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
		case "ssoLoginURL":
			field := field

			innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Query_ssoLoginURL(ctx, field)
				return res
			}

			rrm := func(ctx context.Context) graphql.Marshaler {
				return ec.OperationContext.RootResolverMiddleware(ctx,
					func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
		case "__type":
			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
				return ec._Query___type(ctx, field)
			})
		case "__schema":
			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
				return ec._Query___schema(ctx, field)
			})
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var regenerateSCIMTokenPayloadImplementors = []string{"RegenerateSCIMTokenPayload"}

func (ec *executionContext) _RegenerateSCIMTokenPayload(ctx context.Context, sel ast.SelectionSet, obj *types.RegenerateSCIMTokenPayload) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, regenerateSCIMTokenPayloadImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("RegenerateSCIMTokenPayload")
		case "scimConfiguration":
			out.Values[i] = ec._RegenerateSCIMTokenPayload_scimConfiguration(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "token":
			out.Values[i] = ec._RegenerateSCIMTokenPayload_token(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var removeMemberPayloadImplementors = []string{"RemoveMemberPayload"}

func (ec *executionContext) _RemoveMemberPayload(ctx context.Context, sel ast.SelectionSet, obj *types.RemoveMemberPayload) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, removeMemberPayloadImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("RemoveMemberPayload")
		case "deletedMembershipId":
			out.Values[i] = ec._RemoveMemberPayload_deletedMembershipId(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var resetPasswordPayloadImplementors = []string{"ResetPasswordPayload"}

func (ec *executionContext) _ResetPasswordPayload(ctx context.Context, sel ast.SelectionSet, obj *types.ResetPasswordPayload) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, resetPasswordPayloadImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("ResetPasswordPayload")
		case "success":
			out.Values[i] = ec._ResetPasswordPayload_success(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var revokeAllSessionsPayloadImplementors = []string{"RevokeAllSessionsPayload"}

func (ec *executionContext) _RevokeAllSessionsPayload(ctx context.Context, sel ast.SelectionSet, obj *types.RevokeAllSessionsPayload) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, revokeAllSessionsPayloadImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("RevokeAllSessionsPayload")
		case "revokedCount":
			out.Values[i] = ec._RevokeAllSessionsPayload_revokedCount(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var revokePersonalAPIKeyPayloadImplementors = []string{"RevokePersonalAPIKeyPayload"}

func (ec *executionContext) _RevokePersonalAPIKeyPayload(ctx context.Context, sel ast.SelectionSet, obj *types.RevokePersonalAPIKeyPayload) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, revokePersonalAPIKeyPayloadImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("RevokePersonalAPIKeyPayload")
		case "personalAPIKeyId":
			out.Values[i] = ec._RevokePersonalAPIKeyPayload_personalAPIKeyId(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var revokeSessionPayloadImplementors = []string{"RevokeSessionPayload"}

func (ec *executionContext) _RevokeSessionPayload(ctx context.Context, sel ast.SelectionSet, obj *types.RevokeSessionPayload) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, revokeSessionPayloadImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("RevokeSessionPayload")
		case "success":
			out.Values[i] = ec._RevokeSessionPayload_success(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var sAMLAttributeMappingsImplementors = []string{"SAMLAttributeMappings"}

func (ec *executionContext) _SAMLAttributeMappings(ctx context.Context, sel ast.SelectionSet, obj *types.SAMLAttributeMappings) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, sAMLAttributeMappingsImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("SAMLAttributeMappings")
		case "email":
			out.Values[i] = ec._SAMLAttributeMappings_email(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "firstName":
			out.Values[i] = ec._SAMLAttributeMappings_firstName(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "lastName":
			out.Values[i] = ec._SAMLAttributeMappings_lastName(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "role":
			out.Values[i] = ec._SAMLAttributeMappings_role(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var sAMLAuthenticationRequiredImplementors = []string{"SAMLAuthenticationRequired", "AssumeOrganizationSessionResult"}

func (ec *executionContext) _SAMLAuthenticationRequired(ctx context.Context, sel ast.SelectionSet, obj *types.SAMLAuthenticationRequired) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, sAMLAuthenticationRequiredImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("SAMLAuthenticationRequired")
		case "reason":
			out.Values[i] = ec._SAMLAuthenticationRequired_reason(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "redirectUrl":
			out.Values[i] = ec._SAMLAuthenticationRequired_redirectUrl(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var sAMLConfigurationImplementors = []string{"SAMLConfiguration", "Node"}

func (ec *executionContext) _SAMLConfiguration(ctx context.Context, sel ast.SelectionSet, obj *types.SAMLConfiguration) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, sAMLConfigurationImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("SAMLConfiguration")
		case "id":
			out.Values[i] = ec._SAMLConfiguration_id(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "emailDomain":
			out.Values[i] = ec._SAMLConfiguration_emailDomain(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "enforcementPolicy":
			out.Values[i] = ec._SAMLConfiguration_enforcementPolicy(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "domainVerifiedAt":
			out.Values[i] = ec._SAMLConfiguration_domainVerifiedAt(ctx, field, obj)
		case "domainVerificationToken":
			out.Values[i] = ec._SAMLConfiguration_domainVerificationToken(ctx, field, obj)
		case "idpEntityId":
			out.Values[i] = ec._SAMLConfiguration_idpEntityId(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "idpSsoUrl":
			out.Values[i] = ec._SAMLConfiguration_idpSsoUrl(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "idpCertificate":
			out.Values[i] = ec._SAMLConfiguration_idpCertificate(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "autoSignupEnabled":
			out.Values[i] = ec._SAMLConfiguration_autoSignupEnabled(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "createdAt":
			out.Values[i] = ec._SAMLConfiguration_createdAt(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "updatedAt":
			out.Values[i] = ec._SAMLConfiguration_updatedAt(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "testLoginUrl":
			field := field

			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._SAMLConfiguration_testLoginUrl(ctx, field, obj)
				if res == graphql.Null {
					atomic.AddUint32(&fs.Invalids, 1)
				}
				return res
			}

			if field.Deferrable != nil {
				dfs, ok := deferred[field.Deferrable.Label]
				di := 0
				if ok {
					dfs.AddField(field)
					di = len(dfs.Values) - 1
				} else {
					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
					deferred[field.Deferrable.Label] = dfs
				}
				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
					return innerFunc(ctx, dfs)
				})

				// don't run the out.Concurrently() call below
				out.Values[i] = graphql.Null
				continue
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
		case "attributeMappings":
			out.Values[i] = ec._SAMLConfiguration_attributeMappings(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "permission":
			field := field

			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._SAMLConfiguration_permission(ctx, field, obj)
				if res == graphql.Null {
					atomic.AddUint32(&fs.Invalids, 1)
				}
				return res
			}

			if field.Deferrable != nil {
				dfs, ok := deferred[field.Deferrable.Label]
				di := 0
				if ok {
					dfs.AddField(field)
					di = len(dfs.Values) - 1
				} else {
					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
					deferred[field.Deferrable.Label] = dfs
				}
				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
					return innerFunc(ctx, dfs)
				})

				// don't run the out.Concurrently() call below
				out.Values[i] = graphql.Null
				continue
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var sAMLConfigurationConnectionImplementors = []string{"SAMLConfigurationConnection"}

func (ec *executionContext) _SAMLConfigurationConnection(ctx context.Context, sel ast.SelectionSet, obj *types.SAMLConfigurationConnection) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, sAMLConfigurationConnectionImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("SAMLConfigurationConnection")
		case "edges":
			out.Values[i] = ec._SAMLConfigurationConnection_edges(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "pageInfo":
			out.Values[i] = ec._SAMLConfigurationConnection_pageInfo(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "totalCount":
			field := field

			innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._SAMLConfigurationConnection_totalCount(ctx, field, obj)
				return res
			}

			if field.Deferrable != nil {
				dfs, ok := deferred[field.Deferrable.Label]
				di := 0
				if ok {
					dfs.AddField(field)
					di = len(dfs.Values) - 1
				} else {
					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
					deferred[field.Deferrable.Label] = dfs
				}
				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
					return innerFunc(ctx, dfs)
				})

				// don't run the out.Concurrently() call below
				out.Values[i] = graphql.Null
				continue
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var sAMLConfigurationEdgeImplementors = []string{"SAMLConfigurationEdge"}

func (ec *executionContext) _SAMLConfigurationEdge(ctx context.Context, sel ast.SelectionSet, obj *types.SAMLConfigurationEdge) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, sAMLConfigurationEdgeImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("SAMLConfigurationEdge")
		case "node":
			out.Values[i] = ec._SAMLConfigurationEdge_node(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "cursor":
			out.Values[i] = ec._SAMLConfigurationEdge_cursor(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var sCIMBridgeImplementors = []string{"SCIMBridge", "Node"}

func (ec *executionContext) _SCIMBridge(ctx context.Context, sel ast.SelectionSet, obj *types.SCIMBridge) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, sCIMBridgeImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("SCIMBridge")
		case "id":
			out.Values[i] = ec._SCIMBridge_id(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "state":
			out.Values[i] = ec._SCIMBridge_state(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "scimConfiguration":
			field := field

			innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._SCIMBridge_scimConfiguration(ctx, field, obj)
				return res
			}

			if field.Deferrable != nil {
				dfs, ok := deferred[field.Deferrable.Label]
				di := 0
				if ok {
					dfs.AddField(field)
					di = len(dfs.Values) - 1
				} else {
					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
					deferred[field.Deferrable.Label] = dfs
				}
				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
					return innerFunc(ctx, dfs)
				})

				// don't run the out.Concurrently() call below
				out.Values[i] = graphql.Null
				continue
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
		case "connector":
			field := field

			innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._SCIMBridge_connector(ctx, field, obj)
				return res
			}

			if field.Deferrable != nil {
				dfs, ok := deferred[field.Deferrable.Label]
				di := 0
				if ok {
					dfs.AddField(field)
					di = len(dfs.Values) - 1
				} else {
					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
					deferred[field.Deferrable.Label] = dfs
				}
				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
					return innerFunc(ctx, dfs)
				})

				// don't run the out.Concurrently() call below
				out.Values[i] = graphql.Null
				continue
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
		case "type":
			out.Values[i] = ec._SCIMBridge_type(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "excludedUserNames":
			out.Values[i] = ec._SCIMBridge_excludedUserNames(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "createdAt":
			out.Values[i] = ec._SCIMBridge_createdAt(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "updatedAt":
			out.Values[i] = ec._SCIMBridge_updatedAt(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "permission":
			field := field

			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._SCIMBridge_permission(ctx, field, obj)
				if res == graphql.Null {
					atomic.AddUint32(&fs.Invalids, 1)
				}
				return res
			}

			if field.Deferrable != nil {
				dfs, ok := deferred[field.Deferrable.Label]
				di := 0
				if ok {
					dfs.AddField(field)
					di = len(dfs.Values) - 1
				} else {
					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
					deferred[field.Deferrable.Label] = dfs
				}
				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
					return innerFunc(ctx, dfs)
				})

				// don't run the out.Concurrently() call below
				out.Values[i] = graphql.Null
				continue
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var sCIMConfigurationImplementors = []string{"SCIMConfiguration", "Node"}

func (ec *executionContext) _SCIMConfiguration(ctx context.Context, sel ast.SelectionSet, obj *types.SCIMConfiguration) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, sCIMConfigurationImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("SCIMConfiguration")
		case "id":
			out.Values[i] = ec._SCIMConfiguration_id(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "endpointUrl":
			field := field

			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._SCIMConfiguration_endpointUrl(ctx, field, obj)
				if res == graphql.Null {
					atomic.AddUint32(&fs.Invalids, 1)
				}
				return res
			}

			if field.Deferrable != nil {
				dfs, ok := deferred[field.Deferrable.Label]
				di := 0
				if ok {
					dfs.AddField(field)
					di = len(dfs.Values) - 1
				} else {
					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
					deferred[field.Deferrable.Label] = dfs
				}
				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
					return innerFunc(ctx, dfs)
				})

				// don't run the out.Concurrently() call below
				out.Values[i] = graphql.Null
				continue
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
		case "createdAt":
			out.Values[i] = ec._SCIMConfiguration_createdAt(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "updatedAt":
			out.Values[i] = ec._SCIMConfiguration_updatedAt(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "organization":
			field := field

			innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._SCIMConfiguration_organization(ctx, field, obj)
				return res
			}

			if field.Deferrable != nil {
				dfs, ok := deferred[field.Deferrable.Label]
				di := 0
				if ok {
					dfs.AddField(field)
					di = len(dfs.Values) - 1
				} else {
					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
					deferred[field.Deferrable.Label] = dfs
				}
				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
					return innerFunc(ctx, dfs)
				})

				// don't run the out.Concurrently() call below
				out.Values[i] = graphql.Null
				continue
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
		case "bridge":
			field := field

			innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._SCIMConfiguration_bridge(ctx, field, obj)
				return res
			}

			if field.Deferrable != nil {
				dfs, ok := deferred[field.Deferrable.Label]
				di := 0
				if ok {
					dfs.AddField(field)
					di = len(dfs.Values) - 1
				} else {
					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
					deferred[field.Deferrable.Label] = dfs
				}
				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
					return innerFunc(ctx, dfs)
				})

				// don't run the out.Concurrently() call below
				out.Values[i] = graphql.Null
				continue
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
		case "events":
			field := field

			innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._SCIMConfiguration_events(ctx, field, obj)
				return res
			}

			if field.Deferrable != nil {
				dfs, ok := deferred[field.Deferrable.Label]
				di := 0
				if ok {
					dfs.AddField(field)
					di = len(dfs.Values) - 1
				} else {
					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
					deferred[field.Deferrable.Label] = dfs
				}
				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
					return innerFunc(ctx, dfs)
				})

				// don't run the out.Concurrently() call below
				out.Values[i] = graphql.Null
				continue
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
		case "permission":
			field := field

			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._SCIMConfiguration_permission(ctx, field, obj)
				if res == graphql.Null {
					atomic.AddUint32(&fs.Invalids, 1)
				}
				return res
			}

			if field.Deferrable != nil {
				dfs, ok := deferred[field.Deferrable.Label]
				di := 0
				if ok {
					dfs.AddField(field)
					di = len(dfs.Values) - 1
				} else {
					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
					deferred[field.Deferrable.Label] = dfs
				}
				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
					return innerFunc(ctx, dfs)
				})

				// don't run the out.Concurrently() call below
				out.Values[i] = graphql.Null
				continue
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var sCIMEventImplementors = []string{"SCIMEvent", "Node"}

func (ec *executionContext) _SCIMEvent(ctx context.Context, sel ast.SelectionSet, obj *types.SCIMEvent) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, sCIMEventImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("SCIMEvent")
		case "id":
			out.Values[i] = ec._SCIMEvent_id(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "method":
			out.Values[i] = ec._SCIMEvent_method(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "path":
			out.Values[i] = ec._SCIMEvent_path(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "statusCode":
			out.Values[i] = ec._SCIMEvent_statusCode(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "requestBody":
			out.Values[i] = ec._SCIMEvent_requestBody(ctx, field, obj)
		case "responseBody":
			out.Values[i] = ec._SCIMEvent_responseBody(ctx, field, obj)
		case "errorMessage":
			out.Values[i] = ec._SCIMEvent_errorMessage(ctx, field, obj)
		case "membership":
			field := field

			innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._SCIMEvent_membership(ctx, field, obj)
				return res
			}

			if field.Deferrable != nil {
				dfs, ok := deferred[field.Deferrable.Label]
				di := 0
				if ok {
					dfs.AddField(field)
					di = len(dfs.Values) - 1
				} else {
					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
					deferred[field.Deferrable.Label] = dfs
				}
				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
					return innerFunc(ctx, dfs)
				})

				// don't run the out.Concurrently() call below
				out.Values[i] = graphql.Null
				continue
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
		case "ipAddress":
			out.Values[i] = ec._SCIMEvent_ipAddress(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "createdAt":
			out.Values[i] = ec._SCIMEvent_createdAt(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "permission":
			field := field

			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._SCIMEvent_permission(ctx, field, obj)
				if res == graphql.Null {
					atomic.AddUint32(&fs.Invalids, 1)
				}
				return res
			}

			if field.Deferrable != nil {
				dfs, ok := deferred[field.Deferrable.Label]
				di := 0
				if ok {
					dfs.AddField(field)
					di = len(dfs.Values) - 1
				} else {
					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
					deferred[field.Deferrable.Label] = dfs
				}
				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
					return innerFunc(ctx, dfs)
				})

				// don't run the out.Concurrently() call below
				out.Values[i] = graphql.Null
				continue
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var sCIMEventConnectionImplementors = []string{"SCIMEventConnection"}

func (ec *executionContext) _SCIMEventConnection(ctx context.Context, sel ast.SelectionSet, obj *types.SCIMEventConnection) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, sCIMEventConnectionImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("SCIMEventConnection")
		case "edges":
			out.Values[i] = ec._SCIMEventConnection_edges(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "pageInfo":
			out.Values[i] = ec._SCIMEventConnection_pageInfo(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "totalCount":
			field := field

			innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._SCIMEventConnection_totalCount(ctx, field, obj)
				return res
			}

			if field.Deferrable != nil {
				dfs, ok := deferred[field.Deferrable.Label]
				di := 0
				if ok {
					dfs.AddField(field)
					di = len(dfs.Values) - 1
				} else {
					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
					deferred[field.Deferrable.Label] = dfs
				}
				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
					return innerFunc(ctx, dfs)
				})

				// don't run the out.Concurrently() call below
				out.Values[i] = graphql.Null
				continue
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var sCIMEventEdgeImplementors = []string{"SCIMEventEdge"}

func (ec *executionContext) _SCIMEventEdge(ctx context.Context, sel ast.SelectionSet, obj *types.SCIMEventEdge) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, sCIMEventEdgeImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("SCIMEventEdge")
		case "node":
			out.Values[i] = ec._SCIMEventEdge_node(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "cursor":
			out.Values[i] = ec._SCIMEventEdge_cursor(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var sessionImplementors = []string{"Session", "Node"}

func (ec *executionContext) _Session(ctx context.Context, sel ast.SelectionSet, obj *types.Session) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, sessionImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("Session")
		case "id":
			out.Values[i] = ec._Session_id(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "identity":
			field := field

			innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Session_identity(ctx, field, obj)
				return res
			}

			if field.Deferrable != nil {
				dfs, ok := deferred[field.Deferrable.Label]
				di := 0
				if ok {
					dfs.AddField(field)
					di = len(dfs.Values) - 1
				} else {
					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
					deferred[field.Deferrable.Label] = dfs
				}
				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
					return innerFunc(ctx, dfs)
				})

				// don't run the out.Concurrently() call below
				out.Values[i] = graphql.Null
				continue
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
		case "ipAddress":
			out.Values[i] = ec._Session_ipAddress(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "userAgent":
			out.Values[i] = ec._Session_userAgent(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "updatedAt":
			out.Values[i] = ec._Session_updatedAt(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "createdAt":
			out.Values[i] = ec._Session_createdAt(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "expiresAt":
			out.Values[i] = ec._Session_expiresAt(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "permission":
			field := field

			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Session_permission(ctx, field, obj)
				if res == graphql.Null {
					atomic.AddUint32(&fs.Invalids, 1)
				}
				return res
			}

			if field.Deferrable != nil {
				dfs, ok := deferred[field.Deferrable.Label]
				di := 0
				if ok {
					dfs.AddField(field)
					di = len(dfs.Values) - 1
				} else {
					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
					deferred[field.Deferrable.Label] = dfs
				}
				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
					return innerFunc(ctx, dfs)
				})

				// don't run the out.Concurrently() call below
				out.Values[i] = graphql.Null
				continue
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var sessionConnectionImplementors = []string{"SessionConnection"}

func (ec *executionContext) _SessionConnection(ctx context.Context, sel ast.SelectionSet, obj *types.SessionConnection) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, sessionConnectionImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("SessionConnection")
		case "edges":
			out.Values[i] = ec._SessionConnection_edges(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "pageInfo":
			out.Values[i] = ec._SessionConnection_pageInfo(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "totalCount":
			field := field

			innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._SessionConnection_totalCount(ctx, field, obj)
				return res
			}

			if field.Deferrable != nil {
				dfs, ok := deferred[field.Deferrable.Label]
				di := 0
				if ok {
					dfs.AddField(field)
					di = len(dfs.Values) - 1
				} else {
					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
					deferred[field.Deferrable.Label] = dfs
				}
				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
					return innerFunc(ctx, dfs)
				})

				// don't run the out.Concurrently() call below
				out.Values[i] = graphql.Null
				continue
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var sessionEdgeImplementors = []string{"SessionEdge"}

func (ec *executionContext) _SessionEdge(ctx context.Context, sel ast.SelectionSet, obj *types.SessionEdge) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, sessionEdgeImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("SessionEdge")
		case "node":
			out.Values[i] = ec._SessionEdge_node(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "cursor":
			out.Values[i] = ec._SessionEdge_cursor(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var signInPayloadImplementors = []string{"SignInPayload"}

func (ec *executionContext) _SignInPayload(ctx context.Context, sel ast.SelectionSet, obj *types.SignInPayload) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, signInPayloadImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("SignInPayload")
		case "identity":
			out.Values[i] = ec._SignInPayload_identity(ctx, field, obj)
		case "session":
			out.Values[i] = ec._SignInPayload_session(ctx, field, obj)
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var signOutPayloadImplementors = []string{"SignOutPayload"}

func (ec *executionContext) _SignOutPayload(ctx context.Context, sel ast.SelectionSet, obj *types.SignOutPayload) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, signOutPayloadImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("SignOutPayload")
		case "success":
			out.Values[i] = ec._SignOutPayload_success(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var signUpFromInvitationPayloadImplementors = []string{"SignUpFromInvitationPayload"}

func (ec *executionContext) _SignUpFromInvitationPayload(ctx context.Context, sel ast.SelectionSet, obj *types.SignUpFromInvitationPayload) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, signUpFromInvitationPayloadImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("SignUpFromInvitationPayload")
		case "identity":
			out.Values[i] = ec._SignUpFromInvitationPayload_identity(ctx, field, obj)
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var signUpPayloadImplementors = []string{"SignUpPayload"}

func (ec *executionContext) _SignUpPayload(ctx context.Context, sel ast.SelectionSet, obj *types.SignUpPayload) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, signUpPayloadImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("SignUpPayload")
		case "identity":
			out.Values[i] = ec._SignUpPayload_identity(ctx, field, obj)
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var updateMembershipPayloadImplementors = []string{"UpdateMembershipPayload"}

func (ec *executionContext) _UpdateMembershipPayload(ctx context.Context, sel ast.SelectionSet, obj *types.UpdateMembershipPayload) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, updateMembershipPayloadImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("UpdateMembershipPayload")
		case "membership":
			out.Values[i] = ec._UpdateMembershipPayload_membership(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var updateOrganizationPayloadImplementors = []string{"UpdateOrganizationPayload"}

func (ec *executionContext) _UpdateOrganizationPayload(ctx context.Context, sel ast.SelectionSet, obj *types.UpdateOrganizationPayload) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, updateOrganizationPayloadImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("UpdateOrganizationPayload")
		case "organization":
			out.Values[i] = ec._UpdateOrganizationPayload_organization(ctx, field, obj)
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var updateProfilePayloadImplementors = []string{"UpdateProfilePayload"}

func (ec *executionContext) _UpdateProfilePayload(ctx context.Context, sel ast.SelectionSet, obj *types.UpdateProfilePayload) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, updateProfilePayloadImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("UpdateProfilePayload")
		case "profile":
			out.Values[i] = ec._UpdateProfilePayload_profile(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var updateSAMLConfigurationPayloadImplementors = []string{"UpdateSAMLConfigurationPayload"}

func (ec *executionContext) _UpdateSAMLConfigurationPayload(ctx context.Context, sel ast.SelectionSet, obj *types.UpdateSAMLConfigurationPayload) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, updateSAMLConfigurationPayloadImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("UpdateSAMLConfigurationPayload")
		case "samlConfiguration":
			out.Values[i] = ec._UpdateSAMLConfigurationPayload_samlConfiguration(ctx, field, obj)
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var updateSCIMBridgePayloadImplementors = []string{"UpdateSCIMBridgePayload"}

func (ec *executionContext) _UpdateSCIMBridgePayload(ctx context.Context, sel ast.SelectionSet, obj *types.UpdateSCIMBridgePayload) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, updateSCIMBridgePayloadImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("UpdateSCIMBridgePayload")
		case "scimBridge":
			out.Values[i] = ec._UpdateSCIMBridgePayload_scimBridge(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var verifyEmailPayloadImplementors = []string{"VerifyEmailPayload"}

func (ec *executionContext) _VerifyEmailPayload(ctx context.Context, sel ast.SelectionSet, obj *types.VerifyEmailPayload) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, verifyEmailPayloadImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("VerifyEmailPayload")
		case "success":
			out.Values[i] = ec._VerifyEmailPayload_success(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var __DirectiveImplementors = []string{"__Directive"}

func (ec *executionContext) ___Directive(ctx context.Context, sel ast.SelectionSet, obj *introspection.Directive) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, __DirectiveImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("__Directive")
		case "name":
			out.Values[i] = ec.___Directive_name(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "description":
			out.Values[i] = ec.___Directive_description(ctx, field, obj)
		case "isRepeatable":
			out.Values[i] = ec.___Directive_isRepeatable(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "locations":
			out.Values[i] = ec.___Directive_locations(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "args":
			out.Values[i] = ec.___Directive_args(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var __EnumValueImplementors = []string{"__EnumValue"}

func (ec *executionContext) ___EnumValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.EnumValue) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, __EnumValueImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("__EnumValue")
		case "name":
			out.Values[i] = ec.___EnumValue_name(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "description":
			out.Values[i] = ec.___EnumValue_description(ctx, field, obj)
		case "isDeprecated":
			out.Values[i] = ec.___EnumValue_isDeprecated(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "deprecationReason":
			out.Values[i] = ec.___EnumValue_deprecationReason(ctx, field, obj)
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var __FieldImplementors = []string{"__Field"}

func (ec *executionContext) ___Field(ctx context.Context, sel ast.SelectionSet, obj *introspection.Field) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, __FieldImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("__Field")
		case "name":
			out.Values[i] = ec.___Field_name(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "description":
			out.Values[i] = ec.___Field_description(ctx, field, obj)
		case "args":
			out.Values[i] = ec.___Field_args(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "type":
			out.Values[i] = ec.___Field_type(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "isDeprecated":
			out.Values[i] = ec.___Field_isDeprecated(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "deprecationReason":
			out.Values[i] = ec.___Field_deprecationReason(ctx, field, obj)
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var __InputValueImplementors = []string{"__InputValue"}

func (ec *executionContext) ___InputValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.InputValue) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, __InputValueImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("__InputValue")
		case "name":
			out.Values[i] = ec.___InputValue_name(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "description":
			out.Values[i] = ec.___InputValue_description(ctx, field, obj)
		case "type":
			out.Values[i] = ec.___InputValue_type(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "defaultValue":
			out.Values[i] = ec.___InputValue_defaultValue(ctx, field, obj)
		case "isDeprecated":
			out.Values[i] = ec.___InputValue_isDeprecated(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "deprecationReason":
			out.Values[i] = ec.___InputValue_deprecationReason(ctx, field, obj)
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var __SchemaImplementors = []string{"__Schema"}

func (ec *executionContext) ___Schema(ctx context.Context, sel ast.SelectionSet, obj *introspection.Schema) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, __SchemaImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("__Schema")
		case "description":
			out.Values[i] = ec.___Schema_description(ctx, field, obj)
		case "types":
			out.Values[i] = ec.___Schema_types(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "queryType":
			out.Values[i] = ec.___Schema_queryType(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "mutationType":
			out.Values[i] = ec.___Schema_mutationType(ctx, field, obj)
		case "subscriptionType":
			out.Values[i] = ec.___Schema_subscriptionType(ctx, field, obj)
		case "directives":
			out.Values[i] = ec.___Schema_directives(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var __TypeImplementors = []string{"__Type"}

func (ec *executionContext) ___Type(ctx context.Context, sel ast.SelectionSet, obj *introspection.Type) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, __TypeImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("__Type")
		case "kind":
			out.Values[i] = ec.___Type_kind(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "name":
			out.Values[i] = ec.___Type_name(ctx, field, obj)
		case "description":
			out.Values[i] = ec.___Type_description(ctx, field, obj)
		case "specifiedByURL":
			out.Values[i] = ec.___Type_specifiedByURL(ctx, field, obj)
		case "fields":
			out.Values[i] = ec.___Type_fields(ctx, field, obj)
		case "interfaces":
			out.Values[i] = ec.___Type_interfaces(ctx, field, obj)
		case "possibleTypes":
			out.Values[i] = ec.___Type_possibleTypes(ctx, field, obj)
		case "enumValues":
			out.Values[i] = ec.___Type_enumValues(ctx, field, obj)
		case "inputFields":
			out.Values[i] = ec.___Type_inputFields(ctx, field, obj)
		case "ofType":
			out.Values[i] = ec.___Type_ofType(ctx, field, obj)
		case "isOneOf":
			out.Values[i] = ec.___Type_isOneOf(ctx, field, obj)
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

// endregion **************************** object.gotpl ****************************

// region    ***************************** type.gotpl *****************************

func (ec *executionContext) unmarshalNAcceptInvitationInput2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐAcceptInvitationInput(ctx context.Context, v any) (types.AcceptInvitationInput, error) {
	res, err := ec.unmarshalInputAcceptInvitationInput(ctx, v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) unmarshalNAssumeOrganizationSessionInput2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐAssumeOrganizationSessionInput(ctx context.Context, v any) (types.AssumeOrganizationSessionInput, error) {
	res, err := ec.unmarshalInputAssumeOrganizationSessionInput(ctx, v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNAssumeOrganizationSessionResult2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐAssumeOrganizationSessionResult(ctx context.Context, sel ast.SelectionSet, v types.AssumeOrganizationSessionResult) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
		}
		return graphql.Null
	}
	return ec._AssumeOrganizationSessionResult(ctx, sel, v)
}

func (ec *executionContext) unmarshalNBoolean2bool(ctx context.Context, v any) (bool, error) {
	res, err := graphql.UnmarshalBoolean(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
	_ = sel
	res := graphql.MarshalBoolean(v)
	if res == graphql.Null {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
		}
	}
	return res
}

func (ec *executionContext) unmarshalNChangeEmailInput2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐChangeEmailInput(ctx context.Context, v any) (types.ChangeEmailInput, error) {
	res, err := ec.unmarshalInputChangeEmailInput(ctx, v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) unmarshalNChangePasswordInput2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐChangePasswordInput(ctx context.Context, v any) (types.ChangePasswordInput, error) {
	res, err := ec.unmarshalInputChangePasswordInput(ctx, v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) unmarshalNConnectorProvider2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐConnectorProvider(ctx context.Context, v any) (coredata.ConnectorProvider, error) {
	tmp, err := graphql.UnmarshalString(v)
	res := unmarshalNConnectorProvider2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐConnectorProvider[tmp]
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNConnectorProvider2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐConnectorProvider(ctx context.Context, sel ast.SelectionSet, v coredata.ConnectorProvider) graphql.Marshaler {
	_ = sel
	res := graphql.MarshalString(marshalNConnectorProvider2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐConnectorProvider[v])
	if res == graphql.Null {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
		}
	}
	return res
}

var (
	unmarshalNConnectorProvider2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐConnectorProvider = map[string]coredata.ConnectorProvider{
		"SLACK":            coredata.ConnectorProviderSlack,
		"GOOGLE_WORKSPACE": coredata.ConnectorProviderGoogleWorkspace,
	}
	marshalNConnectorProvider2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐConnectorProvider = map[coredata.ConnectorProvider]string{
		coredata.ConnectorProviderSlack:           "SLACK",
		coredata.ConnectorProviderGoogleWorkspace: "GOOGLE_WORKSPACE",
	}
)

func (ec *executionContext) unmarshalNCreateOrganizationInput2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐCreateOrganizationInput(ctx context.Context, v any) (types.CreateOrganizationInput, error) {
	res, err := ec.unmarshalInputCreateOrganizationInput(ctx, v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) unmarshalNCreatePersonalAPIKeyInput2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐCreatePersonalAPIKeyInput(ctx context.Context, v any) (types.CreatePersonalAPIKeyInput, error) {
	res, err := ec.unmarshalInputCreatePersonalAPIKeyInput(ctx, v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) unmarshalNCreateSAMLConfigurationInput2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐCreateSAMLConfigurationInput(ctx context.Context, v any) (types.CreateSAMLConfigurationInput, error) {
	res, err := ec.unmarshalInputCreateSAMLConfigurationInput(ctx, v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) unmarshalNCreateSCIMConfigurationInput2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐCreateSCIMConfigurationInput(ctx context.Context, v any) (types.CreateSCIMConfigurationInput, error) {
	res, err := ec.unmarshalInputCreateSCIMConfigurationInput(ctx, v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) unmarshalNCursorKey2goᚗproboᚗincᚋproboᚋpkgᚋpageᚐCursorKey(ctx context.Context, v any) (page.CursorKey, error) {
	res, err := cursor.UnmarshalCursorKeyScalar(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNCursorKey2goᚗproboᚗincᚋproboᚋpkgᚋpageᚐCursorKey(ctx context.Context, sel ast.SelectionSet, v page.CursorKey) graphql.Marshaler {
	_ = sel
	res := cursor.MarshalCursorKeyScalar(v)
	if res == graphql.Null {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
		}
	}
	return res
}

func (ec *executionContext) unmarshalNDatetime2timeᚐTime(ctx context.Context, v any) (time.Time, error) {
	res, err := graphql.UnmarshalTime(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNDatetime2timeᚐTime(ctx context.Context, sel ast.SelectionSet, v time.Time) graphql.Marshaler {
	_ = sel
	res := graphql.MarshalTime(v)
	if res == graphql.Null {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
		}
	}
	return res
}

func (ec *executionContext) unmarshalNDeleteInvitationInput2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐDeleteInvitationInput(ctx context.Context, v any) (types.DeleteInvitationInput, error) {
	res, err := ec.unmarshalInputDeleteInvitationInput(ctx, v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) unmarshalNDeleteOrganizationHorizontalLogoInput2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐDeleteOrganizationHorizontalLogoInput(ctx context.Context, v any) (types.DeleteOrganizationHorizontalLogoInput, error) {
	res, err := ec.unmarshalInputDeleteOrganizationHorizontalLogoInput(ctx, v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) unmarshalNDeleteOrganizationInput2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐDeleteOrganizationInput(ctx context.Context, v any) (types.DeleteOrganizationInput, error) {
	res, err := ec.unmarshalInputDeleteOrganizationInput(ctx, v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) unmarshalNDeleteSAMLConfigurationInput2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐDeleteSAMLConfigurationInput(ctx context.Context, v any) (types.DeleteSAMLConfigurationInput, error) {
	res, err := ec.unmarshalInputDeleteSAMLConfigurationInput(ctx, v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) unmarshalNDeleteSCIMConfigurationInput2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐDeleteSCIMConfigurationInput(ctx context.Context, v any) (types.DeleteSCIMConfigurationInput, error) {
	res, err := ec.unmarshalInputDeleteSCIMConfigurationInput(ctx, v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) unmarshalNEmailAddr2goᚗproboᚗincᚋproboᚋpkgᚋmailᚐAddr(ctx context.Context, v any) (mail.Addr, error) {
	res, err := mail1.UnmarshalAddrScalar(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNEmailAddr2goᚗproboᚗincᚋproboᚋpkgᚋmailᚐAddr(ctx context.Context, sel ast.SelectionSet, v mail.Addr) graphql.Marshaler {
	_ = sel
	res := mail1.MarshalAddrScalar(v)
	if res == graphql.Null {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
		}
	}
	return res
}

func (ec *executionContext) unmarshalNEmailAddr2ᚕgoᚗproboᚗincᚋproboᚋpkgᚋmailᚐAddrᚄ(ctx context.Context, v any) ([]mail.Addr, error) {
	var vSlice []any
	vSlice = graphql.CoerceList(v)
	var err error
	res := make([]mail.Addr, len(vSlice))
	for i := range vSlice {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
		res[i], err = ec.unmarshalNEmailAddr2goᚗproboᚗincᚋproboᚋpkgᚋmailᚐAddr(ctx, vSlice[i])
		if err != nil {
			return nil, err
		}
	}
	return res, nil
}

func (ec *executionContext) marshalNEmailAddr2ᚕgoᚗproboᚗincᚋproboᚋpkgᚋmailᚐAddrᚄ(ctx context.Context, sel ast.SelectionSet, v []mail.Addr) graphql.Marshaler {
	ret := make(graphql.Array, len(v))
	for i := range v {
		ret[i] = ec.marshalNEmailAddr2goᚗproboᚗincᚋproboᚋpkgᚋmailᚐAddr(ctx, sel, v[i])
	}

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	return ret
}

func (ec *executionContext) unmarshalNForgotPasswordInput2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐForgotPasswordInput(ctx context.Context, v any) (types.ForgotPasswordInput, error) {
	res, err := ec.unmarshalInputForgotPasswordInput(ctx, v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) unmarshalNID2goᚗproboᚗincᚋproboᚋpkgᚋgidᚐGID(ctx context.Context, v any) (gid.GID, error) {
	res, err := gid1.UnmarshalGIDScalar(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNID2goᚗproboᚗincᚋproboᚋpkgᚋgidᚐGID(ctx context.Context, sel ast.SelectionSet, v gid.GID) graphql.Marshaler {
	_ = sel
	res := gid1.MarshalGIDScalar(v)
	if res == graphql.Null {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
		}
	}
	return res
}

func (ec *executionContext) unmarshalNInt2int(ctx context.Context, v any) (int, error) {
	res, err := graphql.UnmarshalInt(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNInt2int(ctx context.Context, sel ast.SelectionSet, v int) graphql.Marshaler {
	_ = sel
	res := graphql.MarshalInt(v)
	if res == graphql.Null {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
		}
	}
	return res
}

func (ec *executionContext) marshalNInvitation2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐInvitation(ctx context.Context, sel ast.SelectionSet, v *types.Invitation) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
		}
		return graphql.Null
	}
	return ec._Invitation(ctx, sel, v)
}

func (ec *executionContext) marshalNInvitationEdge2ᚕᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐInvitationEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*types.InvitationEdge) graphql.Marshaler {
	ret := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalNInvitationEdge2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐInvitationEdge(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	return ret
}

func (ec *executionContext) marshalNInvitationEdge2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐInvitationEdge(ctx context.Context, sel ast.SelectionSet, v *types.InvitationEdge) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
		}
		return graphql.Null
	}
	return ec._InvitationEdge(ctx, sel, v)
}

func (ec *executionContext) unmarshalNInvitationOrderField2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐInvitationOrderField(ctx context.Context, v any) (coredata.InvitationOrderField, error) {
	tmp, err := graphql.UnmarshalString(v)
	res := unmarshalNInvitationOrderField2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐInvitationOrderField[tmp]
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNInvitationOrderField2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐInvitationOrderField(ctx context.Context, sel ast.SelectionSet, v coredata.InvitationOrderField) graphql.Marshaler {
	_ = sel
	res := graphql.MarshalString(marshalNInvitationOrderField2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐInvitationOrderField[v])
	if res == graphql.Null {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
		}
	}
	return res
}

var (
	unmarshalNInvitationOrderField2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐInvitationOrderField = map[string]coredata.InvitationOrderField{
		"FULL_NAME":   coredata.InvitationOrderFieldFullName,
		"EMAIL":       coredata.InvitationOrderFieldEmail,
		"ROLE":        coredata.InvitationOrderFieldRole,
		"CREATED_AT":  coredata.InvitationOrderFieldCreatedAt,
		"EXPIRES_AT":  coredata.InvitationOrderFieldExpiresAt,
		"ACCEPTED_AT": coredata.InvitationOrderFieldAcceptedAt,
	}
	marshalNInvitationOrderField2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐInvitationOrderField = map[coredata.InvitationOrderField]string{
		coredata.InvitationOrderFieldFullName:   "FULL_NAME",
		coredata.InvitationOrderFieldEmail:      "EMAIL",
		coredata.InvitationOrderFieldRole:       "ROLE",
		coredata.InvitationOrderFieldCreatedAt:  "CREATED_AT",
		coredata.InvitationOrderFieldExpiresAt:  "EXPIRES_AT",
		coredata.InvitationOrderFieldAcceptedAt: "ACCEPTED_AT",
	}
)

func (ec *executionContext) unmarshalNInvitationStatus2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐInvitationStatus(ctx context.Context, v any) (coredata.InvitationStatus, error) {
	tmp, err := graphql.UnmarshalString(v)
	res := unmarshalNInvitationStatus2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐInvitationStatus[tmp]
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNInvitationStatus2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐInvitationStatus(ctx context.Context, sel ast.SelectionSet, v coredata.InvitationStatus) graphql.Marshaler {
	_ = sel
	res := graphql.MarshalString(marshalNInvitationStatus2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐInvitationStatus[v])
	if res == graphql.Null {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
		}
	}
	return res
}

var (
	unmarshalNInvitationStatus2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐInvitationStatus = map[string]coredata.InvitationStatus{
		"PENDING":  coredata.InvitationStatusPending,
		"ACCEPTED": coredata.InvitationStatusAccepted,
		"EXPIRED":  coredata.InvitationStatusExpired,
	}
	marshalNInvitationStatus2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐInvitationStatus = map[coredata.InvitationStatus]string{
		coredata.InvitationStatusPending:  "PENDING",
		coredata.InvitationStatusAccepted: "ACCEPTED",
		coredata.InvitationStatusExpired:  "EXPIRED",
	}
)

func (ec *executionContext) unmarshalNInviteMemberInput2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐInviteMemberInput(ctx context.Context, v any) (types.InviteMemberInput, error) {
	res, err := ec.unmarshalInputInviteMemberInput(ctx, v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNMembership2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐMembership(ctx context.Context, sel ast.SelectionSet, v *types.Membership) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
		}
		return graphql.Null
	}
	return ec._Membership(ctx, sel, v)
}

func (ec *executionContext) marshalNMembershipEdge2ᚕᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐMembershipEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*types.MembershipEdge) graphql.Marshaler {
	ret := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalNMembershipEdge2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐMembershipEdge(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	return ret
}

func (ec *executionContext) marshalNMembershipEdge2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐMembershipEdge(ctx context.Context, sel ast.SelectionSet, v *types.MembershipEdge) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
		}
		return graphql.Null
	}
	return ec._MembershipEdge(ctx, sel, v)
}

func (ec *executionContext) unmarshalNMembershipOrderField2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐMembershipOrderField(ctx context.Context, v any) (coredata.MembershipOrderField, error) {
	tmp, err := graphql.UnmarshalString(v)
	res := unmarshalNMembershipOrderField2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐMembershipOrderField[tmp]
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNMembershipOrderField2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐMembershipOrderField(ctx context.Context, sel ast.SelectionSet, v coredata.MembershipOrderField) graphql.Marshaler {
	_ = sel
	res := graphql.MarshalString(marshalNMembershipOrderField2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐMembershipOrderField[v])
	if res == graphql.Null {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
		}
	}
	return res
}

var (
	unmarshalNMembershipOrderField2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐMembershipOrderField = map[string]coredata.MembershipOrderField{
		"FULL_NAME":         coredata.MembershipOrderFieldFullName,
		"ORGANIZATION_NAME": coredata.MembershipOrderFieldOrganizationName,
		"EMAIL_ADDRESS":     coredata.MembershipOrderFieldEmailAddress,
		"ROLE":              coredata.MembershipOrderFieldRole,
		"CREATED_AT":        coredata.MembershipOrderFieldCreatedAt,
	}
	marshalNMembershipOrderField2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐMembershipOrderField = map[coredata.MembershipOrderField]string{
		coredata.MembershipOrderFieldFullName:         "FULL_NAME",
		coredata.MembershipOrderFieldOrganizationName: "ORGANIZATION_NAME",
		coredata.MembershipOrderFieldEmailAddress:     "EMAIL_ADDRESS",
		coredata.MembershipOrderFieldRole:             "ROLE",
		coredata.MembershipOrderFieldCreatedAt:        "CREATED_AT",
	}
)

func (ec *executionContext) marshalNMembershipProfile2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐMembershipProfile(ctx context.Context, sel ast.SelectionSet, v *types.MembershipProfile) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
		}
		return graphql.Null
	}
	return ec._MembershipProfile(ctx, sel, v)
}

func (ec *executionContext) unmarshalNMembershipRole2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐMembershipRole(ctx context.Context, v any) (coredata.MembershipRole, error) {
	tmp, err := graphql.UnmarshalString(v)
	res := unmarshalNMembershipRole2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐMembershipRole[tmp]
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNMembershipRole2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐMembershipRole(ctx context.Context, sel ast.SelectionSet, v coredata.MembershipRole) graphql.Marshaler {
	_ = sel
	res := graphql.MarshalString(marshalNMembershipRole2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐMembershipRole[v])
	if res == graphql.Null {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
		}
	}
	return res
}

var (
	unmarshalNMembershipRole2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐMembershipRole = map[string]coredata.MembershipRole{
		"OWNER":    coredata.MembershipRoleOwner,
		"ADMIN":    coredata.MembershipRoleAdmin,
		"EMPLOYEE": coredata.MembershipRoleEmployee,
		"VIEWER":   coredata.MembershipRoleViewer,
		"AUDITOR":  coredata.MembershipRoleAuditor,
	}
	marshalNMembershipRole2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐMembershipRole = map[coredata.MembershipRole]string{
		coredata.MembershipRoleOwner:    "OWNER",
		coredata.MembershipRoleAdmin:    "ADMIN",
		coredata.MembershipRoleEmployee: "EMPLOYEE",
		coredata.MembershipRoleViewer:   "VIEWER",
		coredata.MembershipRoleAuditor:  "AUDITOR",
	}
)

func (ec *executionContext) unmarshalNMembershipSource2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐMembershipSource(ctx context.Context, v any) (coredata.MembershipSource, error) {
	tmp, err := graphql.UnmarshalString(v)
	res := unmarshalNMembershipSource2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐMembershipSource[tmp]
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNMembershipSource2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐMembershipSource(ctx context.Context, sel ast.SelectionSet, v coredata.MembershipSource) graphql.Marshaler {
	_ = sel
	res := graphql.MarshalString(marshalNMembershipSource2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐMembershipSource[v])
	if res == graphql.Null {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
		}
	}
	return res
}

var (
	unmarshalNMembershipSource2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐMembershipSource = map[string]coredata.MembershipSource{
		"MANUAL": coredata.MembershipSourceManual,
		"SAML":   coredata.MembershipSourceSAML,
		"SCIM":   coredata.MembershipSourceSCIM,
	}
	marshalNMembershipSource2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐMembershipSource = map[coredata.MembershipSource]string{
		coredata.MembershipSourceManual: "MANUAL",
		coredata.MembershipSourceSAML:   "SAML",
		coredata.MembershipSourceSCIM:   "SCIM",
	}
)

func (ec *executionContext) unmarshalNMembershipState2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐMembershipState(ctx context.Context, v any) (coredata.MembershipState, error) {
	tmp, err := graphql.UnmarshalString(v)
	res := unmarshalNMembershipState2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐMembershipState[tmp]
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNMembershipState2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐMembershipState(ctx context.Context, sel ast.SelectionSet, v coredata.MembershipState) graphql.Marshaler {
	_ = sel
	res := graphql.MarshalString(marshalNMembershipState2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐMembershipState[v])
	if res == graphql.Null {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
		}
	}
	return res
}

var (
	unmarshalNMembershipState2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐMembershipState = map[string]coredata.MembershipState{
		"ACTIVE":   coredata.MembershipStateActive,
		"INACTIVE": coredata.MembershipStateInactive,
	}
	marshalNMembershipState2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐMembershipState = map[coredata.MembershipState]string{
		coredata.MembershipStateActive:   "ACTIVE",
		coredata.MembershipStateInactive: "INACTIVE",
	}
)

func (ec *executionContext) unmarshalNOrderDirection2goᚗproboᚗincᚋproboᚋpkgᚋpageᚐOrderDirection(ctx context.Context, v any) (page.OrderDirection, error) {
	tmp, err := graphql.UnmarshalString(v)
	res := unmarshalNOrderDirection2goᚗproboᚗincᚋproboᚋpkgᚋpageᚐOrderDirection[tmp]
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNOrderDirection2goᚗproboᚗincᚋproboᚋpkgᚋpageᚐOrderDirection(ctx context.Context, sel ast.SelectionSet, v page.OrderDirection) graphql.Marshaler {
	_ = sel
	res := graphql.MarshalString(marshalNOrderDirection2goᚗproboᚗincᚋproboᚋpkgᚋpageᚐOrderDirection[v])
	if res == graphql.Null {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
		}
	}
	return res
}

var (
	unmarshalNOrderDirection2goᚗproboᚗincᚋproboᚋpkgᚋpageᚐOrderDirection = map[string]page.OrderDirection{
		"ASC":  page.OrderDirectionAsc,
		"DESC": page.OrderDirectionDesc,
	}
	marshalNOrderDirection2goᚗproboᚗincᚋproboᚋpkgᚋpageᚐOrderDirection = map[page.OrderDirection]string{
		page.OrderDirectionAsc:  "ASC",
		page.OrderDirectionDesc: "DESC",
	}
)

func (ec *executionContext) marshalNOrganization2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐOrganization(ctx context.Context, sel ast.SelectionSet, v *types.Organization) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
		}
		return graphql.Null
	}
	return ec._Organization(ctx, sel, v)
}

func (ec *executionContext) marshalNPageInfo2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐPageInfo(ctx context.Context, sel ast.SelectionSet, v types.PageInfo) graphql.Marshaler {
	return ec._PageInfo(ctx, sel, &v)
}

func (ec *executionContext) marshalNPersonalAPIKey2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐPersonalAPIKey(ctx context.Context, sel ast.SelectionSet, v *types.PersonalAPIKey) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
		}
		return graphql.Null
	}
	return ec._PersonalAPIKey(ctx, sel, v)
}

func (ec *executionContext) marshalNPersonalAPIKeyEdge2ᚕᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐPersonalAPIKeyEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*types.PersonalAPIKeyEdge) graphql.Marshaler {
	ret := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalNPersonalAPIKeyEdge2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐPersonalAPIKeyEdge(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	return ret
}

func (ec *executionContext) marshalNPersonalAPIKeyEdge2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐPersonalAPIKeyEdge(ctx context.Context, sel ast.SelectionSet, v *types.PersonalAPIKeyEdge) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
		}
		return graphql.Null
	}
	return ec._PersonalAPIKeyEdge(ctx, sel, v)
}

func (ec *executionContext) unmarshalNProfileKind2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐMembershipProfileKind(ctx context.Context, v any) (coredata.MembershipProfileKind, error) {
	tmp, err := graphql.UnmarshalString(v)
	res := unmarshalNProfileKind2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐMembershipProfileKind[tmp]
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNProfileKind2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐMembershipProfileKind(ctx context.Context, sel ast.SelectionSet, v coredata.MembershipProfileKind) graphql.Marshaler {
	_ = sel
	res := graphql.MarshalString(marshalNProfileKind2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐMembershipProfileKind[v])
	if res == graphql.Null {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
		}
	}
	return res
}

var (
	unmarshalNProfileKind2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐMembershipProfileKind = map[string]coredata.MembershipProfileKind{
		"EMPLOYEE":        coredata.MembershipProfileKindEmployee,
		"CONTRACTOR":      coredata.MembershipProfileKindContractor,
		"SERVICE_ACCOUNT": coredata.MembershipProfileKindServiceAccount,
	}
	marshalNProfileKind2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐMembershipProfileKind = map[coredata.MembershipProfileKind]string{
		coredata.MembershipProfileKindEmployee:       "EMPLOYEE",
		coredata.MembershipProfileKindContractor:     "CONTRACTOR",
		coredata.MembershipProfileKindServiceAccount: "SERVICE_ACCOUNT",
	}
)

func (ec *executionContext) unmarshalNReauthenticationReason2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐReauthenticationReason(ctx context.Context, v any) (types.ReauthenticationReason, error) {
	var res types.ReauthenticationReason
	err := res.UnmarshalGQL(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNReauthenticationReason2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐReauthenticationReason(ctx context.Context, sel ast.SelectionSet, v types.ReauthenticationReason) graphql.Marshaler {
	return v
}

func (ec *executionContext) unmarshalNRegenerateSCIMTokenInput2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐRegenerateSCIMTokenInput(ctx context.Context, v any) (types.RegenerateSCIMTokenInput, error) {
	res, err := ec.unmarshalInputRegenerateSCIMTokenInput(ctx, v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) unmarshalNRemoveMemberInput2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐRemoveMemberInput(ctx context.Context, v any) (types.RemoveMemberInput, error) {
	res, err := ec.unmarshalInputRemoveMemberInput(ctx, v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) unmarshalNResetPasswordInput2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐResetPasswordInput(ctx context.Context, v any) (types.ResetPasswordInput, error) {
	res, err := ec.unmarshalInputResetPasswordInput(ctx, v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) unmarshalNRevokePersonalAPIKeyInput2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐRevokePersonalAPIKeyInput(ctx context.Context, v any) (types.RevokePersonalAPIKeyInput, error) {
	res, err := ec.unmarshalInputRevokePersonalAPIKeyInput(ctx, v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) unmarshalNRevokeSessionInput2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐRevokeSessionInput(ctx context.Context, v any) (types.RevokeSessionInput, error) {
	res, err := ec.unmarshalInputRevokeSessionInput(ctx, v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNRevokeSessionPayload2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐRevokeSessionPayload(ctx context.Context, sel ast.SelectionSet, v types.RevokeSessionPayload) graphql.Marshaler {
	return ec._RevokeSessionPayload(ctx, sel, &v)
}

func (ec *executionContext) marshalNRevokeSessionPayload2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐRevokeSessionPayload(ctx context.Context, sel ast.SelectionSet, v *types.RevokeSessionPayload) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
		}
		return graphql.Null
	}
	return ec._RevokeSessionPayload(ctx, sel, v)
}

func (ec *executionContext) marshalNSAMLAttributeMappings2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐSAMLAttributeMappings(ctx context.Context, sel ast.SelectionSet, v *types.SAMLAttributeMappings) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
		}
		return graphql.Null
	}
	return ec._SAMLAttributeMappings(ctx, sel, v)
}

func (ec *executionContext) marshalNSAMLConfiguration2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐSAMLConfiguration(ctx context.Context, sel ast.SelectionSet, v *types.SAMLConfiguration) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
		}
		return graphql.Null
	}
	return ec._SAMLConfiguration(ctx, sel, v)
}

func (ec *executionContext) marshalNSAMLConfigurationEdge2ᚕᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐSAMLConfigurationEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*types.SAMLConfigurationEdge) graphql.Marshaler {
	ret := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalNSAMLConfigurationEdge2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐSAMLConfigurationEdge(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	return ret
}

func (ec *executionContext) marshalNSAMLConfigurationEdge2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐSAMLConfigurationEdge(ctx context.Context, sel ast.SelectionSet, v *types.SAMLConfigurationEdge) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
		}
		return graphql.Null
	}
	return ec._SAMLConfigurationEdge(ctx, sel, v)
}

func (ec *executionContext) unmarshalNSAMLEnforcementPolicy2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐSAMLEnforcementPolicy(ctx context.Context, v any) (coredata.SAMLEnforcementPolicy, error) {
	tmp, err := graphql.UnmarshalString(v)
	res := unmarshalNSAMLEnforcementPolicy2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐSAMLEnforcementPolicy[tmp]
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNSAMLEnforcementPolicy2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐSAMLEnforcementPolicy(ctx context.Context, sel ast.SelectionSet, v coredata.SAMLEnforcementPolicy) graphql.Marshaler {
	_ = sel
	res := graphql.MarshalString(marshalNSAMLEnforcementPolicy2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐSAMLEnforcementPolicy[v])
	if res == graphql.Null {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
		}
	}
	return res
}

var (
	unmarshalNSAMLEnforcementPolicy2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐSAMLEnforcementPolicy = map[string]coredata.SAMLEnforcementPolicy{
		"OFF":      coredata.SAMLEnforcementPolicyOff,
		"OPTIONAL": coredata.SAMLEnforcementPolicyOptional,
		"REQUIRED": coredata.SAMLEnforcementPolicyRequired,
	}
	marshalNSAMLEnforcementPolicy2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐSAMLEnforcementPolicy = map[coredata.SAMLEnforcementPolicy]string{
		coredata.SAMLEnforcementPolicyOff:      "OFF",
		coredata.SAMLEnforcementPolicyOptional: "OPTIONAL",
		coredata.SAMLEnforcementPolicyRequired: "REQUIRED",
	}
)

func (ec *executionContext) marshalNSCIMBridge2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐSCIMBridge(ctx context.Context, sel ast.SelectionSet, v *types.SCIMBridge) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
		}
		return graphql.Null
	}
	return ec._SCIMBridge(ctx, sel, v)
}

func (ec *executionContext) unmarshalNSCIMBridgeState2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐSCIMBridgeState(ctx context.Context, v any) (coredata.SCIMBridgeState, error) {
	tmp, err := graphql.UnmarshalString(v)
	res := unmarshalNSCIMBridgeState2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐSCIMBridgeState[tmp]
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNSCIMBridgeState2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐSCIMBridgeState(ctx context.Context, sel ast.SelectionSet, v coredata.SCIMBridgeState) graphql.Marshaler {
	_ = sel
	res := graphql.MarshalString(marshalNSCIMBridgeState2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐSCIMBridgeState[v])
	if res == graphql.Null {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
		}
	}
	return res
}

var (
	unmarshalNSCIMBridgeState2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐSCIMBridgeState = map[string]coredata.SCIMBridgeState{
		"PENDING": coredata.SCIMBridgeStatePending,
		"ACTIVE":  coredata.SCIMBridgeStateActive,
		"FAILED":  coredata.SCIMBridgeStateFailed,
	}
	marshalNSCIMBridgeState2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐSCIMBridgeState = map[coredata.SCIMBridgeState]string{
		coredata.SCIMBridgeStatePending: "PENDING",
		coredata.SCIMBridgeStateActive:  "ACTIVE",
		coredata.SCIMBridgeStateFailed:  "FAILED",
	}
)

func (ec *executionContext) unmarshalNSCIMBridgeType2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐSCIMBridgeType(ctx context.Context, v any) (coredata.SCIMBridgeType, error) {
	tmp, err := graphql.UnmarshalString(v)
	res := unmarshalNSCIMBridgeType2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐSCIMBridgeType[tmp]
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNSCIMBridgeType2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐSCIMBridgeType(ctx context.Context, sel ast.SelectionSet, v coredata.SCIMBridgeType) graphql.Marshaler {
	_ = sel
	res := graphql.MarshalString(marshalNSCIMBridgeType2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐSCIMBridgeType[v])
	if res == graphql.Null {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
		}
	}
	return res
}

var (
	unmarshalNSCIMBridgeType2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐSCIMBridgeType = map[string]coredata.SCIMBridgeType{
		"GOOGLE_WORKSPACE": coredata.SCIMBridgeTypeGoogleWorkspace,
	}
	marshalNSCIMBridgeType2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐSCIMBridgeType = map[coredata.SCIMBridgeType]string{
		coredata.SCIMBridgeTypeGoogleWorkspace: "GOOGLE_WORKSPACE",
	}
)

func (ec *executionContext) marshalNSCIMConfiguration2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐSCIMConfiguration(ctx context.Context, sel ast.SelectionSet, v *types.SCIMConfiguration) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
		}
		return graphql.Null
	}
	return ec._SCIMConfiguration(ctx, sel, v)
}

func (ec *executionContext) marshalNSCIMEvent2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐSCIMEvent(ctx context.Context, sel ast.SelectionSet, v *types.SCIMEvent) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
		}
		return graphql.Null
	}
	return ec._SCIMEvent(ctx, sel, v)
}

func (ec *executionContext) marshalNSCIMEventEdge2ᚕᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐSCIMEventEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*types.SCIMEventEdge) graphql.Marshaler {
	ret := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalNSCIMEventEdge2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐSCIMEventEdge(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	return ret
}

func (ec *executionContext) marshalNSCIMEventEdge2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐSCIMEventEdge(ctx context.Context, sel ast.SelectionSet, v *types.SCIMEventEdge) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
		}
		return graphql.Null
	}
	return ec._SCIMEventEdge(ctx, sel, v)
}

func (ec *executionContext) unmarshalNSCIMEventOrderField2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐSCIMEventOrderField(ctx context.Context, v any) (coredata.SCIMEventOrderField, error) {
	tmp, err := graphql.UnmarshalString(v)
	res := unmarshalNSCIMEventOrderField2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐSCIMEventOrderField[tmp]
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNSCIMEventOrderField2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐSCIMEventOrderField(ctx context.Context, sel ast.SelectionSet, v coredata.SCIMEventOrderField) graphql.Marshaler {
	_ = sel
	res := graphql.MarshalString(marshalNSCIMEventOrderField2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐSCIMEventOrderField[v])
	if res == graphql.Null {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
		}
	}
	return res
}

var (
	unmarshalNSCIMEventOrderField2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐSCIMEventOrderField = map[string]coredata.SCIMEventOrderField{
		"CREATED_AT": coredata.SCIMEventOrderFieldCreatedAt,
	}
	marshalNSCIMEventOrderField2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐSCIMEventOrderField = map[coredata.SCIMEventOrderField]string{
		coredata.SCIMEventOrderFieldCreatedAt: "CREATED_AT",
	}
)

func (ec *executionContext) marshalNSession2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐSession(ctx context.Context, sel ast.SelectionSet, v *types.Session) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
		}
		return graphql.Null
	}
	return ec._Session(ctx, sel, v)
}

func (ec *executionContext) marshalNSessionEdge2ᚕᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐSessionEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*types.SessionEdge) graphql.Marshaler {
	ret := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalNSessionEdge2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐSessionEdge(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	return ret
}

func (ec *executionContext) marshalNSessionEdge2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐSessionEdge(ctx context.Context, sel ast.SelectionSet, v *types.SessionEdge) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
		}
		return graphql.Null
	}
	return ec._SessionEdge(ctx, sel, v)
}

func (ec *executionContext) unmarshalNSessionOrderField2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐSessionOrderField(ctx context.Context, v any) (coredata.SessionOrderField, error) {
	tmp, err := graphql.UnmarshalString(v)
	res := unmarshalNSessionOrderField2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐSessionOrderField[tmp]
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNSessionOrderField2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐSessionOrderField(ctx context.Context, sel ast.SelectionSet, v coredata.SessionOrderField) graphql.Marshaler {
	_ = sel
	res := graphql.MarshalString(marshalNSessionOrderField2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐSessionOrderField[v])
	if res == graphql.Null {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
		}
	}
	return res
}

var (
	unmarshalNSessionOrderField2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐSessionOrderField = map[string]coredata.SessionOrderField{
		"CREATED_AT": coredata.SessionOrderFieldCreatedAt,
		"EXPIRED_AT": coredata.SessionOrderFieldExpiredAt,
		"UPDATED_AT": coredata.SessionOrderFieldUpdatedAt,
	}
	marshalNSessionOrderField2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐSessionOrderField = map[coredata.SessionOrderField]string{
		coredata.SessionOrderFieldCreatedAt: "CREATED_AT",
		coredata.SessionOrderFieldExpiredAt: "EXPIRED_AT",
		coredata.SessionOrderFieldUpdatedAt: "UPDATED_AT",
	}
)

func (ec *executionContext) unmarshalNSessionRequirement2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋgqlutilsᚋdirectivesᚋsessionᚐSessionRequirement(ctx context.Context, v any) (session.SessionRequirement, error) {
	tmp, err := graphql.UnmarshalString(v)
	res := unmarshalNSessionRequirement2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋgqlutilsᚋdirectivesᚋsessionᚐSessionRequirement[tmp]
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNSessionRequirement2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋgqlutilsᚋdirectivesᚋsessionᚐSessionRequirement(ctx context.Context, sel ast.SelectionSet, v session.SessionRequirement) graphql.Marshaler {
	_ = sel
	res := graphql.MarshalString(marshalNSessionRequirement2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋgqlutilsᚋdirectivesᚋsessionᚐSessionRequirement[v])
	if res == graphql.Null {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
		}
	}
	return res
}

var (
	unmarshalNSessionRequirement2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋgqlutilsᚋdirectivesᚋsessionᚐSessionRequirement = map[string]session.SessionRequirement{
		"PRESENT":  session.SessionRequirementPresent,
		"NONE":     session.SessionRequirementNone,
		"OPTIONAL": session.SessionRequirementOptional,
	}
	marshalNSessionRequirement2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋgqlutilsᚋdirectivesᚋsessionᚐSessionRequirement = map[session.SessionRequirement]string{
		session.SessionRequirementPresent:  "PRESENT",
		session.SessionRequirementNone:     "NONE",
		session.SessionRequirementOptional: "OPTIONAL",
	}
)

func (ec *executionContext) unmarshalNSignInInput2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐSignInInput(ctx context.Context, v any) (types.SignInInput, error) {
	res, err := ec.unmarshalInputSignInInput(ctx, v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) unmarshalNSignUpFromInvitationInput2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐSignUpFromInvitationInput(ctx context.Context, v any) (types.SignUpFromInvitationInput, error) {
	res, err := ec.unmarshalInputSignUpFromInvitationInput(ctx, v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) unmarshalNSignUpInput2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐSignUpInput(ctx context.Context, v any) (types.SignUpInput, error) {
	res, err := ec.unmarshalInputSignUpInput(ctx, v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) unmarshalNString2string(ctx context.Context, v any) (string, error) {
	res, err := graphql.UnmarshalString(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
	_ = sel
	res := graphql.MarshalString(v)
	if res == graphql.Null {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
		}
	}
	return res
}

func (ec *executionContext) unmarshalNString2ᚕstringᚄ(ctx context.Context, v any) ([]string, error) {
	var vSlice []any
	vSlice = graphql.CoerceList(v)
	var err error
	res := make([]string, len(vSlice))
	for i := range vSlice {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
		res[i], err = ec.unmarshalNString2string(ctx, vSlice[i])
		if err != nil {
			return nil, err
		}
	}
	return res, nil
}

func (ec *executionContext) marshalNString2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
	ret := make(graphql.Array, len(v))
	for i := range v {
		ret[i] = ec.marshalNString2string(ctx, sel, v[i])
	}

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	return ret
}

func (ec *executionContext) unmarshalNUpdateMembershipInput2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐUpdateMembershipInput(ctx context.Context, v any) (types.UpdateMembershipInput, error) {
	res, err := ec.unmarshalInputUpdateMembershipInput(ctx, v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNUpdateMembershipPayload2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐUpdateMembershipPayload(ctx context.Context, sel ast.SelectionSet, v types.UpdateMembershipPayload) graphql.Marshaler {
	return ec._UpdateMembershipPayload(ctx, sel, &v)
}

func (ec *executionContext) marshalNUpdateMembershipPayload2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐUpdateMembershipPayload(ctx context.Context, sel ast.SelectionSet, v *types.UpdateMembershipPayload) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
		}
		return graphql.Null
	}
	return ec._UpdateMembershipPayload(ctx, sel, v)
}

func (ec *executionContext) unmarshalNUpdateOrganizationInput2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐUpdateOrganizationInput(ctx context.Context, v any) (types.UpdateOrganizationInput, error) {
	res, err := ec.unmarshalInputUpdateOrganizationInput(ctx, v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) unmarshalNUpdateProfileInput2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐUpdateProfileInput(ctx context.Context, v any) (types.UpdateProfileInput, error) {
	res, err := ec.unmarshalInputUpdateProfileInput(ctx, v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNUpdateProfilePayload2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐUpdateProfilePayload(ctx context.Context, sel ast.SelectionSet, v types.UpdateProfilePayload) graphql.Marshaler {
	return ec._UpdateProfilePayload(ctx, sel, &v)
}

func (ec *executionContext) marshalNUpdateProfilePayload2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐUpdateProfilePayload(ctx context.Context, sel ast.SelectionSet, v *types.UpdateProfilePayload) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
		}
		return graphql.Null
	}
	return ec._UpdateProfilePayload(ctx, sel, v)
}

func (ec *executionContext) unmarshalNUpdateSAMLConfigurationInput2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐUpdateSAMLConfigurationInput(ctx context.Context, v any) (types.UpdateSAMLConfigurationInput, error) {
	res, err := ec.unmarshalInputUpdateSAMLConfigurationInput(ctx, v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) unmarshalNUpdateSCIMBridgeInput2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐUpdateSCIMBridgeInput(ctx context.Context, v any) (types.UpdateSCIMBridgeInput, error) {
	res, err := ec.unmarshalInputUpdateSCIMBridgeInput(ctx, v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) unmarshalNVerifyEmailInput2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐVerifyEmailInput(ctx context.Context, v any) (types.VerifyEmailInput, error) {
	res, err := ec.unmarshalInputVerifyEmailInput(ctx, v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalN__Directive2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx context.Context, sel ast.SelectionSet, v introspection.Directive) graphql.Marshaler {
	return ec.___Directive(ctx, sel, &v)
}

func (ec *executionContext) marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirectiveᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Directive) graphql.Marshaler {
	ret := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalN__Directive2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	return ret
}

func (ec *executionContext) unmarshalN__DirectiveLocation2string(ctx context.Context, v any) (string, error) {
	res, err := graphql.UnmarshalString(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalN__DirectiveLocation2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
	_ = sel
	res := graphql.MarshalString(v)
	if res == graphql.Null {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
		}
	}
	return res
}

func (ec *executionContext) unmarshalN__DirectiveLocation2ᚕstringᚄ(ctx context.Context, v any) ([]string, error) {
	var vSlice []any
	vSlice = graphql.CoerceList(v)
	var err error
	res := make([]string, len(vSlice))
	for i := range vSlice {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
		res[i], err = ec.unmarshalN__DirectiveLocation2string(ctx, vSlice[i])
		if err != nil {
			return nil, err
		}
	}
	return res, nil
}

func (ec *executionContext) marshalN__DirectiveLocation2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
	ret := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalN__DirectiveLocation2string(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	return ret
}

func (ec *executionContext) marshalN__EnumValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx context.Context, sel ast.SelectionSet, v introspection.EnumValue) graphql.Marshaler {
	return ec.___EnumValue(ctx, sel, &v)
}

func (ec *executionContext) marshalN__Field2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx context.Context, sel ast.SelectionSet, v introspection.Field) graphql.Marshaler {
	return ec.___Field(ctx, sel, &v)
}

func (ec *executionContext) marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx context.Context, sel ast.SelectionSet, v introspection.InputValue) graphql.Marshaler {
	return ec.___InputValue(ctx, sel, &v)
}

func (ec *executionContext) marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
	ret := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	return ret
}

func (ec *executionContext) marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v introspection.Type) graphql.Marshaler {
	return ec.___Type(ctx, sel, &v)
}

func (ec *executionContext) marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Type) graphql.Marshaler {
	ret := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	return ret
}

func (ec *executionContext) marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
		}
		return graphql.Null
	}
	return ec.___Type(ctx, sel, v)
}

func (ec *executionContext) unmarshalN__TypeKind2string(ctx context.Context, v any) (string, error) {
	res, err := graphql.UnmarshalString(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalN__TypeKind2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
	_ = sel
	res := graphql.MarshalString(v)
	if res == graphql.Null {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
		}
	}
	return res
}

func (ec *executionContext) marshalOAcceptInvitationPayload2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐAcceptInvitationPayload(ctx context.Context, sel ast.SelectionSet, v *types.AcceptInvitationPayload) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._AcceptInvitationPayload(ctx, sel, v)
}

func (ec *executionContext) marshalOAssumeOrganizationSessionPayload2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐAssumeOrganizationSessionPayload(ctx context.Context, sel ast.SelectionSet, v *types.AssumeOrganizationSessionPayload) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._AssumeOrganizationSessionPayload(ctx, sel, v)
}

func (ec *executionContext) unmarshalOBoolean2bool(ctx context.Context, v any) (bool, error) {
	res, err := graphql.UnmarshalBoolean(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalOBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
	_ = sel
	_ = ctx
	res := graphql.MarshalBoolean(v)
	return res
}

func (ec *executionContext) unmarshalOBoolean2ᚖbool(ctx context.Context, v any) (*bool, error) {
	if v == nil {
		return nil, nil
	}
	res, err := graphql.UnmarshalBoolean(v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalOBoolean2ᚖbool(ctx context.Context, sel ast.SelectionSet, v *bool) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	_ = sel
	_ = ctx
	res := graphql.MarshalBoolean(*v)
	return res
}

func (ec *executionContext) marshalOChangeEmailPayload2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐChangeEmailPayload(ctx context.Context, sel ast.SelectionSet, v *types.ChangeEmailPayload) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._ChangeEmailPayload(ctx, sel, v)
}

func (ec *executionContext) marshalOChangePasswordPayload2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐChangePasswordPayload(ctx context.Context, sel ast.SelectionSet, v *types.ChangePasswordPayload) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._ChangePasswordPayload(ctx, sel, v)
}

func (ec *executionContext) marshalOConnector2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐConnector(ctx context.Context, sel ast.SelectionSet, v *types.Connector) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._Connector(ctx, sel, v)
}

func (ec *executionContext) marshalOCreateOrganizationPayload2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐCreateOrganizationPayload(ctx context.Context, sel ast.SelectionSet, v *types.CreateOrganizationPayload) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._CreateOrganizationPayload(ctx, sel, v)
}

func (ec *executionContext) marshalOCreatePersonalAPIKeyPayload2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐCreatePersonalAPIKeyPayload(ctx context.Context, sel ast.SelectionSet, v *types.CreatePersonalAPIKeyPayload) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._CreatePersonalAPIKeyPayload(ctx, sel, v)
}

func (ec *executionContext) marshalOCreateSAMLConfigurationPayload2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐCreateSAMLConfigurationPayload(ctx context.Context, sel ast.SelectionSet, v *types.CreateSAMLConfigurationPayload) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._CreateSAMLConfigurationPayload(ctx, sel, v)
}

func (ec *executionContext) marshalOCreateSCIMConfigurationPayload2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐCreateSCIMConfigurationPayload(ctx context.Context, sel ast.SelectionSet, v *types.CreateSCIMConfigurationPayload) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._CreateSCIMConfigurationPayload(ctx, sel, v)
}

func (ec *executionContext) unmarshalOCursorKey2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋpageᚐCursorKey(ctx context.Context, v any) (*page.CursorKey, error) {
	if v == nil {
		return nil, nil
	}
	res, err := cursor.UnmarshalCursorKeyScalar(v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalOCursorKey2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋpageᚐCursorKey(ctx context.Context, sel ast.SelectionSet, v *page.CursorKey) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	_ = sel
	_ = ctx
	res := cursor.MarshalCursorKeyScalar(*v)
	return res
}

func (ec *executionContext) unmarshalODatetime2ᚖtimeᚐTime(ctx context.Context, v any) (*time.Time, error) {
	if v == nil {
		return nil, nil
	}
	res, err := graphql.UnmarshalTime(v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalODatetime2ᚖtimeᚐTime(ctx context.Context, sel ast.SelectionSet, v *time.Time) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	_ = sel
	_ = ctx
	res := graphql.MarshalTime(*v)
	return res
}

func (ec *executionContext) marshalODeleteInvitationPayload2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐDeleteInvitationPayload(ctx context.Context, sel ast.SelectionSet, v *types.DeleteInvitationPayload) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._DeleteInvitationPayload(ctx, sel, v)
}

func (ec *executionContext) marshalODeleteOrganizationHorizontalLogoPayload2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐDeleteOrganizationHorizontalLogoPayload(ctx context.Context, sel ast.SelectionSet, v *types.DeleteOrganizationHorizontalLogoPayload) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._DeleteOrganizationHorizontalLogoPayload(ctx, sel, v)
}

func (ec *executionContext) marshalODeleteOrganizationPayload2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐDeleteOrganizationPayload(ctx context.Context, sel ast.SelectionSet, v *types.DeleteOrganizationPayload) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._DeleteOrganizationPayload(ctx, sel, v)
}

func (ec *executionContext) marshalODeleteSAMLConfigurationPayload2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐDeleteSAMLConfigurationPayload(ctx context.Context, sel ast.SelectionSet, v *types.DeleteSAMLConfigurationPayload) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._DeleteSAMLConfigurationPayload(ctx, sel, v)
}

func (ec *executionContext) marshalODeleteSCIMConfigurationPayload2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐDeleteSCIMConfigurationPayload(ctx context.Context, sel ast.SelectionSet, v *types.DeleteSCIMConfigurationPayload) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._DeleteSCIMConfigurationPayload(ctx, sel, v)
}

func (ec *executionContext) unmarshalOEmailAddr2ᚕgoᚗproboᚗincᚋproboᚋpkgᚋmailᚐAddrᚄ(ctx context.Context, v any) ([]mail.Addr, error) {
	if v == nil {
		return nil, nil
	}
	var vSlice []any
	vSlice = graphql.CoerceList(v)
	var err error
	res := make([]mail.Addr, len(vSlice))
	for i := range vSlice {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
		res[i], err = ec.unmarshalNEmailAddr2goᚗproboᚗincᚋproboᚋpkgᚋmailᚐAddr(ctx, vSlice[i])
		if err != nil {
			return nil, err
		}
	}
	return res, nil
}

func (ec *executionContext) marshalOEmailAddr2ᚕgoᚗproboᚗincᚋproboᚋpkgᚋmailᚐAddrᚄ(ctx context.Context, sel ast.SelectionSet, v []mail.Addr) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	ret := make(graphql.Array, len(v))
	for i := range v {
		ret[i] = ec.marshalNEmailAddr2goᚗproboᚗincᚋproboᚋpkgᚋmailᚐAddr(ctx, sel, v[i])
	}

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	return ret
}

func (ec *executionContext) marshalOForgotPasswordPayload2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐForgotPasswordPayload(ctx context.Context, sel ast.SelectionSet, v *types.ForgotPasswordPayload) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._ForgotPasswordPayload(ctx, sel, v)
}

func (ec *executionContext) unmarshalOID2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋgidᚐGID(ctx context.Context, v any) (*gid.GID, error) {
	if v == nil {
		return nil, nil
	}
	res, err := gid1.UnmarshalGIDScalar(v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalOID2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋgidᚐGID(ctx context.Context, sel ast.SelectionSet, v *gid.GID) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	_ = sel
	_ = ctx
	res := gid1.MarshalGIDScalar(*v)
	return res
}

func (ec *executionContext) marshalOIdentity2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐIdentity(ctx context.Context, sel ast.SelectionSet, v *types.Identity) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._Identity(ctx, sel, v)
}

func (ec *executionContext) unmarshalOInt2ᚖint(ctx context.Context, v any) (*int, error) {
	if v == nil {
		return nil, nil
	}
	res, err := graphql.UnmarshalInt(v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalOInt2ᚖint(ctx context.Context, sel ast.SelectionSet, v *int) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	_ = sel
	_ = ctx
	res := graphql.MarshalInt(*v)
	return res
}

func (ec *executionContext) marshalOInvitationConnection2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐInvitationConnection(ctx context.Context, sel ast.SelectionSet, v *types.InvitationConnection) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._InvitationConnection(ctx, sel, v)
}

func (ec *executionContext) unmarshalOInvitationOrder2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐInvitationOrderBy(ctx context.Context, v any) (*types.InvitationOrderBy, error) {
	if v == nil {
		return nil, nil
	}
	res, err := ec.unmarshalInputInvitationOrder(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) unmarshalOInvitationStatus2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐInvitationStatus(ctx context.Context, v any) (*coredata.InvitationStatus, error) {
	if v == nil {
		return nil, nil
	}
	tmp, err := graphql.UnmarshalString(v)
	res := unmarshalOInvitationStatus2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐInvitationStatus[tmp]
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalOInvitationStatus2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐInvitationStatus(ctx context.Context, sel ast.SelectionSet, v *coredata.InvitationStatus) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	_ = sel
	_ = ctx
	res := graphql.MarshalString(marshalOInvitationStatus2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐInvitationStatus[*v])
	return res
}

var (
	unmarshalOInvitationStatus2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐInvitationStatus = map[string]coredata.InvitationStatus{
		"PENDING":  coredata.InvitationStatusPending,
		"ACCEPTED": coredata.InvitationStatusAccepted,
		"EXPIRED":  coredata.InvitationStatusExpired,
	}
	marshalOInvitationStatus2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐInvitationStatus = map[coredata.InvitationStatus]string{
		coredata.InvitationStatusPending:  "PENDING",
		coredata.InvitationStatusAccepted: "ACCEPTED",
		coredata.InvitationStatusExpired:  "EXPIRED",
	}
)

func (ec *executionContext) marshalOInviteMemberPayload2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐInviteMemberPayload(ctx context.Context, sel ast.SelectionSet, v *types.InviteMemberPayload) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._InviteMemberPayload(ctx, sel, v)
}

func (ec *executionContext) marshalOMembership2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐMembership(ctx context.Context, sel ast.SelectionSet, v *types.Membership) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._Membership(ctx, sel, v)
}

func (ec *executionContext) marshalOMembershipConnection2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐMembershipConnection(ctx context.Context, sel ast.SelectionSet, v *types.MembershipConnection) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._MembershipConnection(ctx, sel, v)
}

func (ec *executionContext) unmarshalOMembershipOrder2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐMembershipOrderBy(ctx context.Context, v any) (*types.MembershipOrderBy, error) {
	if v == nil {
		return nil, nil
	}
	res, err := ec.unmarshalInputMembershipOrder(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalOMembershipProfile2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐMembershipProfile(ctx context.Context, sel ast.SelectionSet, v *types.MembershipProfile) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._MembershipProfile(ctx, sel, v)
}

func (ec *executionContext) marshalONode2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐNode(ctx context.Context, sel ast.SelectionSet, v types.Node) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._Node(ctx, sel, v)
}

func (ec *executionContext) marshalOOrganization2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐOrganization(ctx context.Context, sel ast.SelectionSet, v *types.Organization) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._Organization(ctx, sel, v)
}

func (ec *executionContext) marshalOPersonalAPIKeyConnection2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐPersonalAPIKeyConnection(ctx context.Context, sel ast.SelectionSet, v *types.PersonalAPIKeyConnection) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._PersonalAPIKeyConnection(ctx, sel, v)
}

func (ec *executionContext) marshalORegenerateSCIMTokenPayload2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐRegenerateSCIMTokenPayload(ctx context.Context, sel ast.SelectionSet, v *types.RegenerateSCIMTokenPayload) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._RegenerateSCIMTokenPayload(ctx, sel, v)
}

func (ec *executionContext) marshalORemoveMemberPayload2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐRemoveMemberPayload(ctx context.Context, sel ast.SelectionSet, v *types.RemoveMemberPayload) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._RemoveMemberPayload(ctx, sel, v)
}

func (ec *executionContext) marshalOResetPasswordPayload2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐResetPasswordPayload(ctx context.Context, sel ast.SelectionSet, v *types.ResetPasswordPayload) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._ResetPasswordPayload(ctx, sel, v)
}

func (ec *executionContext) marshalORevokeAllSessionsPayload2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐRevokeAllSessionsPayload(ctx context.Context, sel ast.SelectionSet, v *types.RevokeAllSessionsPayload) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._RevokeAllSessionsPayload(ctx, sel, v)
}

func (ec *executionContext) marshalORevokePersonalAPIKeyPayload2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐRevokePersonalAPIKeyPayload(ctx context.Context, sel ast.SelectionSet, v *types.RevokePersonalAPIKeyPayload) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._RevokePersonalAPIKeyPayload(ctx, sel, v)
}

func (ec *executionContext) unmarshalOSAMLAttributeMappingsInput2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐSAMLAttributeMappingsInput(ctx context.Context, v any) (*types.SAMLAttributeMappingsInput, error) {
	if v == nil {
		return nil, nil
	}
	res, err := ec.unmarshalInputSAMLAttributeMappingsInput(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalOSAMLConfiguration2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐSAMLConfiguration(ctx context.Context, sel ast.SelectionSet, v *types.SAMLConfiguration) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._SAMLConfiguration(ctx, sel, v)
}

func (ec *executionContext) marshalOSAMLConfigurationConnection2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐSAMLConfigurationConnection(ctx context.Context, sel ast.SelectionSet, v *types.SAMLConfigurationConnection) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._SAMLConfigurationConnection(ctx, sel, v)
}

func (ec *executionContext) marshalOSCIMBridge2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐSCIMBridge(ctx context.Context, sel ast.SelectionSet, v *types.SCIMBridge) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._SCIMBridge(ctx, sel, v)
}

func (ec *executionContext) marshalOSCIMConfiguration2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐSCIMConfiguration(ctx context.Context, sel ast.SelectionSet, v *types.SCIMConfiguration) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._SCIMConfiguration(ctx, sel, v)
}

func (ec *executionContext) marshalOSCIMEventConnection2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐSCIMEventConnection(ctx context.Context, sel ast.SelectionSet, v *types.SCIMEventConnection) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._SCIMEventConnection(ctx, sel, v)
}

func (ec *executionContext) unmarshalOSCIMEventOrder2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐSCIMEventOrderBy(ctx context.Context, v any) (*types.SCIMEventOrderBy, error) {
	if v == nil {
		return nil, nil
	}
	res, err := ec.unmarshalInputSCIMEventOrder(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalOSession2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐSession(ctx context.Context, sel ast.SelectionSet, v *types.Session) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._Session(ctx, sel, v)
}

func (ec *executionContext) marshalOSessionConnection2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐSessionConnection(ctx context.Context, sel ast.SelectionSet, v *types.SessionConnection) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._SessionConnection(ctx, sel, v)
}

func (ec *executionContext) unmarshalOSessionOrder2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐSessionOrder(ctx context.Context, v any) (*types.SessionOrder, error) {
	if v == nil {
		return nil, nil
	}
	res, err := ec.unmarshalInputSessionOrder(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalOSignInPayload2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐSignInPayload(ctx context.Context, sel ast.SelectionSet, v *types.SignInPayload) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._SignInPayload(ctx, sel, v)
}

func (ec *executionContext) marshalOSignOutPayload2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐSignOutPayload(ctx context.Context, sel ast.SelectionSet, v *types.SignOutPayload) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._SignOutPayload(ctx, sel, v)
}

func (ec *executionContext) marshalOSignUpFromInvitationPayload2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐSignUpFromInvitationPayload(ctx context.Context, sel ast.SelectionSet, v *types.SignUpFromInvitationPayload) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._SignUpFromInvitationPayload(ctx, sel, v)
}

func (ec *executionContext) marshalOSignUpPayload2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐSignUpPayload(ctx context.Context, sel ast.SelectionSet, v *types.SignUpPayload) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._SignUpPayload(ctx, sel, v)
}

func (ec *executionContext) unmarshalOString2ᚕstringᚄ(ctx context.Context, v any) ([]string, error) {
	if v == nil {
		return nil, nil
	}
	var vSlice []any
	vSlice = graphql.CoerceList(v)
	var err error
	res := make([]string, len(vSlice))
	for i := range vSlice {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
		res[i], err = ec.unmarshalNString2string(ctx, vSlice[i])
		if err != nil {
			return nil, err
		}
	}
	return res, nil
}

func (ec *executionContext) marshalOString2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	ret := make(graphql.Array, len(v))
	for i := range v {
		ret[i] = ec.marshalNString2string(ctx, sel, v[i])
	}

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	return ret
}

func (ec *executionContext) unmarshalOString2ᚖstring(ctx context.Context, v any) (*string, error) {
	if v == nil {
		return nil, nil
	}
	res, err := graphql.UnmarshalString(v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalOString2ᚖstring(ctx context.Context, sel ast.SelectionSet, v *string) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	_ = sel
	_ = ctx
	res := graphql.MarshalString(*v)
	return res
}

func (ec *executionContext) marshalOUpdateOrganizationPayload2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐUpdateOrganizationPayload(ctx context.Context, sel ast.SelectionSet, v *types.UpdateOrganizationPayload) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._UpdateOrganizationPayload(ctx, sel, v)
}

func (ec *executionContext) marshalOUpdateSAMLConfigurationPayload2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐUpdateSAMLConfigurationPayload(ctx context.Context, sel ast.SelectionSet, v *types.UpdateSAMLConfigurationPayload) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._UpdateSAMLConfigurationPayload(ctx, sel, v)
}

func (ec *executionContext) marshalOUpdateSCIMBridgePayload2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐUpdateSCIMBridgePayload(ctx context.Context, sel ast.SelectionSet, v *types.UpdateSCIMBridgePayload) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._UpdateSCIMBridgePayload(ctx, sel, v)
}

func (ec *executionContext) unmarshalOUpload2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚐUpload(ctx context.Context, v any) (*graphql.Upload, error) {
	if v == nil {
		return nil, nil
	}
	res, err := graphql.UnmarshalUpload(v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalOUpload2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚐUpload(ctx context.Context, sel ast.SelectionSet, v *graphql.Upload) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	_ = sel
	_ = ctx
	res := graphql.MarshalUpload(*v)
	return res
}

func (ec *executionContext) marshalOVerifyEmailPayload2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐVerifyEmailPayload(ctx context.Context, sel ast.SelectionSet, v *types.VerifyEmailPayload) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._VerifyEmailPayload(ctx, sel, v)
}

func (ec *executionContext) marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.EnumValue) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	ret := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalN__EnumValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	return ret
}

func (ec *executionContext) marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐFieldᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Field) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	ret := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalN__Field2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	return ret
}

func (ec *executionContext) marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	ret := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	return ret
}

func (ec *executionContext) marshalO__Schema2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx context.Context, sel ast.SelectionSet, v *introspection.Schema) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec.___Schema(ctx, sel, v)
}

func (ec *executionContext) marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Type) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	ret := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	return ret
}

func (ec *executionContext) marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec.___Type(ctx, sel, v)
}

// endregion ***************************** type.gotpl *****************************