~netlandish/links

a2c0846bca380ce568a2c41262c3d30aee154519 — Peter Sanchez 30 days ago 221d059 
Moving qr_cores code_type to enums
patch browse .tar.gz 
13 files changed, 2562 insertions(+), 843 deletions(-)

M api/api_test.go
M api/graph/generated.go
M api/graph/model/models_gen.go
M api/graph/schema.graphqls
M api/graph/schema.resolvers.go
M list/routes.go
M migrations/0001_initial.down.sql
M migrations/0001_initial.up.sql
M migrations/test_migration.up.sql
M models/models.go
M models/qr_codes.go
M models/schema.sql
M short/routes.go

M api/api_test.go => api/api_test.go +6 -6
@@ 1677,7 1677,7 @@ func TestAPI(t *testing.T) {

		var result GraphQLResponse
		op := gqlclient.NewOperation(`
			mutation AddQRCode($slug: String!, $type: Int!, $id: Int!, $title: String!) {
			mutation AddQRCode($slug: String!, $type: QRCodeType!, $id: Int!, $title: String!) {
				addQRCode(input: {orgSlug: $slug, codeType: $type, elementId: $id, title: $title}) {
					id
					imagePath


@@ 1703,7 1703,7 @@ func TestAPI(t *testing.T) {

		var result GraphQLResponse
		op := gqlclient.NewOperation(`
			mutation AddQRCode($slug: String!, $type: Int!, $id: Int!, $title: String!) {
			mutation AddQRCode($slug: String!, $type: QRCodeType!, $id: Int!, $title: String!) {
				addQRCode(input: {orgSlug: $slug, codeType: $type, elementId: $id, title: $title}) {
					id
					imagePath


@@ 1734,7 1734,7 @@ func TestAPI(t *testing.T) {

		var result GraphQLResponse
		op := gqlclient.NewOperation(`
			query GetQRList($slug: String!, $element: Int!, $type: Int!) {
			query GetQRList($slug: String!, $element: Int!, $type: QRCodeType!) {
				getQRList(orgSlug: $slug, elementId: $element, codeType: $type) {
					qrCodeId
					qrHashId


@@ 1764,7 1764,7 @@ func TestAPI(t *testing.T) {

		var result GraphQLResponse
		op := gqlclient.NewOperation(`
			query GetQRList($slug: String!, $element: Int!, $type: Int!) {
			query GetQRList($slug: String!, $element: Int!, $type: QRCodeType!) {
				getQRList(orgSlug: $slug, elementId: $element, codeType: $type) {
					qrCodeId
					qrHashId


@@ 2121,7 2121,7 @@ func TestAPI(t *testing.T) {

		var result GraphQLResponse
		op := gqlclient.NewOperation(`
			mutation AddQRCode($slug: String!, $type: Int!, $id: Int!, $title: String!) {
			mutation AddQRCode($slug: String!, $type: QRCodeType!, $id: Int!, $title: String!) {
				addQRCode(input: {orgSlug: $slug, codeType: $type, elementId: $id, title: $title}) {
					id
					imagePath


@@ 2149,7 2149,7 @@ func TestAPI(t *testing.T) {

		var result GraphQLResponse
		op := gqlclient.NewOperation(`
			mutation AddQRCode($slug: String!, $type: Int!, $id: Int!, $title: String!) {
			mutation AddQRCode($slug: String!, $type: QRCodeType!, $id: Int!, $title: String!) {
				addQRCode(input: {orgSlug: $slug, codeType: $type, elementId: $id, title: $title}) {
					id
					imagePath


M api/graph/generated.go => api/graph/generated.go +2459 -809
@@ 47,6 47,7 @@ type ResolverRoot interface {
	OrgLink() OrgLinkResolver
	Organization() OrganizationResolver
	OrganizationSettings() OrganizationSettingsResolver
	QRCode() QRCodeResolver
	Query() QueryResolver
	User() UserResolver
}


@@ 383,7 384,7 @@ type ComplexityRoot struct {
		GetPaymentHistory     func(childComplexity int, input *model.GetPaymentInput) int
		GetPopularLinks       func(childComplexity int, input *model.PopularLinksInput) int
		GetQRDetail           func(childComplexity int, hashID string, orgSlug *string) int
		GetQRList             func(childComplexity int, orgSlug string, codeType int, elementID int) int
		GetQRList             func(childComplexity int, orgSlug string, codeType model.QRCodeType, elementID int) int
		GetUser               func(childComplexity int, id int) int
		GetUsers              func(childComplexity int, input *model.GetUserInput) int
		Me                    func(childComplexity int) int


@@ 491,6 492,9 @@ type OrganizationResolver interface {
type OrganizationSettingsResolver interface {
	DefaultPerm(ctx context.Context, obj *models.OrganizationSettings) (model.LinkVisibility, error)
}
type QRCodeResolver interface {
	CodeType(ctx context.Context, obj *models.QRCode) (model.QRCodeType, error)
}
type QueryResolver interface {
	Version(ctx context.Context) (*model.Version, error)
	Me(ctx context.Context) (*models.User, error)


@@ 508,7 512,7 @@ type QueryResolver interface {
	GetListings(ctx context.Context, input *model.GetListingInput) (*model.ListingCursor, error)
	GetListing(ctx context.Context, input *model.GetListingDetailInput) (*model.ListingLinkCursor, error)
	GetListingLink(ctx context.Context, slug string, id int, domainID int) (*models.ListingLink, error)
	GetQRList(ctx context.Context, orgSlug string, codeType int, elementID int) ([]*model.QRObject, error)
	GetQRList(ctx context.Context, orgSlug string, codeType model.QRCodeType, elementID int) ([]*model.QRObject, error)
	GetQRDetail(ctx context.Context, hashID string, orgSlug *string) (*models.QRCode, error)
	Analytics(ctx context.Context, input model.AnalyticsInput) (*model.Analytics, error)
	GetFeed(ctx context.Context, input *model.GetFeedInput) (*model.OrgLinkCursor, error)


@@ 2379,7 2383,7 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in
			return 0, false
		}

		return e.complexity.Query.GetQRList(childComplexity, args["orgSlug"].(string), args["codeType"].(int), args["elementId"].(int)), true
		return e.complexity.Query.GetQRList(childComplexity, args["orgSlug"].(string), args["codeType"].(model.QRCodeType), args["elementId"].(int)), true

	case "Query.getUser":
		if e.complexity.Query.GetUser == nil {


@@ 2585,8 2589,8 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in
}

func (e *executableSchema) Exec(ctx context.Context) graphql.ResponseHandler {
	rc := graphql.GetOperationContext(ctx)
	ec := executionContext{rc, e, 0, 0, make(chan graphql.DeferredResult)}
	opCtx := graphql.GetOperationContext(ctx)
	ec := executionContext{opCtx, e, 0, 0, make(chan graphql.DeferredResult)}
	inputUnmarshalMap := graphql.BuildUnmarshalerMap(
		ec.unmarshalInputAddListingInput,
		ec.unmarshalInputAddListingLinkInput,


@@ 2624,7 2628,7 @@ func (e *executableSchema) Exec(ctx context.Context) graphql.ResponseHandler {
	)
	first := true

	switch rc.Operation.Operation {
	switch opCtx.Operation.Operation {
	case ast.Query:
		return func(ctx context.Context) *graphql.Response {
			var response graphql.Response


@@ 2632,7 2636,7 @@ func (e *executableSchema) Exec(ctx context.Context) graphql.ResponseHandler {
			if first {
				first = false
				ctx = graphql.WithUnmarshalerMap(ctx, inputUnmarshalMap)
				data = ec._Query(ctx, rc.Operation.SelectionSet)
				data = ec._Query(ctx, opCtx.Operation.SelectionSet)
			} else {
				if atomic.LoadInt32(&ec.pendingDeferred) > 0 {
					result := <-ec.deferredResults


@@ 2662,7 2666,7 @@ func (e *executableSchema) Exec(ctx context.Context) graphql.ResponseHandler {
			}
			first = false
			ctx = graphql.WithUnmarshalerMap(ctx, inputUnmarshalMap)
			data := ec._Mutation(ctx, rc.Operation.SelectionSet)
			data := ec._Mutation(ctx, opCtx.Operation.SelectionSet)
			var buf bytes.Buffer
			data.MarshalGQL(&buf)



@@ 2740,1007 2744,2224 @@ var parsedSchema = gqlparser.MustLoadSchema(sources...)
func (ec *executionContext) dir_access_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 model.AccessScope
	if tmp, ok := rawArgs["scope"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scope"))
		arg0, err = ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, tmp)
		if err != nil {
			return nil, err
		}
	arg0, err := ec.dir_access_argsScope(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["scope"] = arg0
	var arg1 model.AccessKind
	if tmp, ok := rawArgs["kind"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("kind"))
		arg1, err = ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, tmp)
		if err != nil {
			return nil, err
		}
	arg1, err := ec.dir_access_argsKind(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["kind"] = arg1
	return args, nil
}
func (ec *executionContext) dir_access_argsScope(
	ctx context.Context,
	rawArgs map[string]interface{},
) (model.AccessScope, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["scope"]
	if !ok {
		var zeroVal model.AccessScope
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("scope"))
	if tmp, ok := rawArgs["scope"]; ok {
		return ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, tmp)
	}

	var zeroVal model.AccessScope
	return zeroVal, nil
}

func (ec *executionContext) dir_access_argsKind(
	ctx context.Context,
	rawArgs map[string]interface{},
) (model.AccessKind, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["kind"]
	if !ok {
		var zeroVal model.AccessKind
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("kind"))
	if tmp, ok := rawArgs["kind"]; ok {
		return ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, tmp)
	}

	var zeroVal model.AccessKind
	return zeroVal, nil
}

func (ec *executionContext) dir_scopehelp_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 string
	if tmp, ok := rawArgs["details"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("details"))
		arg0, err = ec.unmarshalNString2string(ctx, tmp)
		if err != nil {
			return nil, err
		}
	arg0, err := ec.dir_scopehelp_argsDetails(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["details"] = arg0
	return args, nil
}
func (ec *executionContext) dir_scopehelp_argsDetails(
	ctx context.Context,
	rawArgs map[string]interface{},
) (string, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["details"]
	if !ok {
		var zeroVal string
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("details"))
	if tmp, ok := rawArgs["details"]; ok {
		return ec.unmarshalNString2string(ctx, tmp)
	}

	var zeroVal string
	return zeroVal, nil
}

func (ec *executionContext) field_Mutation_addAdminDomain_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 model.AdminDomainInput
	if tmp, ok := rawArgs["input"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
		arg0, err = ec.unmarshalNAdminDomainInput2linksᚋapiᚋgraphᚋmodelᚐAdminDomainInput(ctx, tmp)
		if err != nil {
			return nil, err
		}
	arg0, err := ec.field_Mutation_addAdminDomain_argsInput(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}
func (ec *executionContext) field_Mutation_addAdminDomain_argsInput(
	ctx context.Context,
	rawArgs map[string]interface{},
) (model.AdminDomainInput, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["input"]
	if !ok {
		var zeroVal model.AdminDomainInput
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
	if tmp, ok := rawArgs["input"]; ok {
		return ec.unmarshalNAdminDomainInput2linksᚋapiᚋgraphᚋmodelᚐAdminDomainInput(ctx, tmp)
	}

	var zeroVal model.AdminDomainInput
	return zeroVal, nil
}

func (ec *executionContext) field_Mutation_addDomain_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 model.DomainInput
	if tmp, ok := rawArgs["input"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
		arg0, err = ec.unmarshalNDomainInput2linksᚋapiᚋgraphᚋmodelᚐDomainInput(ctx, tmp)
		if err != nil {
			return nil, err
		}
	arg0, err := ec.field_Mutation_addDomain_argsInput(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}
func (ec *executionContext) field_Mutation_addDomain_argsInput(
	ctx context.Context,
	rawArgs map[string]interface{},
) (model.DomainInput, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["input"]
	if !ok {
		var zeroVal model.DomainInput
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
	if tmp, ok := rawArgs["input"]; ok {
		return ec.unmarshalNDomainInput2linksᚋapiᚋgraphᚋmodelᚐDomainInput(ctx, tmp)
	}

	var zeroVal model.DomainInput
	return zeroVal, nil
}

func (ec *executionContext) field_Mutation_addLinkShort_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 *model.LinkShortInput
	if tmp, ok := rawArgs["input"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
		arg0, err = ec.unmarshalOLinkShortInput2ᚖlinksᚋapiᚋgraphᚋmodelᚐLinkShortInput(ctx, tmp)
		if err != nil {
			return nil, err
		}
	arg0, err := ec.field_Mutation_addLinkShort_argsInput(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}
func (ec *executionContext) field_Mutation_addLinkShort_argsInput(
	ctx context.Context,
	rawArgs map[string]interface{},
) (*model.LinkShortInput, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["input"]
	if !ok {
		var zeroVal *model.LinkShortInput
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
	if tmp, ok := rawArgs["input"]; ok {
		return ec.unmarshalOLinkShortInput2ᚖlinksᚋapiᚋgraphᚋmodelᚐLinkShortInput(ctx, tmp)
	}

	var zeroVal *model.LinkShortInput
	return zeroVal, nil
}

func (ec *executionContext) field_Mutation_addLink_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 *model.LinkInput
	if tmp, ok := rawArgs["input"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
		arg0, err = ec.unmarshalOLinkInput2ᚖlinksᚋapiᚋgraphᚋmodelᚐLinkInput(ctx, tmp)
		if err != nil {
			return nil, err
		}
	arg0, err := ec.field_Mutation_addLink_argsInput(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}
func (ec *executionContext) field_Mutation_addLink_argsInput(
	ctx context.Context,
	rawArgs map[string]interface{},
) (*model.LinkInput, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["input"]
	if !ok {
		var zeroVal *model.LinkInput
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
	if tmp, ok := rawArgs["input"]; ok {
		return ec.unmarshalOLinkInput2ᚖlinksᚋapiᚋgraphᚋmodelᚐLinkInput(ctx, tmp)
	}

	var zeroVal *model.LinkInput
	return zeroVal, nil
}

func (ec *executionContext) field_Mutation_addListingLink_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 *model.AddListingLinkInput
	if tmp, ok := rawArgs["input"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
		arg0, err = ec.unmarshalOAddListingLinkInput2ᚖlinksᚋapiᚋgraphᚋmodelᚐAddListingLinkInput(ctx, tmp)
		if err != nil {
			return nil, err
		}
	arg0, err := ec.field_Mutation_addListingLink_argsInput(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}
func (ec *executionContext) field_Mutation_addListingLink_argsInput(
	ctx context.Context,
	rawArgs map[string]interface{},
) (*model.AddListingLinkInput, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["input"]
	if !ok {
		var zeroVal *model.AddListingLinkInput
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
	if tmp, ok := rawArgs["input"]; ok {
		return ec.unmarshalOAddListingLinkInput2ᚖlinksᚋapiᚋgraphᚋmodelᚐAddListingLinkInput(ctx, tmp)
	}

	var zeroVal *model.AddListingLinkInput
	return zeroVal, nil
}

func (ec *executionContext) field_Mutation_addListing_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 *model.AddListingInput
	if tmp, ok := rawArgs["input"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
		arg0, err = ec.unmarshalOAddListingInput2ᚖlinksᚋapiᚋgraphᚋmodelᚐAddListingInput(ctx, tmp)
		if err != nil {
			return nil, err
		}
	arg0, err := ec.field_Mutation_addListing_argsInput(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}
func (ec *executionContext) field_Mutation_addListing_argsInput(
	ctx context.Context,
	rawArgs map[string]interface{},
) (*model.AddListingInput, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["input"]
	if !ok {
		var zeroVal *model.AddListingInput
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
	if tmp, ok := rawArgs["input"]; ok {
		return ec.unmarshalOAddListingInput2ᚖlinksᚋapiᚋgraphᚋmodelᚐAddListingInput(ctx, tmp)
	}

	var zeroVal *model.AddListingInput
	return zeroVal, nil
}

func (ec *executionContext) field_Mutation_addMember_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 *model.MemberInput
	if tmp, ok := rawArgs["input"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
		arg0, err = ec.unmarshalOMemberInput2ᚖlinksᚋapiᚋgraphᚋmodelᚐMemberInput(ctx, tmp)
		if err != nil {
			return nil, err
		}
	arg0, err := ec.field_Mutation_addMember_argsInput(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}
func (ec *executionContext) field_Mutation_addMember_argsInput(
	ctx context.Context,
	rawArgs map[string]interface{},
) (*model.MemberInput, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["input"]
	if !ok {
		var zeroVal *model.MemberInput
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
	if tmp, ok := rawArgs["input"]; ok {
		return ec.unmarshalOMemberInput2ᚖlinksᚋapiᚋgraphᚋmodelᚐMemberInput(ctx, tmp)
	}

	var zeroVal *model.MemberInput
	return zeroVal, nil
}

func (ec *executionContext) field_Mutation_addNote_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 *model.NoteInput
	if tmp, ok := rawArgs["input"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
		arg0, err = ec.unmarshalONoteInput2ᚖlinksᚋapiᚋgraphᚋmodelᚐNoteInput(ctx, tmp)
		if err != nil {
			return nil, err
		}
	arg0, err := ec.field_Mutation_addNote_argsInput(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}
func (ec *executionContext) field_Mutation_addNote_argsInput(
	ctx context.Context,
	rawArgs map[string]interface{},
) (*model.NoteInput, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["input"]
	if !ok {
		var zeroVal *model.NoteInput
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
	if tmp, ok := rawArgs["input"]; ok {
		return ec.unmarshalONoteInput2ᚖlinksᚋapiᚋgraphᚋmodelᚐNoteInput(ctx, tmp)
	}

	var zeroVal *model.NoteInput
	return zeroVal, nil
}

func (ec *executionContext) field_Mutation_addOrganization_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 model.OrganizationInput
	if tmp, ok := rawArgs["input"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
		arg0, err = ec.unmarshalNOrganizationInput2linksᚋapiᚋgraphᚋmodelᚐOrganizationInput(ctx, tmp)
		if err != nil {
			return nil, err
		}
	arg0, err := ec.field_Mutation_addOrganization_argsInput(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}
func (ec *executionContext) field_Mutation_addOrganization_argsInput(
	ctx context.Context,
	rawArgs map[string]interface{},
) (model.OrganizationInput, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["input"]
	if !ok {
		var zeroVal model.OrganizationInput
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
	if tmp, ok := rawArgs["input"]; ok {
		return ec.unmarshalNOrganizationInput2linksᚋapiᚋgraphᚋmodelᚐOrganizationInput(ctx, tmp)
	}

	var zeroVal model.OrganizationInput
	return zeroVal, nil
}

func (ec *executionContext) field_Mutation_addQRCode_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 model.AddQRCodeInput
	if tmp, ok := rawArgs["input"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
		arg0, err = ec.unmarshalNAddQRCodeInput2linksᚋapiᚋgraphᚋmodelᚐAddQRCodeInput(ctx, tmp)
		if err != nil {
			return nil, err
		}
	arg0, err := ec.field_Mutation_addQRCode_argsInput(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}
func (ec *executionContext) field_Mutation_addQRCode_argsInput(
	ctx context.Context,
	rawArgs map[string]interface{},
) (model.AddQRCodeInput, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["input"]
	if !ok {
		var zeroVal model.AddQRCodeInput
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
	if tmp, ok := rawArgs["input"]; ok {
		return ec.unmarshalNAddQRCodeInput2linksᚋapiᚋgraphᚋmodelᚐAddQRCodeInput(ctx, tmp)
	}

	var zeroVal model.AddQRCodeInput
	return zeroVal, nil
}

func (ec *executionContext) field_Mutation_completeRegister_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 *model.CompleteRegisterInput
	if tmp, ok := rawArgs["input"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
		arg0, err = ec.unmarshalOCompleteRegisterInput2ᚖlinksᚋapiᚋgraphᚋmodelᚐCompleteRegisterInput(ctx, tmp)
		if err != nil {
			return nil, err
		}
	arg0, err := ec.field_Mutation_completeRegister_argsInput(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}
func (ec *executionContext) field_Mutation_completeRegister_argsInput(
	ctx context.Context,
	rawArgs map[string]interface{},
) (*model.CompleteRegisterInput, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["input"]
	if !ok {
		var zeroVal *model.CompleteRegisterInput
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
	if tmp, ok := rawArgs["input"]; ok {
		return ec.unmarshalOCompleteRegisterInput2ᚖlinksᚋapiᚋgraphᚋmodelᚐCompleteRegisterInput(ctx, tmp)
	}

	var zeroVal *model.CompleteRegisterInput
	return zeroVal, nil
}

func (ec *executionContext) field_Mutation_confirmMember_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 string
	if tmp, ok := rawArgs["key"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("key"))
		arg0, err = ec.unmarshalNString2string(ctx, tmp)
		if err != nil {
			return nil, err
		}
	arg0, err := ec.field_Mutation_confirmMember_argsKey(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["key"] = arg0
	return args, nil
}
func (ec *executionContext) field_Mutation_confirmMember_argsKey(
	ctx context.Context,
	rawArgs map[string]interface{},
) (string, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["key"]
	if !ok {
		var zeroVal string
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("key"))
	if tmp, ok := rawArgs["key"]; ok {
		return ec.unmarshalNString2string(ctx, tmp)
	}

	var zeroVal string
	return zeroVal, nil
}

func (ec *executionContext) field_Mutation_deleteDomain_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 int
	if tmp, ok := rawArgs["id"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
		arg0, err = ec.unmarshalNInt2int(ctx, tmp)
		if err != nil {
			return nil, err
		}
	arg0, err := ec.field_Mutation_deleteDomain_argsID(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["id"] = arg0
	return args, nil
}
func (ec *executionContext) field_Mutation_deleteDomain_argsID(
	ctx context.Context,
	rawArgs map[string]interface{},
) (int, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["id"]
	if !ok {
		var zeroVal int
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
	if tmp, ok := rawArgs["id"]; ok {
		return ec.unmarshalNInt2int(ctx, tmp)
	}

	var zeroVal int
	return zeroVal, nil
}

func (ec *executionContext) field_Mutation_deleteLinkShort_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 int
	if tmp, ok := rawArgs["id"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
		arg0, err = ec.unmarshalNInt2int(ctx, tmp)
		if err != nil {
			return nil, err
		}
	arg0, err := ec.field_Mutation_deleteLinkShort_argsID(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["id"] = arg0
	return args, nil
}
func (ec *executionContext) field_Mutation_deleteLinkShort_argsID(
	ctx context.Context,
	rawArgs map[string]interface{},
) (int, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["id"]
	if !ok {
		var zeroVal int
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
	if tmp, ok := rawArgs["id"]; ok {
		return ec.unmarshalNInt2int(ctx, tmp)
	}

	var zeroVal int
	return zeroVal, nil
}

func (ec *executionContext) field_Mutation_deleteLink_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 string
	if tmp, ok := rawArgs["hash"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hash"))
		arg0, err = ec.unmarshalNString2string(ctx, tmp)
		if err != nil {
			return nil, err
		}
	arg0, err := ec.field_Mutation_deleteLink_argsHash(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["hash"] = arg0
	return args, nil
}
func (ec *executionContext) field_Mutation_deleteLink_argsHash(
	ctx context.Context,
	rawArgs map[string]interface{},
) (string, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["hash"]
	if !ok {
		var zeroVal string
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("hash"))
	if tmp, ok := rawArgs["hash"]; ok {
		return ec.unmarshalNString2string(ctx, tmp)
	}

	var zeroVal string
	return zeroVal, nil
}

func (ec *executionContext) field_Mutation_deleteListingLink_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 int
	if tmp, ok := rawArgs["id"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
		arg0, err = ec.unmarshalNInt2int(ctx, tmp)
		if err != nil {
			return nil, err
		}
	arg0, err := ec.field_Mutation_deleteListingLink_argsID(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["id"] = arg0
	return args, nil
}
func (ec *executionContext) field_Mutation_deleteListingLink_argsID(
	ctx context.Context,
	rawArgs map[string]interface{},
) (int, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["id"]
	if !ok {
		var zeroVal int
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
	if tmp, ok := rawArgs["id"]; ok {
		return ec.unmarshalNInt2int(ctx, tmp)
	}

	var zeroVal int
	return zeroVal, nil
}

func (ec *executionContext) field_Mutation_deleteListing_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 int
	if tmp, ok := rawArgs["id"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
		arg0, err = ec.unmarshalNInt2int(ctx, tmp)
		if err != nil {
			return nil, err
		}
	arg0, err := ec.field_Mutation_deleteListing_argsID(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["id"] = arg0
	return args, nil
}
func (ec *executionContext) field_Mutation_deleteListing_argsID(
	ctx context.Context,
	rawArgs map[string]interface{},
) (int, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["id"]
	if !ok {
		var zeroVal int
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
	if tmp, ok := rawArgs["id"]; ok {
		return ec.unmarshalNInt2int(ctx, tmp)
	}

	var zeroVal int
	return zeroVal, nil
}

func (ec *executionContext) field_Mutation_deleteMember_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 string
	if tmp, ok := rawArgs["orgSlug"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("orgSlug"))
		arg0, err = ec.unmarshalNString2string(ctx, tmp)
		if err != nil {
			return nil, err
		}
	arg0, err := ec.field_Mutation_deleteMember_argsOrgSlug(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["orgSlug"] = arg0
	var arg1 string
	if tmp, ok := rawArgs["email"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("email"))
		arg1, err = ec.unmarshalNString2string(ctx, tmp)
		if err != nil {
			return nil, err
		}
	arg1, err := ec.field_Mutation_deleteMember_argsEmail(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["email"] = arg1
	return args, nil
}
func (ec *executionContext) field_Mutation_deleteMember_argsOrgSlug(
	ctx context.Context,
	rawArgs map[string]interface{},
) (string, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["orgSlug"]
	if !ok {
		var zeroVal string
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("orgSlug"))
	if tmp, ok := rawArgs["orgSlug"]; ok {
		return ec.unmarshalNString2string(ctx, tmp)
	}

	var zeroVal string
	return zeroVal, nil
}

func (ec *executionContext) field_Mutation_deleteMember_argsEmail(
	ctx context.Context,
	rawArgs map[string]interface{},
) (string, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["email"]
	if !ok {
		var zeroVal string
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("email"))
	if tmp, ok := rawArgs["email"]; ok {
		return ec.unmarshalNString2string(ctx, tmp)
	}

	var zeroVal string
	return zeroVal, nil
}

func (ec *executionContext) field_Mutation_deleteQRCode_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 int
	if tmp, ok := rawArgs["id"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
		arg0, err = ec.unmarshalNInt2int(ctx, tmp)
		if err != nil {
			return nil, err
		}
	arg0, err := ec.field_Mutation_deleteQRCode_argsID(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["id"] = arg0
	return args, nil
}
func (ec *executionContext) field_Mutation_deleteQRCode_argsID(
	ctx context.Context,
	rawArgs map[string]interface{},
) (int, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["id"]
	if !ok {
		var zeroVal int
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
	if tmp, ok := rawArgs["id"]; ok {
		return ec.unmarshalNInt2int(ctx, tmp)
	}

	var zeroVal int
	return zeroVal, nil
}

func (ec *executionContext) field_Mutation_follow_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 string
	if tmp, ok := rawArgs["orgSlug"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("orgSlug"))
		arg0, err = ec.unmarshalNString2string(ctx, tmp)
		if err != nil {
			return nil, err
		}
	arg0, err := ec.field_Mutation_follow_argsOrgSlug(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["orgSlug"] = arg0
	return args, nil
}
func (ec *executionContext) field_Mutation_follow_argsOrgSlug(
	ctx context.Context,
	rawArgs map[string]interface{},
) (string, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["orgSlug"]
	if !ok {
		var zeroVal string
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("orgSlug"))
	if tmp, ok := rawArgs["orgSlug"]; ok {
		return ec.unmarshalNString2string(ctx, tmp)
	}

	var zeroVal string
	return zeroVal, nil
}

func (ec *executionContext) field_Mutation_register_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 *model.RegisterInput
	if tmp, ok := rawArgs["input"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
		arg0, err = ec.unmarshalORegisterInput2ᚖlinksᚋapiᚋgraphᚋmodelᚐRegisterInput(ctx, tmp)
		if err != nil {
			return nil, err
		}
	arg0, err := ec.field_Mutation_register_argsInput(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}
func (ec *executionContext) field_Mutation_register_argsInput(
	ctx context.Context,
	rawArgs map[string]interface{},
) (*model.RegisterInput, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["input"]
	if !ok {
		var zeroVal *model.RegisterInput
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
	if tmp, ok := rawArgs["input"]; ok {
		return ec.unmarshalORegisterInput2ᚖlinksᚋapiᚋgraphᚋmodelᚐRegisterInput(ctx, tmp)
	}

	var zeroVal *model.RegisterInput
	return zeroVal, nil
}

func (ec *executionContext) field_Mutation_sendRegisterInvitation_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 string
	if tmp, ok := rawArgs["toEmail"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("toEmail"))
		arg0, err = ec.unmarshalNString2string(ctx, tmp)
		if err != nil {
			return nil, err
		}
	arg0, err := ec.field_Mutation_sendRegisterInvitation_argsToEmail(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["toEmail"] = arg0
	return args, nil
}
func (ec *executionContext) field_Mutation_sendRegisterInvitation_argsToEmail(
	ctx context.Context,
	rawArgs map[string]interface{},
) (string, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["toEmail"]
	if !ok {
		var zeroVal string
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("toEmail"))
	if tmp, ok := rawArgs["toEmail"]; ok {
		return ec.unmarshalNString2string(ctx, tmp)
	}

	var zeroVal string
	return zeroVal, nil
}

func (ec *executionContext) field_Mutation_unfollow_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 string
	if tmp, ok := rawArgs["orgSlug"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("orgSlug"))
		arg0, err = ec.unmarshalNString2string(ctx, tmp)
		if err != nil {
			return nil, err
		}
	arg0, err := ec.field_Mutation_unfollow_argsOrgSlug(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["orgSlug"] = arg0
	return args, nil
}
func (ec *executionContext) field_Mutation_unfollow_argsOrgSlug(
	ctx context.Context,
	rawArgs map[string]interface{},
) (string, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["orgSlug"]
	if !ok {
		var zeroVal string
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("orgSlug"))
	if tmp, ok := rawArgs["orgSlug"]; ok {
		return ec.unmarshalNString2string(ctx, tmp)
	}

	var zeroVal string
	return zeroVal, nil
}

func (ec *executionContext) field_Mutation_updateAdminDomain_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 model.UpdateAdminDomainInput
	if tmp, ok := rawArgs["input"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
		arg0, err = ec.unmarshalNUpdateAdminDomainInput2linksᚋapiᚋgraphᚋmodelᚐUpdateAdminDomainInput(ctx, tmp)
		if err != nil {
			return nil, err
		}
	arg0, err := ec.field_Mutation_updateAdminDomain_argsInput(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}
func (ec *executionContext) field_Mutation_updateAdminDomain_argsInput(
	ctx context.Context,
	rawArgs map[string]interface{},
) (model.UpdateAdminDomainInput, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["input"]
	if !ok {
		var zeroVal model.UpdateAdminDomainInput
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
	if tmp, ok := rawArgs["input"]; ok {
		return ec.unmarshalNUpdateAdminDomainInput2linksᚋapiᚋgraphᚋmodelᚐUpdateAdminDomainInput(ctx, tmp)
	}

	var zeroVal model.UpdateAdminDomainInput
	return zeroVal, nil
}

func (ec *executionContext) field_Mutation_updateAdminOrgType_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 string
	if tmp, ok := rawArgs["orgSlug"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("orgSlug"))
		arg0, err = ec.unmarshalNString2string(ctx, tmp)
		if err != nil {
			return nil, err
		}
	arg0, err := ec.field_Mutation_updateAdminOrgType_argsOrgSlug(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["orgSlug"] = arg0
	var arg1 model.OrgBillingStatus
	if tmp, ok := rawArgs["orgType"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("orgType"))
		arg1, err = ec.unmarshalNOrgBillingStatus2linksᚋapiᚋgraphᚋmodelᚐOrgBillingStatus(ctx, tmp)
		if err != nil {
			return nil, err
		}
	arg1, err := ec.field_Mutation_updateAdminOrgType_argsOrgType(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["orgType"] = arg1
	return args, nil
}
func (ec *executionContext) field_Mutation_updateAdminOrgType_argsOrgSlug(
	ctx context.Context,
	rawArgs map[string]interface{},
) (string, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["orgSlug"]
	if !ok {
		var zeroVal string
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("orgSlug"))
	if tmp, ok := rawArgs["orgSlug"]; ok {
		return ec.unmarshalNString2string(ctx, tmp)
	}

	var zeroVal string
	return zeroVal, nil
}

func (ec *executionContext) field_Mutation_updateAdminOrgType_argsOrgType(
	ctx context.Context,
	rawArgs map[string]interface{},
) (model.OrgBillingStatus, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["orgType"]
	if !ok {
		var zeroVal model.OrgBillingStatus
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("orgType"))
	if tmp, ok := rawArgs["orgType"]; ok {
		return ec.unmarshalNOrgBillingStatus2linksᚋapiᚋgraphᚋmodelᚐOrgBillingStatus(ctx, tmp)
	}

	var zeroVal model.OrgBillingStatus
	return zeroVal, nil
}

func (ec *executionContext) field_Mutation_updateAdminUser_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 *model.UpdateUserInput
	if tmp, ok := rawArgs["input"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
		arg0, err = ec.unmarshalOUpdateUserInput2ᚖlinksᚋapiᚋgraphᚋmodelᚐUpdateUserInput(ctx, tmp)
		if err != nil {
			return nil, err
		}
	arg0, err := ec.field_Mutation_updateAdminUser_argsInput(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}
func (ec *executionContext) field_Mutation_updateAdminUser_argsInput(
	ctx context.Context,
	rawArgs map[string]interface{},
) (*model.UpdateUserInput, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["input"]
	if !ok {
		var zeroVal *model.UpdateUserInput
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
	if tmp, ok := rawArgs["input"]; ok {
		return ec.unmarshalOUpdateUserInput2ᚖlinksᚋapiᚋgraphᚋmodelᚐUpdateUserInput(ctx, tmp)
	}

	var zeroVal *model.UpdateUserInput
	return zeroVal, nil
}

func (ec *executionContext) field_Mutation_updateLinkShort_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 *model.UpdateLinkShortInput
	if tmp, ok := rawArgs["input"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
		arg0, err = ec.unmarshalOUpdateLinkShortInput2ᚖlinksᚋapiᚋgraphᚋmodelᚐUpdateLinkShortInput(ctx, tmp)
		if err != nil {
			return nil, err
		}
	arg0, err := ec.field_Mutation_updateLinkShort_argsInput(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}
func (ec *executionContext) field_Mutation_updateLinkShort_argsInput(
	ctx context.Context,
	rawArgs map[string]interface{},
) (*model.UpdateLinkShortInput, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["input"]
	if !ok {
		var zeroVal *model.UpdateLinkShortInput
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
	if tmp, ok := rawArgs["input"]; ok {
		return ec.unmarshalOUpdateLinkShortInput2ᚖlinksᚋapiᚋgraphᚋmodelᚐUpdateLinkShortInput(ctx, tmp)
	}

	var zeroVal *model.UpdateLinkShortInput
	return zeroVal, nil
}

func (ec *executionContext) field_Mutation_updateLink_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 *model.UpdateLinkInput
	if tmp, ok := rawArgs["input"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
		arg0, err = ec.unmarshalOUpdateLinkInput2ᚖlinksᚋapiᚋgraphᚋmodelᚐUpdateLinkInput(ctx, tmp)
		if err != nil {
			return nil, err
		}
	arg0, err := ec.field_Mutation_updateLink_argsInput(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}
func (ec *executionContext) field_Mutation_updateLink_argsInput(
	ctx context.Context,
	rawArgs map[string]interface{},
) (*model.UpdateLinkInput, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["input"]
	if !ok {
		var zeroVal *model.UpdateLinkInput
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
	if tmp, ok := rawArgs["input"]; ok {
		return ec.unmarshalOUpdateLinkInput2ᚖlinksᚋapiᚋgraphᚋmodelᚐUpdateLinkInput(ctx, tmp)
	}

	var zeroVal *model.UpdateLinkInput
	return zeroVal, nil
}

func (ec *executionContext) field_Mutation_updateListingLink_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 *model.UpdateListingLinkInput
	if tmp, ok := rawArgs["input"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
		arg0, err = ec.unmarshalOUpdateListingLinkInput2ᚖlinksᚋapiᚋgraphᚋmodelᚐUpdateListingLinkInput(ctx, tmp)
		if err != nil {
			return nil, err
		}
	arg0, err := ec.field_Mutation_updateListingLink_argsInput(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}
func (ec *executionContext) field_Mutation_updateListingLink_argsInput(
	ctx context.Context,
	rawArgs map[string]interface{},
) (*model.UpdateListingLinkInput, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["input"]
	if !ok {
		var zeroVal *model.UpdateListingLinkInput
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
	if tmp, ok := rawArgs["input"]; ok {
		return ec.unmarshalOUpdateListingLinkInput2ᚖlinksᚋapiᚋgraphᚋmodelᚐUpdateListingLinkInput(ctx, tmp)
	}

	var zeroVal *model.UpdateListingLinkInput
	return zeroVal, nil
}

func (ec *executionContext) field_Mutation_updateListing_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 *model.UpdateListingInput
	if tmp, ok := rawArgs["input"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
		arg0, err = ec.unmarshalOUpdateListingInput2ᚖlinksᚋapiᚋgraphᚋmodelᚐUpdateListingInput(ctx, tmp)
		if err != nil {
			return nil, err
		}
	arg0, err := ec.field_Mutation_updateListing_argsInput(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}
func (ec *executionContext) field_Mutation_updateListing_argsInput(
	ctx context.Context,
	rawArgs map[string]interface{},
) (*model.UpdateListingInput, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["input"]
	if !ok {
		var zeroVal *model.UpdateListingInput
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
	if tmp, ok := rawArgs["input"]; ok {
		return ec.unmarshalOUpdateListingInput2ᚖlinksᚋapiᚋgraphᚋmodelᚐUpdateListingInput(ctx, tmp)
	}

	var zeroVal *model.UpdateListingInput
	return zeroVal, nil
}

func (ec *executionContext) field_Mutation_updateOrganization_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 *model.UpdateOrganizationInput
	if tmp, ok := rawArgs["input"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
		arg0, err = ec.unmarshalOUpdateOrganizationInput2ᚖlinksᚋapiᚋgraphᚋmodelᚐUpdateOrganizationInput(ctx, tmp)
		if err != nil {
			return nil, err
		}
	arg0, err := ec.field_Mutation_updateOrganization_argsInput(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}
func (ec *executionContext) field_Mutation_updateOrganization_argsInput(
	ctx context.Context,
	rawArgs map[string]interface{},
) (*model.UpdateOrganizationInput, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["input"]
	if !ok {
		var zeroVal *model.UpdateOrganizationInput
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
	if tmp, ok := rawArgs["input"]; ok {
		return ec.unmarshalOUpdateOrganizationInput2ᚖlinksᚋapiᚋgraphᚋmodelᚐUpdateOrganizationInput(ctx, tmp)
	}

	var zeroVal *model.UpdateOrganizationInput
	return zeroVal, nil
}

func (ec *executionContext) field_Mutation_updateProfile_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 *model.ProfileInput
	if tmp, ok := rawArgs["input"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
		arg0, err = ec.unmarshalOProfileInput2ᚖlinksᚋapiᚋgraphᚋmodelᚐProfileInput(ctx, tmp)
		if err != nil {
			return nil, err
		}
	arg0, err := ec.field_Mutation_updateProfile_argsInput(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}
func (ec *executionContext) field_Mutation_updateProfile_argsInput(
	ctx context.Context,
	rawArgs map[string]interface{},
) (*model.ProfileInput, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["input"]
	if !ok {
		var zeroVal *model.ProfileInput
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
	if tmp, ok := rawArgs["input"]; ok {
		return ec.unmarshalOProfileInput2ᚖlinksᚋapiᚋgraphᚋmodelᚐProfileInput(ctx, tmp)
	}

	var zeroVal *model.ProfileInput
	return zeroVal, nil
}

func (ec *executionContext) field_Query___type_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 string
	if tmp, ok := rawArgs["name"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name"))
		arg0, err = ec.unmarshalNString2string(ctx, tmp)
		if err != nil {
			return nil, err
		}
	arg0, err := ec.field_Query___type_argsName(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["name"] = arg0
	return args, nil
}
func (ec *executionContext) field_Query___type_argsName(
	ctx context.Context,
	rawArgs map[string]interface{},
) (string, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["name"]
	if !ok {
		var zeroVal string
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("name"))
	if tmp, ok := rawArgs["name"]; ok {
		return ec.unmarshalNString2string(ctx, tmp)
	}

	var zeroVal string
	return zeroVal, nil
}

func (ec *executionContext) field_Query_analytics_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 model.AnalyticsInput
	if tmp, ok := rawArgs["input"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
		arg0, err = ec.unmarshalNAnalyticsInput2linksᚋapiᚋgraphᚋmodelᚐAnalyticsInput(ctx, tmp)
		if err != nil {
			return nil, err
		}
	arg0, err := ec.field_Query_analytics_argsInput(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}
func (ec *executionContext) field_Query_analytics_argsInput(
	ctx context.Context,
	rawArgs map[string]interface{},
) (model.AnalyticsInput, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["input"]
	if !ok {
		var zeroVal model.AnalyticsInput
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
	if tmp, ok := rawArgs["input"]; ok {
		return ec.unmarshalNAnalyticsInput2linksᚋapiᚋgraphᚋmodelᚐAnalyticsInput(ctx, tmp)
	}

	var zeroVal model.AnalyticsInput
	return zeroVal, nil
}

func (ec *executionContext) field_Query_getAdminBillingStats_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 *model.AdminBillingInput
	if tmp, ok := rawArgs["input"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
		arg0, err = ec.unmarshalOAdminBillingInput2ᚖlinksᚋapiᚋgraphᚋmodelᚐAdminBillingInput(ctx, tmp)
		if err != nil {
			return nil, err
		}
	arg0, err := ec.field_Query_getAdminBillingStats_argsInput(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}
func (ec *executionContext) field_Query_getAdminBillingStats_argsInput(
	ctx context.Context,
	rawArgs map[string]interface{},
) (*model.AdminBillingInput, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["input"]
	if !ok {
		var zeroVal *model.AdminBillingInput
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
	if tmp, ok := rawArgs["input"]; ok {
		return ec.unmarshalOAdminBillingInput2ᚖlinksᚋapiᚋgraphᚋmodelᚐAdminBillingInput(ctx, tmp)
	}

	var zeroVal *model.AdminBillingInput
	return zeroVal, nil
}

func (ec *executionContext) field_Query_getAdminDomains_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 *model.GetAdminDomainInput
	if tmp, ok := rawArgs["input"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
		arg0, err = ec.unmarshalOGetAdminDomainInput2ᚖlinksᚋapiᚋgraphᚋmodelᚐGetAdminDomainInput(ctx, tmp)
		if err != nil {
			return nil, err
		}
	arg0, err := ec.field_Query_getAdminDomains_argsInput(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}
func (ec *executionContext) field_Query_getAdminDomains_argsInput(
	ctx context.Context,
	rawArgs map[string]interface{},
) (*model.GetAdminDomainInput, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["input"]
	if !ok {
		var zeroVal *model.GetAdminDomainInput
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
	if tmp, ok := rawArgs["input"]; ok {
		return ec.unmarshalOGetAdminDomainInput2ᚖlinksᚋapiᚋgraphᚋmodelᚐGetAdminDomainInput(ctx, tmp)
	}

	var zeroVal *model.GetAdminDomainInput
	return zeroVal, nil
}

func (ec *executionContext) field_Query_getAdminOrgStats_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 int
	if tmp, ok := rawArgs["id"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
		arg0, err = ec.unmarshalNInt2int(ctx, tmp)
		if err != nil {
			return nil, err
		}
	arg0, err := ec.field_Query_getAdminOrgStats_argsID(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["id"] = arg0
	return args, nil
}
func (ec *executionContext) field_Query_getAdminOrgStats_argsID(
	ctx context.Context,
	rawArgs map[string]interface{},
) (int, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["id"]
	if !ok {
		var zeroVal int
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
	if tmp, ok := rawArgs["id"]; ok {
		return ec.unmarshalNInt2int(ctx, tmp)
	}

	var zeroVal int
	return zeroVal, nil
}

func (ec *executionContext) field_Query_getAdminOrganizations_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 *model.GetAdminOrganizationsInput
	if tmp, ok := rawArgs["input"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
		arg0, err = ec.unmarshalOGetAdminOrganizationsInput2ᚖlinksᚋapiᚋgraphᚋmodelᚐGetAdminOrganizationsInput(ctx, tmp)
		if err != nil {
			return nil, err
		}
	arg0, err := ec.field_Query_getAdminOrganizations_argsInput(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}
func (ec *executionContext) field_Query_getAdminOrganizations_argsInput(
	ctx context.Context,
	rawArgs map[string]interface{},
) (*model.GetAdminOrganizationsInput, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["input"]
	if !ok {
		var zeroVal *model.GetAdminOrganizationsInput
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
	if tmp, ok := rawArgs["input"]; ok {
		return ec.unmarshalOGetAdminOrganizationsInput2ᚖlinksᚋapiᚋgraphᚋmodelᚐGetAdminOrganizationsInput(ctx, tmp)
	}

	var zeroVal *model.GetAdminOrganizationsInput
	return zeroVal, nil
}

func (ec *executionContext) field_Query_getDomain_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 int
	if tmp, ok := rawArgs["id"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
		arg0, err = ec.unmarshalNInt2int(ctx, tmp)
		if err != nil {
			return nil, err
		}
	arg0, err := ec.field_Query_getDomain_argsID(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["id"] = arg0
	return args, nil
}
func (ec *executionContext) field_Query_getDomain_argsID(
	ctx context.Context,
	rawArgs map[string]interface{},
) (int, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["id"]
	if !ok {
		var zeroVal int
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
	if tmp, ok := rawArgs["id"]; ok {
		return ec.unmarshalNInt2int(ctx, tmp)
	}

	var zeroVal int
	return zeroVal, nil
}

func (ec *executionContext) field_Query_getDomains_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 *string
	if tmp, ok := rawArgs["orgSlug"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("orgSlug"))
		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
		if err != nil {
			return nil, err
		}
	arg0, err := ec.field_Query_getDomains_argsOrgSlug(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["orgSlug"] = arg0
	var arg1 *model.DomainService
	if tmp, ok := rawArgs["service"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("service"))
		arg1, err = ec.unmarshalODomainService2ᚖlinksᚋapiᚋgraphᚋmodelᚐDomainService(ctx, tmp)
		if err != nil {
			return nil, err
		}
	arg1, err := ec.field_Query_getDomains_argsService(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["service"] = arg1
	return args, nil
}
func (ec *executionContext) field_Query_getDomains_argsOrgSlug(
	ctx context.Context,
	rawArgs map[string]interface{},
) (*string, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["orgSlug"]
	if !ok {
		var zeroVal *string
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("orgSlug"))
	if tmp, ok := rawArgs["orgSlug"]; ok {
		return ec.unmarshalOString2ᚖstring(ctx, tmp)
	}

	var zeroVal *string
	return zeroVal, nil
}

func (ec *executionContext) field_Query_getDomains_argsService(
	ctx context.Context,
	rawArgs map[string]interface{},
) (*model.DomainService, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["service"]
	if !ok {
		var zeroVal *model.DomainService
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("service"))
	if tmp, ok := rawArgs["service"]; ok {
		return ec.unmarshalODomainService2ᚖlinksᚋapiᚋgraphᚋmodelᚐDomainService(ctx, tmp)
	}

	var zeroVal *model.DomainService
	return zeroVal, nil
}

func (ec *executionContext) field_Query_getFeed_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 *model.GetFeedInput
	if tmp, ok := rawArgs["input"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
		arg0, err = ec.unmarshalOGetFeedInput2ᚖlinksᚋapiᚋgraphᚋmodelᚐGetFeedInput(ctx, tmp)
		if err != nil {
			return nil, err
		}
	arg0, err := ec.field_Query_getFeed_argsInput(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}
func (ec *executionContext) field_Query_getFeed_argsInput(
	ctx context.Context,
	rawArgs map[string]interface{},
) (*model.GetFeedInput, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["input"]
	if !ok {
		var zeroVal *model.GetFeedInput
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
	if tmp, ok := rawArgs["input"]; ok {
		return ec.unmarshalOGetFeedInput2ᚖlinksᚋapiᚋgraphᚋmodelᚐGetFeedInput(ctx, tmp)
	}

	var zeroVal *model.GetFeedInput
	return zeroVal, nil
}

func (ec *executionContext) field_Query_getLinkShort_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 string
	if tmp, ok := rawArgs["shortCode"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("shortCode"))
		arg0, err = ec.unmarshalNString2string(ctx, tmp)
		if err != nil {
			return nil, err
		}
	arg0, err := ec.field_Query_getLinkShort_argsShortCode(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["shortCode"] = arg0
	var arg1 *int
	if tmp, ok := rawArgs["domainId"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("domainId"))
		arg1, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
		if err != nil {
			return nil, err
		}
	arg1, err := ec.field_Query_getLinkShort_argsDomainID(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["domainId"] = arg1
	return args, nil
}
func (ec *executionContext) field_Query_getLinkShort_argsShortCode(
	ctx context.Context,
	rawArgs map[string]interface{},
) (string, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["shortCode"]
	if !ok {
		var zeroVal string
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("shortCode"))
	if tmp, ok := rawArgs["shortCode"]; ok {
		return ec.unmarshalNString2string(ctx, tmp)
	}

	var zeroVal string
	return zeroVal, nil
}

func (ec *executionContext) field_Query_getLinkShort_argsDomainID(
	ctx context.Context,
	rawArgs map[string]interface{},
) (*int, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["domainId"]
	if !ok {
		var zeroVal *int
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("domainId"))
	if tmp, ok := rawArgs["domainId"]; ok {
		return ec.unmarshalOInt2ᚖint(ctx, tmp)
	}

	var zeroVal *int
	return zeroVal, nil
}

func (ec *executionContext) field_Query_getLinkShorts_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 *model.GetLinkShortInput
	if tmp, ok := rawArgs["input"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
		arg0, err = ec.unmarshalOGetLinkShortInput2ᚖlinksᚋapiᚋgraphᚋmodelᚐGetLinkShortInput(ctx, tmp)
		if err != nil {
			return nil, err
		}
	arg0, err := ec.field_Query_getLinkShorts_argsInput(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}
func (ec *executionContext) field_Query_getLinkShorts_argsInput(
	ctx context.Context,
	rawArgs map[string]interface{},
) (*model.GetLinkShortInput, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["input"]
	if !ok {
		var zeroVal *model.GetLinkShortInput
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
	if tmp, ok := rawArgs["input"]; ok {
		return ec.unmarshalOGetLinkShortInput2ᚖlinksᚋapiᚋgraphᚋmodelᚐGetLinkShortInput(ctx, tmp)
	}

	var zeroVal *model.GetLinkShortInput
	return zeroVal, nil
}

func (ec *executionContext) field_Query_getListingLink_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 string
	if tmp, ok := rawArgs["slug"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("slug"))
		arg0, err = ec.unmarshalNString2string(ctx, tmp)
		if err != nil {
			return nil, err
		}
	arg0, err := ec.field_Query_getListingLink_argsSlug(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["slug"] = arg0
	var arg1 int
	if tmp, ok := rawArgs["id"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
		arg1, err = ec.unmarshalNInt2int(ctx, tmp)
		if err != nil {
			return nil, err
		}
	arg1, err := ec.field_Query_getListingLink_argsID(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["id"] = arg1
	var arg2 int
	if tmp, ok := rawArgs["domainId"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("domainId"))
		arg2, err = ec.unmarshalNInt2int(ctx, tmp)
		if err != nil {
			return nil, err
		}
	arg2, err := ec.field_Query_getListingLink_argsDomainID(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["domainId"] = arg2
	return args, nil
}
func (ec *executionContext) field_Query_getListingLink_argsSlug(
	ctx context.Context,
	rawArgs map[string]interface{},
) (string, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["slug"]
	if !ok {
		var zeroVal string
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("slug"))
	if tmp, ok := rawArgs["slug"]; ok {
		return ec.unmarshalNString2string(ctx, tmp)
	}

	var zeroVal string
	return zeroVal, nil
}

func (ec *executionContext) field_Query_getListingLink_argsID(
	ctx context.Context,
	rawArgs map[string]interface{},
) (int, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["id"]
	if !ok {
		var zeroVal int
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
	if tmp, ok := rawArgs["id"]; ok {
		return ec.unmarshalNInt2int(ctx, tmp)
	}

	var zeroVal int
	return zeroVal, nil
}

func (ec *executionContext) field_Query_getListingLink_argsDomainID(
	ctx context.Context,
	rawArgs map[string]interface{},
) (int, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["domainId"]
	if !ok {
		var zeroVal int
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("domainId"))
	if tmp, ok := rawArgs["domainId"]; ok {
		return ec.unmarshalNInt2int(ctx, tmp)
	}

	var zeroVal int
	return zeroVal, nil
}

func (ec *executionContext) field_Query_getListing_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 *model.GetListingDetailInput
	if tmp, ok := rawArgs["input"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
		arg0, err = ec.unmarshalOGetListingDetailInput2ᚖlinksᚋapiᚋgraphᚋmodelᚐGetListingDetailInput(ctx, tmp)
		if err != nil {
			return nil, err
		}
	arg0, err := ec.field_Query_getListing_argsInput(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}
func (ec *executionContext) field_Query_getListing_argsInput(
	ctx context.Context,
	rawArgs map[string]interface{},
) (*model.GetListingDetailInput, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["input"]
	if !ok {
		var zeroVal *model.GetListingDetailInput
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
	if tmp, ok := rawArgs["input"]; ok {
		return ec.unmarshalOGetListingDetailInput2ᚖlinksᚋapiᚋgraphᚋmodelᚐGetListingDetailInput(ctx, tmp)
	}

	var zeroVal *model.GetListingDetailInput
	return zeroVal, nil
}

func (ec *executionContext) field_Query_getListings_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 *model.GetListingInput
	if tmp, ok := rawArgs["input"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
		arg0, err = ec.unmarshalOGetListingInput2ᚖlinksᚋapiᚋgraphᚋmodelᚐGetListingInput(ctx, tmp)
		if err != nil {
			return nil, err
		}
	arg0, err := ec.field_Query_getListings_argsInput(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}
func (ec *executionContext) field_Query_getListings_argsInput(
	ctx context.Context,
	rawArgs map[string]interface{},
) (*model.GetListingInput, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["input"]
	if !ok {
		var zeroVal *model.GetListingInput
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
	if tmp, ok := rawArgs["input"]; ok {
		return ec.unmarshalOGetListingInput2ᚖlinksᚋapiᚋgraphᚋmodelᚐGetListingInput(ctx, tmp)
	}

	var zeroVal *model.GetListingInput
	return zeroVal, nil
}

func (ec *executionContext) field_Query_getOrgLink_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 string
	if tmp, ok := rawArgs["hash"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hash"))
		arg0, err = ec.unmarshalNString2string(ctx, tmp)
		if err != nil {
			return nil, err
		}
	arg0, err := ec.field_Query_getOrgLink_argsHash(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["hash"] = arg0
	return args, nil
}
func (ec *executionContext) field_Query_getOrgLink_argsHash(
	ctx context.Context,
	rawArgs map[string]interface{},
) (string, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["hash"]
	if !ok {
		var zeroVal string
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("hash"))
	if tmp, ok := rawArgs["hash"]; ok {
		return ec.unmarshalNString2string(ctx, tmp)
	}

	var zeroVal string
	return zeroVal, nil
}

func (ec *executionContext) field_Query_getOrgLinks_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 *model.GetLinkInput
	if tmp, ok := rawArgs["input"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
		arg0, err = ec.unmarshalOGetLinkInput2ᚖlinksᚋapiᚋgraphᚋmodelᚐGetLinkInput(ctx, tmp)
		if err != nil {
			return nil, err
		}
	arg0, err := ec.field_Query_getOrgLinks_argsInput(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}
func (ec *executionContext) field_Query_getOrgLinks_argsInput(
	ctx context.Context,
	rawArgs map[string]interface{},
) (*model.GetLinkInput, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["input"]
	if !ok {
		var zeroVal *model.GetLinkInput
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
	if tmp, ok := rawArgs["input"]; ok {
		return ec.unmarshalOGetLinkInput2ᚖlinksᚋapiᚋgraphᚋmodelᚐGetLinkInput(ctx, tmp)
	}

	var zeroVal *model.GetLinkInput
	return zeroVal, nil
}

func (ec *executionContext) field_Query_getOrgMembers_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 string
	if tmp, ok := rawArgs["orgSlug"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("orgSlug"))
		arg0, err = ec.unmarshalNString2string(ctx, tmp)
		if err != nil {
			return nil, err
		}
	arg0, err := ec.field_Query_getOrgMembers_argsOrgSlug(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["orgSlug"] = arg0
	return args, nil
}
func (ec *executionContext) field_Query_getOrgMembers_argsOrgSlug(
	ctx context.Context,
	rawArgs map[string]interface{},
) (string, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["orgSlug"]
	if !ok {
		var zeroVal string
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("orgSlug"))
	if tmp, ok := rawArgs["orgSlug"]; ok {
		return ec.unmarshalNString2string(ctx, tmp)
	}

	var zeroVal string
	return zeroVal, nil
}

func (ec *executionContext) field_Query_getOrganization_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 string
	if tmp, ok := rawArgs["slug"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("slug"))
		arg0, err = ec.unmarshalNString2string(ctx, tmp)
		if err != nil {
			return nil, err
		}
	arg0, err := ec.field_Query_getOrganization_argsSlug(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["slug"] = arg0
	return args, nil
}
func (ec *executionContext) field_Query_getOrganization_argsSlug(
	ctx context.Context,
	rawArgs map[string]interface{},
) (string, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["slug"]
	if !ok {
		var zeroVal string
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("slug"))
	if tmp, ok := rawArgs["slug"]; ok {
		return ec.unmarshalNString2string(ctx, tmp)
	}

	var zeroVal string
	return zeroVal, nil
}

func (ec *executionContext) field_Query_getOrganizations_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 *model.GetOrganizationsInput
	if tmp, ok := rawArgs["input"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
		arg0, err = ec.unmarshalOGetOrganizationsInput2ᚖlinksᚋapiᚋgraphᚋmodelᚐGetOrganizationsInput(ctx, tmp)
		if err != nil {
			return nil, err
		}
	arg0, err := ec.field_Query_getOrganizations_argsInput(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}
func (ec *executionContext) field_Query_getOrganizations_argsInput(
	ctx context.Context,
	rawArgs map[string]interface{},
) (*model.GetOrganizationsInput, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["input"]
	if !ok {
		var zeroVal *model.GetOrganizationsInput
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
	if tmp, ok := rawArgs["input"]; ok {
		return ec.unmarshalOGetOrganizationsInput2ᚖlinksᚋapiᚋgraphᚋmodelᚐGetOrganizationsInput(ctx, tmp)
	}

	var zeroVal *model.GetOrganizationsInput
	return zeroVal, nil
}

func (ec *executionContext) field_Query_getPaymentHistory_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 *model.GetPaymentInput
	if tmp, ok := rawArgs["input"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
		arg0, err = ec.unmarshalOGetPaymentInput2ᚖlinksᚋapiᚋgraphᚋmodelᚐGetPaymentInput(ctx, tmp)
		if err != nil {
			return nil, err
		}
	arg0, err := ec.field_Query_getPaymentHistory_argsInput(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}
func (ec *executionContext) field_Query_getPaymentHistory_argsInput(
	ctx context.Context,
	rawArgs map[string]interface{},
) (*model.GetPaymentInput, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["input"]
	if !ok {
		var zeroVal *model.GetPaymentInput
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
	if tmp, ok := rawArgs["input"]; ok {
		return ec.unmarshalOGetPaymentInput2ᚖlinksᚋapiᚋgraphᚋmodelᚐGetPaymentInput(ctx, tmp)
	}

	var zeroVal *model.GetPaymentInput
	return zeroVal, nil
}

func (ec *executionContext) field_Query_getPopularLinks_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 *model.PopularLinksInput
	if tmp, ok := rawArgs["input"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
		arg0, err = ec.unmarshalOPopularLinksInput2ᚖlinksᚋapiᚋgraphᚋmodelᚐPopularLinksInput(ctx, tmp)
		if err != nil {
			return nil, err
		}
	arg0, err := ec.field_Query_getPopularLinks_argsInput(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}
func (ec *executionContext) field_Query_getPopularLinks_argsInput(
	ctx context.Context,
	rawArgs map[string]interface{},
) (*model.PopularLinksInput, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["input"]
	if !ok {
		var zeroVal *model.PopularLinksInput
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
	if tmp, ok := rawArgs["input"]; ok {
		return ec.unmarshalOPopularLinksInput2ᚖlinksᚋapiᚋgraphᚋmodelᚐPopularLinksInput(ctx, tmp)
	}

	var zeroVal *model.PopularLinksInput
	return zeroVal, nil
}

func (ec *executionContext) field_Query_getQRDetail_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 string
	if tmp, ok := rawArgs["hashId"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hashId"))
		arg0, err = ec.unmarshalNString2string(ctx, tmp)
		if err != nil {
			return nil, err
		}
	arg0, err := ec.field_Query_getQRDetail_argsHashID(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["hashId"] = arg0
	var arg1 *string
	arg1, err := ec.field_Query_getQRDetail_argsOrgSlug(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["orgSlug"] = arg1
	return args, nil
}
func (ec *executionContext) field_Query_getQRDetail_argsHashID(
	ctx context.Context,
	rawArgs map[string]interface{},
) (string, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["hashId"]
	if !ok {
		var zeroVal string
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("hashId"))
	if tmp, ok := rawArgs["hashId"]; ok {
		return ec.unmarshalNString2string(ctx, tmp)
	}

	var zeroVal string
	return zeroVal, nil
}

func (ec *executionContext) field_Query_getQRDetail_argsOrgSlug(
	ctx context.Context,
	rawArgs map[string]interface{},
) (*string, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["orgSlug"]
	if !ok {
		var zeroVal *string
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("orgSlug"))
	if tmp, ok := rawArgs["orgSlug"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("orgSlug"))
		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
		if err != nil {
			return nil, err
		}
		return ec.unmarshalOString2ᚖstring(ctx, tmp)
	}
	args["orgSlug"] = arg1
	return args, nil

	var zeroVal *string
	return zeroVal, nil
}

func (ec *executionContext) field_Query_getQRList_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 string
	if tmp, ok := rawArgs["orgSlug"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("orgSlug"))
		arg0, err = ec.unmarshalNString2string(ctx, tmp)
		if err != nil {
			return nil, err
		}
	arg0, err := ec.field_Query_getQRList_argsOrgSlug(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["orgSlug"] = arg0
	var arg1 int
	if tmp, ok := rawArgs["codeType"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("codeType"))
		arg1, err = ec.unmarshalNInt2int(ctx, tmp)
		if err != nil {
			return nil, err
		}
	arg1, err := ec.field_Query_getQRList_argsCodeType(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["codeType"] = arg1
	var arg2 int
	if tmp, ok := rawArgs["elementId"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("elementId"))
		arg2, err = ec.unmarshalNInt2int(ctx, tmp)
		if err != nil {
			return nil, err
		}
	arg2, err := ec.field_Query_getQRList_argsElementID(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["elementId"] = arg2
	return args, nil
}
func (ec *executionContext) field_Query_getQRList_argsOrgSlug(
	ctx context.Context,
	rawArgs map[string]interface{},
) (string, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["orgSlug"]
	if !ok {
		var zeroVal string
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("orgSlug"))
	if tmp, ok := rawArgs["orgSlug"]; ok {
		return ec.unmarshalNString2string(ctx, tmp)
	}

	var zeroVal string
	return zeroVal, nil
}

func (ec *executionContext) field_Query_getQRList_argsCodeType(
	ctx context.Context,
	rawArgs map[string]interface{},
) (model.QRCodeType, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["codeType"]
	if !ok {
		var zeroVal model.QRCodeType
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("codeType"))
	if tmp, ok := rawArgs["codeType"]; ok {
		return ec.unmarshalNQRCodeType2linksᚋapiᚋgraphᚋmodelᚐQRCodeType(ctx, tmp)
	}

	var zeroVal model.QRCodeType
	return zeroVal, nil
}

func (ec *executionContext) field_Query_getQRList_argsElementID(
	ctx context.Context,
	rawArgs map[string]interface{},
) (int, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["elementId"]
	if !ok {
		var zeroVal int
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("elementId"))
	if tmp, ok := rawArgs["elementId"]; ok {
		return ec.unmarshalNInt2int(ctx, tmp)
	}

	var zeroVal int
	return zeroVal, nil
}

func (ec *executionContext) field_Query_getUser_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 int
	if tmp, ok := rawArgs["id"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
		arg0, err = ec.unmarshalNInt2int(ctx, tmp)
		if err != nil {
			return nil, err
		}
	arg0, err := ec.field_Query_getUser_argsID(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["id"] = arg0
	return args, nil
}
func (ec *executionContext) field_Query_getUser_argsID(
	ctx context.Context,
	rawArgs map[string]interface{},
) (int, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["id"]
	if !ok {
		var zeroVal int
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
	if tmp, ok := rawArgs["id"]; ok {
		return ec.unmarshalNInt2int(ctx, tmp)
	}

	var zeroVal int
	return zeroVal, nil
}

func (ec *executionContext) field_Query_getUsers_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 *model.GetUserInput
	if tmp, ok := rawArgs["input"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
		arg0, err = ec.unmarshalOGetUserInput2ᚖlinksᚋapiᚋgraphᚋmodelᚐGetUserInput(ctx, tmp)
		if err != nil {
			return nil, err
		}
	arg0, err := ec.field_Query_getUsers_argsInput(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}
func (ec *executionContext) field_Query_getUsers_argsInput(
	ctx context.Context,
	rawArgs map[string]interface{},
) (*model.GetUserInput, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["input"]
	if !ok {
		var zeroVal *model.GetUserInput
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
	if tmp, ok := rawArgs["input"]; ok {
		return ec.unmarshalOGetUserInput2ᚖlinksᚋapiᚋgraphᚋmodelᚐGetUserInput(ctx, tmp)
	}

	var zeroVal *model.GetUserInput
	return zeroVal, nil
}

func (ec *executionContext) field___Type_enumValues_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 bool
	if tmp, ok := rawArgs["includeDeprecated"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("includeDeprecated"))
		arg0, err = ec.unmarshalOBoolean2bool(ctx, tmp)
		if err != nil {
			return nil, err
		}
	arg0, err := ec.field___Type_enumValues_argsIncludeDeprecated(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["includeDeprecated"] = arg0
	return args, nil
}
func (ec *executionContext) field___Type_enumValues_argsIncludeDeprecated(
	ctx context.Context,
	rawArgs map[string]interface{},
) (bool, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["includeDeprecated"]
	if !ok {
		var zeroVal bool
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("includeDeprecated"))
	if tmp, ok := rawArgs["includeDeprecated"]; ok {
		return ec.unmarshalOBoolean2bool(ctx, tmp)
	}

	var zeroVal bool
	return zeroVal, nil
}

func (ec *executionContext) field___Type_fields_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 bool
	if tmp, ok := rawArgs["includeDeprecated"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("includeDeprecated"))
		arg0, err = ec.unmarshalOBoolean2bool(ctx, tmp)
		if err != nil {
			return nil, err
		}
	arg0, err := ec.field___Type_fields_argsIncludeDeprecated(ctx, rawArgs)
	if err != nil {
		return nil, err
	}
	args["includeDeprecated"] = arg0
	return args, nil
}
func (ec *executionContext) field___Type_fields_argsIncludeDeprecated(
	ctx context.Context,
	rawArgs map[string]interface{},
) (bool, error) {
	// We won't call the directive if the argument is null.
	// Set call_argument_directives_with_null to true to call directives
	// even if the argument is null.
	_, ok := rawArgs["includeDeprecated"]
	if !ok {
		var zeroVal bool
		return zeroVal, nil
	}

	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("includeDeprecated"))
	if tmp, ok := rawArgs["includeDeprecated"]; ok {
		return ec.unmarshalOBoolean2bool(ctx, tmp)
	}

	var zeroVal bool
	return zeroVal, nil
}

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



@@ 4940,9 6161,11 @@ func (ec *executionContext) _BaseURL_publicReady(ctx context.Context, field grap
			ctx = rctx // use context from middleware stack in children
			return obj.PublicReady, nil
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			if ec.directives.Internal == nil {
				return nil, errors.New("directive internal is not implemented")
				var zeroVal bool
				return zeroVal, errors.New("directive internal is not implemented")
			}
			return ec.directives.Internal(ctx, obj, directive0)
		}


@@ 5499,17 6722,21 @@ func (ec *executionContext) _Domain_orgId(ctx context.Context, field graphql.Col
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.Domain().OrgID(rctx, obj)
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "DOMAINS")
			if err != nil {
				return nil, err
				var zeroVal *model.NullInt
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RO")
			if err != nil {
				return nil, err
				var zeroVal *model.NullInt
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal *model.NullInt
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, obj, directive0, scope, kind)
		}


@@ 5577,17 6804,21 @@ func (ec *executionContext) _Domain_orgSlug(ctx context.Context, field graphql.C
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.Domain().OrgSlug(rctx, obj)
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "DOMAINS")
			if err != nil {
				return nil, err
				var zeroVal *model.NullString
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RO")
			if err != nil {
				return nil, err
				var zeroVal *model.NullString
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal *model.NullString
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, obj, directive0, scope, kind)
		}


@@ 5787,17 7018,21 @@ func (ec *executionContext) _Domain_isActive(ctx context.Context, field graphql.
			ctx = rctx // use context from middleware stack in children
			return obj.IsActive, nil
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "DOMAINS")
			if err != nil {
				return nil, err
				var zeroVal bool
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RO")
			if err != nil {
				return nil, err
				var zeroVal bool
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal bool
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, obj, directive0, scope, kind)
		}


@@ 5859,17 7094,21 @@ func (ec *executionContext) _Domain_createdOn(ctx context.Context, field graphql
			ctx = rctx // use context from middleware stack in children
			return obj.CreatedOn, nil
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "DOMAINS")
			if err != nil {
				return nil, err
				var zeroVal time.Time
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RO")
			if err != nil {
				return nil, err
				var zeroVal time.Time
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal time.Time
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, obj, directive0, scope, kind)
		}


@@ 5931,17 7170,21 @@ func (ec *executionContext) _Domain_updatedOn(ctx context.Context, field graphql
			ctx = rctx // use context from middleware stack in children
			return obj.UpdatedOn, nil
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "DOMAINS")
			if err != nil {
				return nil, err
				var zeroVal time.Time
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RO")
			if err != nil {
				return nil, err
				var zeroVal time.Time
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal time.Time
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, obj, directive0, scope, kind)
		}


@@ 6611,17 7854,21 @@ func (ec *executionContext) _LinkShort_userId(ctx context.Context, field graphql
			ctx = rctx // use context from middleware stack in children
			return obj.UserID, nil
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "SHORTS")
			if err != nil {
				return nil, err
				var zeroVal int
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RO")
			if err != nil {
				return nil, err
				var zeroVal int
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal int
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, obj, directive0, scope, kind)
		}


@@ 6683,17 7930,21 @@ func (ec *executionContext) _LinkShort_domainId(ctx context.Context, field graph
			ctx = rctx // use context from middleware stack in children
			return obj.DomainID, nil
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "SHORTS")
			if err != nil {
				return nil, err
				var zeroVal int
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RO")
			if err != nil {
				return nil, err
				var zeroVal int
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal int
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, obj, directive0, scope, kind)
		}


@@ 6796,17 8047,21 @@ func (ec *executionContext) _LinkShort_lookupName(ctx context.Context, field gra
			ctx = rctx // use context from middleware stack in children
			return obj.LookupName, nil
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "SHORTS")
			if err != nil {
				return nil, err
				var zeroVal string
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RO")
			if err != nil {
				return nil, err
				var zeroVal string
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal string
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, obj, directive0, scope, kind)
		}


@@ 6868,17 8123,21 @@ func (ec *executionContext) _LinkShort_createdOn(ctx context.Context, field grap
			ctx = rctx // use context from middleware stack in children
			return obj.CreatedOn, nil
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "SHORTS")
			if err != nil {
				return nil, err
				var zeroVal time.Time
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RO")
			if err != nil {
				return nil, err
				var zeroVal time.Time
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal time.Time
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, obj, directive0, scope, kind)
		}


@@ 6940,17 8199,21 @@ func (ec *executionContext) _LinkShort_updatedOn(ctx context.Context, field grap
			ctx = rctx // use context from middleware stack in children
			return obj.UpdatedOn, nil
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "SHORTS")
			if err != nil {
				return nil, err
				var zeroVal time.Time
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RO")
			if err != nil {
				return nil, err
				var zeroVal time.Time
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal time.Time
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, obj, directive0, scope, kind)
		}


@@ 7353,17 8616,21 @@ func (ec *executionContext) _Listing_isActive(ctx context.Context, field graphql
			ctx = rctx // use context from middleware stack in children
			return obj.IsActive, nil
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "LISTS")
			if err != nil {
				return nil, err
				var zeroVal bool
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RO")
			if err != nil {
				return nil, err
				var zeroVal bool
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal bool
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, obj, directive0, scope, kind)
		}


@@ 7425,17 8692,21 @@ func (ec *executionContext) _Listing_isDefault(ctx context.Context, field graphq
			ctx = rctx // use context from middleware stack in children
			return obj.IsDefault, nil
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "LISTS")
			if err != nil {
				return nil, err
				var zeroVal bool
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RO")
			if err != nil {
				return nil, err
				var zeroVal bool
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal bool
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, obj, directive0, scope, kind)
		}


@@ 7551,17 8822,21 @@ func (ec *executionContext) _Listing_userId(ctx context.Context, field graphql.C
			ctx = rctx // use context from middleware stack in children
			return obj.UserID, nil
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "LISTS")
			if err != nil {
				return nil, err
				var zeroVal int
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RO")
			if err != nil {
				return nil, err
				var zeroVal int
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal int
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, obj, directive0, scope, kind)
		}


@@ 7623,17 8898,21 @@ func (ec *executionContext) _Listing_orgId(ctx context.Context, field graphql.Co
			ctx = rctx // use context from middleware stack in children
			return obj.OrgID, nil
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "LISTS")
			if err != nil {
				return nil, err
				var zeroVal int
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RO")
			if err != nil {
				return nil, err
				var zeroVal int
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal int
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, obj, directive0, scope, kind)
		}


@@ 7695,17 8974,21 @@ func (ec *executionContext) _Listing_domainId(ctx context.Context, field graphql
			ctx = rctx // use context from middleware stack in children
			return obj.DomainID, nil
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "LISTS")
			if err != nil {
				return nil, err
				var zeroVal int
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RO")
			if err != nil {
				return nil, err
				var zeroVal int
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal int
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, obj, directive0, scope, kind)
		}


@@ 7767,17 9050,21 @@ func (ec *executionContext) _Listing_lookupName(ctx context.Context, field graph
			ctx = rctx // use context from middleware stack in children
			return obj.LookupName, nil
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "LISTS")
			if err != nil {
				return nil, err
				var zeroVal string
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RO")
			if err != nil {
				return nil, err
				var zeroVal string
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal string
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, obj, directive0, scope, kind)
		}


@@ 7839,17 9126,21 @@ func (ec *executionContext) _Listing_createdOn(ctx context.Context, field graphq
			ctx = rctx // use context from middleware stack in children
			return obj.CreatedOn, nil
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "LISTS")
			if err != nil {
				return nil, err
				var zeroVal time.Time
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RO")
			if err != nil {
				return nil, err
				var zeroVal time.Time
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal time.Time
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, obj, directive0, scope, kind)
		}


@@ 7911,17 9202,21 @@ func (ec *executionContext) _Listing_updatedOn(ctx context.Context, field graphq
			ctx = rctx // use context from middleware stack in children
			return obj.UpdatedOn, nil
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "LISTS")
			if err != nil {
				return nil, err
				var zeroVal time.Time
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RO")
			if err != nil {
				return nil, err
				var zeroVal time.Time
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal time.Time
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, obj, directive0, scope, kind)
		}


@@ 8323,17 9618,21 @@ func (ec *executionContext) _ListingLink_userId(ctx context.Context, field graph
			ctx = rctx // use context from middleware stack in children
			return obj.UserID, nil
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "LISTS")
			if err != nil {
				return nil, err
				var zeroVal int
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RO")
			if err != nil {
				return nil, err
				var zeroVal int
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal int
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, obj, directive0, scope, kind)
		}


@@ 8439,17 9738,21 @@ func (ec *executionContext) _ListingLink_clicks(ctx context.Context, field graph
			ctx = rctx // use context from middleware stack in children
			return obj.Clicks, nil
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "LISTS")
			if err != nil {
				return nil, err
				var zeroVal int
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RO")
			if err != nil {
				return nil, err
				var zeroVal int
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal int
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, obj, directive0, scope, kind)
		}


@@ 8511,17 9814,21 @@ func (ec *executionContext) _ListingLink_createdOn(ctx context.Context, field gr
			ctx = rctx // use context from middleware stack in children
			return obj.CreatedOn, nil
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "LISTS")
			if err != nil {
				return nil, err
				var zeroVal time.Time
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RO")
			if err != nil {
				return nil, err
				var zeroVal time.Time
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal time.Time
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, obj, directive0, scope, kind)
		}


@@ 8583,17 9890,21 @@ func (ec *executionContext) _ListingLink_updatedOn(ctx context.Context, field gr
			ctx = rctx // use context from middleware stack in children
			return obj.UpdatedOn, nil
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "LISTS")
			if err != nil {
				return nil, err
				var zeroVal time.Time
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RO")
			if err != nil {
				return nil, err
				var zeroVal time.Time
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal time.Time
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, obj, directive0, scope, kind)
		}


@@ 8900,17 10211,21 @@ func (ec *executionContext) _Mutation_addOrganization(ctx context.Context, field
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.Mutation().AddOrganization(rctx, fc.Args["input"].(model.OrganizationInput))
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "ORGS")
			if err != nil {
				return nil, err
				var zeroVal *models.Organization
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RW")
			if err != nil {
				return nil, err
				var zeroVal *models.Organization
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal *models.Organization
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, nil, directive0, scope, kind)
		}


@@ 9009,17 10324,21 @@ func (ec *executionContext) _Mutation_addLink(ctx context.Context, field graphql
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.Mutation().AddLink(rctx, fc.Args["input"].(*model.LinkInput))
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "LINKS")
			if err != nil {
				return nil, err
				var zeroVal *models.OrgLink
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RW")
			if err != nil {
				return nil, err
				var zeroVal *models.OrgLink
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal *models.OrgLink
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, nil, directive0, scope, kind)
		}


@@ 9132,17 10451,21 @@ func (ec *executionContext) _Mutation_updateLink(ctx context.Context, field grap
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.Mutation().UpdateLink(rctx, fc.Args["input"].(*model.UpdateLinkInput))
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "LINKS")
			if err != nil {
				return nil, err
				var zeroVal *models.OrgLink
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RW")
			if err != nil {
				return nil, err
				var zeroVal *models.OrgLink
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal *models.OrgLink
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, nil, directive0, scope, kind)
		}


@@ 9255,17 10578,21 @@ func (ec *executionContext) _Mutation_deleteLink(ctx context.Context, field grap
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.Mutation().DeleteLink(rctx, fc.Args["hash"].(string))
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "LINKS")
			if err != nil {
				return nil, err
				var zeroVal *model.DeletePayload
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RW")
			if err != nil {
				return nil, err
				var zeroVal *model.DeletePayload
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal *model.DeletePayload
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, nil, directive0, scope, kind)
		}


@@ 9344,17 10671,21 @@ func (ec *executionContext) _Mutation_addNote(ctx context.Context, field graphql
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.Mutation().AddNote(rctx, fc.Args["input"].(*model.NoteInput))
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "LINKS")
			if err != nil {
				return nil, err
				var zeroVal *models.OrgLink
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RW")
			if err != nil {
				return nil, err
				var zeroVal *models.OrgLink
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal *models.OrgLink
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, nil, directive0, scope, kind)
		}


@@ 9467,17 10798,21 @@ func (ec *executionContext) _Mutation_addMember(ctx context.Context, field graph
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.Mutation().AddMember(rctx, fc.Args["input"].(*model.MemberInput))
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "ORGS")
			if err != nil {
				return nil, err
				var zeroVal *model.AddMemberPayload
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RW")
			if err != nil {
				return nil, err
				var zeroVal *model.AddMemberPayload
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal *model.AddMemberPayload
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, nil, directive0, scope, kind)
		}


@@ 9556,17 10891,21 @@ func (ec *executionContext) _Mutation_deleteMember(ctx context.Context, field gr
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.Mutation().DeleteMember(rctx, fc.Args["orgSlug"].(string), fc.Args["email"].(string))
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "ORGS")
			if err != nil {
				return nil, err
				var zeroVal *model.AddMemberPayload
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RW")
			if err != nil {
				return nil, err
				var zeroVal *model.AddMemberPayload
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal *model.AddMemberPayload
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, nil, directive0, scope, kind)
		}


@@ 9645,17 10984,21 @@ func (ec *executionContext) _Mutation_confirmMember(ctx context.Context, field g
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.Mutation().ConfirmMember(rctx, fc.Args["key"].(string))
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "PROFILE")
			if err != nil {
				return nil, err
				var zeroVal *model.AddMemberPayload
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RW")
			if err != nil {
				return nil, err
				var zeroVal *model.AddMemberPayload
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal *model.AddMemberPayload
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, nil, directive0, scope, kind)
		}


@@ 9734,9 11077,11 @@ func (ec *executionContext) _Mutation_register(ctx context.Context, field graphq
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.Mutation().Register(rctx, fc.Args["input"].(*model.RegisterInput))
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			if ec.directives.Internal == nil {
				return nil, errors.New("directive internal is not implemented")
				var zeroVal *models.User
				return zeroVal, errors.New("directive internal is not implemented")
			}
			return ec.directives.Internal(ctx, nil, directive0)
		}


@@ 9825,17 11170,21 @@ func (ec *executionContext) _Mutation_completeRegister(ctx context.Context, fiel
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.Mutation().CompleteRegister(rctx, fc.Args["input"].(*model.CompleteRegisterInput))
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "PROFILE")
			if err != nil {
				return nil, err
				var zeroVal *models.User
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RW")
			if err != nil {
				return nil, err
				var zeroVal *models.User
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal *models.User
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, nil, directive0, scope, kind)
		}


@@ 9924,17 11273,21 @@ func (ec *executionContext) _Mutation_updateProfile(ctx context.Context, field g
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.Mutation().UpdateProfile(rctx, fc.Args["input"].(*model.ProfileInput))
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "PROFILE")
			if err != nil {
				return nil, err
				var zeroVal *models.User
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RW")
			if err != nil {
				return nil, err
				var zeroVal *models.User
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal *models.User
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, nil, directive0, scope, kind)
		}


@@ 10023,17 11376,21 @@ func (ec *executionContext) _Mutation_updateOrganization(ctx context.Context, fi
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.Mutation().UpdateOrganization(rctx, fc.Args["input"].(*model.UpdateOrganizationInput))
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "ORGS")
			if err != nil {
				return nil, err
				var zeroVal *models.Organization
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RW")
			if err != nil {
				return nil, err
				var zeroVal *models.Organization
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal *models.Organization
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, nil, directive0, scope, kind)
		}


@@ 10132,17 11489,21 @@ func (ec *executionContext) _Mutation_addDomain(ctx context.Context, field graph
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.Mutation().AddDomain(rctx, fc.Args["input"].(model.DomainInput))
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "DOMAINS")
			if err != nil {
				return nil, err
				var zeroVal *models.Domain
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RW")
			if err != nil {
				return nil, err
				var zeroVal *models.Domain
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal *models.Domain
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, nil, directive0, scope, kind)
		}


@@ 10239,17 11600,21 @@ func (ec *executionContext) _Mutation_deleteDomain(ctx context.Context, field gr
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.Mutation().DeleteDomain(rctx, fc.Args["id"].(int))
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "DOMAINS")
			if err != nil {
				return nil, err
				var zeroVal *model.DeletePayload
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RW")
			if err != nil {
				return nil, err
				var zeroVal *model.DeletePayload
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal *model.DeletePayload
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, nil, directive0, scope, kind)
		}


@@ 10328,17 11693,21 @@ func (ec *executionContext) _Mutation_addLinkShort(ctx context.Context, field gr
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.Mutation().AddLinkShort(rctx, fc.Args["input"].(*model.LinkShortInput))
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "SHORTS")
			if err != nil {
				return nil, err
				var zeroVal *models.LinkShort
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RW")
			if err != nil {
				return nil, err
				var zeroVal *models.LinkShort
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal *models.LinkShort
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, nil, directive0, scope, kind)
		}


@@ 10435,17 11804,21 @@ func (ec *executionContext) _Mutation_updateLinkShort(ctx context.Context, field
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.Mutation().UpdateLinkShort(rctx, fc.Args["input"].(*model.UpdateLinkShortInput))
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "SHORTS")
			if err != nil {
				return nil, err
				var zeroVal *models.LinkShort
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RW")
			if err != nil {
				return nil, err
				var zeroVal *models.LinkShort
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal *models.LinkShort
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, nil, directive0, scope, kind)
		}


@@ 10542,17 11915,21 @@ func (ec *executionContext) _Mutation_deleteLinkShort(ctx context.Context, field
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.Mutation().DeleteLinkShort(rctx, fc.Args["id"].(int))
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "SHORTS")
			if err != nil {
				return nil, err
				var zeroVal *model.DeletePayload
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RW")
			if err != nil {
				return nil, err
				var zeroVal *model.DeletePayload
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal *model.DeletePayload
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, nil, directive0, scope, kind)
		}


@@ 10631,17 12008,21 @@ func (ec *executionContext) _Mutation_addListing(ctx context.Context, field grap
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.Mutation().AddListing(rctx, fc.Args["input"].(*model.AddListingInput))
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "LISTS")
			if err != nil {
				return nil, err
				var zeroVal *models.Listing
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RW")
			if err != nil {
				return nil, err
				var zeroVal *models.Listing
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal *models.Listing
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, nil, directive0, scope, kind)
		}


@@ 10744,17 12125,21 @@ func (ec *executionContext) _Mutation_addListingLink(ctx context.Context, field 
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.Mutation().AddListingLink(rctx, fc.Args["input"].(*model.AddListingLinkInput))
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "LISTS")
			if err != nil {
				return nil, err
				var zeroVal *models.ListingLink
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RW")
			if err != nil {
				return nil, err
				var zeroVal *models.ListingLink
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal *models.ListingLink
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, nil, directive0, scope, kind)
		}


@@ 10849,17 12234,21 @@ func (ec *executionContext) _Mutation_updateListing(ctx context.Context, field g
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.Mutation().UpdateListing(rctx, fc.Args["input"].(*model.UpdateListingInput))
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "LISTS")
			if err != nil {
				return nil, err
				var zeroVal *models.Listing
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RW")
			if err != nil {
				return nil, err
				var zeroVal *models.Listing
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal *models.Listing
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, nil, directive0, scope, kind)
		}


@@ 10962,17 12351,21 @@ func (ec *executionContext) _Mutation_updateListingLink(ctx context.Context, fie
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.Mutation().UpdateListingLink(rctx, fc.Args["input"].(*model.UpdateListingLinkInput))
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "LISTS")
			if err != nil {
				return nil, err
				var zeroVal *models.ListingLink
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RW")
			if err != nil {
				return nil, err
				var zeroVal *models.ListingLink
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal *models.ListingLink
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, nil, directive0, scope, kind)
		}


@@ 11067,17 12460,21 @@ func (ec *executionContext) _Mutation_deleteListing(ctx context.Context, field g
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.Mutation().DeleteListing(rctx, fc.Args["id"].(int))
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "LISTS")
			if err != nil {
				return nil, err
				var zeroVal *model.DeletePayload
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RW")
			if err != nil {
				return nil, err
				var zeroVal *model.DeletePayload
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal *model.DeletePayload
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, nil, directive0, scope, kind)
		}


@@ 11156,17 12553,21 @@ func (ec *executionContext) _Mutation_deleteListingLink(ctx context.Context, fie
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.Mutation().DeleteListingLink(rctx, fc.Args["id"].(int))
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "LISTS")
			if err != nil {
				return nil, err
				var zeroVal *model.DeletePayload
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RW")
			if err != nil {
				return nil, err
				var zeroVal *model.DeletePayload
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal *model.DeletePayload
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, nil, directive0, scope, kind)
		}


@@ 11245,17 12646,21 @@ func (ec *executionContext) _Mutation_addQRCode(ctx context.Context, field graph
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.Mutation().AddQRCode(rctx, fc.Args["input"].(model.AddQRCodeInput))
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "QRCODES")
			if err != nil {
				return nil, err
				var zeroVal *models.QRCode
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RW")
			if err != nil {
				return nil, err
				var zeroVal *models.QRCode
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal *models.QRCode
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, nil, directive0, scope, kind)
		}


@@ 11348,17 12753,21 @@ func (ec *executionContext) _Mutation_deleteQRCode(ctx context.Context, field gr
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.Mutation().DeleteQRCode(rctx, fc.Args["id"].(int))
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "QRCODES")
			if err != nil {
				return nil, err
				var zeroVal *model.DeletePayload
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RW")
			if err != nil {
				return nil, err
				var zeroVal *model.DeletePayload
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal *model.DeletePayload
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, nil, directive0, scope, kind)
		}


@@ 11437,17 12846,21 @@ func (ec *executionContext) _Mutation_follow(ctx context.Context, field graphql.
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.Mutation().Follow(rctx, fc.Args["orgSlug"].(string))
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "PROFILE")
			if err != nil {
				return nil, err
				var zeroVal *model.FollowPayload
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RW")
			if err != nil {
				return nil, err
				var zeroVal *model.FollowPayload
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal *model.FollowPayload
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, nil, directive0, scope, kind)
		}


@@ 11526,17 12939,21 @@ func (ec *executionContext) _Mutation_unfollow(ctx context.Context, field graphq
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.Mutation().Unfollow(rctx, fc.Args["orgSlug"].(string))
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "PROFILE")
			if err != nil {
				return nil, err
				var zeroVal *model.FollowPayload
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RW")
			if err != nil {
				return nil, err
				var zeroVal *model.FollowPayload
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal *model.FollowPayload
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, nil, directive0, scope, kind)
		}


@@ 11615,9 13032,11 @@ func (ec *executionContext) _Mutation_updateAdminOrgType(ctx context.Context, fi
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.Mutation().UpdateAdminOrgType(rctx, fc.Args["orgSlug"].(string), fc.Args["orgType"].(model.OrgBillingStatus))
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			if ec.directives.Admin == nil {
				return nil, errors.New("directive admin is not implemented")
				var zeroVal *models.Organization
				return zeroVal, errors.New("directive admin is not implemented")
			}
			return ec.directives.Admin(ctx, nil, directive0)
		}


@@ 11716,9 13135,11 @@ func (ec *executionContext) _Mutation_addAdminDomain(ctx context.Context, field 
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.Mutation().AddAdminDomain(rctx, fc.Args["input"].(model.AdminDomainInput))
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			if ec.directives.Admin == nil {
				return nil, errors.New("directive admin is not implemented")
				var zeroVal *models.Domain
				return zeroVal, errors.New("directive admin is not implemented")
			}
			return ec.directives.Admin(ctx, nil, directive0)
		}


@@ 11815,9 13236,11 @@ func (ec *executionContext) _Mutation_updateAdminDomain(ctx context.Context, fie
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.Mutation().UpdateAdminDomain(rctx, fc.Args["input"].(model.UpdateAdminDomainInput))
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			if ec.directives.Admin == nil {
				return nil, errors.New("directive admin is not implemented")
				var zeroVal *models.Domain
				return zeroVal, errors.New("directive admin is not implemented")
			}
			return ec.directives.Admin(ctx, nil, directive0)
		}


@@ 11914,9 13337,11 @@ func (ec *executionContext) _Mutation_updateAdminUser(ctx context.Context, field
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.Mutation().UpdateAdminUser(rctx, fc.Args["input"].(*model.UpdateUserInput))
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			if ec.directives.Admin == nil {
				return nil, errors.New("directive admin is not implemented")
				var zeroVal *models.User
				return zeroVal, errors.New("directive admin is not implemented")
			}
			return ec.directives.Admin(ctx, nil, directive0)
		}


@@ 12005,9 13430,11 @@ func (ec *executionContext) _Mutation_sendRegisterInvitation(ctx context.Context
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.Mutation().SendRegisterInvitation(rctx, fc.Args["toEmail"].(string))
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			if ec.directives.Admin == nil {
				return nil, errors.New("directive admin is not implemented")
				var zeroVal *model.RegisterInvitation
				return zeroVal, errors.New("directive admin is not implemented")
			}
			return ec.directives.Admin(ctx, nil, directive0)
		}


@@ 12480,17 13907,21 @@ func (ec *executionContext) _OrgLink_baseUrlId(ctx context.Context, field graphq
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.OrgLink().BaseURLID(rctx, obj)
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "LINKS")
			if err != nil {
				return nil, err
				var zeroVal *model.NullInt
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RO")
			if err != nil {
				return nil, err
				var zeroVal *model.NullInt
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal *model.NullInt
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, obj, directive0, scope, kind)
		}


@@ 12558,17 13989,21 @@ func (ec *executionContext) _OrgLink_orgId(ctx context.Context, field graphql.Co
			ctx = rctx // use context from middleware stack in children
			return obj.OrgID, nil
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "LINKS")
			if err != nil {
				return nil, err
				var zeroVal int
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RO")
			if err != nil {
				return nil, err
				var zeroVal int
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal int
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, obj, directive0, scope, kind)
		}


@@ 12630,17 14065,21 @@ func (ec *executionContext) _OrgLink_userId(ctx context.Context, field graphql.C
			ctx = rctx // use context from middleware stack in children
			return obj.UserID, nil
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "LINKS")
			if err != nil {
				return nil, err
				var zeroVal int
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RO")
			if err != nil {
				return nil, err
				var zeroVal int
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal int
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, obj, directive0, scope, kind)
		}


@@ 12699,17 14138,21 @@ func (ec *executionContext) _OrgLink_visibility(ctx context.Context, field graph
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.OrgLink().Visibility(rctx, obj)
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "LINKS")
			if err != nil {
				return nil, err
				var zeroVal model.LinkVisibility
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RO")
			if err != nil {
				return nil, err
				var zeroVal model.LinkVisibility
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal model.LinkVisibility
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, obj, directive0, scope, kind)
		}


@@ 12771,17 14214,21 @@ func (ec *executionContext) _OrgLink_unread(ctx context.Context, field graphql.C
			ctx = rctx // use context from middleware stack in children
			return obj.Unread, nil
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "LINKS")
			if err != nil {
				return nil, err
				var zeroVal bool
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RO")
			if err != nil {
				return nil, err
				var zeroVal bool
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal bool
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, obj, directive0, scope, kind)
		}


@@ 12843,17 14290,21 @@ func (ec *executionContext) _OrgLink_starred(ctx context.Context, field graphql.
			ctx = rctx // use context from middleware stack in children
			return obj.Starred, nil
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "LINKS")
			if err != nil {
				return nil, err
				var zeroVal bool
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RO")
			if err != nil {
				return nil, err
				var zeroVal bool
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal bool
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, obj, directive0, scope, kind)
		}


@@ 13101,17 14552,21 @@ func (ec *executionContext) _OrgLink_orgSlug(ctx context.Context, field graphql.
			ctx = rctx // use context from middleware stack in children
			return obj.OrgSlug, nil
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "LINKS")
			if err != nil {
				return nil, err
				var zeroVal string
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RO")
			if err != nil {
				return nil, err
				var zeroVal string
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal string
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, obj, directive0, scope, kind)
		}


@@ 13486,17 14941,21 @@ func (ec *executionContext) _Organization_ownerId(ctx context.Context, field gra
			ctx = rctx // use context from middleware stack in children
			return obj.OwnerID, nil
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "ORGS")
			if err != nil {
				return nil, err
				var zeroVal int
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RO")
			if err != nil {
				return nil, err
				var zeroVal int
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal int
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, obj, directive0, scope, kind)
		}


@@ 13731,17 15190,21 @@ func (ec *executionContext) _Organization_timezone(ctx context.Context, field gr
			ctx = rctx // use context from middleware stack in children
			return obj.Timezone, nil
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "ORGS")
			if err != nil {
				return nil, err
				var zeroVal string
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RO")
			if err != nil {
				return nil, err
				var zeroVal string
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal string
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, obj, directive0, scope, kind)
		}


@@ 13803,17 15266,21 @@ func (ec *executionContext) _Organization_settings(ctx context.Context, field gr
			ctx = rctx // use context from middleware stack in children
			return obj.Settings, nil
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "ORGS")
			if err != nil {
				return nil, err
				var zeroVal models.OrganizationSettings
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RO")
			if err != nil {
				return nil, err
				var zeroVal models.OrganizationSettings
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal models.OrganizationSettings
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, obj, directive0, scope, kind)
		}


@@ 13881,17 15348,21 @@ func (ec *executionContext) _Organization_isActive(ctx context.Context, field gr
			ctx = rctx // use context from middleware stack in children
			return obj.IsActive, nil
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "ORGS")
			if err != nil {
				return nil, err
				var zeroVal bool
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RO")
			if err != nil {
				return nil, err
				var zeroVal bool
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal bool
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, obj, directive0, scope, kind)
		}


@@ 14041,17 15512,21 @@ func (ec *executionContext) _Organization_ownerName(ctx context.Context, field g
			ctx = rctx // use context from middleware stack in children
			return obj.OwnerName, nil
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "ORGS")
			if err != nil {
				return nil, err
				var zeroVal string
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RO")
			if err != nil {
				return nil, err
				var zeroVal string
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal string
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, obj, directive0, scope, kind)
		}


@@ 14849,9 16324,11 @@ func (ec *executionContext) _Payment_amountNet(ctx context.Context, field graphq
			ctx = rctx // use context from middleware stack in children
			return obj.AmountNet, nil
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			if ec.directives.Admin == nil {
				return nil, errors.New("directive admin is not implemented")
				var zeroVal int
				return zeroVal, errors.New("directive admin is not implemented")
			}
			return ec.directives.Admin(ctx, obj, directive0)
		}


@@ 14957,17 16434,21 @@ func (ec *executionContext) _Payment_orgId(ctx context.Context, field graphql.Co
			ctx = rctx // use context from middleware stack in children
			return obj.OrgID, nil
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "BILLING")
			if err != nil {
				return nil, err
				var zeroVal int
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RO")
			if err != nil {
				return nil, err
				var zeroVal int
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal int
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, obj, directive0, scope, kind)
		}


@@ 15029,17 16510,21 @@ func (ec *executionContext) _Payment_orgSlug(ctx context.Context, field graphql.
			ctx = rctx // use context from middleware stack in children
			return obj.OrgSlug, nil
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "BILLING")
			if err != nil {
				return nil, err
				var zeroVal string
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RO")
			if err != nil {
				return nil, err
				var zeroVal string
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal string
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, obj, directive0, scope, kind)
		}


@@ 15345,7 16830,7 @@ func (ec *executionContext) _QRCode_codeType(ctx context.Context, field graphql.
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.CodeType, nil
		return ec.resolvers.QRCode().CodeType(rctx, obj)
	})
	if err != nil {
		ec.Error(ctx, err)


@@ 15357,19 16842,19 @@ func (ec *executionContext) _QRCode_codeType(ctx context.Context, field graphql.
		}
		return graphql.Null
	}
	res := resTmp.(int)
	res := resTmp.(model.QRCodeType)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
	return ec.marshalNQRCodeType2linksᚋapiᚋgraphᚋmodelᚐQRCodeType(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_QRCode_codeType(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "QRCode",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		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 nil, errors.New("field of type QRCodeType does not have child fields")
		},
	}
	return fc, nil


@@ 15480,17 16965,21 @@ func (ec *executionContext) _QRCode_hashId(ctx context.Context, field graphql.Co
			ctx = rctx // use context from middleware stack in children
			return obj.HashID, nil
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "QRCODES")
			if err != nil {
				return nil, err
				var zeroVal string
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RO")
			if err != nil {
				return nil, err
				var zeroVal string
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal string
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, obj, directive0, scope, kind)
		}


@@ 15640,17 17129,21 @@ func (ec *executionContext) _QRObject_qrCodeId(ctx context.Context, field graphq
			ctx = rctx // use context from middleware stack in children
			return obj.QRCodeID, nil
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "QRCODES")
			if err != nil {
				return nil, err
				var zeroVal int
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RO")
			if err != nil {
				return nil, err
				var zeroVal int
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal int
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, obj, directive0, scope, kind)
		}


@@ 15712,17 17205,21 @@ func (ec *executionContext) _QRObject_qrHashId(ctx context.Context, field graphq
			ctx = rctx // use context from middleware stack in children
			return obj.QRHashID, nil
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "QRCODES")
			if err != nil {
				return nil, err
				var zeroVal string
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RO")
			if err != nil {
				return nil, err
				var zeroVal string
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal string
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, obj, directive0, scope, kind)
		}


@@ 15784,17 17281,21 @@ func (ec *executionContext) _QRObject_userId(ctx context.Context, field graphql.
			ctx = rctx // use context from middleware stack in children
			return obj.UserID, nil
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "QRCODES")
			if err != nil {
				return nil, err
				var zeroVal int
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RO")
			if err != nil {
				return nil, err
				var zeroVal int
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal int
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, obj, directive0, scope, kind)
		}


@@ 15998,17 17499,21 @@ func (ec *executionContext) _Query_me(ctx context.Context, field graphql.Collect
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.Query().Me(rctx)
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "PROFILE")
			if err != nil {
				return nil, err
				var zeroVal *models.User
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RO")
			if err != nil {
				return nil, err
				var zeroVal *models.User
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal *models.User
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, nil, directive0, scope, kind)
		}


@@ 16086,17 17591,21 @@ func (ec *executionContext) _Query_getOrganizations(ctx context.Context, field g
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.Query().GetOrganizations(rctx, fc.Args["input"].(*model.GetOrganizationsInput))
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "ORGS")
			if err != nil {
				return nil, err
				var zeroVal []*models.Organization
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RO")
			if err != nil {
				return nil, err
				var zeroVal []*models.Organization
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal []*models.Organization
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, nil, directive0, scope, kind)
		}


@@ 16195,17 17704,21 @@ func (ec *executionContext) _Query_getOrganization(ctx context.Context, field gr
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.Query().GetOrganization(rctx, fc.Args["slug"].(string))
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "ORGS")
			if err != nil {
				return nil, err
				var zeroVal *models.Organization
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RO")
			if err != nil {
				return nil, err
				var zeroVal *models.Organization
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal *models.Organization
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, nil, directive0, scope, kind)
		}


@@ 16301,17 17814,21 @@ func (ec *executionContext) _Query_getPaymentHistory(ctx context.Context, field 
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.Query().GetPaymentHistory(rctx, fc.Args["input"].(*model.GetPaymentInput))
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "BILLING")
			if err != nil {
				return nil, err
				var zeroVal *model.PaymentCursor
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RO")
			if err != nil {
				return nil, err
				var zeroVal *model.PaymentCursor
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal *model.PaymentCursor
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, nil, directive0, scope, kind)
		}


@@ 16390,17 17907,21 @@ func (ec *executionContext) _Query_getPopularLinks(ctx context.Context, field gr
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.Query().GetPopularLinks(rctx, fc.Args["input"].(*model.PopularLinksInput))
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "LINKS")
			if err != nil {
				return nil, err
				var zeroVal []*models.BaseURL
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RO")
			if err != nil {
				return nil, err
				var zeroVal []*models.BaseURL
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal []*models.BaseURL
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, nil, directive0, scope, kind)
		}


@@ 16495,17 18016,21 @@ func (ec *executionContext) _Query_getOrgLink(ctx context.Context, field graphql
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.Query().GetOrgLink(rctx, fc.Args["hash"].(string))
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "LINKS")
			if err != nil {
				return nil, err
				var zeroVal *models.OrgLink
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RO")
			if err != nil {
				return nil, err
				var zeroVal *models.OrgLink
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal *models.OrgLink
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, nil, directive0, scope, kind)
		}


@@ 16615,17 18140,21 @@ func (ec *executionContext) _Query_getOrgLinks(ctx context.Context, field graphq
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.Query().GetOrgLinks(rctx, fc.Args["input"].(*model.GetLinkInput))
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "LINKS")
			if err != nil {
				return nil, err
				var zeroVal *model.OrgLinkCursor
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RO")
			if err != nil {
				return nil, err
				var zeroVal *model.OrgLinkCursor
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal *model.OrgLinkCursor
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, nil, directive0, scope, kind)
		}


@@ 16704,17 18233,21 @@ func (ec *executionContext) _Query_getOrgMembers(ctx context.Context, field grap
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.Query().GetOrgMembers(rctx, fc.Args["orgSlug"].(string))
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "ORGS")
			if err != nil {
				return nil, err
				var zeroVal []*models.User
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RO")
			if err != nil {
				return nil, err
				var zeroVal []*models.User
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal []*models.User
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, nil, directive0, scope, kind)
		}


@@ 16803,17 18336,21 @@ func (ec *executionContext) _Query_getDomains(ctx context.Context, field graphql
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.Query().GetDomains(rctx, fc.Args["orgSlug"].(*string), fc.Args["service"].(*model.DomainService))
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "DOMAINS")
			if err != nil {
				return nil, err
				var zeroVal []*models.Domain
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RO")
			if err != nil {
				return nil, err
				var zeroVal []*models.Domain
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal []*models.Domain
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, nil, directive0, scope, kind)
		}


@@ 16910,17 18447,21 @@ func (ec *executionContext) _Query_getDomain(ctx context.Context, field graphql.
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.Query().GetDomain(rctx, fc.Args["id"].(int))
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "DOMAINS")
			if err != nil {
				return nil, err
				var zeroVal *models.Domain
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RO")
			if err != nil {
				return nil, err
				var zeroVal *models.Domain
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal *models.Domain
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, nil, directive0, scope, kind)
		}


@@ 17017,17 18558,21 @@ func (ec *executionContext) _Query_getLinkShorts(ctx context.Context, field grap
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.Query().GetLinkShorts(rctx, fc.Args["input"].(*model.GetLinkShortInput))
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "SHORTS")
			if err != nil {
				return nil, err
				var zeroVal *model.LinkShortCursor
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RO")
			if err != nil {
				return nil, err
				var zeroVal *model.LinkShortCursor
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal *model.LinkShortCursor
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, nil, directive0, scope, kind)
		}


@@ 17106,17 18651,21 @@ func (ec *executionContext) _Query_getLinkShort(ctx context.Context, field graph
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.Query().GetLinkShort(rctx, fc.Args["shortCode"].(string), fc.Args["domainId"].(*int))
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "SHORTS")
			if err != nil {
				return nil, err
				var zeroVal *models.LinkShort
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RO")
			if err != nil {
				return nil, err
				var zeroVal *models.LinkShort
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal *models.LinkShort
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, nil, directive0, scope, kind)
		}


@@ 17213,17 18762,21 @@ func (ec *executionContext) _Query_getListings(ctx context.Context, field graphq
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.Query().GetListings(rctx, fc.Args["input"].(*model.GetListingInput))
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "LISTS")
			if err != nil {
				return nil, err
				var zeroVal *model.ListingCursor
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RO")
			if err != nil {
				return nil, err
				var zeroVal *model.ListingCursor
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal *model.ListingCursor
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, nil, directive0, scope, kind)
		}


@@ 17302,17 18855,21 @@ func (ec *executionContext) _Query_getListing(ctx context.Context, field graphql
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.Query().GetListing(rctx, fc.Args["input"].(*model.GetListingDetailInput))
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "LISTS")
			if err != nil {
				return nil, err
				var zeroVal *model.ListingLinkCursor
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RO")
			if err != nil {
				return nil, err
				var zeroVal *model.ListingLinkCursor
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal *model.ListingLinkCursor
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, nil, directive0, scope, kind)
		}


@@ 17393,17 18950,21 @@ func (ec *executionContext) _Query_getListingLink(ctx context.Context, field gra
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.Query().GetListingLink(rctx, fc.Args["slug"].(string), fc.Args["id"].(int), fc.Args["domainId"].(int))
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "LISTS")
			if err != nil {
				return nil, err
				var zeroVal *models.ListingLink
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RO")
			if err != nil {
				return nil, err
				var zeroVal *models.ListingLink
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal *models.ListingLink
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, nil, directive0, scope, kind)
		}


@@ 17496,19 19057,23 @@ func (ec *executionContext) _Query_getQRList(ctx context.Context, field graphql.
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		directive0 := func(rctx context.Context) (interface{}, error) {
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.Query().GetQRList(rctx, fc.Args["orgSlug"].(string), fc.Args["codeType"].(int), fc.Args["elementId"].(int))
			return ec.resolvers.Query().GetQRList(rctx, fc.Args["orgSlug"].(string), fc.Args["codeType"].(model.QRCodeType), fc.Args["elementId"].(int))
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "QRCODES")
			if err != nil {
				return nil, err
				var zeroVal []*model.QRObject
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RO")
			if err != nil {
				return nil, err
				var zeroVal []*model.QRObject
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal []*model.QRObject
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, nil, directive0, scope, kind)
		}


@@ 17593,17 19158,21 @@ func (ec *executionContext) _Query_getQRDetail(ctx context.Context, field graphq
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.Query().GetQRDetail(rctx, fc.Args["hashId"].(string), fc.Args["orgSlug"].(*string))
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "QRCODES")
			if err != nil {
				return nil, err
				var zeroVal *models.QRCode
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RO")
			if err != nil {
				return nil, err
				var zeroVal *models.QRCode
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal *models.QRCode
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, nil, directive0, scope, kind)
		}


@@ 17696,17 19265,21 @@ func (ec *executionContext) _Query_analytics(ctx context.Context, field graphql.
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.Query().Analytics(rctx, fc.Args["input"].(model.AnalyticsInput))
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "ANALYTICS")
			if err != nil {
				return nil, err
				var zeroVal *model.Analytics
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RO")
			if err != nil {
				return nil, err
				var zeroVal *model.Analytics
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal *model.Analytics
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, nil, directive0, scope, kind)
		}


@@ 17797,17 19370,21 @@ func (ec *executionContext) _Query_getFeed(ctx context.Context, field graphql.Co
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.Query().GetFeed(rctx, fc.Args["input"].(*model.GetFeedInput))
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "PROFILE")
			if err != nil {
				return nil, err
				var zeroVal *model.OrgLinkCursor
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RO")
			if err != nil {
				return nil, err
				var zeroVal *model.OrgLinkCursor
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal *model.OrgLinkCursor
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, nil, directive0, scope, kind)
		}


@@ 17886,17 19463,21 @@ func (ec *executionContext) _Query_getFeedFollowing(ctx context.Context, field g
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.Query().GetFeedFollowing(rctx)
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "PROFILE")
			if err != nil {
				return nil, err
				var zeroVal []*models.Organization
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RO")
			if err != nil {
				return nil, err
				var zeroVal []*models.Organization
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal []*models.Organization
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, nil, directive0, scope, kind)
		}


@@ 17984,9 19565,11 @@ func (ec *executionContext) _Query_getUsers(ctx context.Context, field graphql.C
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.Query().GetUsers(rctx, fc.Args["input"].(*model.GetUserInput))
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			if ec.directives.Admin == nil {
				return nil, errors.New("directive admin is not implemented")
				var zeroVal *model.UserCursor
				return zeroVal, errors.New("directive admin is not implemented")
			}
			return ec.directives.Admin(ctx, nil, directive0)
		}


@@ 18065,9 19648,11 @@ func (ec *executionContext) _Query_getUser(ctx context.Context, field graphql.Co
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.Query().GetUser(rctx, fc.Args["id"].(int))
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			if ec.directives.Admin == nil {
				return nil, errors.New("directive admin is not implemented")
				var zeroVal *models.User
				return zeroVal, errors.New("directive admin is not implemented")
			}
			return ec.directives.Admin(ctx, nil, directive0)
		}


@@ 18156,9 19741,11 @@ func (ec *executionContext) _Query_getAdminOrganizations(ctx context.Context, fi
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.Query().GetAdminOrganizations(rctx, fc.Args["input"].(*model.GetAdminOrganizationsInput))
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			if ec.directives.Admin == nil {
				return nil, errors.New("directive admin is not implemented")
				var zeroVal *model.OrganizationCursor
				return zeroVal, errors.New("directive admin is not implemented")
			}
			return ec.directives.Admin(ctx, nil, directive0)
		}


@@ 18237,9 19824,11 @@ func (ec *executionContext) _Query_getAdminOrgStats(ctx context.Context, field g
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.Query().GetAdminOrgStats(rctx, fc.Args["id"].(int))
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			if ec.directives.Admin == nil {
				return nil, errors.New("directive admin is not implemented")
				var zeroVal *model.OrganizationStats
				return zeroVal, errors.New("directive admin is not implemented")
			}
			return ec.directives.Admin(ctx, nil, directive0)
		}


@@ 18320,9 19909,11 @@ func (ec *executionContext) _Query_getAdminBillingStats(ctx context.Context, fie
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.Query().GetAdminBillingStats(rctx, fc.Args["input"].(*model.AdminBillingInput))
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			if ec.directives.Admin == nil {
				return nil, errors.New("directive admin is not implemented")
				var zeroVal *model.AdminBillingStats
				return zeroVal, errors.New("directive admin is not implemented")
			}
			return ec.directives.Admin(ctx, nil, directive0)
		}


@@ 18413,9 20004,11 @@ func (ec *executionContext) _Query_getAdminDomains(ctx context.Context, field gr
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.Query().GetAdminDomains(rctx, fc.Args["input"].(*model.GetAdminDomainInput))
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			if ec.directives.Admin == nil {
				return nil, errors.New("directive admin is not implemented")
				var zeroVal *model.DomainCursor
				return zeroVal, errors.New("directive admin is not implemented")
			}
			return ec.directives.Admin(ctx, nil, directive0)
		}


@@ 19180,17 20773,21 @@ func (ec *executionContext) _User_createdOn(ctx context.Context, field graphql.C
			ctx = rctx // use context from middleware stack in children
			return obj.CreatedOn, nil
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "PROFILE")
			if err != nil {
				return nil, err
				var zeroVal time.Time
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RO")
			if err != nil {
				return nil, err
				var zeroVal time.Time
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal time.Time
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, obj, directive0, scope, kind)
		}


@@ 19252,17 20849,21 @@ func (ec *executionContext) _User_isEmailVerified(ctx context.Context, field gra
			ctx = rctx // use context from middleware stack in children
			return obj.IsEmailVerified, nil
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "PROFILE")
			if err != nil {
				return nil, err
				var zeroVal bool
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RO")
			if err != nil {
				return nil, err
				var zeroVal bool
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal bool
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, obj, directive0, scope, kind)
		}


@@ 19324,17 20925,21 @@ func (ec *executionContext) _User_isLocked(ctx context.Context, field graphql.Co
			ctx = rctx // use context from middleware stack in children
			return obj.IsLocked, nil
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "PROFILE")
			if err != nil {
				return nil, err
				var zeroVal bool
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RO")
			if err != nil {
				return nil, err
				var zeroVal bool
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal bool
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, obj, directive0, scope, kind)
		}


@@ 19396,17 21001,21 @@ func (ec *executionContext) _User_lockReason(ctx context.Context, field graphql.
			ctx = rctx // use context from middleware stack in children
			return obj.LockReason, nil
		}

		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2linksᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "PROFILE")
			if err != nil {
				return nil, err
				var zeroVal string
				return zeroVal, err
			}
			kind, err := ec.unmarshalNAccessKind2linksᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RO")
			if err != nil {
				return nil, err
				var zeroVal string
				return zeroVal, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
				var zeroVal string
				return zeroVal, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, obj, directive0, scope, kind)
		}


@@ 21695,7 23304,7 @@ func (ec *executionContext) unmarshalInputAddQRCodeInput(ctx context.Context, ob
			it.OrgSlug = data
		case "codeType":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("codeType"))
			data, err := ec.unmarshalNInt2int(ctx, v)
			data, err := ec.unmarshalNQRCodeType2linksᚋapiᚋgraphᚋmodelᚐQRCodeType(ctx, v)
			if err != nil {
				return it, err
			}


@@ 25984,47 27593,78 @@ func (ec *executionContext) _QRCode(ctx context.Context, sel ast.SelectionSet, o
		case "id":
			out.Values[i] = ec._QRCode_id(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "title":
			out.Values[i] = ec._QRCode_title(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "orgId":
			out.Values[i] = ec._QRCode_orgId(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "codeType":
			out.Values[i] = ec._QRCode_codeType(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			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._QRCode_codeType(ctx, field, obj)
				if res == graphql.Null {
					atomic.AddUint32(&fs.Invalids, 1)
				}
				return res
			}

			if field.Deferrable != nil {
				dfs, ok := deferred[field.Deferrable.Label]
				di := 0
				if ok {
					dfs.AddField(field)
					di = len(dfs.Values) - 1
				} else {
					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
					deferred[field.Deferrable.Label] = dfs
				}
				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
					return innerFunc(ctx, dfs)
				})

				// don't run the out.Concurrently() call below
				out.Values[i] = graphql.Null
				continue
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
		case "url":
			out.Values[i] = ec._QRCode_url(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "imagePath":
			out.Values[i] = ec._QRCode_imagePath(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "hashId":
			out.Values[i] = ec._QRCode_hashId(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "createdOn":
			out.Values[i] = ec._QRCode_createdOn(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "clicks":
			out.Values[i] = ec._QRCode_clicks(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
				atomic.AddUint32(&out.Invalids, 1)
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))


@@ 28287,6 29927,16 @@ func (ec *executionContext) marshalNQRCode2ᚖlinksᚋmodelsᚐQRCode(ctx contex
	return ec._QRCode(ctx, sel, v)
}

func (ec *executionContext) unmarshalNQRCodeType2linksᚋapiᚋgraphᚋmodelᚐQRCodeType(ctx context.Context, v interface{}) (model.QRCodeType, error) {
	var res model.QRCodeType
	err := res.UnmarshalGQL(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNQRCodeType2linksᚋapiᚋgraphᚋmodelᚐQRCodeType(ctx context.Context, sel ast.SelectionSet, v model.QRCodeType) graphql.Marshaler {
	return v
}

func (ec *executionContext) marshalNQRObject2ᚕᚖlinksᚋapiᚋgraphᚋmodelᚐQRObject(ctx context.Context, sel ast.SelectionSet, v []*model.QRObject) graphql.Marshaler {
	ret := make(graphql.Array, len(v))
	var wg sync.WaitGroup


M api/graph/model/models_gen.go => api/graph/model/models_gen.go +42 -1
@@ 43,7 43,7 @@ type AddMemberPayload struct {
type AddQRCodeInput struct {
	Title     string          `json:"title"`
	OrgSlug   string          `json:"orgSlug"`
	CodeType  int             `json:"codeType"`
	CodeType  QRCodeType      `json:"codeType"`
	ElementID int             `json:"elementId"`
	Image     *graphql.Upload `json:"image,omitempty"`
}


@@ 897,3 897,44 @@ func (e *OrgType) UnmarshalGQL(v interface{}) error {
func (e OrgType) MarshalGQL(w io.Writer) {
	fmt.Fprint(w, strconv.Quote(e.String()))
}

type QRCodeType string

const (
	QRCodeTypeList  QRCodeType = "LIST"
	QRCodeTypeShort QRCodeType = "SHORT"
)

var AllQRCodeType = []QRCodeType{
	QRCodeTypeList,
	QRCodeTypeShort,
}

func (e QRCodeType) IsValid() bool {
	switch e {
	case QRCodeTypeList, QRCodeTypeShort:
		return true
	}
	return false
}

func (e QRCodeType) String() string {
	return string(e)
}

func (e *QRCodeType) UnmarshalGQL(v interface{}) error {
	str, ok := v.(string)
	if !ok {
		return fmt.Errorf("enums must be strings")
	}

	*e = QRCodeType(str)
	if !e.IsValid() {
		return fmt.Errorf("%s is not a valid QRCodeType", str)
	}
	return nil
}

func (e QRCodeType) MarshalGQL(w io.Writer) {
	fmt.Fprint(w, strconv.Quote(e.String()))
}


M api/graph/schema.graphqls => api/graph/schema.graphqls +8 -3
@@ 110,6 110,11 @@ enum OrgBillingStatus {
  SPONSORED
}

enum QRCodeType {
  LIST
  SHORT
}


# Considering removing these Null* fields:
# https://todo.code.netlandish.com/~netlandish/links/75


@@ 384,7 389,7 @@ type QRCode {
    id: Int!
    title: String!
    orgId: Int!
    codeType: Int!
    codeType: QRCodeType!
    url: String!
    imagePath: String!
    hashId: String! @access(scope: QRCODES, kind: RO)


@@ 696,7 701,7 @@ input UpdateAdminDomainInput {
input AddQRCodeInput {
    title: String!
    orgSlug: String!
    codeType: Int!
    codeType: QRCodeType!
    elementId: Int!
    image: Upload
}


@@ 766,7 771,7 @@ type Query {
    getListingLink(slug: String!, id: Int!, domainId: Int!): ListingLink! @access(scope: LISTS, kind: RO)

    "Returns an array of QR codes"
    getQRList(orgSlug: String!, codeType: Int!, elementId: Int!): [QRObject]! @access(scope: QRCODES, kind: RO)
    getQRList(orgSlug: String!, codeType: QRCodeType!, elementId: Int!): [QRObject]! @access(scope: QRCODES, kind: RO)

    "Returns a specific QR code"
    getQRDetail(hashId: String!, orgSlug: String): QRCode! @access(scope: QRCODES, kind: RO)


M api/graph/schema.resolvers.go => api/graph/schema.resolvers.go +22 -13
@@ 2,7 2,7 @@ package graph

// This file will be automatically regenerated based on the schema, any resolver implementations
// will be copied through when generating and any unknown code will be moved to the end.
// Code generated by github.com/99designs/gqlgen version v0.17.49
// Code generated by github.com/99designs/gqlgen version v0.17.57

import (
	"bytes"


@@ 1293,10 1293,10 @@ func (r *mutationResolver) Register(ctx context.Context, input *model.RegisterIn
}

// CompleteRegister is the resolver for the completeRegister field.
// This is used when adding a member to an existing organization but the email account
// is not registered. When completing their acceptance they will register an account
// during the process. This method is for that process specifically.
func (r *mutationResolver) CompleteRegister(ctx context.Context, input *model.CompleteRegisterInput) (*models.User, error) {
	// This is used when adding a member to an existing organization but the email account
	// is not registered. When completing their acceptance they will register an account
	// during the process. This method is for that process specifically.
	lang := links.GetLangFromRequest(server.EchoForContext(ctx).Request(), nil)
	lt := localizer.GetLocalizer(lang)
	validator := valid.New(ctx)


@@ 3228,8 3228,8 @@ func (r *mutationResolver) AddQRCode(ctx context.Context, input model.AddQRCodeI
	validator.Expect(input.OrgSlug != "", lt.Translate("Org slug is required.")).
		WithField("orgSlug").
		WithCode(valid.ErrValidationCode)
	validator.Expect(input.CodeType == models.CodeTypeList ||
		input.CodeType == models.CodeTypeShort, lt.Translate("Code is invalid.")).
	validator.Expect(string(input.CodeType) == models.CodeTypeList ||
		string(input.CodeType) == models.CodeTypeShort, lt.Translate("Code is invalid.")).
		WithField("orgSlug").
		WithCode(valid.ErrValidationCode)
	validator.Expect(input.ElementID > 0, lt.Translate("Element ID is invalid.")).


@@ 3267,7 3267,7 @@ func (r *mutationResolver) AddQRCode(ctx context.Context, input model.AddQRCodeI
	var short *models.LinkShort
	var domain string
	var path string
	if input.CodeType == models.CodeTypeList {
	if string(input.CodeType) == models.CodeTypeList {
		opts = &database.FilterOptions{
			Filter: sq.And{
				sq.Eq{"l.id": input.ElementID},


@@ 3301,7 3301,7 @@ func (r *mutationResolver) AddQRCode(ctx context.Context, input model.AddQRCodeI
		}
		domain = listing.LookupName
		path = listing.Slug
	} else if input.CodeType == models.CodeTypeShort {
	} else if string(input.CodeType) == models.CodeTypeShort {
		opts = &database.FilterOptions{
			Filter: sq.Eq{"l.id": input.ElementID},
			Limit:  1,


@@ 3340,7 3340,7 @@ func (r *mutationResolver) AddQRCode(ctx context.Context, input model.AddQRCodeI
	qr := &models.QRCode{
		Title:    input.Title,
		OrgID:    org.ID,
		CodeType: input.CodeType,
		CodeType: string(input.CodeType),
		UserID:   int(user.ID),
		URL:      qrURL.String(),
	}


@@ 4246,6 4246,11 @@ func (r *organizationSettingsResolver) DefaultPerm(ctx context.Context, obj *mod
	return model.LinkVisibility(obj.DefaultPerm), nil
}

// CodeType is the resolver for the codeType field.
func (r *qRCodeResolver) CodeType(ctx context.Context, obj *models.QRCode) (model.QRCodeType, error) {
	return model.QRCodeType(obj.CodeType), nil
}

// Version is the resolver for the version field.
func (r *queryResolver) Version(ctx context.Context) (*model.Version, error) {
	return &model.Version{


@@ 5491,7 5496,7 @@ func (r *queryResolver) GetListingLink(ctx context.Context, slug string, id int,
}

// GetQRList is the resolver for the getQRList field.
func (r *queryResolver) GetQRList(ctx context.Context, orgSlug string, codeType int, elementID int) ([]*model.QRObject, error) {
func (r *queryResolver) GetQRList(ctx context.Context, orgSlug string, codeType model.QRCodeType, elementID int) ([]*model.QRObject, error) {
	tokenUser := oauth2.ForContext(ctx)
	if tokenUser == nil {
		return nil, valid.ErrAuthorization


@@ 5501,7 5506,7 @@ func (r *queryResolver) GetQRList(ctx context.Context, orgSlug string, codeType 
	lt := localizer.GetLocalizer(lang)

	validator := valid.New(ctx)
	if codeType != models.CodeTypeList && codeType != models.CodeTypeShort {
	if string(codeType) != models.CodeTypeList && string(codeType) != models.CodeTypeShort {
		validator.Error(lt.Translate("Invalid code type")).
			WithField("orgSlug").
			WithCode(valid.ErrValidationCode)


@@ 5533,7 5538,7 @@ func (r *queryResolver) GetQRList(ctx context.Context, orgSlug string, codeType 
	}

	objectQRs := make([]*model.QRObject, 0)
	if codeType == models.CodeTypeList {
	if string(codeType) == models.CodeTypeList {
		opts = &database.FilterOptions{
			Filter: sq.Eq{"ql.list_id": elementID},
		}


@@ 5552,7 5557,7 @@ func (r *queryResolver) GetQRList(ctx context.Context, orgSlug string, codeType 
			objectQRs = append(objectQRs, qrObject)
		}

	} else if codeType == models.CodeTypeShort {
	} else if string(codeType) == models.CodeTypeShort {
		opts = &database.FilterOptions{
			Filter: sq.Eq{"qs.short_id": elementID},
		}


@@ 6740,6 6745,9 @@ func (r *Resolver) OrganizationSettings() OrganizationSettingsResolver {
	return &organizationSettingsResolver{r}
}

// QRCode returns QRCodeResolver implementation.
func (r *Resolver) QRCode() QRCodeResolver { return &qRCodeResolver{r} }

// Query returns QueryResolver implementation.
func (r *Resolver) Query() QueryResolver { return &queryResolver{r} }



@@ 6752,5 6760,6 @@ type mutationResolver struct{ *Resolver }
type orgLinkResolver struct{ *Resolver }
type organizationResolver struct{ *Resolver }
type organizationSettingsResolver struct{ *Resolver }
type qRCodeResolver struct{ *Resolver }
type queryResolver struct{ *Resolver }
type userResolver struct{ *Resolver }


M list/routes.go => list/routes.go +2 -2
@@ 1268,7 1268,7 @@ func (s *Service) ListingQRCodeCreate(c echo.Context) error {

		var result GraphQLResponse
		op := gqlclient.NewOperation(`
			mutation AddQRCode($title: String!, $slug: String!, $type: Int!, $id: Int!, $image: Upload) {
			mutation AddQRCode($title: String!, $slug: String!, $type: QRCodeType!, $id: Int!, $image: Upload) {
				addQRCode(input: {title: $title, orgSlug: $slug, codeType: $type, elementId: $id, image: $image}) {
					id
					imagePath


@@ 1374,7 1374,7 @@ func (s *Service) ListingQRCodeList(c echo.Context) error {

	var result GraphQLResponse
	op := gqlclient.NewOperation(`
		query GetQRList($slug: String!, $element: Int!, $type: Int!) {
		query GetQRList($slug: String!, $element: Int!, $type: QRCodeType!) {
			getQRList(orgSlug: $slug, elementId: $element, codeType: $type) {
				title
				qrCodeId


M migrations/0001_initial.down.sql => migrations/0001_initial.down.sql +1 -0
@@ 41,3 41,4 @@ DROP TYPE IF EXISTS org_link_type;
DROP TYPE IF EXISTS org_user_perm;
DROP TYPE IF EXISTS org_type;
DROP TYPE IF EXISTS subscription_type;
DROP TYPE IF EXISTS qr_code_type;


M migrations/0001_initial.up.sql => migrations/0001_initial.up.sql +10 -1
@@ 98,6 98,15 @@ EXCEPTION
    WHEN duplicate_object THEN null;
END $$;

DO $$ BEGIN
  CREATE TYPE qr_code_type AS ENUM (
    'LIST',
    'SHORT'
  );
EXCEPTION
    WHEN duplicate_object THEN null;
END $$;


CREATE TABLE users (
  id SERIAL PRIMARY KEY,


@@ 446,7 455,7 @@ CREATE TABLE qr_codes (
  hash_id VARCHAR(10) UNIQUE NOT NULL,
  url TEXT NOT NULL,
  org_id INT REFERENCES organizations (id) ON DELETE CASCADE NOT NULL,
  code_type INT NOT NULL,
  code_type qr_code_type NOT NULL,
  image_path TEXT DEFAULT '',
  user_id INT REFERENCES users (id) ON DELETE CASCADE NOT NULL,
  created_on TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,


M migrations/test_migration.up.sql => migrations/test_migration.up.sql +2 -2
@@ 22,8 22,8 @@ INSERT INTO link_shorts (id, title, url, domain_id, org_id, short_code, user_id)
INSERT INTO listings (id, title, slug, domain_id, is_default, user_id, org_id) VALUES (100, 'test listing', 'test-listing-slug', 2, false, 1, 1);
INSERT INTO listing_links (id, listing_id, url, description, link_order, user_id, title) VALUES (100, 100, 'http://foo.com', 'description', 2, 1, 'title');

INSERT INTO qr_codes (id, hash_id, url, org_id, code_type, image_path, user_id, title) VALUES (100, 'a10x', 'http://short.com/abc', 1, 1, 'path/qr.png', 1, 'title');
INSERT INTO qr_codes (id, hash_id, url, org_id, code_type, image_path, user_id, title) VALUES (101, 'a99z', 'http://list.com/abc', 1, 0, 'path/qr.png', 1, 'title');
INSERT INTO qr_codes (id, hash_id, url, org_id, code_type, image_path, user_id, title) VALUES (100, 'a10x', 'http://short.com/abc', 1, 'SHORT', 'path/qr.png', 1, 'title');
INSERT INTO qr_codes (id, hash_id, url, org_id, code_type, image_path, user_id, title) VALUES (101, 'a99z', 'http://list.com/abc', 1, 'LIST', 'path/qr.png', 1, 'title');

INSERT INTO subscription_plans (id, name, plan_id, stripe_price_id, price, type) VALUES (1, 'Personal', 'plan_personal', 'price_personal', 1000, 'PERSONAL');
INSERT INTO subscription_plans (id, name, plan_id, stripe_price_id, price, type) VALUES (2, 'Business', 'plan_business', 'price_business', 2000, 'BUSINESS');


M models/models.go => models/models.go +1 -1
@@ 271,7 271,7 @@ type QRCode struct {
	Title     string    `db:"title"`
	HashID    string    `db:"hash_id"`
	OrgID     int       `db:"org_id" json:"orgId"`
	CodeType  int       `db:"code_type"`
	CodeType  string    `db:"code_type"`
	ImagePath string    `db:"image_path"`
	URL       string    `db:"url"`
	UserID    int       `db:"user_id"`


M models/qr_codes.go => models/qr_codes.go +2 -2
@@ 12,8 12,8 @@ import (
)

const (
	CodeTypeList int = iota
	CodeTypeShort
	CodeTypeList  string = "LIST"
	CodeTypeShort string = "SHORT"
)

func GetQRCodes(ctx context.Context, opts *database.FilterOptions) ([]*QRCode, error) {


M models/schema.sql => models/schema.sql +5 -1
@@ 61,6 61,10 @@ CREATE TYPE subscription_type AS ENUM (
  'BUSINESS'
);

CREATE TYPE qr_code_type AS ENUM (
  'LIST',
  'SHORT'
);

CREATE TABLE users (
  id SERIAL PRIMARY KEY,


@@ 409,7 413,7 @@ CREATE TABLE qr_codes (
  hash_id VARCHAR(10) UNIQUE NOT NULL,
  url TEXT NOT NULL,
  org_id INT REFERENCES organizations (id) ON DELETE CASCADE NOT NULL,
  code_type INT NOT NULL,
  code_type qr_code_type NOT NULL,
  image_path TEXT DEFAULT '',
  user_id INT REFERENCES users (id) ON DELETE CASCADE NOT NULL,
  created_on TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,


M short/routes.go => short/routes.go +2 -2
@@ 640,7 640,7 @@ func (s *Service) LinkShortQRCodeList(c echo.Context) error {

	var result GraphQLResponse
	op := gqlclient.NewOperation(`
		query GetQRList($slug: String!, $element: Int!, $type: Int!) {
		query GetQRList($slug: String!, $element: Int!, $type: QRCodeType!) {
			getQRList(orgSlug: $slug, elementId: $element, codeType: $type) {
				title
				qrCodeId


@@ 759,7 759,7 @@ func (s *Service) LinkShortQRCodeCreate(c echo.Context) error {
		}
		var result GraphQLResponse
		op := gqlclient.NewOperation(`
			mutation AddQRCode($title: String!, $slug: String!, $type: Int!, $id: Int!, $image: Upload) {
			mutation AddQRCode($title: String!, $slug: String!, $type: QRCodeType!, $id: Int!, $image: Upload) {
				addQRCode(input: {title: $title, orgSlug: $slug, codeType: $type, elementId: $id, image: $image}) {
					id
					imagePath