~sircmpwn/meta.sr.ht

5070ce9f34c0785b4fc6760c1f1d0439bdd4335f — Drew DeVault a month ago a735d9b
API: design schema for webhooks
M api/graph/api/generated.go => api/graph/api/generated.go +3806 -476
@@ 64,6 64,11 @@ type ComplexityRoot struct {
		IPAddress func(childComplexity int) int
	}

	HTTPHeader struct {
		Name  func(childComplexity int) int
		Value func(childComplexity int) int
	}

	Invoice struct {
		Cents     func(childComplexity int) int
		Created   func(childComplexity int) int


@@ 78,11 83,14 @@ type ComplexityRoot struct {
	}

	Mutation struct {
		CreatePGPKey func(childComplexity int, key string) int
		CreateSSHKey func(childComplexity int, key string) int
		DeletePGPKey func(childComplexity int, key string) int
		DeleteSSHKey func(childComplexity int, key string) int
		UpdateUser   func(childComplexity int, input map[string]interface{}) int
		CreatePGPKey    func(childComplexity int, key string) int
		CreateSSHKey    func(childComplexity int, key string) int
		DeletePGPKey    func(childComplexity int, key string) int
		DeleteSSHKey    func(childComplexity int, key string) int
		DeleteWebhook   func(childComplexity int, id string) int
		RegisterWebhook func(childComplexity int, events []*model.WebhookEvent, url string, payload string) int
		UpdateSSHKey    func(childComplexity int, id string) int
		UpdateUser      func(childComplexity int, input map[string]interface{}) int
	}

	PGPKey struct {


@@ 99,6 107,36 @@ type ComplexityRoot struct {
		Results func(childComplexity int) int
	}

	PGPKeyUpdate struct {
		Created            func(childComplexity int) int
		DeliveryID         func(childComplexity int) int
		Event              func(childComplexity int) int
		Key                func(childComplexity int) int
		Kind               func(childComplexity int) int
		RequestBody        func(childComplexity int) int
		RequestHeaders     func(childComplexity int) int
		ResponseBody       func(childComplexity int) int
		ResponseHeaders    func(childComplexity int) int
		ResponseStatusCode func(childComplexity int) int
		ResponseStatusText func(childComplexity int) int
		Subscription       func(childComplexity int) int
	}

	ProfileUpdate struct {
		Created            func(childComplexity int) int
		DeliveryID         func(childComplexity int) int
		Event              func(childComplexity int) int
		New                func(childComplexity int) int
		Old                func(childComplexity int) int
		RequestBody        func(childComplexity int) int
		RequestHeaders     func(childComplexity int) int
		ResponseBody       func(childComplexity int) int
		ResponseHeaders    func(childComplexity int) int
		ResponseStatusCode func(childComplexity int) int
		ResponseStatusText func(childComplexity int) int
		Subscription       func(childComplexity int) int
	}

	Query struct {
		AuditLog            func(childComplexity int, cursor *model1.Cursor) int
		Invoices            func(childComplexity int, cursor *model1.Cursor) int


@@ 109,6 147,9 @@ type ComplexityRoot struct {
		UserByID            func(childComplexity int, id int) int
		UserByName          func(childComplexity int, username string) int
		Version             func(childComplexity int) int
		Webhook             func(childComplexity int) int
		WebhookByID         func(childComplexity int, id string) int
		Webhooks            func(childComplexity int) int
	}

	SSHKey struct {


@@ 126,6 167,21 @@ type ComplexityRoot struct {
		Results func(childComplexity int) int
	}

	SSHKeyUpdate struct {
		Created            func(childComplexity int) int
		DeliveryID         func(childComplexity int) int
		Event              func(childComplexity int) int
		Key                func(childComplexity int) int
		Kind               func(childComplexity int) int
		RequestBody        func(childComplexity int) int
		RequestHeaders     func(childComplexity int) int
		ResponseBody       func(childComplexity int) int
		ResponseHeaders    func(childComplexity int) int
		ResponseStatusCode func(childComplexity int) int
		ResponseStatusText func(childComplexity int) int
		Subscription       func(childComplexity int) int
	}

	User struct {
		Bio           func(childComplexity int) int
		CanonicalName func(childComplexity int) int


@@ 147,6 203,23 @@ type ComplexityRoot struct {
		Minor           func(childComplexity int) int
		Patch           func(childComplexity int) int
	}

	Webhook struct {
		Created    func(childComplexity int) int
		Deliveries func(childComplexity int, cursor *model1.Cursor) int
		ID         func(childComplexity int) int
		Payload    func(childComplexity int) int
	}

	WebhookCursor struct {
		Cursor  func(childComplexity int) int
		Results func(childComplexity int) int
	}

	WebhookDeliveryCursor struct {
		Cursor  func(childComplexity int) int
		Results func(childComplexity int) int
	}
}

type MutationResolver interface {


@@ 155,6 228,9 @@ type MutationResolver interface {
	DeletePGPKey(ctx context.Context, key string) (*model.PGPKey, error)
	CreateSSHKey(ctx context.Context, key string) (*model.SSHKey, error)
	DeleteSSHKey(ctx context.Context, key string) (*model.SSHKey, error)
	UpdateSSHKey(ctx context.Context, id string) (*model.SSHKey, error)
	RegisterWebhook(ctx context.Context, events []*model.WebhookEvent, url string, payload string) (*model.Webhook, error)
	DeleteWebhook(ctx context.Context, id string) (*model.Webhook, error)
}
type PGPKeyResolver interface {
	User(ctx context.Context, obj *model.PGPKey) (*model.User, error)


@@ 169,6 245,9 @@ type QueryResolver interface {
	PGPKeyByKeyID(ctx context.Context, keyID string) (*model.PGPKey, error)
	Invoices(ctx context.Context, cursor *model1.Cursor) (*model.InvoiceCursor, error)
	AuditLog(ctx context.Context, cursor *model1.Cursor) (*model.AuditLogCursor, error)
	Webhook(ctx context.Context) (model.WebhookPayload, error)
	Webhooks(ctx context.Context) (*model.WebhookCursor, error)
	WebhookByID(ctx context.Context, id string) (*model.Webhook, error)
}
type SSHKeyResolver interface {
	User(ctx context.Context, obj *model.SSHKey) (*model.User, error)


@@ 242,6 321,20 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in

		return e.complexity.AuditLogEntry.IPAddress(childComplexity), true

	case "HTTPHeader.name":
		if e.complexity.HTTPHeader.Name == nil {
			break
		}

		return e.complexity.HTTPHeader.Name(childComplexity), true

	case "HTTPHeader.value":
		if e.complexity.HTTPHeader.Value == nil {
			break
		}

		return e.complexity.HTTPHeader.Value(childComplexity), true

	case "Invoice.cents":
		if e.complexity.Invoice.Cents == nil {
			break


@@ 339,6 432,42 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in

		return e.complexity.Mutation.DeleteSSHKey(childComplexity, args["key"].(string)), true

	case "Mutation.deleteWebhook":
		if e.complexity.Mutation.DeleteWebhook == nil {
			break
		}

		args, err := ec.field_Mutation_deleteWebhook_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Mutation.DeleteWebhook(childComplexity, args["id"].(string)), true

	case "Mutation.registerWebhook":
		if e.complexity.Mutation.RegisterWebhook == nil {
			break
		}

		args, err := ec.field_Mutation_registerWebhook_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Mutation.RegisterWebhook(childComplexity, args["events"].([]*model.WebhookEvent), args["url"].(string), args["payload"].(string)), true

	case "Mutation.updateSSHKey":
		if e.complexity.Mutation.UpdateSSHKey == nil {
			break
		}

		args, err := ec.field_Mutation_updateSSHKey_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Mutation.UpdateSSHKey(childComplexity, args["id"].(string)), true

	case "Mutation.updateUser":
		if e.complexity.Mutation.UpdateUser == nil {
			break


@@ 407,6 536,174 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in

		return e.complexity.PGPKeyCursor.Results(childComplexity), true

	case "PGPKeyUpdate.created":
		if e.complexity.PGPKeyUpdate.Created == nil {
			break
		}

		return e.complexity.PGPKeyUpdate.Created(childComplexity), true

	case "PGPKeyUpdate.deliveryID":
		if e.complexity.PGPKeyUpdate.DeliveryID == nil {
			break
		}

		return e.complexity.PGPKeyUpdate.DeliveryID(childComplexity), true

	case "PGPKeyUpdate.event":
		if e.complexity.PGPKeyUpdate.Event == nil {
			break
		}

		return e.complexity.PGPKeyUpdate.Event(childComplexity), true

	case "PGPKeyUpdate.key":
		if e.complexity.PGPKeyUpdate.Key == nil {
			break
		}

		return e.complexity.PGPKeyUpdate.Key(childComplexity), true

	case "PGPKeyUpdate.kind":
		if e.complexity.PGPKeyUpdate.Kind == nil {
			break
		}

		return e.complexity.PGPKeyUpdate.Kind(childComplexity), true

	case "PGPKeyUpdate.requestBody":
		if e.complexity.PGPKeyUpdate.RequestBody == nil {
			break
		}

		return e.complexity.PGPKeyUpdate.RequestBody(childComplexity), true

	case "PGPKeyUpdate.requestHeaders":
		if e.complexity.PGPKeyUpdate.RequestHeaders == nil {
			break
		}

		return e.complexity.PGPKeyUpdate.RequestHeaders(childComplexity), true

	case "PGPKeyUpdate.responseBody":
		if e.complexity.PGPKeyUpdate.ResponseBody == nil {
			break
		}

		return e.complexity.PGPKeyUpdate.ResponseBody(childComplexity), true

	case "PGPKeyUpdate.responseHeaders":
		if e.complexity.PGPKeyUpdate.ResponseHeaders == nil {
			break
		}

		return e.complexity.PGPKeyUpdate.ResponseHeaders(childComplexity), true

	case "PGPKeyUpdate.responseStatusCode":
		if e.complexity.PGPKeyUpdate.ResponseStatusCode == nil {
			break
		}

		return e.complexity.PGPKeyUpdate.ResponseStatusCode(childComplexity), true

	case "PGPKeyUpdate.responseStatusText":
		if e.complexity.PGPKeyUpdate.ResponseStatusText == nil {
			break
		}

		return e.complexity.PGPKeyUpdate.ResponseStatusText(childComplexity), true

	case "PGPKeyUpdate.subscription":
		if e.complexity.PGPKeyUpdate.Subscription == nil {
			break
		}

		return e.complexity.PGPKeyUpdate.Subscription(childComplexity), true

	case "ProfileUpdate.created":
		if e.complexity.ProfileUpdate.Created == nil {
			break
		}

		return e.complexity.ProfileUpdate.Created(childComplexity), true

	case "ProfileUpdate.deliveryID":
		if e.complexity.ProfileUpdate.DeliveryID == nil {
			break
		}

		return e.complexity.ProfileUpdate.DeliveryID(childComplexity), true

	case "ProfileUpdate.event":
		if e.complexity.ProfileUpdate.Event == nil {
			break
		}

		return e.complexity.ProfileUpdate.Event(childComplexity), true

	case "ProfileUpdate.new":
		if e.complexity.ProfileUpdate.New == nil {
			break
		}

		return e.complexity.ProfileUpdate.New(childComplexity), true

	case "ProfileUpdate.old":
		if e.complexity.ProfileUpdate.Old == nil {
			break
		}

		return e.complexity.ProfileUpdate.Old(childComplexity), true

	case "ProfileUpdate.requestBody":
		if e.complexity.ProfileUpdate.RequestBody == nil {
			break
		}

		return e.complexity.ProfileUpdate.RequestBody(childComplexity), true

	case "ProfileUpdate.requestHeaders":
		if e.complexity.ProfileUpdate.RequestHeaders == nil {
			break
		}

		return e.complexity.ProfileUpdate.RequestHeaders(childComplexity), true

	case "ProfileUpdate.responseBody":
		if e.complexity.ProfileUpdate.ResponseBody == nil {
			break
		}

		return e.complexity.ProfileUpdate.ResponseBody(childComplexity), true

	case "ProfileUpdate.responseHeaders":
		if e.complexity.ProfileUpdate.ResponseHeaders == nil {
			break
		}

		return e.complexity.ProfileUpdate.ResponseHeaders(childComplexity), true

	case "ProfileUpdate.responseStatusCode":
		if e.complexity.ProfileUpdate.ResponseStatusCode == nil {
			break
		}

		return e.complexity.ProfileUpdate.ResponseStatusCode(childComplexity), true

	case "ProfileUpdate.responseStatusText":
		if e.complexity.ProfileUpdate.ResponseStatusText == nil {
			break
		}

		return e.complexity.ProfileUpdate.ResponseStatusText(childComplexity), true

	case "ProfileUpdate.subscription":
		if e.complexity.ProfileUpdate.Subscription == nil {
			break
		}

		return e.complexity.ProfileUpdate.Subscription(childComplexity), true

	case "Query.auditLog":
		if e.complexity.Query.AuditLog == nil {
			break


@@ 505,6 802,32 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in

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

	case "Query.webhook":
		if e.complexity.Query.Webhook == nil {
			break
		}

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

	case "Query.webhookByID":
		if e.complexity.Query.WebhookByID == nil {
			break
		}

		args, err := ec.field_Query_webhookByID_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Query.WebhookByID(childComplexity, args["id"].(string)), true

	case "Query.webhooks":
		if e.complexity.Query.Webhooks == nil {
			break
		}

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

	case "SSHKey.comment":
		if e.complexity.SSHKey.Comment == nil {
			break


@@ 568,6 891,90 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in

		return e.complexity.SSHKeyCursor.Results(childComplexity), true

	case "SSHKeyUpdate.created":
		if e.complexity.SSHKeyUpdate.Created == nil {
			break
		}

		return e.complexity.SSHKeyUpdate.Created(childComplexity), true

	case "SSHKeyUpdate.deliveryID":
		if e.complexity.SSHKeyUpdate.DeliveryID == nil {
			break
		}

		return e.complexity.SSHKeyUpdate.DeliveryID(childComplexity), true

	case "SSHKeyUpdate.event":
		if e.complexity.SSHKeyUpdate.Event == nil {
			break
		}

		return e.complexity.SSHKeyUpdate.Event(childComplexity), true

	case "SSHKeyUpdate.key":
		if e.complexity.SSHKeyUpdate.Key == nil {
			break
		}

		return e.complexity.SSHKeyUpdate.Key(childComplexity), true

	case "SSHKeyUpdate.kind":
		if e.complexity.SSHKeyUpdate.Kind == nil {
			break
		}

		return e.complexity.SSHKeyUpdate.Kind(childComplexity), true

	case "SSHKeyUpdate.requestBody":
		if e.complexity.SSHKeyUpdate.RequestBody == nil {
			break
		}

		return e.complexity.SSHKeyUpdate.RequestBody(childComplexity), true

	case "SSHKeyUpdate.requestHeaders":
		if e.complexity.SSHKeyUpdate.RequestHeaders == nil {
			break
		}

		return e.complexity.SSHKeyUpdate.RequestHeaders(childComplexity), true

	case "SSHKeyUpdate.responseBody":
		if e.complexity.SSHKeyUpdate.ResponseBody == nil {
			break
		}

		return e.complexity.SSHKeyUpdate.ResponseBody(childComplexity), true

	case "SSHKeyUpdate.responseHeaders":
		if e.complexity.SSHKeyUpdate.ResponseHeaders == nil {
			break
		}

		return e.complexity.SSHKeyUpdate.ResponseHeaders(childComplexity), true

	case "SSHKeyUpdate.responseStatusCode":
		if e.complexity.SSHKeyUpdate.ResponseStatusCode == nil {
			break
		}

		return e.complexity.SSHKeyUpdate.ResponseStatusCode(childComplexity), true

	case "SSHKeyUpdate.responseStatusText":
		if e.complexity.SSHKeyUpdate.ResponseStatusText == nil {
			break
		}

		return e.complexity.SSHKeyUpdate.ResponseStatusText(childComplexity), true

	case "SSHKeyUpdate.subscription":
		if e.complexity.SSHKeyUpdate.Subscription == nil {
			break
		}

		return e.complexity.SSHKeyUpdate.Subscription(childComplexity), true

	case "User.bio":
		if e.complexity.User.Bio == nil {
			break


@@ 690,6 1097,67 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in

		return e.complexity.Version.Patch(childComplexity), true

	case "Webhook.created":
		if e.complexity.Webhook.Created == nil {
			break
		}

		return e.complexity.Webhook.Created(childComplexity), true

	case "Webhook.deliveries":
		if e.complexity.Webhook.Deliveries == nil {
			break
		}

		args, err := ec.field_Webhook_deliveries_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Webhook.Deliveries(childComplexity, args["cursor"].(*model1.Cursor)), true

	case "Webhook.id":
		if e.complexity.Webhook.ID == nil {
			break
		}

		return e.complexity.Webhook.ID(childComplexity), true

	case "Webhook.payload":
		if e.complexity.Webhook.Payload == nil {
			break
		}

		return e.complexity.Webhook.Payload(childComplexity), true

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

		return e.complexity.WebhookCursor.Cursor(childComplexity), true

	case "WebhookCursor.results":
		if e.complexity.WebhookCursor.Results == nil {
			break
		}

		return e.complexity.WebhookCursor.Results(childComplexity), true

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

		return e.complexity.WebhookDeliveryCursor.Cursor(childComplexity), true

	case "WebhookDeliveryCursor.results":
		if e.complexity.WebhookDeliveryCursor.Results == nil {
			break
		}

		return e.complexity.WebhookDeliveryCursor.Results(childComplexity), true

	}
	return 0, false
}


@@ 904,17 1372,141 @@ type AuditLogCursor {
  cursor: Cursor
}

type Query {
  # Returns API version information.
  version: Version!

  # Returns the authenticated user.
  me: User!
type Webhook {
  id: ID!
  created: Time!
  payload: String!

  # Returns a specific user
  userByID(id: Int!): User
  userByName(username: String!): User
  userByEmail(email: String!): User
  deliveries(cursor: Cursor): WebhookDeliveryCursor!
}

# A cursor for enumerating a list of webhook registrations.
#
# If there are additional results available, the cursor object may be passed
# back into the same endpoint to retrieve another page. If the cursor is null,
# there are no remaining results to return.
type WebhookCursor {
  results: [Webhook]!
  cursor: Cursor
}

enum WebhookEvent {
  PROFILE_UPDATE
  SSH_KEY_UPDATE
  PGP_KEY_UPDATE
}

type HTTPHeader {
  name: String!
  value: String!
}

interface WebhookDelivery {
  # The event which caused this delivery to occur.
  event: WebhookEvent!

  # A unique UUID assigned to this delivery.
  deliveryID: ID!

  # The time which this event was generated - not necessarily when the HTTP
  # request was submitted to the webhook URL.
  created: Time!

  # The request and response headers and body may be null on payload deliveries
  # older than 30 days, or more than 90 deliveries in the past.
  requestBody: String
  requestHeaders: [HTTPHeader]

  responseBody: String
  responseHeaders: [HTTPHeader]

  # If a non-HTTP error occurs, the status code is set to a negative number and
  # the status text is set to a plain-English description of the error.
  responseStatusCode: Int
  responseStatusText: String

  subscription: Webhook!
}

# A cursor for enumerating a list of webhook deliveries.
#
# If there are additional results available, the cursor object may be passed
# back into the same endpoint to retrieve another page. If the cursor is null,
# there are no remaining results to return.
type WebhookDeliveryCursor {
  results: [WebhookDelivery]!
  cursor: Cursor
}

# Raised when the user updates their profile information.
type ProfileUpdate implements WebhookDelivery {
  created: Time!
  deliveryID: ID!
  event: WebhookEvent!
  requestBody: String!
  requestHeaders: [HTTPHeader]!
  responseBody: String
  responseHeaders: [HTTPHeader]
  responseStatusCode: Int
  responseStatusText: String
  subscription: Webhook!

  old: User!
  new: User!
}

enum UpdateKind {
  OBJECT_ADDED
  OBJECT_REMOVED
}

# Raised when an SSH key is added or removed.
type SSHKeyUpdate implements WebhookDelivery {
  created: Time!
  deliveryID: ID!
  event: WebhookEvent!
  requestBody: String!
  requestHeaders: [HTTPHeader]!
  responseBody: String
  responseHeaders: [HTTPHeader]
  responseStatusCode: Int
  responseStatusText: String
  subscription: Webhook!

  key: SSHKey!
  kind: UpdateKind
}

# Raised when a PGP key is added or removed.
type PGPKeyUpdate implements WebhookDelivery {
  created: Time!
  deliveryID: ID!
  event: WebhookEvent!
  requestBody: String!
  requestHeaders: [HTTPHeader]!
  responseBody: String
  responseHeaders: [HTTPHeader]
  responseStatusCode: Int
  responseStatusText: String
  subscription: Webhook!

  key: SSHKey!
  kind: UpdateKind
}

union WebhookPayload = ProfileUpdate | SSHKeyUpdate | PGPKeyUpdate

type Query {
  # Returns API version information.
  version: Version!

  # Returns the authenticated user.
  me: User!

  # Returns a specific user
  userByID(id: Int!): User
  userByName(username: String!): User
  userByEmail(email: String!): User

  # Returns a specific SSH key by its fingerprint, in hexadecimal
  sshKeyByFingerprint(fingerprint: String!): SSHKey


@@ 927,6 1519,27 @@ type Query {

  # Returns the audit log for the authenticated user
  auditLog(cursor: Cursor): AuditLogCursor! @access(scope: AUDIT_LOG, kind: RO)

  # This field is designed to be used in the construction of user-defined
  # webhook payloads. When your payload query is executed in the context of
  # webhook delivery preparation, this will be configured with details of the
  # event.
  #
  # Attempting to use this field outside of this context will raise an error.
  webhook: WebhookPayload

  # Returns a list of registered webhooks. The set of registered webhooks is
  # unique to your view of this account. If you are registered with an OAuth2
  # personal access token, or with your web browser's login session, this is
  # the list of personal webhooks you have configured for your account.
  #
  # If you are authenticated with an OAuth2 token assigned to your OAuth
  # client, this is the set of webhooks configured for your particular OAuth
  # client.
  webhooks: WebhookCursor

  # Looks up a registered webhook by its ID.
  webhookByID(id: ID!): Webhook
}

input UserInput {


@@ 941,6 1554,22 @@ input UserInput {
  email: String
}

input WebhookInput {
  # The list of webhook events to subscribe to.
  events: [WebhookEvent]!

  # The URL to which the webhook shall be delivered as an HTTP POST request.
  url: String!

  # An arbitrary GraphQL query which is executed to obtain the request body.
  payload: String!

  # If true, delivery will be re-attempted if the server cannot be reached, or
  # if the server returns a 5xx status code. An exponential backoff is used,
  # starting from five seconds, up to 10 attempts.
  retry: Boolean
}

type Mutation {
  updateUser(input: UserInput): User! @access(scope: PROFILE, kind: RW)



@@ 949,6 1578,18 @@ type Mutation {

  createSSHKey(key: String!): SSHKey! @access(scope: SSH_KEYS, kind: RW)
  deleteSSHKey(key: String!): SSHKey! @access(scope: SSH_KEYS, kind: RW)

  # Causes the "last used" time of this SSH key to be updated.
  updateSSHKey(id: ID!): SSHKey!

  # Registers a webhook for the set of events. When an event occurs, the
  # payload parameter is executed as a GraphQL query, and query { webhook } is
  # available with the details of the event. The result is submitted to "url"
  # with an HTTP POST.
  registerWebhook(events: [WebhookEvent]!, url: String!, payload: String!): Webhook!

  # Deletes a webhook by ID and returns the updated webhook.
  deleteWebhook(id: ID!): Webhook!
}
`, BuiltIn: false},
}


@@ 1036,6 1677,64 @@ func (ec *executionContext) field_Mutation_deleteSSHKey_args(ctx context.Context
	return args, nil
}

func (ec *executionContext) field_Mutation_deleteWebhook_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["id"]; ok {
		arg0, err = ec.unmarshalNID2string(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["id"] = arg0
	return args, nil
}

func (ec *executionContext) field_Mutation_registerWebhook_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 []*model.WebhookEvent
	if tmp, ok := rawArgs["events"]; ok {
		arg0, err = ec.unmarshalNWebhookEvent2ᚕᚖgitᚗsrᚗhtᚋאsircmpwnᚋmetaᚗsrᚗhtᚋapiᚋgraphᚋmodelᚐWebhookEvent(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["events"] = arg0
	var arg1 string
	if tmp, ok := rawArgs["url"]; ok {
		arg1, err = ec.unmarshalNString2string(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["url"] = arg1
	var arg2 string
	if tmp, ok := rawArgs["payload"]; ok {
		arg2, err = ec.unmarshalNString2string(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["payload"] = arg2
	return args, nil
}

func (ec *executionContext) field_Mutation_updateSSHKey_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["id"]; ok {
		arg0, err = ec.unmarshalNID2string(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["id"] = arg0
	return args, nil
}

func (ec *executionContext) field_Mutation_updateUser_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}


@@ 1162,6 1861,20 @@ func (ec *executionContext) field_Query_userByName_args(ctx context.Context, raw
	return args, nil
}

func (ec *executionContext) field_Query_webhookByID_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["id"]; ok {
		arg0, err = ec.unmarshalNID2string(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["id"] = arg0
	return args, nil
}

func (ec *executionContext) field_User_pgpKeys_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}


@@ 1190,6 1903,20 @@ func (ec *executionContext) field_User_sshKeys_args(ctx context.Context, rawArgs
	return args, nil
}

func (ec *executionContext) field_Webhook_deliveries_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 *model1.Cursor
	if tmp, ok := rawArgs["cursor"]; ok {
		arg0, err = ec.unmarshalOCursor2ᚖgitᚗsrᚗhtᚋאsircmpwnᚋgqlᚗsrᚗhtᚋmodelᚐCursor(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["cursor"] = arg0
	return args, 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{}{}


@@ 1458,6 2185,74 @@ func (ec *executionContext) _AuditLogEntry_details(ctx context.Context, field gr
	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
}

func (ec *executionContext) _HTTPHeader_name(ctx context.Context, field graphql.CollectedField, obj *model.HTTPHeader) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "HTTPHeader",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Name, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNString2string(ctx, field.Selections, res)
}

func (ec *executionContext) _HTTPHeader_value(ctx context.Context, field graphql.CollectedField, obj *model.HTTPHeader) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "HTTPHeader",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Value, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNString2string(ctx, field.Selections, res)
}

func (ec *executionContext) _Invoice_id(ctx context.Context, field graphql.CollectedField, obj *model.Invoice) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {


@@ 2035,7 2830,7 @@ func (ec *executionContext) _Mutation_deleteSSHKey(ctx context.Context, field gr
	return ec.marshalNSSHKey2ᚖgitᚗsrᚗhtᚋאsircmpwnᚋmetaᚗsrᚗhtᚋapiᚋgraphᚋmodelᚐSSHKey(ctx, field.Selections, res)
}

func (ec *executionContext) _PGPKey_id(ctx context.Context, field graphql.CollectedField, obj *model.PGPKey) (ret graphql.Marshaler) {
func (ec *executionContext) _Mutation_updateSSHKey(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))


@@ 2043,16 2838,23 @@ func (ec *executionContext) _PGPKey_id(ctx context.Context, field graphql.Collec
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "PGPKey",
		Object:   "Mutation",
		Field:    field,
		Args:     nil,
		IsMethod: false,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Mutation_updateSSHKey_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ID, nil
		return ec.resolvers.Mutation().UpdateSSHKey(rctx, args["id"].(string))
	})
	if err != nil {
		ec.Error(ctx, err)


@@ 2064,12 2866,12 @@ func (ec *executionContext) _PGPKey_id(ctx context.Context, field graphql.Collec
		}
		return graphql.Null
	}
	res := resTmp.(int)
	res := resTmp.(*model.SSHKey)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
	return ec.marshalNSSHKey2ᚖgitᚗsrᚗhtᚋאsircmpwnᚋmetaᚗsrᚗhtᚋapiᚋgraphᚋmodelᚐSSHKey(ctx, field.Selections, res)
}

func (ec *executionContext) _PGPKey_created(ctx context.Context, field graphql.CollectedField, obj *model.PGPKey) (ret graphql.Marshaler) {
func (ec *executionContext) _Mutation_registerWebhook(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))


@@ 2077,16 2879,23 @@ func (ec *executionContext) _PGPKey_created(ctx context.Context, field graphql.C
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "PGPKey",
		Object:   "Mutation",
		Field:    field,
		Args:     nil,
		IsMethod: false,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Mutation_registerWebhook_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Created, nil
		return ec.resolvers.Mutation().RegisterWebhook(rctx, args["events"].([]*model.WebhookEvent), args["url"].(string), args["payload"].(string))
	})
	if err != nil {
		ec.Error(ctx, err)


@@ 2098,12 2907,12 @@ func (ec *executionContext) _PGPKey_created(ctx context.Context, field graphql.C
		}
		return graphql.Null
	}
	res := resTmp.(time.Time)
	res := resTmp.(*model.Webhook)
	fc.Result = res
	return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
	return ec.marshalNWebhook2ᚖgitᚗsrᚗhtᚋאsircmpwnᚋmetaᚗsrᚗhtᚋapiᚋgraphᚋmodelᚐWebhook(ctx, field.Selections, res)
}

func (ec *executionContext) _PGPKey_user(ctx context.Context, field graphql.CollectedField, obj *model.PGPKey) (ret graphql.Marshaler) {
func (ec *executionContext) _Mutation_deleteWebhook(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))


@@ 2111,16 2920,23 @@ func (ec *executionContext) _PGPKey_user(ctx context.Context, field graphql.Coll
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "PGPKey",
		Object:   "Mutation",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Mutation_deleteWebhook_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.PGPKey().User(rctx, obj)
		return ec.resolvers.Mutation().DeleteWebhook(rctx, args["id"].(string))
	})
	if err != nil {
		ec.Error(ctx, err)


@@ 2132,12 2948,12 @@ func (ec *executionContext) _PGPKey_user(ctx context.Context, field graphql.Coll
		}
		return graphql.Null
	}
	res := resTmp.(*model.User)
	res := resTmp.(*model.Webhook)
	fc.Result = res
	return ec.marshalNUser2ᚖgitᚗsrᚗhtᚋאsircmpwnᚋmetaᚗsrᚗhtᚋapiᚋgraphᚋmodelᚐUser(ctx, field.Selections, res)
	return ec.marshalNWebhook2ᚖgitᚗsrᚗhtᚋאsircmpwnᚋmetaᚗsrᚗhtᚋapiᚋgraphᚋmodelᚐWebhook(ctx, field.Selections, res)
}

func (ec *executionContext) _PGPKey_key(ctx context.Context, field graphql.CollectedField, obj *model.PGPKey) (ret graphql.Marshaler) {
func (ec *executionContext) _PGPKey_id(ctx context.Context, field graphql.CollectedField, obj *model.PGPKey) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))


@@ 2154,7 2970,7 @@ func (ec *executionContext) _PGPKey_key(ctx context.Context, field graphql.Colle
	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Key, nil
		return obj.ID, nil
	})
	if err != nil {
		ec.Error(ctx, err)


@@ 2166,12 2982,12 @@ func (ec *executionContext) _PGPKey_key(ctx context.Context, field graphql.Colle
		}
		return graphql.Null
	}
	res := resTmp.(string)
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNString2string(ctx, field.Selections, res)
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _PGPKey_keyId(ctx context.Context, field graphql.CollectedField, obj *model.PGPKey) (ret graphql.Marshaler) {
func (ec *executionContext) _PGPKey_created(ctx context.Context, field graphql.CollectedField, obj *model.PGPKey) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))


@@ 2188,7 3004,7 @@ func (ec *executionContext) _PGPKey_keyId(ctx context.Context, field graphql.Col
	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.KeyID, nil
		return obj.Created, nil
	})
	if err != nil {
		ec.Error(ctx, err)


@@ 2200,12 3016,12 @@ func (ec *executionContext) _PGPKey_keyId(ctx context.Context, field graphql.Col
		}
		return graphql.Null
	}
	res := resTmp.(string)
	res := resTmp.(time.Time)
	fc.Result = res
	return ec.marshalNString2string(ctx, field.Selections, res)
	return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
}

func (ec *executionContext) _PGPKey_email(ctx context.Context, field graphql.CollectedField, obj *model.PGPKey) (ret graphql.Marshaler) {
func (ec *executionContext) _PGPKey_user(ctx context.Context, field graphql.CollectedField, obj *model.PGPKey) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))


@@ 2216,13 3032,13 @@ func (ec *executionContext) _PGPKey_email(ctx context.Context, field graphql.Col
		Object:   "PGPKey",
		Field:    field,
		Args:     nil,
		IsMethod: false,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Email, nil
		return ec.resolvers.PGPKey().User(rctx, obj)
	})
	if err != nil {
		ec.Error(ctx, err)


@@ 2234,7 3050,109 @@ func (ec *executionContext) _PGPKey_email(ctx context.Context, field graphql.Col
		}
		return graphql.Null
	}
	res := resTmp.(string)
	res := resTmp.(*model.User)
	fc.Result = res
	return ec.marshalNUser2ᚖgitᚗsrᚗhtᚋאsircmpwnᚋmetaᚗsrᚗhtᚋapiᚋgraphᚋmodelᚐUser(ctx, field.Selections, res)
}

func (ec *executionContext) _PGPKey_key(ctx context.Context, field graphql.CollectedField, obj *model.PGPKey) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "PGPKey",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Key, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNString2string(ctx, field.Selections, res)
}

func (ec *executionContext) _PGPKey_keyId(ctx context.Context, field graphql.CollectedField, obj *model.PGPKey) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "PGPKey",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.KeyID, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNString2string(ctx, field.Selections, res)
}

func (ec *executionContext) _PGPKey_email(ctx context.Context, field graphql.CollectedField, obj *model.PGPKey) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "PGPKey",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Email, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNString2string(ctx, field.Selections, res)
}


@@ 2304,7 3222,7 @@ func (ec *executionContext) _PGPKeyCursor_cursor(ctx context.Context, field grap
	return ec.marshalOCursor2ᚖgitᚗsrᚗhtᚋאsircmpwnᚋgqlᚗsrᚗhtᚋmodelᚐCursor(ctx, field.Selections, res)
}

func (ec *executionContext) _Query_version(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
func (ec *executionContext) _PGPKeyUpdate_created(ctx context.Context, field graphql.CollectedField, obj *model.PGPKeyUpdate) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))


@@ 2312,16 3230,16 @@ func (ec *executionContext) _Query_version(ctx context.Context, field graphql.Co
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Query",
		Object:   "PGPKeyUpdate",
		Field:    field,
		Args:     nil,
		IsMethod: true,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Query().Version(rctx)
		return obj.Created, nil
	})
	if err != nil {
		ec.Error(ctx, err)


@@ 2333,12 3251,12 @@ func (ec *executionContext) _Query_version(ctx context.Context, field graphql.Co
		}
		return graphql.Null
	}
	res := resTmp.(*model.Version)
	res := resTmp.(time.Time)
	fc.Result = res
	return ec.marshalNVersion2ᚖgitᚗsrᚗhtᚋאsircmpwnᚋmetaᚗsrᚗhtᚋapiᚋgraphᚋmodelᚐVersion(ctx, field.Selections, res)
	return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
}

func (ec *executionContext) _Query_me(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
func (ec *executionContext) _PGPKeyUpdate_deliveryID(ctx context.Context, field graphql.CollectedField, obj *model.PGPKeyUpdate) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))


@@ 2346,16 3264,16 @@ func (ec *executionContext) _Query_me(ctx context.Context, field graphql.Collect
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Query",
		Object:   "PGPKeyUpdate",
		Field:    field,
		Args:     nil,
		IsMethod: true,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Query().Me(rctx)
		return obj.DeliveryID, nil
	})
	if err != nil {
		ec.Error(ctx, err)


@@ 2367,12 3285,12 @@ func (ec *executionContext) _Query_me(ctx context.Context, field graphql.Collect
		}
		return graphql.Null
	}
	res := resTmp.(*model.User)
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNUser2ᚖgitᚗsrᚗhtᚋאsircmpwnᚋmetaᚗsrᚗhtᚋapiᚋgraphᚋmodelᚐUser(ctx, field.Selections, res)
	return ec.marshalNID2string(ctx, field.Selections, res)
}

func (ec *executionContext) _Query_userByID(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
func (ec *executionContext) _PGPKeyUpdate_event(ctx context.Context, field graphql.CollectedField, obj *model.PGPKeyUpdate) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))


@@ 2380,37 3298,67 @@ func (ec *executionContext) _Query_userByID(ctx context.Context, field graphql.C
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Query",
		Object:   "PGPKeyUpdate",
		Field:    field,
		Args:     nil,
		IsMethod: true,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Query_userByID_args(ctx, rawArgs)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Event, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(model.WebhookEvent)
	fc.Result = res
	return ec.marshalNWebhookEvent2gitᚗsrᚗhtᚋאsircmpwnᚋmetaᚗsrᚗhtᚋapiᚋgraphᚋmodelᚐWebhookEvent(ctx, field.Selections, res)
}

func (ec *executionContext) _PGPKeyUpdate_requestBody(ctx context.Context, field graphql.CollectedField, obj *model.PGPKeyUpdate) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "PGPKeyUpdate",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Query().UserByID(rctx, args["id"].(int))
		return obj.RequestBody, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*model.User)
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalOUser2ᚖgitᚗsrᚗhtᚋאsircmpwnᚋmetaᚗsrᚗhtᚋapiᚋgraphᚋmodelᚐUser(ctx, field.Selections, res)
	return ec.marshalNString2string(ctx, field.Selections, res)
}

func (ec *executionContext) _Query_userByName(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
func (ec *executionContext) _PGPKeyUpdate_requestHeaders(ctx context.Context, field graphql.CollectedField, obj *model.PGPKeyUpdate) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))


@@ 2418,23 3366,50 @@ func (ec *executionContext) _Query_userByName(ctx context.Context, field graphql
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Query",
		Object:   "PGPKeyUpdate",
		Field:    field,
		Args:     nil,
		IsMethod: true,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Query_userByName_args(ctx, rawArgs)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.RequestHeaders, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.([]*model.HTTPHeader)
	fc.Result = res
	return ec.marshalNHTTPHeader2ᚕᚖgitᚗsrᚗhtᚋאsircmpwnᚋmetaᚗsrᚗhtᚋapiᚋgraphᚋmodelᚐHTTPHeader(ctx, field.Selections, res)
}

func (ec *executionContext) _PGPKeyUpdate_responseBody(ctx context.Context, field graphql.CollectedField, obj *model.PGPKeyUpdate) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "PGPKeyUpdate",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Query().UserByName(rctx, args["username"].(string))
		return obj.ResponseBody, nil
	})
	if err != nil {
		ec.Error(ctx, err)


@@ 2443,12 3418,12 @@ func (ec *executionContext) _Query_userByName(ctx context.Context, field graphql
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*model.User)
	res := resTmp.(*string)
	fc.Result = res
	return ec.marshalOUser2ᚖgitᚗsrᚗhtᚋאsircmpwnᚋmetaᚗsrᚗhtᚋapiᚋgraphᚋmodelᚐUser(ctx, field.Selections, res)
	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
}

func (ec *executionContext) _Query_userByEmail(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
func (ec *executionContext) _PGPKeyUpdate_responseHeaders(ctx context.Context, field graphql.CollectedField, obj *model.PGPKeyUpdate) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))


@@ 2456,37 3431,1622 @@ func (ec *executionContext) _Query_userByEmail(ctx context.Context, field graphq
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Query",
		Object:   "PGPKeyUpdate",
		Field:    field,
		Args:     nil,
		IsMethod: true,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Query_userByEmail_args(ctx, rawArgs)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ResponseHeaders, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.([]*model.HTTPHeader)
	fc.Result = res
	return ec.marshalOHTTPHeader2ᚕᚖgitᚗsrᚗhtᚋאsircmpwnᚋmetaᚗsrᚗhtᚋapiᚋgraphᚋmodelᚐHTTPHeader(ctx, field.Selections, res)
}

func (ec *executionContext) _PGPKeyUpdate_responseStatusCode(ctx context.Context, field graphql.CollectedField, obj *model.PGPKeyUpdate) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "PGPKeyUpdate",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ResponseStatusCode, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*int)
	fc.Result = res
	return ec.marshalOInt2ᚖint(ctx, field.Selections, res)
}

func (ec *executionContext) _PGPKeyUpdate_responseStatusText(ctx context.Context, field graphql.CollectedField, obj *model.PGPKeyUpdate) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "PGPKeyUpdate",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ResponseStatusText, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*string)
	fc.Result = res
	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
}

func (ec *executionContext) _PGPKeyUpdate_subscription(ctx context.Context, field graphql.CollectedField, obj *model.PGPKeyUpdate) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "PGPKeyUpdate",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Subscription, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*model.Webhook)
	fc.Result = res
	return ec.marshalNWebhook2ᚖgitᚗsrᚗhtᚋאsircmpwnᚋmetaᚗsrᚗhtᚋapiᚋgraphᚋmodelᚐWebhook(ctx, field.Selections, res)
}

func (ec *executionContext) _PGPKeyUpdate_key(ctx context.Context, field graphql.CollectedField, obj *model.PGPKeyUpdate) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "PGPKeyUpdate",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Key, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*model.SSHKey)
	fc.Result = res
	return ec.marshalNSSHKey2ᚖgitᚗsrᚗhtᚋאsircmpwnᚋmetaᚗsrᚗhtᚋapiᚋgraphᚋmodelᚐSSHKey(ctx, field.Selections, res)
}

func (ec *executionContext) _PGPKeyUpdate_kind(ctx context.Context, field graphql.CollectedField, obj *model.PGPKeyUpdate) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "PGPKeyUpdate",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Kind, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*model.UpdateKind)
	fc.Result = res
	return ec.marshalOUpdateKind2ᚖgitᚗsrᚗhtᚋאsircmpwnᚋmetaᚗsrᚗhtᚋapiᚋgraphᚋmodelᚐUpdateKind(ctx, field.Selections, res)
}

func (ec *executionContext) _ProfileUpdate_created(ctx context.Context, field graphql.CollectedField, obj *model.ProfileUpdate) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ProfileUpdate",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Created, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(time.Time)
	fc.Result = res
	return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
}

func (ec *executionContext) _ProfileUpdate_deliveryID(ctx context.Context, field graphql.CollectedField, obj *model.ProfileUpdate) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ProfileUpdate",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.DeliveryID, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNID2string(ctx, field.Selections, res)
}

func (ec *executionContext) _ProfileUpdate_event(ctx context.Context, field graphql.CollectedField, obj *model.ProfileUpdate) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ProfileUpdate",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Event, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(model.WebhookEvent)
	fc.Result = res
	return ec.marshalNWebhookEvent2gitᚗsrᚗhtᚋאsircmpwnᚋmetaᚗsrᚗhtᚋapiᚋgraphᚋmodelᚐWebhookEvent(ctx, field.Selections, res)
}

func (ec *executionContext) _ProfileUpdate_requestBody(ctx context.Context, field graphql.CollectedField, obj *model.ProfileUpdate) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ProfileUpdate",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.RequestBody, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNString2string(ctx, field.Selections, res)
}

func (ec *executionContext) _ProfileUpdate_requestHeaders(ctx context.Context, field graphql.CollectedField, obj *model.ProfileUpdate) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ProfileUpdate",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.RequestHeaders, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.([]*model.HTTPHeader)
	fc.Result = res
	return ec.marshalNHTTPHeader2ᚕᚖgitᚗsrᚗhtᚋאsircmpwnᚋmetaᚗsrᚗhtᚋapiᚋgraphᚋmodelᚐHTTPHeader(ctx, field.Selections, res)
}

func (ec *executionContext) _ProfileUpdate_responseBody(ctx context.Context, field graphql.CollectedField, obj *model.ProfileUpdate) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ProfileUpdate",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ResponseBody, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*string)
	fc.Result = res
	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
}

func (ec *executionContext) _ProfileUpdate_responseHeaders(ctx context.Context, field graphql.CollectedField, obj *model.ProfileUpdate) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ProfileUpdate",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ResponseHeaders, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.([]*model.HTTPHeader)
	fc.Result = res
	return ec.marshalOHTTPHeader2ᚕᚖgitᚗsrᚗhtᚋאsircmpwnᚋmetaᚗsrᚗhtᚋapiᚋgraphᚋmodelᚐHTTPHeader(ctx, field.Selections, res)
}

func (ec *executionContext) _ProfileUpdate_responseStatusCode(ctx context.Context, field graphql.CollectedField, obj *model.ProfileUpdate) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ProfileUpdate",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ResponseStatusCode, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*int)
	fc.Result = res
	return ec.marshalOInt2ᚖint(ctx, field.Selections, res)
}

func (ec *executionContext) _ProfileUpdate_responseStatusText(ctx context.Context, field graphql.CollectedField, obj *model.ProfileUpdate) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ProfileUpdate",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ResponseStatusText, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*string)
	fc.Result = res
	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
}

func (ec *executionContext) _ProfileUpdate_subscription(ctx context.Context, field graphql.CollectedField, obj *model.ProfileUpdate) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ProfileUpdate",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Subscription, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*model.Webhook)
	fc.Result = res
	return ec.marshalNWebhook2ᚖgitᚗsrᚗhtᚋאsircmpwnᚋmetaᚗsrᚗhtᚋapiᚋgraphᚋmodelᚐWebhook(ctx, field.Selections, res)
}

func (ec *executionContext) _ProfileUpdate_old(ctx context.Context, field graphql.CollectedField, obj *model.ProfileUpdate) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ProfileUpdate",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Old, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*model.User)
	fc.Result = res
	return ec.marshalNUser2ᚖgitᚗsrᚗhtᚋאsircmpwnᚋmetaᚗsrᚗhtᚋapiᚋgraphᚋmodelᚐUser(ctx, field.Selections, res)
}

func (ec *executionContext) _ProfileUpdate_new(ctx context.Context, field graphql.CollectedField, obj *model.ProfileUpdate) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ProfileUpdate",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.New, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*model.User)
	fc.Result = res
	return ec.marshalNUser2ᚖgitᚗsrᚗhtᚋאsircmpwnᚋmetaᚗsrᚗhtᚋapiᚋgraphᚋmodelᚐUser(ctx, field.Selections, res)
}

func (ec *executionContext) _Query_version(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Query",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Query().Version(rctx)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*model.Version)
	fc.Result = res
	return ec.marshalNVersion2ᚖgitᚗsrᚗhtᚋאsircmpwnᚋmetaᚗsrᚗhtᚋapiᚋgraphᚋmodelᚐVersion(ctx, field.Selections, res)
}

func (ec *executionContext) _Query_me(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Query",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Query().Me(rctx)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*model.User)
	fc.Result = res
	return ec.marshalNUser2ᚖgitᚗsrᚗhtᚋאsircmpwnᚋmetaᚗsrᚗhtᚋapiᚋgraphᚋmodelᚐUser(ctx, field.Selections, res)
}

func (ec *executionContext) _Query_userByID(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Query",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Query_userByID_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Query().UserByID(rctx, args["id"].(int))
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*model.User)
	fc.Result = res
	return ec.marshalOUser2ᚖgitᚗsrᚗhtᚋאsircmpwnᚋmetaᚗsrᚗhtᚋapiᚋgraphᚋmodelᚐUser(ctx, field.Selections, res)
}

func (ec *executionContext) _Query_userByName(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Query",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Query_userByName_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Query().UserByName(rctx, args["username"].(string))
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*model.User)
	fc.Result = res
	return ec.marshalOUser2ᚖgitᚗsrᚗhtᚋאsircmpwnᚋmetaᚗsrᚗhtᚋapiᚋgraphᚋmodelᚐUser(ctx, field.Selections, res)
}

func (ec *executionContext) _Query_userByEmail(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Query",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Query_userByEmail_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Query().UserByEmail(rctx, args["email"].(string))
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*model.User)
	fc.Result = res
	return ec.marshalOUser2ᚖgitᚗsrᚗhtᚋאsircmpwnᚋmetaᚗsrᚗhtᚋapiᚋgraphᚋmodelᚐUser(ctx, field.Selections, res)
}

func (ec *executionContext) _Query_sshKeyByFingerprint(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Query",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Query_sshKeyByFingerprint_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Query().SSHKeyByFingerprint(rctx, args["fingerprint"].(string))
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*model.SSHKey)
	fc.Result = res
	return ec.marshalOSSHKey2ᚖgitᚗsrᚗhtᚋאsircmpwnᚋmetaᚗsrᚗhtᚋapiᚋgraphᚋmodelᚐSSHKey(ctx, field.Selections, res)
}

func (ec *executionContext) _Query_pgpKeyByKeyId(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Query",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Query_pgpKeyByKeyId_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Query().PGPKeyByKeyID(rctx, args["keyId"].(string))
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*model.PGPKey)
	fc.Result = res
	return ec.marshalOPGPKey2ᚖgitᚗsrᚗhtᚋאsircmpwnᚋmetaᚗsrᚗhtᚋapiᚋgraphᚋmodelᚐPGPKey(ctx, field.Selections, res)
}

func (ec *executionContext) _Query_invoices(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Query",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Query_invoices_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	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().Invoices(rctx, args["cursor"].(*model1.Cursor))
		}
		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2gitᚗsrᚗhtᚋאsircmpwnᚋmetaᚗsrᚗhtᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "BILLING")
			if err != nil {
				return nil, err
			}
			kind, err := ec.unmarshalNAccessKind2gitᚗsrᚗhtᚋאsircmpwnᚋmetaᚗsrᚗhtᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RO")
			if err != nil {
				return nil, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, nil, directive0, scope, kind)
		}

		tmp, err := directive1(rctx)
		if err != nil {
			return nil, err
		}
		if tmp == nil {
			return nil, nil
		}
		if data, ok := tmp.(*model.InvoiceCursor); ok {
			return data, nil
		}
		return nil, fmt.Errorf(`unexpected type %T from directive, should be *git.sr.ht/~sircmpwn/meta.sr.ht/api/graph/model.InvoiceCursor`, tmp)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*model.InvoiceCursor)
	fc.Result = res
	return ec.marshalNInvoiceCursor2ᚖgitᚗsrᚗhtᚋאsircmpwnᚋmetaᚗsrᚗhtᚋapiᚋgraphᚋmodelᚐInvoiceCursor(ctx, field.Selections, res)
}

func (ec *executionContext) _Query_auditLog(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Query",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Query_auditLog_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	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().AuditLog(rctx, args["cursor"].(*model1.Cursor))
		}
		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2gitᚗsrᚗhtᚋאsircmpwnᚋmetaᚗsrᚗhtᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "AUDIT_LOG")
			if err != nil {
				return nil, err
			}
			kind, err := ec.unmarshalNAccessKind2gitᚗsrᚗhtᚋאsircmpwnᚋmetaᚗsrᚗhtᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RO")
			if err != nil {
				return nil, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, nil, directive0, scope, kind)
		}

		tmp, err := directive1(rctx)
		if err != nil {
			return nil, err
		}
		if tmp == nil {
			return nil, nil
		}
		if data, ok := tmp.(*model.AuditLogCursor); ok {
			return data, nil
		}
		return nil, fmt.Errorf(`unexpected type %T from directive, should be *git.sr.ht/~sircmpwn/meta.sr.ht/api/graph/model.AuditLogCursor`, tmp)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*model.AuditLogCursor)
	fc.Result = res
	return ec.marshalNAuditLogCursor2ᚖgitᚗsrᚗhtᚋאsircmpwnᚋmetaᚗsrᚗhtᚋapiᚋgraphᚋmodelᚐAuditLogCursor(ctx, field.Selections, res)
}

func (ec *executionContext) _Query_webhook(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Query",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Query().Webhook(rctx)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(model.WebhookPayload)
	fc.Result = res
	return ec.marshalOWebhookPayload2gitᚗsrᚗhtᚋאsircmpwnᚋmetaᚗsrᚗhtᚋapiᚋgraphᚋmodelᚐWebhookPayload(ctx, field.Selections, res)
}

func (ec *executionContext) _Query_webhooks(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Query",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Query().Webhooks(rctx)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*model.WebhookCursor)
	fc.Result = res
	return ec.marshalOWebhookCursor2ᚖgitᚗsrᚗhtᚋאsircmpwnᚋmetaᚗsrᚗhtᚋapiᚋgraphᚋmodelᚐWebhookCursor(ctx, field.Selections, res)
}

func (ec *executionContext) _Query_webhookByID(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Query",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Query_webhookByID_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Query().WebhookByID(rctx, args["id"].(string))
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*model.Webhook)
	fc.Result = res
	return ec.marshalOWebhook2ᚖgitᚗsrᚗhtᚋאsircmpwnᚋmetaᚗsrᚗhtᚋapiᚋgraphᚋmodelᚐWebhook(ctx, field.Selections, res)
}

func (ec *executionContext) _Query___type(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Query",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Query___type_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.introspectType(args["name"].(string))
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*introspection.Type)
	fc.Result = res
	return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
}

func (ec *executionContext) _Query___schema(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Query",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.introspectSchema()
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*introspection.Schema)
	fc.Result = res
	return ec.marshalO__Schema2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx, field.Selections, res)
}

func (ec *executionContext) _SSHKey_id(ctx context.Context, field graphql.CollectedField, obj *model.SSHKey) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "SSHKey",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ID, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _SSHKey_created(ctx context.Context, field graphql.CollectedField, obj *model.SSHKey) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "SSHKey",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Created, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(time.Time)
	fc.Result = res
	return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
}

func (ec *executionContext) _SSHKey_lastUsed(ctx context.Context, field graphql.CollectedField, obj *model.SSHKey) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "SSHKey",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.LastUsed, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(time.Time)
	fc.Result = res
	return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
}

func (ec *executionContext) _SSHKey_user(ctx context.Context, field graphql.CollectedField, obj *model.SSHKey) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "SSHKey",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.SSHKey().User(rctx, obj)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*model.User)
	fc.Result = res
	return ec.marshalNUser2ᚖgitᚗsrᚗhtᚋאsircmpwnᚋmetaᚗsrᚗhtᚋapiᚋgraphᚋmodelᚐUser(ctx, field.Selections, res)
}

func (ec *executionContext) _SSHKey_key(ctx context.Context, field graphql.CollectedField, obj *model.SSHKey) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "SSHKey",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Key, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNString2string(ctx, field.Selections, res)
}

func (ec *executionContext) _SSHKey_fingerprint(ctx context.Context, field graphql.CollectedField, obj *model.SSHKey) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "SSHKey",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Fingerprint, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNString2string(ctx, field.Selections, res)
}

func (ec *executionContext) _SSHKey_comment(ctx context.Context, field graphql.CollectedField, obj *model.SSHKey) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "SSHKey",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Comment, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*string)
	fc.Result = res
	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
}

func (ec *executionContext) _SSHKeyCursor_results(ctx context.Context, field graphql.CollectedField, obj *model.SSHKeyCursor) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "SSHKeyCursor",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Results, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.([]*model.SSHKey)
	fc.Result = res
	return ec.marshalNSSHKey2ᚕᚖgitᚗsrᚗhtᚋאsircmpwnᚋmetaᚗsrᚗhtᚋapiᚋgraphᚋmodelᚐSSHKey(ctx, field.Selections, res)
}

func (ec *executionContext) _SSHKeyCursor_cursor(ctx context.Context, field graphql.CollectedField, obj *model.SSHKeyCursor) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "SSHKeyCursor",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Cursor, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*model1.Cursor)
	fc.Result = res
	return ec.marshalOCursor2ᚖgitᚗsrᚗhtᚋאsircmpwnᚋgqlᚗsrᚗhtᚋmodelᚐCursor(ctx, field.Selections, res)
}

func (ec *executionContext) _SSHKeyUpdate_created(ctx context.Context, field graphql.CollectedField, obj *model.SSHKeyUpdate) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "SSHKeyUpdate",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Created, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(time.Time)
	fc.Result = res
	return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
}

func (ec *executionContext) _SSHKeyUpdate_deliveryID(ctx context.Context, field graphql.CollectedField, obj *model.SSHKeyUpdate) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "SSHKeyUpdate",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.DeliveryID, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNID2string(ctx, field.Selections, res)
}

func (ec *executionContext) _SSHKeyUpdate_event(ctx context.Context, field graphql.CollectedField, obj *model.SSHKeyUpdate) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "SSHKeyUpdate",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Event, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(model.WebhookEvent)
	fc.Result = res
	return ec.marshalNWebhookEvent2gitᚗsrᚗhtᚋאsircmpwnᚋmetaᚗsrᚗhtᚋapiᚋgraphᚋmodelᚐWebhookEvent(ctx, field.Selections, res)
}

func (ec *executionContext) _SSHKeyUpdate_requestBody(ctx context.Context, field graphql.CollectedField, obj *model.SSHKeyUpdate) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "SSHKeyUpdate",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.RequestBody, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNString2string(ctx, field.Selections, res)
}

func (ec *executionContext) _SSHKeyUpdate_requestHeaders(ctx context.Context, field graphql.CollectedField, obj *model.SSHKeyUpdate) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "SSHKeyUpdate",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Query().UserByEmail(rctx, args["email"].(string))
		return obj.RequestHeaders, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*model.User)
	res := resTmp.([]*model.HTTPHeader)
	fc.Result = res
	return ec.marshalOUser2ᚖgitᚗsrᚗhtᚋאsircmpwnᚋmetaᚗsrᚗhtᚋapiᚋgraphᚋmodelᚐUser(ctx, field.Selections, res)
	return ec.marshalNHTTPHeader2ᚕᚖgitᚗsrᚗhtᚋאsircmpwnᚋmetaᚗsrᚗhtᚋapiᚋgraphᚋmodelᚐHTTPHeader(ctx, field.Selections, res)
}

func (ec *executionContext) _Query_sshKeyByFingerprint(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
func (ec *executionContext) _SSHKeyUpdate_responseBody(ctx context.Context, field graphql.CollectedField, obj *model.SSHKeyUpdate) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))


@@ 2494,23 5054,16 @@ func (ec *executionContext) _Query_sshKeyByFingerprint(ctx context.Context, fiel
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Query",
		Object:   "SSHKeyUpdate",
		Field:    field,
		Args:     nil,
		IsMethod: true,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Query_sshKeyByFingerprint_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Query().SSHKeyByFingerprint(rctx, args["fingerprint"].(string))
		return obj.ResponseBody, nil
	})
	if err != nil {
		ec.Error(ctx, err)


@@ 2519,12 5072,12 @@ func (ec *executionContext) _Query_sshKeyByFingerprint(ctx context.Context, fiel
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*model.SSHKey)
	res := resTmp.(*string)
	fc.Result = res
	return ec.marshalOSSHKey2ᚖgitᚗsrᚗhtᚋאsircmpwnᚋmetaᚗsrᚗhtᚋapiᚋgraphᚋmodelᚐSSHKey(ctx, field.Selections, res)
	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
}

func (ec *executionContext) _Query_pgpKeyByKeyId(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
func (ec *executionContext) _SSHKeyUpdate_responseHeaders(ctx context.Context, field graphql.CollectedField, obj *model.SSHKeyUpdate) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))


@@ 2532,23 5085,16 @@ func (ec *executionContext) _Query_pgpKeyByKeyId(ctx context.Context, field grap
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Query",
		Object:   "SSHKeyUpdate",
		Field:    field,
		Args:     nil,
		IsMethod: true,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Query_pgpKeyByKeyId_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Query().PGPKeyByKeyID(rctx, args["keyId"].(string))
		return obj.ResponseHeaders, nil
	})
	if err != nil {
		ec.Error(ctx, err)


@@ 2557,12 5103,12 @@ func (ec *executionContext) _Query_pgpKeyByKeyId(ctx context.Context, field grap
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*model.PGPKey)
	res := resTmp.([]*model.HTTPHeader)
	fc.Result = res
	return ec.marshalOPGPKey2ᚖgitᚗsrᚗhtᚋאsircmpwnᚋmetaᚗsrᚗhtᚋapiᚋgraphᚋmodelᚐPGPKey(ctx, field.Selections, res)
	return ec.marshalOHTTPHeader2ᚕᚖgitᚗsrᚗhtᚋאsircmpwnᚋmetaᚗsrᚗhtᚋapiᚋgraphᚋmodelᚐHTTPHeader(ctx, field.Selections, res)
}

func (ec *executionContext) _Query_invoices(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
func (ec *executionContext) _SSHKeyUpdate_responseStatusCode(ctx context.Context, field graphql.CollectedField, obj *model.SSHKeyUpdate) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))


@@ 2570,68 5116,30 @@ func (ec *executionContext) _Query_invoices(ctx context.Context, field graphql.C
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Query",
		Object:   "SSHKeyUpdate",
		Field:    field,
		Args:     nil,
		IsMethod: true,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Query_invoices_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	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().Invoices(rctx, args["cursor"].(*model1.Cursor))
		}
		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2gitᚗsrᚗhtᚋאsircmpwnᚋmetaᚗsrᚗhtᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "BILLING")
			if err != nil {
				return nil, err
			}
			kind, err := ec.unmarshalNAccessKind2gitᚗsrᚗhtᚋאsircmpwnᚋmetaᚗsrᚗhtᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RO")
			if err != nil {
				return nil, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, nil, directive0, scope, kind)
		}

		tmp, err := directive1(rctx)
		if err != nil {
			return nil, err
		}
		if tmp == nil {
			return nil, nil
		}
		if data, ok := tmp.(*model.InvoiceCursor); ok {
			return data, nil
		}
		return nil, fmt.Errorf(`unexpected type %T from directive, should be *git.sr.ht/~sircmpwn/meta.sr.ht/api/graph/model.InvoiceCursor`, tmp)
		ctx = rctx // use context from middleware stack in children
		return obj.ResponseStatusCode, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*model.InvoiceCursor)
	res := resTmp.(*int)
	fc.Result = res
	return ec.marshalNInvoiceCursor2ᚖgitᚗsrᚗhtᚋאsircmpwnᚋmetaᚗsrᚗhtᚋapiᚋgraphᚋmodelᚐInvoiceCursor(ctx, field.Selections, res)
	return ec.marshalOInt2ᚖint(ctx, field.Selections, res)
}

func (ec *executionContext) _Query_auditLog(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
func (ec *executionContext) _SSHKeyUpdate_responseStatusText(ctx context.Context, field graphql.CollectedField, obj *model.SSHKeyUpdate) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))


@@ 2639,68 5147,30 @@ func (ec *executionContext) _Query_auditLog(ctx context.Context, field graphql.C
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Query",
		Object:   "SSHKeyUpdate",
		Field:    field,
		Args:     nil,
		IsMethod: true,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Query_auditLog_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	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().AuditLog(rctx, args["cursor"].(*model1.Cursor))
		}
		directive1 := func(ctx context.Context) (interface{}, error) {
			scope, err := ec.unmarshalNAccessScope2gitᚗsrᚗhtᚋאsircmpwnᚋmetaᚗsrᚗhtᚋapiᚋgraphᚋmodelᚐAccessScope(ctx, "AUDIT_LOG")
			if err != nil {
				return nil, err
			}
			kind, err := ec.unmarshalNAccessKind2gitᚗsrᚗhtᚋאsircmpwnᚋmetaᚗsrᚗhtᚋapiᚋgraphᚋmodelᚐAccessKind(ctx, "RO")
			if err != nil {
				return nil, err
			}
			if ec.directives.Access == nil {
				return nil, errors.New("directive access is not implemented")
			}
			return ec.directives.Access(ctx, nil, directive0, scope, kind)
		}

		tmp, err := directive1(rctx)
		if err != nil {
			return nil, err
		}
		if tmp == nil {
			return nil, nil
		}
		if data, ok := tmp.(*model.AuditLogCursor); ok {
			return data, nil
		}
		return nil, fmt.Errorf(`unexpected type %T from directive, should be *git.sr.ht/~sircmpwn/meta.sr.ht/api/graph/model.AuditLogCursor`, tmp)
		ctx = rctx // use context from middleware stack in children
		return obj.ResponseStatusText, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*model.AuditLogCursor)
	res := resTmp.(*string)
	fc.Result = res
	return ec.marshalNAuditLogCursor2ᚖgitᚗsrᚗhtᚋאsircmpwnᚋmetaᚗsrᚗhtᚋapiᚋgraphᚋmodelᚐAuditLogCursor(ctx, field.Selections, res)
	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
}

func (ec *executionContext) _Query___type(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
func (ec *executionContext) _SSHKeyUpdate_subscription(ctx context.Context, field graphql.CollectedField, obj *model.SSHKeyUpdate) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))


@@ 2708,37 5178,33 @@ func (ec *executionContext) _Query___type(ctx context.Context, field graphql.Col
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Query",
		Object:   "SSHKeyUpdate",
		Field:    field,
		Args:     nil,
		IsMethod: true,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Query___type_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.introspectType(args["name"].(string))
		return obj.Subscription, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*introspection.Type)
	res := resTmp.(*model.Webhook)
	fc.Result = res
	return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
	return ec.marshalNWebhook2ᚖgitᚗsrᚗhtᚋאsircmpwnᚋmetaᚗsrᚗhtᚋapiᚋgraphᚋmodelᚐWebhook(ctx, field.Selections, res)
}

func (ec *executionContext) _Query___schema(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
func (ec *executionContext) _SSHKeyUpdate_key(ctx context.Context, field graphql.CollectedField, obj *model.SSHKeyUpdate) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))


@@ 2746,30 5212,33 @@ func (ec *executionContext) _Query___schema(ctx context.Context, field graphql.C
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Query",
		Object:   "SSHKeyUpdate",
		Field:    field,
		Args:     nil,
		IsMethod: true,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.introspectSchema()
		return obj.Key, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*introspection.Schema)
	res := resTmp.(*model.SSHKey)
	fc.Result = res
	return ec.marshalO__Schema2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx, field.Selections, res)
	return ec.marshalNSSHKey2ᚖgitᚗsrᚗhtᚋאsircmpwnᚋmetaᚗsrᚗhtᚋapiᚋgraphᚋmodelᚐSSHKey(ctx, field.Selections, res)
}

func (ec *executionContext) _SSHKey_id(ctx context.Context, field graphql.CollectedField, obj *model.SSHKey) (ret graphql.Marshaler) {
func (ec *executionContext) _SSHKeyUpdate_kind(ctx context.Context, field graphql.CollectedField, obj *model.SSHKeyUpdate) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))


@@ 2777,7 5246,7 @@ func (ec *executionContext) _SSHKey_id(ctx context.Context, field graphql.Collec
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "SSHKey",
		Object:   "SSHKeyUpdate",
		Field:    field,
		Args:     nil,
		IsMethod: false,


@@ 2786,24 5255,21 @@ func (ec *executionContext) _SSHKey_id(ctx context.Context, field graphql.Collec
	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ID, nil
		return obj.Kind, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	res := resTmp.(*model.UpdateKind)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
	return ec.marshalOUpdateKind2ᚖgitᚗsrᚗhtᚋאsircmpwnᚋmetaᚗsrᚗhtᚋapiᚋgraphᚋmodelᚐUpdateKind(ctx, field.Selections, res)
}

func (ec *executionContext) _SSHKey_created(ctx context.Context, field graphql.CollectedField, obj *model.SSHKey) (ret graphql.Marshaler) {
func (ec *executionContext) _User_id(ctx context.Context, field graphql.CollectedField, obj *model.User) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))


@@ 2811,7 5277,7 @@ func (ec *executionContext) _SSHKey_created(ctx context.Context, field graphql.C
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "SSHKey",
		Object:   "User",
		Field:    field,
		Args:     nil,
		IsMethod: false,


@@ 2820,7 5286,7 @@ func (ec *executionContext) _SSHKey_created(ctx context.Context, field graphql.C
	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Created, nil
		return obj.ID, nil
	})
	if err != nil {
		ec.Error(ctx, err)


@@ 2832,12 5298,12 @@ func (ec *executionContext) _SSHKey_created(ctx context.Context, field graphql.C
		}
		return graphql.Null
	}
	res := resTmp.(time.Time)
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _SSHKey_lastUsed(ctx context.Context, field graphql.CollectedField, obj *model.SSHKey) (ret graphql.Marshaler) {
func (ec *executionContext) _User_created(ctx context.Context, field graphql.CollectedField, obj *model.User) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))


@@ 2845,7 5311,7 @@ func (ec *executionContext) _SSHKey_lastUsed(ctx context.Context, field graphql.
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "SSHKey",
		Object:   "User",
		Field:    field,
		Args:     nil,
		IsMethod: false,


@@ 2854,7 5320,7 @@ func (ec *executionContext) _SSHKey_lastUsed(ctx context.Context, field graphql.
	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.LastUsed, nil
		return obj.Created, nil
	})
	if err != nil {
		ec.Error(ctx, err)


@@ 2871,7 5337,7 @@ func (ec *executionContext) _SSHKey_lastUsed(ctx context.Context, field graphql.
	return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
}

func (ec *executionContext) _SSHKey_user(ctx context.Context, field graphql.CollectedField, obj *model.SSHKey) (ret graphql.Marshaler) {
func (ec *executionContext) _User_updated(ctx context.Context, field graphql.CollectedField, obj *model.User) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))


@@ 2879,16 5345,16 @@ func (ec *executionContext) _SSHKey_user(ctx context.Context, field graphql.Coll
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "SSHKey",
		Object:   "User",
		Field:    field,
		Args:     nil,
		IsMethod: true,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.SSHKey().User(rctx, obj)
		return obj.Updated, nil
	})
	if err != nil {
		ec.Error(ctx, err)


@@ 2900,12 5366,12 @@ func (ec *executionContext) _SSHKey_user(ctx context.Context, field graphql.Coll
		}
		return graphql.Null
	}
	res := resTmp.(*model.User)
	res := resTmp.(time.Time)
	fc.Result = res
	return ec.marshalNUser2ᚖgitᚗsrᚗhtᚋאsircmpwnᚋmetaᚗsrᚗhtᚋapiᚋgraphᚋmodelᚐUser(ctx, field.Selections, res)
	return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
}

func (ec *executionContext) _SSHKey_key(ctx context.Context, field graphql.CollectedField, obj *model.SSHKey) (ret graphql.Marshaler) {
func (ec *executionContext) _User_canonicalName(ctx context.Context, field graphql.CollectedField, obj *model.User) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))


@@ 2913,16 5379,16 @@ func (ec *executionContext) _SSHKey_key(ctx context.Context, field graphql.Colle
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "SSHKey",
		Object:   "User",
		Field:    field,
		Args:     nil,
		IsMethod: false,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Key, nil
		return obj.CanonicalName(), nil
	})
	if err != nil {
		ec.Error(ctx, err)


@@ 2939,7 5405,7 @@ func (ec *executionContext) _SSHKey_key(ctx context.Context, field graphql.Colle
	return ec.marshalNString2string(ctx, field.Selections, res)
}

func (ec *executionContext) _SSHKey_fingerprint(ctx context.Context, field graphql.CollectedField, obj *model.SSHKey) (ret graphql.Marshaler) {
func (ec *executionContext) _User_username(ctx context.Context, field graphql.CollectedField, obj *model.User) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))


@@ 2947,7 5413,7 @@ func (ec *executionContext) _SSHKey_fingerprint(ctx context.Context, field graph
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "SSHKey",
		Object:   "User",
		Field:    field,
		Args:     nil,
		IsMethod: false,


@@ 2956,7 5422,7 @@ func (ec *executionContext) _SSHKey_fingerprint(ctx context.Context, field graph
	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Fingerprint, nil
		return obj.Username, nil
	})
	if err != nil {
		ec.Error(ctx, err)


@@ 2973,7 5439,7 @@ func (ec *executionContext) _SSHKey_fingerprint(ctx context.Context, field graph
	return ec.marshalNString2string(ctx, field.Selections, res)
}

func (ec *executionContext) _SSHKey_comment(ctx context.Context, field graphql.CollectedField, obj *model.SSHKey) (ret graphql.Marshaler) {
func (ec *executionContext) _User_email(ctx context.Context, field graphql.CollectedField, obj *model.User) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))


@@ 2981,7 5447,7 @@ func (ec *executionContext) _SSHKey_comment(ctx context.Context, field graphql.C
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "SSHKey",
		Object:   "User",
		Field:    field,
		Args:     nil,
		IsMethod: false,


@@ 2990,21 5456,24 @@ func (ec *executionContext) _SSHKey_comment(ctx context.Context, field graphql.C
	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Comment, nil
		return obj.Email, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*string)
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
	return ec.marshalNString2string(ctx, field.Selections, res)
}

func (ec *executionContext) _SSHKeyCursor_results(ctx context.Context, field graphql.CollectedField, obj *model.SSHKeyCursor) (ret graphql.Marshaler) {
func (ec *executionContext) _User_url(ctx context.Context, field graphql.CollectedField, obj *model.User) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))


@@ 3012,7 5481,7 @@ func (ec *executionContext) _SSHKeyCursor_results(ctx context.Context, field gra
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "SSHKeyCursor",
		Object:   "User",
		Field:    field,
		Args:     nil,
		IsMethod: false,


@@ 3021,24 5490,21 @@ func (ec *executionContext) _SSHKeyCursor_results(ctx context.Context, field gra
	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Results, nil
		return obj.URL, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.([]*model.SSHKey)
	res := resTmp.(*string)
	fc.Result = res
	return ec.marshalNSSHKey2ᚕᚖgitᚗsrᚗhtᚋאsircmpwnᚋmetaᚗsrᚗhtᚋapiᚋgraphᚋmodelᚐSSHKey(ctx, field.Selections, res)
	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
}

func (ec *executionContext) _SSHKeyCursor_cursor(ctx context.Context, field graphql.CollectedField, obj *model.SSHKeyCursor) (ret graphql.Marshaler) {
func (ec *executionContext) _User_location(ctx context.Context, field graphql.CollectedField, obj *model.User) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))


@@ 3046,7 5512,7 @@ func (ec *executionContext) _SSHKeyCursor_cursor(ctx context.Context, field grap
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "SSHKeyCursor",
		Object:   "User",
		Field:    field,
		Args:     nil,
		IsMethod: false,


@@ 3055,7 5521,7 @@ func (ec *executionContext) _SSHKeyCursor_cursor(ctx context.Context, field grap
	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Cursor, nil
		return obj.Location, nil
	})
	if err != nil {
		ec.Error(ctx, err)


@@ 3064,12 5530,12 @@ func (ec *executionContext) _SSHKeyCursor_cursor(ctx context.Context, field grap
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*model1.Cursor)
	res := resTmp.(*string)
	fc.Result = res
	return ec.marshalOCursor2ᚖgitᚗsrᚗhtᚋאsircmpwnᚋgqlᚗsrᚗhtᚋmodelᚐCursor(ctx, field.Selections, res)
	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
}

func (ec *executionContext) _User_id(ctx context.Context, field graphql.CollectedField, obj *model.User) (ret graphql.Marshaler) {
func (ec *executionContext) _User_bio(ctx context.Context, field graphql.CollectedField, obj *model.User) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))


@@ 3086,24 5552,21 @@ func (ec *executionContext) _User_id(ctx context.Context, field graphql.Collecte
	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ID, nil
		return obj.Bio, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	res := resTmp.(*string)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
}

func (ec *executionContext) _User_created(ctx context.Context, field graphql.CollectedField, obj *model.User) (ret graphql.Marshaler) {
func (ec *executionContext) _User_userType(ctx context.Context, field graphql.CollectedField, obj *model.User) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))


@@ 3114,13 5577,33 @@ func (ec *executionContext) _User_created(ctx context.Context, field graphql.Col
		Object:   "User",
		Field:    field,
		Args:     nil,
		IsMethod: false,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Created, nil
		directive0 := func(rctx context.Context) (interface{}, error) {
			ctx = rctx // use context from middleware stack in children
			return obj.UserType(), nil
		}
		directive1 := func(ctx context.Context) (interface{}, error) {
			if ec.directives.Internal == nil {
				return nil, errors.New("directive internal is not implemented")
			}
			return ec.directives.Internal(ctx, obj, directive0)
		}

		tmp, err := directive1(rctx)
		if err != nil {
			return nil, err
		}
		if tmp == nil {
			return nil, nil
		}
		if data, ok := tmp.(model.UserType); ok {
			return data, nil
		}
		return nil, fmt.Errorf(`unexpected type %T from directive, should be git.sr.ht/~sircmpwn/meta.sr.ht/api/graph/model.UserType`, tmp)
	})
	if err != nil {
		ec.Error(ctx, err)


@@ 3132,12 5615,12 @@ func (ec *executionContext) _User_created(ctx context.Context, field graphql.Col
		}
		return graphql.Null
	}
	res := resTmp.(time.Time)
	res := resTmp.(model.UserType)
	fc.Result = res
	return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
	return ec.marshalNUserType2gitᚗsrᚗhtᚋאsircmpwnᚋmetaᚗsrᚗhtᚋapiᚋgraphᚋmodelᚐUserType(ctx, field.Selections, res)
}

func (ec *executionContext) _User_updated(ctx context.Context, field graphql.CollectedField, obj *model.User) (ret graphql.Marshaler) {
func (ec *executionContext) _User_sshKeys(ctx context.Context, field graphql.CollectedField, obj *model.User) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))


@@ 3148,13 5631,20 @@ func (ec *executionContext) _User_updated(ctx context.Context, field graphql.Col
		Object:   "User",
		Field:    field,
		Args:     nil,
		IsMethod: false,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_User_sshKeys_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Updated, nil
		return ec.resolvers.User().SSHKeys(rctx, obj, args["cursor"].(*model1.Cursor))
	})
	if err != nil {
		ec.Error(ctx, err)


@@ 3166,12 5656,12 @@ func (ec *executionContext) _User_updated(ctx context.Context, field graphql.Col
		}
		return graphql.Null
	}
	res := resTmp.(time.Time)
	res := resTmp.(*model.SSHKeyCursor)
	fc.Result = res
	return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
	return ec.marshalNSSHKeyCursor2ᚖgitᚗsrᚗhtᚋאsircmpwnᚋmetaᚗsrᚗhtᚋapiᚋgraphᚋmodelᚐSSHKeyCursor(ctx, field.Selections, res)
}

func (ec *executionContext) _User_canonicalName(ctx context.Context, field graphql.CollectedField, obj *model.User) (ret graphql.Marshaler) {
func (ec *executionContext) _User_pgpKeys(ctx context.Context, field graphql.CollectedField, obj *model.User) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))


@@ 3186,9 5676,16 @@ func (ec *executionContext) _User_canonicalName(ctx context.Context, field graph
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_User_pgpKeys_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.CanonicalName(), nil
		return ec.resolvers.User().PGPKeys(rctx, obj, args["cursor"].(*model1.Cursor))
	})
	if err != nil {
		ec.Error(ctx, err)


@@ 3200,12 5697,12 @@ func (ec *executionContext) _User_canonicalName(ctx context.Context, field graph
		}
		return graphql.Null
	}
	res := resTmp.(string)
	res := resTmp.(*model.PGPKeyCursor)
	fc.Result = res
	return ec.marshalNString2string(ctx, field.Selections, res)
	return ec.marshalNPGPKeyCursor2ᚖgitᚗsrᚗhtᚋאsircmpwnᚋmetaᚗsrᚗhtᚋapiᚋgraphᚋmodelᚐPGPKeyCursor(ctx, field.Selections, res)
}

func (ec *executionContext) _User_username(ctx context.Context, field graphql.CollectedField, obj *model.User) (ret graphql.Marshaler) {
func (ec *executionContext) _Version_major(ctx context.Context, field graphql.CollectedField, obj *model.Version) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))


@@ 3213,7 5710,7 @@ func (ec *executionContext) _User_username(ctx context.Context, field graphql.Co
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "User",
		Object:   "Version",
		Field:    field,
		Args:     nil,
		IsMethod: false,


@@ 3222,7 5719,7 @@ func (ec *executionContext) _User_username(ctx context.Context, field graphql.Co
	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Username, nil
		return obj.Major, nil
	})
	if err != nil {
		ec.Error(ctx, err)


@@ 3234,12 5731,12 @@ func (ec *executionContext) _User_username(ctx context.Context, field graphql.Co
		}
		return graphql.Null
	}
	res := resTmp.(string)
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNString2string(ctx, field.Selections, res)
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _User_email(ctx context.Context, field graphql.CollectedField, obj *model.User) (ret graphql.Marshaler) {
func (ec *executionContext) _Version_minor(ctx context.Context, field graphql.CollectedField, obj *model.Version) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))


@@ 3247,7 5744,7 @@ func (ec *executionContext) _User_email(ctx context.Context, field graphql.Colle
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "User",
		Object:   "Version",
		Field:    field,
		Args:     nil,
		IsMethod: false,


@@ 3256,7 5753,7 @@ func (ec *executionContext) _User_email(ctx context.Context, field graphql.Colle
	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Email, nil
		return obj.Minor, nil
	})
	if err != nil {
		ec.Error(ctx, err)


@@ 3268,12 5765,12 @@ func (ec *executionContext) _User_email(ctx context.Context, field graphql.Colle
		}
		return graphql.Null
	}
	res := resTmp.(string)
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNString2string(ctx, field.Selections, res)
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _User_url(ctx context.Context, field graphql.CollectedField, obj *model.User) (ret graphql.Marshaler) {
func (ec *executionContext) _Version_patch(ctx context.Context, field graphql.CollectedField, obj *model.Version) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))


@@ 3281,7 5778,7 @@ func (ec *executionContext) _User_url(ctx context.Context, field graphql.Collect
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "User",
		Object:   "Version",
		Field:    field,
		Args:     nil,
		IsMethod: false,


@@ 3290,21 5787,24 @@ func (ec *executionContext) _User_url(ctx context.Context, field graphql.Collect
	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.URL, nil
		return obj.Patch, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*string)
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _User_location(ctx context.Context, field graphql.CollectedField, obj *model.User) (ret graphql.Marshaler) {
func (ec *executionContext) _Version_deprecationDate(ctx context.Context, field graphql.CollectedField, obj *model.Version) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))


@@ 3312,7 5812,7 @@ func (ec *executionContext) _User_location(ctx context.Context, field graphql.Co
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "User",
		Object:   "Version",
		Field:    field,
		Args:     nil,
		IsMethod: false,


@@ 3321,7 5821,7 @@ func (ec *executionContext) _User_location(ctx context.Context, field graphql.Co
	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Location, nil
		return obj.DeprecationDate, nil
	})
	if err != nil {
		ec.Error(ctx, err)


@@ 3330,12 5830,12 @@ func (ec *executionContext) _User_location(ctx context.Context, field graphql.Co
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*string)
	res := resTmp.(*time.Time)
	fc.Result = res
	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
	return ec.marshalOTime2ᚖtimeᚐTime(ctx, field.Selections, res)
}

func (ec *executionContext) _User_bio(ctx context.Context, field graphql.CollectedField, obj *model.User) (ret graphql.Marshaler) {
func (ec *executionContext) _Webhook_id(ctx context.Context, field graphql.CollectedField, obj *model.Webhook) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))


@@ 3343,7 5843,7 @@ func (ec *executionContext) _User_bio(ctx context.Context, field graphql.Collect
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "User",
		Object:   "Webhook",
		Field:    field,
		Args:     nil,
		IsMethod: false,


@@ 3352,21 5852,24 @@ func (ec *executionContext) _User_bio(ctx context.Context, field graphql.Collect
	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Bio, nil
		return obj.ID, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*string)
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
	return ec.marshalNID2string(ctx, field.Selections, res)
}

func (ec *executionContext) _User_userType(ctx context.Context, field graphql.CollectedField, obj *model.User) (ret graphql.Marshaler) {
func (ec *executionContext) _Webhook_created(ctx context.Context, field graphql.CollectedField, obj *model.Webhook) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))


@@ 3374,36 5877,16 @@ func (ec *executionContext) _User_userType(ctx context.Context, field graphql.Co
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "User",
		Object:   "Webhook",
		Field:    field,
		Args:     nil,
		IsMethod: true,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	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 obj.UserType(), nil
		}
		directive1 := func(ctx context.Context) (interface{}, error) {
			if ec.directives.Internal == nil {
				return nil, errors.New("directive internal is not implemented")
			}
			return ec.directives.Internal(ctx, obj, directive0)
		}

		tmp, err := directive1(rctx)
		if err != nil {
			return nil, err
		}
		if tmp == nil {
			return nil, nil
		}
		if data, ok := tmp.(model.UserType); ok {
			return data, nil
		}
		return nil, fmt.Errorf(`unexpected type %T from directive, should be git.sr.ht/~sircmpwn/meta.sr.ht/api/graph/model.UserType`, tmp)
		ctx = rctx // use context from middleware stack in children
		return obj.Created, nil
	})
	if err != nil {
		ec.Error(ctx, err)


@@ 3415,12 5898,12 @@ func (ec *executionContext) _User_userType(ctx context.Context, field graphql.Co
		}
		return graphql.Null
	}
	res := resTmp.(model.UserType)
	res := resTmp.(time.Time)
	fc.Result = res
	return ec.marshalNUserType2gitᚗsrᚗhtᚋאsircmpwnᚋmetaᚗsrᚗhtᚋapiᚋgraphᚋmodelᚐUserType(ctx, field.Selections, res)
	return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
}

func (ec *executionContext) _User_sshKeys(ctx context.Context, field graphql.CollectedField, obj *model.User) (ret graphql.Marshaler) {
func (ec *executionContext) _Webhook_payload(ctx context.Context, field graphql.CollectedField, obj *model.Webhook) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))


@@ 3428,23 5911,16 @@ func (ec *executionContext) _User_sshKeys(ctx context.Context, field graphql.Col
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "User",
		Object:   "Webhook",
		Field:    field,
		Args:     nil,
		IsMethod: true,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_User_sshKeys_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.User().SSHKeys(rctx, obj, args["cursor"].(*model1.Cursor))
		return obj.Payload, nil
	})
	if err != nil {
		ec.Error(ctx, err)


@@ 3456,12 5932,12 @@ func (ec *executionContext) _User_sshKeys(ctx context.Context, field graphql.Col
		}
		return graphql.Null
	}
	res := resTmp.(*model.SSHKeyCursor)
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNSSHKeyCursor2ᚖgitᚗsrᚗhtᚋאsircmpwnᚋmetaᚗsrᚗhtᚋapiᚋgraphᚋmodelᚐSSHKeyCursor(ctx, field.Selections, res)
	return ec.marshalNString2string(ctx, field.Selections, res)
}

func (ec *executionContext) _User_pgpKeys(ctx context.Context, field graphql.CollectedField, obj *model.User) (ret graphql.Marshaler) {
func (ec *executionContext) _Webhook_deliveries(ctx context.Context, field graphql.CollectedField, obj *model.Webhook) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))


@@ 3469,15 5945,15 @@ func (ec *executionContext) _User_pgpKeys(ctx context.Context, field graphql.Col
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "User",
		Object:   "Webhook",
		Field:    field,
		Args:     nil,
		IsMethod: true,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_User_pgpKeys_args(ctx, rawArgs)
	args, err := ec.field_Webhook_deliveries_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null


@@ 3485,7 5961,7 @@ func (ec *executionContext) _User_pgpKeys(ctx context.Context, field graphql.Col
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.User().PGPKeys(rctx, obj, args["cursor"].(*model1.Cursor))
		return obj.Deliveries, nil
	})
	if err != nil {
		ec.Error(ctx, err)


@@ 3497,12 5973,12 @@ func (ec *executionContext) _User_pgpKeys(ctx context.Context, field graphql.Col
		}
		return graphql.Null
	}
	res := resTmp.(*model.PGPKeyCursor)
	res := resTmp.(*model.WebhookDeliveryCursor)
	fc.Result = res
	return ec.marshalNPGPKeyCursor2ᚖgitᚗsrᚗhtᚋאsircmpwnᚋmetaᚗsrᚗhtᚋapiᚋgraphᚋmodelᚐPGPKeyCursor(ctx, field.Selections, res)
	return ec.marshalNWebhookDeliveryCursor2ᚖgitᚗsrᚗhtᚋאsircmpwnᚋmetaᚗsrᚗhtᚋapiᚋgraphᚋmodelᚐWebhookDeliveryCursor(ctx, field.Selections, res)
}

func (ec *executionContext) _Version_major(ctx context.Context, field graphql.CollectedField, obj *model.Version) (ret graphql.Marshaler) {
func (ec *executionContext) _WebhookCursor_results(ctx context.Context, field graphql.CollectedField, obj *model.WebhookCursor) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))


@@ 3510,7 5986,7 @@ func (ec *executionContext) _Version_major(ctx context.Context, field graphql.Co
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Version",
		Object:   "WebhookCursor",
		Field:    field,
		Args:     nil,
		IsMethod: false,


@@ 3519,7 5995,7 @@ func (ec *executionContext) _Version_major(ctx context.Context, field graphql.Co
	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Major, nil
		return obj.Results, nil
	})
	if err != nil {
		ec.Error(ctx, err)


@@ 3531,12 6007,12 @@ func (ec *executionContext) _Version_major(ctx context.Context, field graphql.Co
		}
		return graphql.Null
	}
	res := resTmp.(int)
	res := resTmp.([]*model.Webhook)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
	return ec.marshalNWebhook2ᚕᚖgitᚗsrᚗhtᚋאsircmpwnᚋmetaᚗsrᚗhtᚋapiᚋgraphᚋmodelᚐWebhook(ctx, field.Selections, res)
}

func (ec *executionContext) _Version_minor(ctx context.Context, field graphql.CollectedField, obj *model.Version) (ret graphql.Marshaler) {
func (ec *executionContext) _WebhookCursor_cursor(ctx context.Context, field graphql.CollectedField, obj *model.WebhookCursor) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))


@@ 3544,7 6020,7 @@ func (ec *executionContext) _Version_minor(ctx context.Context, field graphql.Co
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Version",
		Object:   "WebhookCursor",
		Field:    field,
		Args:     nil,
		IsMethod: false,


@@ 3553,24 6029,21 @@ func (ec *executionContext) _Version_minor(ctx context.Context, field graphql.Co
	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Minor, nil
		return obj.Cursor, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	res := resTmp.(*model1.Cursor)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
	return ec.marshalOCursor2ᚖgitᚗsrᚗhtᚋאsircmpwnᚋgqlᚗsrᚗhtᚋmodelᚐCursor(ctx, field.Selections, res)
}

func (ec *executionContext) _Version_patch(ctx context.Context, field graphql.CollectedField, obj *model.Version) (ret graphql.Marshaler) {
func (ec *executionContext) _WebhookDeliveryCursor_results(ctx context.Context, field graphql.CollectedField, obj *model.WebhookDeliveryCursor) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))


@@ 3578,7 6051,7 @@ func (ec *executionContext) _Version_patch(ctx context.Context, field graphql.Co
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Version",
		Object:   "WebhookDeliveryCursor",
		Field:    field,
		Args:     nil,
		IsMethod: false,


@@ 3587,7 6060,7 @@ func (ec *executionContext) _Version_patch(ctx context.Context, field graphql.Co
	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Patch, nil
		return obj.Results, nil
	})
	if err != nil {
		ec.Error(ctx, err)


@@ 3599,12 6072,12 @@ func (ec *executionContext) _Version_patch(ctx context.Context, field graphql.Co
		}
		return graphql.Null
	}
	res := resTmp.(int)
	res := resTmp.([]model.WebhookDelivery)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
	return ec.marshalNWebhookDelivery2ᚕgitᚗsrᚗhtᚋאsircmpwnᚋmetaᚗsrᚗhtᚋapiᚋgraphᚋmodelᚐWebhookDelivery(ctx, field.Selections, res)
}

func (ec *executionContext) _Version_deprecationDate(ctx context.Context, field graphql.CollectedField, obj *model.Version) (ret graphql.Marshaler) {
func (ec *executionContext) _WebhookDeliveryCursor_cursor(ctx context.Context, field graphql.CollectedField, obj *model.WebhookDeliveryCursor) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))


@@ 3612,7 6085,7 @@ func (ec *executionContext) _Version_deprecationDate(ctx context.Context, field 
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Version",
		Object:   "WebhookDeliveryCursor",
		Field:    field,
		Args:     nil,
		IsMethod: false,


@@ 3621,7 6094,7 @@ func (ec *executionContext) _Version_deprecationDate(ctx context.Context, field 
	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.DeprecationDate, nil
		return obj.Cursor, nil
	})
	if err != nil {
		ec.Error(ctx, err)


@@ 3630,9 6103,9 @@ func (ec *executionContext) _Version_deprecationDate(ctx context.Context, field 
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*time.Time)
	res := resTmp.(*model1.Cursor)
	fc.Result = res
	return ec.marshalOTime2ᚖtimeᚐTime(ctx, field.Selections, res)
	return ec.marshalOCursor2ᚖgitᚗsrᚗhtᚋאsircmpwnᚋgqlᚗsrᚗhtᚋmodelᚐCursor(ctx, field.Selections, res)
}

func (ec *executionContext) ___Directive_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {


@@ 4690,6 7163,42 @@ func (ec *executionContext) ___Type_ofType(ctx context.Context, field graphql.Co

// region    **************************** input.gotpl *****************************

func (ec *executionContext) unmarshalInputWebhookInput(ctx context.Context, obj interface{}) (model.WebhookInput, error) {
	var it model.WebhookInput
	var asMap = obj.(map[string]interface{})

	for k, v := range asMap {
		switch k {
		case "events":
			var err error
			it.Events, err = ec.unmarshalNWebhookEvent2ᚕᚖgitᚗsrᚗhtᚋאsircmpwnᚋmetaᚗsrᚗhtᚋapiᚋgraphᚋmodelᚐWebhookEvent(ctx, v)
			if err != nil {
				return it, err
			}
		case "url":
			var err error
			it.URL, err = ec.unmarshalNString2string(ctx, v)
			if err != nil {
				return it, err
			}
		case "payload":
			var err error
			it.Payload, err = ec.unmarshalNString2string(ctx, v)
			if err != nil {
				return it, err
			}
		case "retry":
			var err error
			it.Retry, err = ec.unmarshalOBoolean2ᚖbool(ctx, v)
			if err != nil {
				return it, err
			}
		}
	}

	return it, nil
}

// endregion **************************** input.gotpl *****************************

// region    ************************** interface.gotpl ***************************


@@ 4704,7 7213,67 @@ func (ec *executionContext) _Entity(ctx context.Context, sel ast.SelectionSet, o
		if obj == nil {
			return graphql.Null
		}
		return ec._User(ctx, sel, obj)
		return ec._User(ctx, sel, obj)
	default:
		panic(fmt.Errorf("unexpected type %T", obj))
	}
}

func (ec *executionContext) _WebhookDelivery(ctx context.Context, sel ast.SelectionSet, obj model.WebhookDelivery) graphql.Marshaler {
	switch obj := (obj).(type) {