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/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 {
	Identity() IdentityResolver
	Invitation() InvitationResolver
	InvitationConnection() InvitationConnectionResolver
	Membership() MembershipResolver
	MembershipConnection() MembershipConnectionResolver
	Mutation() MutationResolver
	Organization() OrganizationResolver
	PersonalAPIKeyConnection() PersonalAPIKeyConnectionResolver
	Query() QueryResolver
	SAMLConfigurationConnection() SAMLConfigurationConnectionResolver
	Session() SessionResolver
	SessionConnection() SessionConnectionResolver
}

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

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

	Application struct {
		AvailableAccessLevels func(childComplexity int) int
		Description           func(childComplexity int) int
		ID                    func(childComplexity int) int
		Name                  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
	}

	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
	}

	DeactivateAccountPayload struct {
		Success 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
	}

	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
		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
		ID           func(childComplexity int) int
		Organization func(childComplexity int) 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
		Permissions  func(childComplexity int) int
		Profile      func(childComplexity int) int
		Role         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 {
		CreatedAt func(childComplexity int) int
		FullName  func(childComplexity int) int
		ID        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
		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
		ForgotPassword                   func(childComplexity int, input types.ForgotPasswordInput) int
		InviteMember                     func(childComplexity int, input types.InviteMemberInput) 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
		UpdateOrganization               func(childComplexity int, input types.UpdateOrganizationInput) int
		UpdatePersonalAPIKey             func(childComplexity int, input types.UpdatePersonalAPIKeyInput) int
		UpdateSAMLConfiguration          func(childComplexity int, input types.UpdateSAMLConfigurationInput) 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) 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
		SamlConfigurations func(childComplexity int, first *int, after *page.CursorKey, last *int, before *page.CursorKey) 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
	}

	Permission struct {
		AccessLevel   func(childComplexity int) int
		Application   func(childComplexity int) int
		CreatedAt     func(childComplexity int) int
		ID            func(childComplexity int) int
		Organization  func(childComplexity int) int
		PrincipalID   func(childComplexity int) int
		PrincipalType func(childComplexity int) int
	}

	PermissionGrant struct {
		AccessLevel func(childComplexity int) int
		Application 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
		Organizations func(childComplexity int) int
		Scopes        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 {
		CheckSSOAvailability func(childComplexity int, email string) int
		Node                 func(childComplexity int, id gid.GID) int
		Viewer               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 {
		Success 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
		DefaultPermissions      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
		SpMetadataURL           func(childComplexity int) 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
	}

	SSOAvailability struct {
		Available      func(childComplexity int) int
		OrganizationID func(childComplexity int) int
		SamlConfigID   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
		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
	}

	UpdateOrganizationPayload struct {
		Organization func(childComplexity int) int
	}

	UpdatePersonalAPIKeyPayload struct {
		PersonalAPIKey func(childComplexity int) int
	}

	UpdateSAMLConfigurationPayload struct {
		SamlConfiguration func(childComplexity int) int
	}

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

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)
}
type InvitationResolver interface {
	Organization(ctx context.Context, obj *types.Invitation) (*types.Organization, 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)
}
type MembershipConnectionResolver interface {
	TotalCount(ctx context.Context, obj *types.MembershipConnection) (*int, 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)
	UpdatePersonalAPIKey(ctx context.Context, input types.UpdatePersonalAPIKeyInput) (*types.UpdatePersonalAPIKeyPayload, 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)
	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)
}
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) (*types.InvitationConnection, error)
	SamlConfigurations(ctx context.Context, obj *types.Organization, first *int, after *page.CursorKey, last *int, before *page.CursorKey) (*types.SAMLConfigurationConnection, error)
	ViewerMembership(ctx context.Context, obj *types.Organization) (*types.Membership, 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)
	CheckSSOAvailability(ctx context.Context, email string) (*types.SSOAvailability, error)
}
type SAMLConfigurationConnectionResolver interface {
	TotalCount(ctx context.Context, obj *types.SAMLConfigurationConnection) (*int, error)
}
type SessionResolver interface {
	Identity(ctx context.Context, obj *types.Session) (*types.Identity, 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.membershipEdge":
		if e.complexity.AcceptInvitationPayload.MembershipEdge == nil {
			break
		}

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

	case "Application.availableAccessLevels":
		if e.complexity.Application.AvailableAccessLevels == nil {
			break
		}

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

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

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

		return e.complexity.Application.Name(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 "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 "DeactivateAccountPayload.success":
		if e.complexity.DeactivateAccountPayload.Success == nil {
			break
		}

		return e.complexity.DeactivateAccountPayload.Success(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 "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.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.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.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.permissions":
		if e.complexity.Membership.Permissions == nil {
			break
		}

		return e.complexity.Membership.Permissions(childComplexity), 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 "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.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.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.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.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.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.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.updatePersonalAPIKey":
		if e.complexity.Mutation.UpdatePersonalAPIKey == nil {
			break
		}

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

		return e.complexity.Mutation.UpdatePersonalAPIKey(childComplexity, args["input"].(types.UpdatePersonalAPIKeyInput)), 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.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)), 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.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.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 "Permission.accessLevel":
		if e.complexity.Permission.AccessLevel == nil {
			break
		}

		return e.complexity.Permission.AccessLevel(childComplexity), true
	case "Permission.application":
		if e.complexity.Permission.Application == nil {
			break
		}

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

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

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

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

		return e.complexity.Permission.PrincipalID(childComplexity), true
	case "Permission.principalType":
		if e.complexity.Permission.PrincipalType == nil {
			break
		}

		return e.complexity.Permission.PrincipalType(childComplexity), true

	case "PermissionGrant.accessLevel":
		if e.complexity.PermissionGrant.AccessLevel == nil {
			break
		}

		return e.complexity.PermissionGrant.AccessLevel(childComplexity), true
	case "PermissionGrant.application":
		if e.complexity.PermissionGrant.Application == nil {
			break
		}

		return e.complexity.PermissionGrant.Application(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.organizations":
		if e.complexity.PersonalAPIKey.Organizations == nil {
			break
		}

		return e.complexity.PersonalAPIKey.Organizations(childComplexity), true
	case "PersonalAPIKey.scopes":
		if e.complexity.PersonalAPIKey.Scopes == nil {
			break
		}

		return e.complexity.PersonalAPIKey.Scopes(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.checkSSOAvailability":
		if e.complexity.Query.CheckSSOAvailability == nil {
			break
		}

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

		return e.complexity.Query.CheckSSOAvailability(childComplexity, args["email"].(string)), 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.viewer":
		if e.complexity.Query.Viewer == nil {
			break
		}

		return e.complexity.Query.Viewer(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.success":
		if e.complexity.RevokePersonalAPIKeyPayload.Success == nil {
			break
		}

		return e.complexity.RevokePersonalAPIKeyPayload.Success(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.defaultPermissions":
		if e.complexity.SAMLConfiguration.DefaultPermissions == nil {
			break
		}

		return e.complexity.SAMLConfiguration.DefaultPermissions(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.spMetadataUrl":
		if e.complexity.SAMLConfiguration.SpMetadataURL == nil {
			break
		}

		return e.complexity.SAMLConfiguration.SpMetadataURL(childComplexity), 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 "SSOAvailability.available":
		if e.complexity.SSOAvailability.Available == nil {
			break
		}

		return e.complexity.SSOAvailability.Available(childComplexity), true
	case "SSOAvailability.organizationId":
		if e.complexity.SSOAvailability.OrganizationID == nil {
			break
		}

		return e.complexity.SSOAvailability.OrganizationID(childComplexity), true
	case "SSOAvailability.samlConfigId":
		if e.complexity.SSOAvailability.SamlConfigID == nil {
			break
		}

		return e.complexity.SSOAvailability.SamlConfigID(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.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 "UpdateOrganizationPayload.organization":
		if e.complexity.UpdateOrganizationPayload.Organization == nil {
			break
		}

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

	case "UpdatePersonalAPIKeyPayload.personalAPIKey":
		if e.complexity.UpdatePersonalAPIKeyPayload.PersonalAPIKey == nil {
			break
		}

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

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

		return e.complexity.UpdateSAMLConfigurationPayload.SamlConfiguration(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.unmarshalInputDeleteInvitationInput,
		ec.unmarshalInputDeleteOrganizationHorizontalLogoInput,
		ec.unmarshalInputDeleteOrganizationInput,
		ec.unmarshalInputDeleteSAMLConfigurationInput,
		ec.unmarshalInputForgotPasswordInput,
		ec.unmarshalInputInvitationOrder,
		ec.unmarshalInputInviteMemberInput,
		ec.unmarshalInputMembershipOrder,
		ec.unmarshalInputRemoveMemberInput,
		ec.unmarshalInputResetPasswordInput,
		ec.unmarshalInputRevokePersonalAPIKeyInput,
		ec.unmarshalInputRevokeSessionInput,
		ec.unmarshalInputSAMLAttributeMappingsInput,
		ec.unmarshalInputSessionOrder,
		ec.unmarshalInputSignInInput,
		ec.unmarshalInputSignUpFromInvitationInput,
		ec.unmarshalInputSignUpInput,
		ec.unmarshalInputUpdateOrganizationInput,
		ec.unmarshalInputUpdatePersonalAPIKeyInput,
		ec.unmarshalInputUpdateSAMLConfigurationInput,
		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

directive @session(required: SessionRequirement!) on FIELD_DEFINITION

directive @isViewer on FIELD_DEFINITION

scalar CursorKey
scalar Datetime
scalar Upload
scalar EmailAddr

enum SessionRequirement {
  PRESENT
  NONE
  OPTIONAL
}

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)
  checkSSOAvailability(email: String!): SSOAvailability!
    @session(required: NONE)
}

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)
  updatePersonalAPIKey(
    input: UpdatePersonalAPIKeyInput!
  ): UpdatePersonalAPIKeyPayload @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)
  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)
}

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) @isViewer

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

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

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

type MembershipProfile implements Node {
  id: ID!
  fullName: String!
  createdAt: Datetime!
  updatedAt: Datetime!
}

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
  ): InvitationConnection @goField(forceResolver: true)

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

  viewerMembership: Membership @goField(forceResolver: true)
}

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

type Membership implements Node {
  id: ID!
  createdAt: Datetime!
  identity: Identity @goField(forceResolver: true)
  profile: MembershipProfile @goField(forceResolver: true) @isViewer
  organization: Organization @goField(forceResolver: true)
  role: MembershipRole!
  permissions: [Permission!]!

  lastSession: Session @goField(forceResolver: true) @isViewer
}

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

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

type PersonalAPIKey implements Node {
  id: ID!
  name: String!
  lastUsedAt: Datetime
  expiresAt: Datetime!
  createdAt: Datetime!
  scopes: [TokenScope!]!
  organizations: [Organization!]!
}

type Permission implements Node {
  id: ID!
  createdAt: Datetime!
  application: Application!
  accessLevel: AccessLevel!
  organization: Organization!
  principalType: PrincipalType!
  principalId: ID!
}

type PermissionGrant {
  application: Application!
  accessLevel: AccessLevel!
}

type Application {
  id: ApplicationId!
  name: String!
  description: String!
  availableAccessLevels: [AccessLevel!]!
}

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!
  spMetadataUrl: String!
  testLoginUrl: String!
  attributeMappings: SAMLAttributeMappings!
  defaultPermissions: [PermissionGrant!]!
}

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

type SSOAvailability {
  available: Boolean!
  samlConfigId: ID
  organizationId: ID
}

enum ApplicationId {
  CONSOLE
  COMPLIANCE
  RISK
  VENDOR
  DOCUMENTS
  TRUST_CENTER
  SETTINGS
  API
}

enum AccessLevel {
  READ
  WRITE
  ADMIN
}

enum PrincipalType {
  IDENTITY
  SERVICE_ACCOUNT
}

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 TokenScope {
  READ_ORGANIZATION
  WRITE_ORGANIZATION
  READ_COMPLIANCE
  WRITE_COMPLIANCE
  READ_RISK
  WRITE_RISK
  READ_VENDOR
  WRITE_VENDOR
  READ_DOCUMENTS
  WRITE_DOCUMENTS
  READ_TRUST_CENTER
  WRITE_TRUST_CENTER
  ADMIN
}

enum ReauthenticationReason {
  SESSION_EXPIRED
  SENSITIVE_ACTION
  POLICY_REQUIREMENT
}

enum MembershipOrderField
  @goModel(model: "go.probo.inc/probo/pkg/coredata.MembershipOrderField") {
  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") {
  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!
}

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

input SignInInput {
  email: EmailAddr!
  password: String!
}

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

input SignUpFromInvitationInput {
  token: String!
  password: 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!
}

input RevokeSessionInput {
  sessionId: ID!
}

input CreatePersonalAPIKeyInput {
  name: String!
  expiresAt: Datetime!
  organizationIds: [ID!]!
}

input UpdatePersonalAPIKeyInput {
  tokenId: ID!
  name: String
  description: String
}

input RevokePersonalAPIKeyInput {
  tokenId: 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!
}

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 DeactivateAccountPayload {
  success: Boolean!
}

type RevokeSessionPayload {
  success: Boolean!
}

type RevokeAllSessionsPayload {
  revokedCount: Int!
}

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

type UpdatePersonalAPIKeyPayload {
  personalAPIKey: PersonalAPIKey
}

type RevokePersonalAPIKeyPayload {
  success: Boolean!
}

type CreateOrganizationPayload {
  organization: Organization
  membershipEdge: MembershipEdge!
}

type UpdateOrganizationPayload {
  organization: Organization
}

type DeleteOrganizationPayload {
  deletedOrganizationId: ID!
}

type DeleteOrganizationHorizontalLogoPayload {
  organization: Organization!
}

type InviteMemberPayload {
  invitationEdge: InvitationEdge!
}

type RemoveMemberPayload {
  deletedMembershipId: ID!
}

type AcceptInvitationPayload {
  membershipEdge: MembershipEdge!
}

type DeleteInvitationPayload {
  deletedInvitationId: ID!
}

type CreateSAMLConfigurationPayload {
  samlConfigurationEdge: SAMLConfigurationEdge!
}

type UpdateSAMLConfigurationPayload {
  samlConfiguration: SAMLConfiguration
}

type DeleteSAMLConfigurationPayload {
  deletedSamlConfigurationId: ID!
}
`, 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ᚋapiᚋconnectᚋv1ᚋtypesᚐSessionRequirement)
	if err != nil {
		return nil, err
	}
	args["required"] = 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_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_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_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_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_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_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_updatePersonalAPIKey_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.unmarshalNUpdatePersonalAPIKeyInput2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐUpdatePersonalAPIKeyInput)
	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_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
	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_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_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_checkSSOAvailability_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.unmarshalNString2string)
	if err != nil {
		return nil, err
	}
	args["email"] = 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___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) _Application_id(ctx context.Context, field graphql.CollectedField, obj *types.Application) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Application_id,
		func(ctx context.Context) (any, error) {
			return obj.ID, nil
		},
		nil,
		ec.marshalNApplicationId2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐApplicationID,
		true,
		true,
	)
}

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

func (ec *executionContext) _Application_name(ctx context.Context, field graphql.CollectedField, obj *types.Application) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Application_name,
		func(ctx context.Context) (any, error) {
			return obj.Name, nil
		},
		nil,
		ec.marshalNString2string,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_Application_name(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Application",
		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) _Application_description(ctx context.Context, field graphql.CollectedField, obj *types.Application) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Application_description,
		func(ctx context.Context) (any, error) {
			return obj.Description, nil
		},
		nil,
		ec.marshalNString2string,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_Application_description(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Application",
		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) _Application_availableAccessLevels(ctx context.Context, field graphql.CollectedField, obj *types.Application) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Application_availableAccessLevels,
		func(ctx context.Context) (any, error) {
			return obj.AvailableAccessLevels, nil
		},
		nil,
		ec.marshalNAccessLevel2ᚕgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐAccessLevelᚄ,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_Application_availableAccessLevels(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Application",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type AccessLevel does not have child fields")
		},
	}
	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) _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 "viewerMembership":
				return ec.fieldContext_Organization_viewerMembership(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) _DeactivateAccountPayload_success(ctx context.Context, field graphql.CollectedField, obj *types.DeactivateAccountPayload) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_DeactivateAccountPayload_success,
		func(ctx context.Context) (any, error) {
			return obj.Success, nil
		},
		nil,
		ec.marshalNBoolean2bool,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_DeactivateAccountPayload_success(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "DeactivateAccountPayload",
		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) _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 "viewerMembership":
				return ec.fieldContext_Organization_viewerMembership(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) _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))
		},
		func(ctx context.Context, next graphql.Resolver) graphql.Resolver {
			directive0 := next

			directive1 := func(ctx context.Context) (any, error) {
				if ec.directives.IsViewer == nil {
					var zeroVal *types.MembershipConnection
					return zeroVal, errors.New("directive isViewer is not implemented")
				}
				return ec.directives.IsViewer(ctx, obj, directive0)
			}

			next = directive1
			return next
		},
		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))
		},
		func(ctx context.Context, next graphql.Resolver) graphql.Resolver {
			directive0 := next

			directive1 := func(ctx context.Context) (any, error) {
				if ec.directives.IsViewer == nil {
					var zeroVal *types.InvitationConnection
					return zeroVal, errors.New("directive isViewer is not implemented")
				}
				return ec.directives.IsViewer(ctx, obj, directive0)
			}

			next = directive1
			return next
		},
		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))
		},
		func(ctx context.Context, next graphql.Resolver) graphql.Resolver {
			directive0 := next

			directive1 := func(ctx context.Context) (any, error) {
				if ec.directives.IsViewer == nil {
					var zeroVal *types.SessionConnection
					return zeroVal, errors.New("directive isViewer is not implemented")
				}
				return ec.directives.IsViewer(ctx, obj, directive0)
			}

			next = directive1
			return next
		},
		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))
		},
		func(ctx context.Context, next graphql.Resolver) graphql.Resolver {
			directive0 := next

			directive1 := func(ctx context.Context) (any, error) {
				if ec.directives.IsViewer == nil {
					var zeroVal *types.PersonalAPIKeyConnection
					return zeroVal, errors.New("directive isViewer is not implemented")
				}
				return ec.directives.IsViewer(ctx, obj, directive0)
			}

			next = directive1
			return next
		},
		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) _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_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 "viewerMembership":
				return ec.fieldContext_Organization_viewerMembership(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type Organization", field.Name)
		},
	}
	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 "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)
			}
			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)
			}
			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)
		},
		func(ctx context.Context, next graphql.Resolver) graphql.Resolver {
			directive0 := next

			directive1 := func(ctx context.Context) (any, error) {
				if ec.directives.IsViewer == nil {
					var zeroVal *types.MembershipProfile
					return zeroVal, errors.New("directive isViewer is not implemented")
				}
				return ec.directives.IsViewer(ctx, obj, directive0)
			}

			next = directive1
			return next
		},
		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 "createdAt":
				return ec.fieldContext_MembershipProfile_createdAt(ctx, field)
			case "updatedAt":
				return ec.fieldContext_MembershipProfile_updatedAt(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 "viewerMembership":
				return ec.fieldContext_Organization_viewerMembership(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_permissions(ctx context.Context, field graphql.CollectedField, obj *types.Membership) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Membership_permissions,
		func(ctx context.Context) (any, error) {
			return obj.Permissions, nil
		},
		nil,
		ec.marshalNPermission2ᚕᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐPermissionᚄ,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_Membership_permissions(_ 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) {
			switch field.Name {
			case "id":
				return ec.fieldContext_Permission_id(ctx, field)
			case "createdAt":
				return ec.fieldContext_Permission_createdAt(ctx, field)
			case "application":
				return ec.fieldContext_Permission_application(ctx, field)
			case "accessLevel":
				return ec.fieldContext_Permission_accessLevel(ctx, field)
			case "organization":
				return ec.fieldContext_Permission_organization(ctx, field)
			case "principalType":
				return ec.fieldContext_Permission_principalType(ctx, field)
			case "principalId":
				return ec.fieldContext_Permission_principalId(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type Permission", field.Name)
		},
	}
	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)
		},
		func(ctx context.Context, next graphql.Resolver) graphql.Resolver {
			directive0 := next

			directive1 := func(ctx context.Context) (any, error) {
				if ec.directives.IsViewer == nil {
					var zeroVal *types.Session
					return zeroVal, errors.New("directive isViewer is not implemented")
				}
				return ec.directives.IsViewer(ctx, obj, directive0)
			}

			next = directive1
			return next
		},
		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)
			}
			return nil, fmt.Errorf("no field named %q was found under type Session", field.Name)
		},
	}
	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 "permissions":
				return ec.fieldContext_Membership_permissions(ctx, field)
			case "lastSession":
				return ec.fieldContext_Membership_lastSession(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_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) _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ᚋapiᚋconnectᚋv1ᚋtypesᚐ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ᚋapiᚋconnectᚋv1ᚋtypesᚐ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ᚋapiᚋconnectᚋv1ᚋtypesᚐ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ᚋapiᚋconnectᚋv1ᚋtypesᚐ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ᚋapiᚋconnectᚋv1ᚋtypesᚐ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ᚋapiᚋconnectᚋv1ᚋtypesᚐ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ᚋapiᚋconnectᚋv1ᚋtypesᚐ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ᚋapiᚋconnectᚋv1ᚋtypesᚐ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ᚋapiᚋconnectᚋv1ᚋtypesᚐ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ᚋapiᚋconnectᚋv1ᚋtypesᚐ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ᚋapiᚋconnectᚋv1ᚋtypesᚐ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ᚋapiᚋconnectᚋv1ᚋtypesᚐ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ᚋapiᚋconnectᚋv1ᚋtypesᚐ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_updatePersonalAPIKey(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Mutation_updatePersonalAPIKey,
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.resolvers.Mutation().UpdatePersonalAPIKey(ctx, fc.Args["input"].(types.UpdatePersonalAPIKeyInput))
		},
		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ᚋapiᚋconnectᚋv1ᚋtypesᚐSessionRequirement(ctx, "PRESENT")
				if err != nil {
					var zeroVal *types.UpdatePersonalAPIKeyPayload
					return zeroVal, err
				}
				if ec.directives.Session == nil {
					var zeroVal *types.UpdatePersonalAPIKeyPayload
					return zeroVal, errors.New("directive session is not implemented")
				}
				return ec.directives.Session(ctx, nil, directive0, required)
			}

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

func (ec *executionContext) fieldContext_Mutation_updatePersonalAPIKey(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 "personalAPIKey":
				return ec.fieldContext_UpdatePersonalAPIKeyPayload_personalAPIKey(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type UpdatePersonalAPIKeyPayload", 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_updatePersonalAPIKey_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ᚋapiᚋconnectᚋv1ᚋtypesᚐ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 "success":
				return ec.fieldContext_RevokePersonalAPIKeyPayload_success(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ᚋapiᚋconnectᚋv1ᚋtypesᚐ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ᚋapiᚋconnectᚋv1ᚋtypesᚐ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ᚋapiᚋconnectᚋv1ᚋtypesᚐ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ᚋapiᚋconnectᚋv1ᚋtypesᚐ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ᚋapiᚋconnectᚋv1ᚋtypesᚐ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ᚋapiᚋconnectᚋv1ᚋtypesᚐ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_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ᚋapiᚋconnectᚋv1ᚋtypesᚐ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ᚋapiᚋconnectᚋv1ᚋtypesᚐ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)
			}
			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ᚋapiᚋconnectᚋv1ᚋtypesᚐ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ᚋapiᚋconnectᚋv1ᚋtypesᚐ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ᚋapiᚋconnectᚋv1ᚋtypesᚐ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) _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))
		},
		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_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 "permissions":
				return ec.fieldContext_Membership_permissions(ctx, field)
			case "lastSession":
				return ec.fieldContext_Membership_lastSession(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type Membership", field.Name)
		},
	}
	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)
			}
			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 "permissions":
				return ec.fieldContext_Membership_permissions(ctx, field)
			case "lastSession":
				return ec.fieldContext_Membership_lastSession(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) _Permission_id(ctx context.Context, field graphql.CollectedField, obj *types.Permission) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Permission_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_Permission_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Permission",
		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) _Permission_createdAt(ctx context.Context, field graphql.CollectedField, obj *types.Permission) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Permission_createdAt,
		func(ctx context.Context) (any, error) {
			return obj.CreatedAt, nil
		},
		nil,
		ec.marshalNDatetime2timeᚐTime,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_Permission_createdAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Permission",
		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) _Permission_application(ctx context.Context, field graphql.CollectedField, obj *types.Permission) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Permission_application,
		func(ctx context.Context) (any, error) {
			return obj.Application, nil
		},
		nil,
		ec.marshalNApplication2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐApplication,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_Permission_application(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Permission",
		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_Application_id(ctx, field)
			case "name":
				return ec.fieldContext_Application_name(ctx, field)
			case "description":
				return ec.fieldContext_Application_description(ctx, field)
			case "availableAccessLevels":
				return ec.fieldContext_Application_availableAccessLevels(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type Application", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _Permission_accessLevel(ctx context.Context, field graphql.CollectedField, obj *types.Permission) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Permission_accessLevel,
		func(ctx context.Context) (any, error) {
			return obj.AccessLevel, nil
		},
		nil,
		ec.marshalNAccessLevel2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐAccessLevel,
		true,
		true,
	)
}

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

func (ec *executionContext) _Permission_organization(ctx context.Context, field graphql.CollectedField, obj *types.Permission) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Permission_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_Permission_organization(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Permission",
		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 "viewerMembership":
				return ec.fieldContext_Organization_viewerMembership(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type Organization", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _Permission_principalType(ctx context.Context, field graphql.CollectedField, obj *types.Permission) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Permission_principalType,
		func(ctx context.Context) (any, error) {
			return obj.PrincipalType, nil
		},
		nil,
		ec.marshalNPrincipalType2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐPrincipalType,
		true,
		true,
	)
}

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

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

func (ec *executionContext) fieldContext_Permission_principalId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Permission",
		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) _PermissionGrant_application(ctx context.Context, field graphql.CollectedField, obj *types.PermissionGrant) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_PermissionGrant_application,
		func(ctx context.Context) (any, error) {
			return obj.Application, nil
		},
		nil,
		ec.marshalNApplication2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐApplication,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_PermissionGrant_application(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "PermissionGrant",
		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_Application_id(ctx, field)
			case "name":
				return ec.fieldContext_Application_name(ctx, field)
			case "description":
				return ec.fieldContext_Application_description(ctx, field)
			case "availableAccessLevels":
				return ec.fieldContext_Application_availableAccessLevels(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type Application", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _PermissionGrant_accessLevel(ctx context.Context, field graphql.CollectedField, obj *types.PermissionGrant) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_PermissionGrant_accessLevel,
		func(ctx context.Context) (any, error) {
			return obj.AccessLevel, nil
		},
		nil,
		ec.marshalNAccessLevel2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐAccessLevel,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_PermissionGrant_accessLevel(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "PermissionGrant",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type AccessLevel 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_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_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_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_scopes(ctx context.Context, field graphql.CollectedField, obj *types.PersonalAPIKey) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_PersonalAPIKey_scopes,
		func(ctx context.Context) (any, error) {
			return obj.Scopes, nil
		},
		nil,
		ec.marshalNTokenScope2ᚕgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐTokenScopeᚄ,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_PersonalAPIKey_scopes(_ 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 TokenScope does not have child fields")
		},
	}
	return fc, nil
}

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

func (ec *executionContext) fieldContext_PersonalAPIKey_organizations(_ 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) {
			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 "viewerMembership":
				return ec.fieldContext_Organization_viewerMembership(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type Organization", field.Name)
		},
	}
	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 "lastUsedAt":
				return ec.fieldContext_PersonalAPIKey_lastUsedAt(ctx, field)
			case "expiresAt":
				return ec.fieldContext_PersonalAPIKey_expiresAt(ctx, field)
			case "createdAt":
				return ec.fieldContext_PersonalAPIKey_createdAt(ctx, field)
			case "scopes":
				return ec.fieldContext_PersonalAPIKey_scopes(ctx, field)
			case "organizations":
				return ec.fieldContext_PersonalAPIKey_organizations(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ᚋapiᚋconnectᚋv1ᚋtypesᚐ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ᚋapiᚋconnectᚋv1ᚋtypesᚐ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)
			}
			return nil, fmt.Errorf("no field named %q was found under type Identity", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _Query_checkSSOAvailability(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_Query_checkSSOAvailability,
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.resolvers.Query().CheckSSOAvailability(ctx, fc.Args["email"].(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ᚋapiᚋconnectᚋv1ᚋtypesᚐSessionRequirement(ctx, "NONE")
				if err != nil {
					var zeroVal *types.SSOAvailability
					return zeroVal, err
				}
				if ec.directives.Session == nil {
					var zeroVal *types.SSOAvailability
					return zeroVal, errors.New("directive session is not implemented")
				}
				return ec.directives.Session(ctx, nil, directive0, required)
			}

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

func (ec *executionContext) fieldContext_Query_checkSSOAvailability(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) {
			switch field.Name {
			case "available":
				return ec.fieldContext_SSOAvailability_available(ctx, field)
			case "samlConfigId":
				return ec.fieldContext_SSOAvailability_samlConfigId(ctx, field)
			case "organizationId":
				return ec.fieldContext_SSOAvailability_organizationId(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type SSOAvailability", 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_checkSSOAvailability_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) _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_success(ctx context.Context, field graphql.CollectedField, obj *types.RevokePersonalAPIKeyPayload) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_RevokePersonalAPIKeyPayload_success,
		func(ctx context.Context) (any, error) {
			return obj.Success, nil
		},
		nil,
		ec.marshalNBoolean2bool,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_RevokePersonalAPIKeyPayload_success(_ 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 Boolean 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_spMetadataUrl(ctx context.Context, field graphql.CollectedField, obj *types.SAMLConfiguration) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SAMLConfiguration_spMetadataUrl,
		func(ctx context.Context) (any, error) {
			return obj.SpMetadataURL, nil
		},
		nil,
		ec.marshalNString2string,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_SAMLConfiguration_spMetadataUrl(_ 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_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 obj.TestLoginURL, nil
		},
		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:   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_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_defaultPermissions(ctx context.Context, field graphql.CollectedField, obj *types.SAMLConfiguration) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SAMLConfiguration_defaultPermissions,
		func(ctx context.Context) (any, error) {
			return obj.DefaultPermissions, nil
		},
		nil,
		ec.marshalNPermissionGrant2ᚕᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐPermissionGrantᚄ,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_SAMLConfiguration_defaultPermissions(_ 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 "application":
				return ec.fieldContext_PermissionGrant_application(ctx, field)
			case "accessLevel":
				return ec.fieldContext_PermissionGrant_accessLevel(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type PermissionGrant", field.Name)
		},
	}
	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 "spMetadataUrl":
				return ec.fieldContext_SAMLConfiguration_spMetadataUrl(ctx, field)
			case "testLoginUrl":
				return ec.fieldContext_SAMLConfiguration_testLoginUrl(ctx, field)
			case "attributeMappings":
				return ec.fieldContext_SAMLConfiguration_attributeMappings(ctx, field)
			case "defaultPermissions":
				return ec.fieldContext_SAMLConfiguration_defaultPermissions(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) _SSOAvailability_available(ctx context.Context, field graphql.CollectedField, obj *types.SSOAvailability) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SSOAvailability_available,
		func(ctx context.Context) (any, error) {
			return obj.Available, nil
		},
		nil,
		ec.marshalNBoolean2bool,
		true,
		true,
	)
}

func (ec *executionContext) fieldContext_SSOAvailability_available(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SSOAvailability",
		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) _SSOAvailability_samlConfigId(ctx context.Context, field graphql.CollectedField, obj *types.SSOAvailability) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SSOAvailability_samlConfigId,
		func(ctx context.Context) (any, error) {
			return obj.SamlConfigID, nil
		},
		nil,
		ec.marshalOID2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋgidᚐGID,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_SSOAvailability_samlConfigId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SSOAvailability",
		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) _SSOAvailability_organizationId(ctx context.Context, field graphql.CollectedField, obj *types.SSOAvailability) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		ec.fieldContext_SSOAvailability_organizationId,
		func(ctx context.Context) (any, error) {
			return obj.OrganizationID, nil
		},
		nil,
		ec.marshalOID2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋgidᚐGID,
		true,
		false,
	)
}

func (ec *executionContext) fieldContext_SSOAvailability_organizationId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SSOAvailability",
		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_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)
		},
		func(ctx context.Context, next graphql.Resolver) graphql.Resolver {
			directive0 := next

			directive1 := func(ctx context.Context) (any, error) {
				if ec.directives.IsViewer == nil {
					var zeroVal *types.Identity
					return zeroVal, errors.New("directive isViewer is not implemented")
				}
				return ec.directives.IsViewer(ctx, obj, directive0)
			}

			next = directive1
			return next
		},
		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)
			}
			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) _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)
			}
			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)
			}
			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)
			}
			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)
			}
			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)
			}
			return nil, fmt.Errorf("no field named %q was found under type Identity", 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 "viewerMembership":
				return ec.fieldContext_Organization_viewerMembership(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type Organization", field.Name)
		},
	}
	return fc, nil
}

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

func (ec *executionContext) fieldContext_UpdatePersonalAPIKeyPayload_personalAPIKey(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "UpdatePersonalAPIKeyPayload",
		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 "lastUsedAt":
				return ec.fieldContext_PersonalAPIKey_lastUsedAt(ctx, field)
			case "expiresAt":
				return ec.fieldContext_PersonalAPIKey_expiresAt(ctx, field)
			case "createdAt":
				return ec.fieldContext_PersonalAPIKey_createdAt(ctx, field)
			case "scopes":
				return ec.fieldContext_PersonalAPIKey_scopes(ctx, field)
			case "organizations":
				return ec.fieldContext_PersonalAPIKey_organizations(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type PersonalAPIKey", 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 "spMetadataUrl":
				return ec.fieldContext_SAMLConfiguration_spMetadataUrl(ctx, field)
			case "testLoginUrl":
				return ec.fieldContext_SAMLConfiguration_testLoginUrl(ctx, field)
			case "attributeMappings":
				return ec.fieldContext_SAMLConfiguration_attributeMappings(ctx, field)
			case "defaultPermissions":
				return ec.fieldContext_SAMLConfiguration_defaultPermissions(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type SAMLConfiguration", 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"}
	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) 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", "organizationIds"}
	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
		case "organizationIds":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("organizationIds"))
			data, err := ec.unmarshalNID2ᚕgoᚗproboᚗincᚋproboᚋpkgᚋgidᚐGIDᚄ(ctx, v)
			if err != nil {
				return it, err
			}
			it.OrganizationIds = 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) 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) 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"}
	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
		}
	}

	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) 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{"tokenId"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "tokenId":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tokenId"))
			data, err := ec.unmarshalNID2goᚗproboᚗincᚋproboᚋpkgᚋgidᚐGID(ctx, v)
			if err != nil {
				return it, err
			}
			it.TokenID = 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) 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{"email", "password"}
	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
		}
	}

	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"}
	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) 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) 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) unmarshalInputUpdatePersonalAPIKeyInput(ctx context.Context, obj any) (types.UpdatePersonalAPIKeyInput, error) {
	var it types.UpdatePersonalAPIKeyInput
	asMap := map[string]any{}
	for k, v := range obj.(map[string]any) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"tokenId", "name", "description"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "tokenId":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tokenId"))
			data, err := ec.unmarshalNID2goᚗproboᚗincᚋproboᚋpkgᚋgidᚐGID(ctx, v)
			if err != nil {
				return it, err
			}
			it.TokenID = 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 "description":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("description"))
			data, err := ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
			it.Description = 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.unmarshalOSAMLEnforcementPolicy2ᚖgoᚗ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) 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:
		panic(fmt.Errorf("unexpected type %T", 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.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.Permission:
		return ec._Permission(ctx, sel, &obj)
	case *types.Permission:
		if obj == nil {
			return graphql.Null
		}
		return ec._Permission(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)
	default:
		panic(fmt.Errorf("unexpected type %T", 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++
			}
		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 applicationImplementors = []string{"Application"}

func (ec *executionContext) _Application(ctx context.Context, sel ast.SelectionSet, obj *types.Application) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, applicationImplementors)

	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("Application")
		case "id":
			out.Values[i] = ec._Application_id(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "name":
			out.Values[i] = ec._Application_name(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "description":
			out.Values[i] = ec._Application_description(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "availableAccessLevels":
			out.Values[i] = ec._Application_availableAccessLevels(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 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 deactivateAccountPayloadImplementors = []string{"DeactivateAccountPayload"}

func (ec *executionContext) _DeactivateAccountPayload(ctx context.Context, sel ast.SelectionSet, obj *types.DeactivateAccountPayload) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, deactivateAccountPayloadImplementors)

	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("DeactivateAccountPayload")
		case "success":
			out.Values[i] = ec._DeactivateAccountPayload_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 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 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) })
		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 "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) })
		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 "permissions":
			out.Values[i] = ec._Membership_permissions(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) })
		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 {
				out.Invalids++
			}
		case "fullName":
			out.Values[i] = ec._MembershipProfile_fullName(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "createdAt":
			out.Values[i] = ec._MembershipProfile_createdAt(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "updatedAt":
			out.Values[i] = ec._MembershipProfile_updatedAt(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 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 "updatePersonalAPIKey":
			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
				return ec._Mutation_updatePersonalAPIKey(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 "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)
			})
		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 "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) })
		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 permissionImplementors = []string{"Permission", "Node"}

func (ec *executionContext) _Permission(ctx context.Context, sel ast.SelectionSet, obj *types.Permission) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, permissionImplementors)

	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("Permission")
		case "id":
			out.Values[i] = ec._Permission_id(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "createdAt":
			out.Values[i] = ec._Permission_createdAt(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "application":
			out.Values[i] = ec._Permission_application(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "accessLevel":
			out.Values[i] = ec._Permission_accessLevel(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "organization":
			out.Values[i] = ec._Permission_organization(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "principalType":
			out.Values[i] = ec._Permission_principalType(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "principalId":
			out.Values[i] = ec._Permission_principalId(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 permissionGrantImplementors = []string{"PermissionGrant"}

func (ec *executionContext) _PermissionGrant(ctx context.Context, sel ast.SelectionSet, obj *types.PermissionGrant) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, permissionGrantImplementors)

	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("PermissionGrant")
		case "application":
			out.Values[i] = ec._PermissionGrant_application(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "accessLevel":
			out.Values[i] = ec._PermissionGrant_accessLevel(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 {
				out.Invalids++
			}
		case "name":
			out.Values[i] = ec._PersonalAPIKey_name(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "lastUsedAt":
			out.Values[i] = ec._PersonalAPIKey_lastUsedAt(ctx, field, obj)
		case "expiresAt":
			out.Values[i] = ec._PersonalAPIKey_expiresAt(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "createdAt":
			out.Values[i] = ec._PersonalAPIKey_createdAt(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "scopes":
			out.Values[i] = ec._PersonalAPIKey_scopes(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "organizations":
			out.Values[i] = ec._PersonalAPIKey_organizations(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 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 "checkSSOAvailability":
			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._Query_checkSSOAvailability(ctx, field)
				if res == graphql.Null {
					atomic.AddUint32(&fs.Invalids, 1)
				}
				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 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 "success":
			out.Values[i] = ec._RevokePersonalAPIKeyPayload_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 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 {
				out.Invalids++
			}
		case "emailDomain":
			out.Values[i] = ec._SAMLConfiguration_emailDomain(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "enforcementPolicy":
			out.Values[i] = ec._SAMLConfiguration_enforcementPolicy(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		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 {
				out.Invalids++
			}
		case "idpSsoUrl":
			out.Values[i] = ec._SAMLConfiguration_idpSsoUrl(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "idpCertificate":
			out.Values[i] = ec._SAMLConfiguration_idpCertificate(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "autoSignupEnabled":
			out.Values[i] = ec._SAMLConfiguration_autoSignupEnabled(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "createdAt":
			out.Values[i] = ec._SAMLConfiguration_createdAt(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "updatedAt":
			out.Values[i] = ec._SAMLConfiguration_updatedAt(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "spMetadataUrl":
			out.Values[i] = ec._SAMLConfiguration_spMetadataUrl(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "testLoginUrl":
			out.Values[i] = ec._SAMLConfiguration_testLoginUrl(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "attributeMappings":
			out.Values[i] = ec._SAMLConfiguration_attributeMappings(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "defaultPermissions":
			out.Values[i] = ec._SAMLConfiguration_defaultPermissions(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 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 sSOAvailabilityImplementors = []string{"SSOAvailability"}

func (ec *executionContext) _SSOAvailability(ctx context.Context, sel ast.SelectionSet, obj *types.SSOAvailability) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, sSOAvailabilityImplementors)

	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("SSOAvailability")
		case "available":
			out.Values[i] = ec._SSOAvailability_available(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "samlConfigId":
			out.Values[i] = ec._SSOAvailability_samlConfigId(ctx, field, obj)
		case "organizationId":
			out.Values[i] = ec._SSOAvailability_organizationId(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 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)
			}
		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 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 updatePersonalAPIKeyPayloadImplementors = []string{"UpdatePersonalAPIKeyPayload"}

func (ec *executionContext) _UpdatePersonalAPIKeyPayload(ctx context.Context, sel ast.SelectionSet, obj *types.UpdatePersonalAPIKeyPayload) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, updatePersonalAPIKeyPayloadImplementors)

	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("UpdatePersonalAPIKeyPayload")
		case "personalAPIKey":
			out.Values[i] = ec._UpdatePersonalAPIKeyPayload_personalAPIKey(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 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 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) unmarshalNAccessLevel2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐAccessLevel(ctx context.Context, v any) (types.AccessLevel, error) {
	var res types.AccessLevel
	err := res.UnmarshalGQL(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNAccessLevel2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐAccessLevel(ctx context.Context, sel ast.SelectionSet, v types.AccessLevel) graphql.Marshaler {
	return v
}

func (ec *executionContext) unmarshalNAccessLevel2ᚕgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐAccessLevelᚄ(ctx context.Context, v any) ([]types.AccessLevel, error) {
	var vSlice []any
	vSlice = graphql.CoerceList(v)
	var err error
	res := make([]types.AccessLevel, len(vSlice))
	for i := range vSlice {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
		res[i], err = ec.unmarshalNAccessLevel2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐAccessLevel(ctx, vSlice[i])
		if err != nil {
			return nil, err
		}
	}
	return res, nil
}

func (ec *executionContext) marshalNAccessLevel2ᚕgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐAccessLevelᚄ(ctx context.Context, sel ast.SelectionSet, v []types.AccessLevel) 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.marshalNAccessLevel2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐAccessLevel(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) marshalNApplication2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐApplication(ctx context.Context, sel ast.SelectionSet, v *types.Application) 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._Application(ctx, sel, v)
}

func (ec *executionContext) unmarshalNApplicationId2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐApplicationID(ctx context.Context, v any) (types.ApplicationID, error) {
	var res types.ApplicationID
	err := res.UnmarshalGQL(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNApplicationId2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐApplicationID(ctx context.Context, sel ast.SelectionSet, v types.ApplicationID) graphql.Marshaler {
	return v
}

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) 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) 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) 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) 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) unmarshalNID2ᚕgoᚗproboᚗincᚋproboᚋpkgᚋgidᚐGIDᚄ(ctx context.Context, v any) ([]gid.GID, error) {
	var vSlice []any
	vSlice = graphql.CoerceList(v)
	var err error
	res := make([]gid.GID, len(vSlice))
	for i := range vSlice {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
		res[i], err = ec.unmarshalNID2goᚗproboᚗincᚋproboᚋpkgᚋgidᚐGID(ctx, vSlice[i])
		if err != nil {
			return nil, err
		}
	}
	return res, nil
}

func (ec *executionContext) marshalNID2ᚕgoᚗproboᚗincᚋproboᚋpkgᚋgidᚐGIDᚄ(ctx context.Context, sel ast.SelectionSet, v []gid.GID) graphql.Marshaler {
	ret := make(graphql.Array, len(v))
	for i := range v {
		ret[i] = ec.marshalNID2goᚗproboᚗincᚋproboᚋpkgᚋgidᚐGID(ctx, sel, v[i])
	}

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	return ret
}

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{
		"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.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{
		"ROLE":       coredata.MembershipOrderFieldRole,
		"CREATED_AT": coredata.MembershipOrderFieldCreatedAt,
	}
	marshalNMembershipOrderField2goᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐMembershipOrderField = map[coredata.MembershipOrderField]string{
		coredata.MembershipOrderFieldRole:      "ROLE",
		coredata.MembershipOrderFieldCreatedAt: "CREATED_AT",
	}
)

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) 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 {
	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.marshalNOrganization2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐOrganization(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) 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) marshalNPermission2ᚕᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐPermissionᚄ(ctx context.Context, sel ast.SelectionSet, v []*types.Permission) 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.marshalNPermission2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐPermission(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) marshalNPermission2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐPermission(ctx context.Context, sel ast.SelectionSet, v *types.Permission) 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._Permission(ctx, sel, v)
}

func (ec *executionContext) marshalNPermissionGrant2ᚕᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐPermissionGrantᚄ(ctx context.Context, sel ast.SelectionSet, v []*types.PermissionGrant) 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.marshalNPermissionGrant2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐPermissionGrant(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) marshalNPermissionGrant2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐPermissionGrant(ctx context.Context, sel ast.SelectionSet, v *types.PermissionGrant) 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._PermissionGrant(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) unmarshalNPrincipalType2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐPrincipalType(ctx context.Context, v any) (types.PrincipalType, error) {
	var res types.PrincipalType
	err := res.UnmarshalGQL(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNPrincipalType2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐPrincipalType(ctx context.Context, sel ast.SelectionSet, v types.PrincipalType) graphql.Marshaler {
	return v
}

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) 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) marshalNSSOAvailability2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐSSOAvailability(ctx context.Context, sel ast.SelectionSet, v types.SSOAvailability) graphql.Marshaler {
	return ec._SSOAvailability(ctx, sel, &v)
}

func (ec *executionContext) marshalNSSOAvailability2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐSSOAvailability(ctx context.Context, sel ast.SelectionSet, v *types.SSOAvailability) 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._SSOAvailability(ctx, sel, v)
}

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ᚋapiᚋconnectᚋv1ᚋtypesᚐSessionRequirement(ctx context.Context, v any) (types.SessionRequirement, error) {
	var res types.SessionRequirement
	err := res.UnmarshalGQL(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNSessionRequirement2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐSessionRequirement(ctx context.Context, sel ast.SelectionSet, v types.SessionRequirement) graphql.Marshaler {
	return v
}

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) unmarshalNTokenScope2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐTokenScope(ctx context.Context, v any) (types.TokenScope, error) {
	var res types.TokenScope
	err := res.UnmarshalGQL(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNTokenScope2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐTokenScope(ctx context.Context, sel ast.SelectionSet, v types.TokenScope) graphql.Marshaler {
	return v
}

func (ec *executionContext) unmarshalNTokenScope2ᚕgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐTokenScopeᚄ(ctx context.Context, v any) ([]types.TokenScope, error) {
	var vSlice []any
	vSlice = graphql.CoerceList(v)
	var err error
	res := make([]types.TokenScope, len(vSlice))
	for i := range vSlice {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
		res[i], err = ec.unmarshalNTokenScope2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐTokenScope(ctx, vSlice[i])
		if err != nil {
			return nil, err
		}
	}
	return res, nil
}

func (ec *executionContext) marshalNTokenScope2ᚕgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐTokenScopeᚄ(ctx context.Context, sel ast.SelectionSet, v []types.TokenScope) 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.marshalNTokenScope2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐTokenScope(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) 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) unmarshalNUpdatePersonalAPIKeyInput2goᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐUpdatePersonalAPIKeyInput(ctx context.Context, v any) (types.UpdatePersonalAPIKeyInput, error) {
	res, err := ec.unmarshalInputUpdatePersonalAPIKeyInput(ctx, v)
	return res, graphql.ErrorOnPath(ctx, err)
}

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) 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) 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) 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) 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) marshalOPersonalAPIKey2ᚖ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 {
		return graphql.Null
	}
	return ec._PersonalAPIKey(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) 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) unmarshalOSAMLEnforcementPolicy2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐSAMLEnforcementPolicy(ctx context.Context, v any) (*coredata.SAMLEnforcementPolicy, error) {
	if v == nil {
		return nil, nil
	}
	tmp, err := graphql.UnmarshalString(v)
	res := unmarshalOSAMLEnforcementPolicy2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐSAMLEnforcementPolicy[tmp]
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalOSAMLEnforcementPolicy2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐSAMLEnforcementPolicy(ctx context.Context, sel ast.SelectionSet, v *coredata.SAMLEnforcementPolicy) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	_ = sel
	_ = ctx
	res := graphql.MarshalString(marshalOSAMLEnforcementPolicy2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐSAMLEnforcementPolicy[*v])
	return res
}

var (
	unmarshalOSAMLEnforcementPolicy2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐSAMLEnforcementPolicy = map[string]coredata.SAMLEnforcementPolicy{
		"OFF":      coredata.SAMLEnforcementPolicyOff,
		"OPTIONAL": coredata.SAMLEnforcementPolicyOptional,
		"REQUIRED": coredata.SAMLEnforcementPolicyRequired,
	}
	marshalOSAMLEnforcementPolicy2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋcoredataᚐSAMLEnforcementPolicy = map[coredata.SAMLEnforcementPolicy]string{
		coredata.SAMLEnforcementPolicyOff:      "OFF",
		coredata.SAMLEnforcementPolicyOptional: "OPTIONAL",
		coredata.SAMLEnforcementPolicyRequired: "REQUIRED",
	}
)

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) marshalOUpdatePersonalAPIKeyPayload2ᚖgoᚗproboᚗincᚋproboᚋpkgᚋserverᚋapiᚋconnectᚋv1ᚋtypesᚐUpdatePersonalAPIKeyPayload(ctx context.Context, sel ast.SelectionSet, v *types.UpdatePersonalAPIKeyPayload) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._UpdatePersonalAPIKeyPayload(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) 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 *****************************