import { TypedDocumentNode as DocumentNode } from '@graphql-typed-document-node/core'
export type Maybe<T> = T | null
export type InputMaybe<T> = Maybe<T>
export type Exact<T extends { [key: string]: unknown }> = {
	[K in keyof T]: T[K]
}
export type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
	[SubKey in K]?: Maybe<T[SubKey]>
}
export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
	[SubKey in K]: Maybe<T[SubKey]>
}
/** All built-in and custom scalars, mapped to their actual values */
export type Scalars = {
	ID: string
	String: string
	Boolean: boolean
	Int: number
	Float: number
	/** A date-time string at UTC, such as 2019-12-03T09:54:33Z, compliant with the date-time format. */
	DateTime: string
}

export type Agent = {
	__typename?: 'Agent'
	createdAt: Scalars['DateTime']
	id: Scalars['ID']
	job?: Maybe<BuildJob>
	jobs: Array<BuildJob>
	lastActivity: Scalars['DateTime']
	name: Scalars['String']
	org: Org
	platform: AgentPlatform
	priority: Scalars['Float']
	tags: Array<Scalars['String']>
	token: AgentToken
}

export type AgentjobsArgs = {
	order?: InputMaybe<BuildJobOrder>
	skip?: InputMaybe<Scalars['Int']>
	take?: InputMaybe<Scalars['Int']>
	where?: InputMaybe<BuildJobFilter>
}

export type AgentFilter = {
	agentId?: InputMaybe<StringFilter>
	hasJob?: InputMaybe<Scalars['Boolean']>
	id?: InputMaybe<StringFilter>
	lastActivity?: InputMaybe<DateFilter>
	name?: InputMaybe<StringFilter>
	org?: InputMaybe<Array<InputMaybe<Scalars['String']>>>
	tags?: InputMaybe<TagFilter>
}

export type AgentMutation = {
	__typename?: 'AgentMutation'
	build: BuildAgentMutation
	job: JobAgentMutation
	register: AgentRegistration
	step: StepAgentMutation
}

export type AgentMutationregisterArgs = {
	name: Scalars['String']
	platform: AgentPlatform
	priority?: InputMaybe<Scalars['Int']>
	tags?: InputMaybe<Array<Scalars['String']>>
	token: Scalars['String']
}

export type AgentOrder = {
	createdAt?: InputMaybe<SortOrder>
	lastActivity?: InputMaybe<SortOrder>
	priority?: InputMaybe<SortOrder>
}

export enum AgentPlatform {
	Linux = 'Linux',
	Windows = 'Windows',
	macOS = 'macOS',
}

export type AgentRegistration = {
	__typename?: 'AgentRegistration'
	agent: Agent
	token: Scalars['String']
}

export type AgentToken = {
	__typename?: 'AgentToken'
	createdAt: Scalars['DateTime']
	default: Scalars['Boolean']
	id: Scalars['ID']
	name: Scalars['String']
	org: Org
	token: Scalars['String']
}

export type AgentTokenFilter = {
	id?: InputMaybe<Array<InputMaybe<Scalars['ID']>>>
	name?: InputMaybe<Array<InputMaybe<Scalars['String']>>>
	org?: InputMaybe<Array<InputMaybe<Scalars['String']>>>
	token?: InputMaybe<Array<InputMaybe<Scalars['String']>>>
}

export type AgentTokenOrder = {
	createdAt?: InputMaybe<SortOrder>
}

export type AgentTokens = {
	__typename?: 'AgentTokens'
	count: Scalars['Int']
	cursor: Cursor
	list: Array<AgentToken>
	one?: Maybe<AgentToken>
}

export type Agents = {
	__typename?: 'Agents'
	count: Scalars['Int']
	cursor: Cursor
	list: Array<Agent>
	one?: Maybe<Agent>
}

export type Artifact = {
	__typename?: 'Artifact'
	build: Build
	createdAt: Scalars['DateTime']
	download: Scalars['String']
	id: Scalars['ID']
	job: BuildJob
	key: Scalars['String']
	org: Org
	path: Scalars['String']
	repo: Repo
	size: Scalars['Int']
	step: BuildStep
}

export type AuthMutation = {
	__typename?: 'AuthMutation'
	signIn: User
	signUp: User
}

export type AuthMutationsignInArgs = {
	email: Scalars['String']
	password: Scalars['String']
	remember?: InputMaybe<Scalars['Boolean']>
}

export type AuthMutationsignUpArgs = {
	email: Scalars['String']
	password: Scalars['String']
	remember?: InputMaybe<Scalars['Boolean']>
}

export type Build = {
	__typename?: 'Build'
	artifacts: Array<Artifact>
	branch: Scalars['String']
	completedAt?: Maybe<Scalars['DateTime']>
	config?: Maybe<BuildConfig>
	createdAt: Scalars['DateTime']
	dependencies: Array<Build>
	dependencyOf?: Maybe<Build>
	errors: BuildErrors
	id: Scalars['ID']
	jobs: Array<BuildJob>
	message: Scalars['String']
	number: Scalars['Float']
	org: Org
	path: Scalars['String']
	repo: Repo
	sha: Scalars['String']
	startedAt?: Maybe<Scalars['DateTime']>
	state: RunState
	steps: Array<BuildStep>
	user: BuildUser
}

export type BuildAgentMutation = {
	__typename?: 'BuildAgentMutation'
	acquire?: Maybe<Build>
	configure?: Maybe<Build>
	error?: Maybe<Build>
}

export type BuildAgentMutationconfigureArgs = {
	build: Scalars['ID']
	config?: InputMaybe<RunConfigs>
	dependencies: Array<Scalars['String']>
	sha: Scalars['String']
}

export type BuildAgentMutationerrorArgs = {
	build: Scalars['ID']
	error: Scalars['String']
	notFound?: InputMaybe<Scalars['Boolean']>
	sha?: InputMaybe<Scalars['String']>
}

export type BuildConfig = {
	__typename?: 'BuildConfig'
	build: Build
	createdAt: Scalars['DateTime']
	dependencies: Array<Scalars['String']>
	file: Scalars['String']
	id: Scalars['ID']
	platforms: PlatformConfigs
	repos: Array<Repo>
	source: Scalars['String']
}

export type BuildErrors = {
	__typename?: 'BuildErrors'
	cancelled: Scalars['Boolean']
	config?: Maybe<Scalars['String']>
	configNotFound: Scalars['Boolean']
}

export type BuildFilter = {
	dependencyOf?: InputMaybe<Array<InputMaybe<Scalars['ID']>>>
	id?: InputMaybe<Array<InputMaybe<Scalars['ID']>>>
	number?: InputMaybe<Array<InputMaybe<Scalars['Int']>>>
	org?: InputMaybe<Array<InputMaybe<Scalars['String']>>>
	path?: InputMaybe<Array<InputMaybe<Scalars['String']>>>
	repo?: InputMaybe<Array<InputMaybe<Scalars['String']>>>
}

export type BuildJob = {
	__typename?: 'BuildJob'
	agent: Agent
	artifacts: Array<Artifact>
	build: Build
	completedAt?: Maybe<Scalars['DateTime']>
	createdAt: Scalars['DateTime']
	docker?: Maybe<DockerOptions>
	id: Scalars['ID']
	name: Scalars['String']
	number: Scalars['Float']
	org: Org
	path: Scalars['String']
	repo: Repo
	slug: Scalars['String']
	startedAt?: Maybe<Scalars['DateTime']>
	state: StepState
	steps: Array<BuildStep>
	tags: Array<Scalars['String']>
}

export type BuildJobFilter = {
	build?: InputMaybe<IntFilter>
	id?: InputMaybe<StringFilter>
	name?: InputMaybe<StringFilter>
	number?: InputMaybe<IntFilter>
	org?: InputMaybe<Array<InputMaybe<Scalars['String']>>>
	path?: InputMaybe<StringFilter>
	repo?: InputMaybe<StringFilter>
	slug?: InputMaybe<StringFilter>
	state?: InputMaybe<Array<InputMaybe<StepState>>>
	tags?: InputMaybe<Array<TagFilter>>
}

export type BuildJobOrder = {
	createdAt?: InputMaybe<SortOrder>
}

export type BuildJobs = {
	__typename?: 'BuildJobs'
	count: Scalars['Int']
	cursor: Cursor
	list: Array<BuildJob>
	one?: Maybe<BuildJob>
}

export type BuildOrder = {
	createdAt?: InputMaybe<SortOrder>
}

export type BuildStep = {
	__typename?: 'BuildStep'
	artifacts: Array<Artifact>
	build: Build
	command: Array<Scalars['String']>
	completedAt?: Maybe<Scalars['DateTime']>
	configId: Scalars['String']
	createdAt: Scalars['DateTime']
	dependencies: Array<BuildStep>
	dependents: Array<BuildStep>
	env: Array<BuildStepEnv>
	id: Scalars['ID']
	job: BuildJob
	name: Scalars['String']
	org: Org
	output?: Maybe<Scalars['String']>
	path: Scalars['String']
	repo: Repo
	startedAt?: Maybe<Scalars['DateTime']>
	state: StepState
	step: Scalars['Int']
}

export type BuildStepEnv = {
	__typename?: 'BuildStepEnv'
	name: Scalars['String']
	secret: Scalars['Boolean']
	value: Scalars['String']
}

export type BuildStepFilter = {
	build?: InputMaybe<Array<InputMaybe<Scalars['Int']>>>
	id?: InputMaybe<Array<InputMaybe<Scalars['ID']>>>
	job?: InputMaybe<Array<InputMaybe<Scalars['String']>>>
	name?: InputMaybe<Array<InputMaybe<Scalars['String']>>>
	number?: InputMaybe<Array<InputMaybe<Scalars['Int']>>>
	org?: InputMaybe<Array<InputMaybe<Scalars['String']>>>
	path?: InputMaybe<Array<InputMaybe<Scalars['String']>>>
	repo?: InputMaybe<Array<InputMaybe<Scalars['String']>>>
}

export type BuildStepOrder = {
	createdAt?: InputMaybe<SortOrder>
}

export type BuildSteps = {
	__typename?: 'BuildSteps'
	count: Scalars['Int']
	cursor: Cursor
	list: Array<BuildStep>
	one?: Maybe<BuildStep>
}

export type BuildUser = {
	__typename?: 'BuildUser'
	avatarUrl?: Maybe<Scalars['String']>
	createdAt: Scalars['DateTime']
	displayName: Scalars['String']
	id: Scalars['ID']
	link?: Maybe<Scalars['String']>
	provider: BuildUserProvider
	providerId: Scalars['String']
}

export enum BuildUserProvider {
	Bitbucket = 'Bitbucket',
	GitHub = 'GitHub',
	Refloat = 'Refloat',
}

export type Builds = {
	__typename?: 'Builds'
	count: Scalars['Int']
	cursor: Cursor
	list: Array<Build>
	one?: Maybe<Build>
}

export type CurrentUserMutation = {
	__typename?: 'CurrentUserMutation'
	invitation: UserInvitationMutation
	org: UserOrgMutation
	update: User
}

export type CurrentUserMutationupdateArgs = {
	displayName?: InputMaybe<Scalars['String']>
}

export type Cursor = {
	__typename?: 'Cursor'
	current?: Maybe<Scalars['String']>
	next?: Maybe<Scalars['String']>
}

export type DateFilter = {
	and?: InputMaybe<Array<DateFilter>>
	eq?: InputMaybe<Scalars['DateTime']>
	gt?: InputMaybe<Scalars['DateTime']>
	gte?: InputMaybe<Scalars['DateTime']>
	lt?: InputMaybe<Scalars['DateTime']>
	lte?: InputMaybe<Scalars['DateTime']>
	not?: InputMaybe<DateFilter>
	null?: InputMaybe<Scalars['Boolean']>
	or?: InputMaybe<Array<DateFilter>>
}

export type DockerOptions = {
	__typename?: 'DockerOptions'
	context?: Maybe<Scalars['String']>
	file?: Maybe<Scalars['String']>
	image?: Maybe<Scalars['String']>
}

export type IntFilter = {
	and?: InputMaybe<Array<IntFilter>>
	eq?: InputMaybe<Scalars['Int']>
	gt?: InputMaybe<Scalars['Int']>
	gte?: InputMaybe<Scalars['Int']>
	lt?: InputMaybe<Scalars['Int']>
	lte?: InputMaybe<Scalars['Int']>
	not?: InputMaybe<IntFilter>
	null?: InputMaybe<Scalars['Boolean']>
	or?: InputMaybe<Array<IntFilter>>
}

export type JobAgentMutation = {
	__typename?: 'JobAgentMutation'
	acquire?: Maybe<BuildJob>
}

export type Mutation = {
	__typename?: 'Mutation'
	agent: AgentMutation
	auth: AuthMutation
	me: CurrentUserMutation
	org: OrgMutation
	repo: RepoMutation
	runBuild: Build
}

export type MutationrunBuildArgs = {
	branch: Scalars['String']
	message: Scalars['String']
	org?: InputMaybe<Scalars['String']>
	repo?: InputMaybe<Scalars['String']>
	sha: Scalars['String']
}

export type Org = {
	__typename?: 'Org'
	agentConfigured: Scalars['Boolean']
	avatarUrl?: Maybe<Scalars['String']>
	createdAt: Scalars['DateTime']
	id: Scalars['ID']
	invitations: OrgInvitations
	name: Scalars['String']
	repoProviders: Array<RepoProvider>
	repos: Array<Repo>
	slug: Scalars['String']
	users: Users
}

export type OrginvitationsArgs = {
	order?: InputMaybe<OrgInvitationOrder>
	skip?: InputMaybe<Scalars['Int']>
	take?: InputMaybe<Scalars['Int']>
	where?: InputMaybe<OrgInvitationFilter>
}

export type OrgreposArgs = {
	order?: InputMaybe<RepoOrder>
	skip?: InputMaybe<Scalars['Int']>
	take?: InputMaybe<Scalars['Int']>
	where?: InputMaybe<RepoFilter>
}

export type OrgusersArgs = {
	order?: InputMaybe<UserOrder>
	skip?: InputMaybe<Scalars['Int']>
	take?: InputMaybe<Scalars['Int']>
	where?: InputMaybe<UserFilter>
}

export type OrgFilter = {
	id?: InputMaybe<Array<InputMaybe<Scalars['ID']>>>
	slug?: InputMaybe<Array<InputMaybe<Scalars['String']>>>
}

export type OrgInvitation = {
	__typename?: 'OrgInvitation'
	createdAt: Scalars['DateTime']
	email: Scalars['String']
	id: Scalars['ID']
	org: Org
	state: OrgInvitationState
}

export type OrgInvitationFilter = {
	id?: InputMaybe<StringFilter>
	mine?: InputMaybe<Scalars['Boolean']>
	state?: InputMaybe<OrgInvitationStateFilter>
}

export type OrgInvitationOrder = {
	createdAt?: InputMaybe<SortOrder>
}

export enum OrgInvitationState {
	Accepted = 'Accepted',
	Declined = 'Declined',
	Pending = 'Pending',
}

export type OrgInvitationStateFilter = {
	and?: InputMaybe<Array<OrgInvitationStateFilter>>
	eq?: InputMaybe<OrgInvitationState>
	not?: InputMaybe<OrgInvitationStateFilter>
	or?: InputMaybe<Array<OrgInvitationStateFilter>>
}

export type OrgInvitations = {
	__typename?: 'OrgInvitations'
	count: Scalars['Int']
	cursor: Cursor
	list: Array<OrgInvitation>
	one?: Maybe<OrgInvitation>
}

export type OrgMutation = {
	__typename?: 'OrgMutation'
	create: Org
	users: OrgUsersMutation
}

export type OrgMutationcreateArgs = {
	name: Scalars['String']
	slug: Scalars['String']
}

export type OrgOrder = {
	createdAt?: InputMaybe<SortOrder>
}

export type OrgUsersMutation = {
	__typename?: 'OrgUsersMutation'
	invite: OrgInvitation
	remove: Org
}

export type OrgUsersMutationinviteArgs = {
	email: Scalars['String']
	org: Scalars['String']
}

export type OrgUsersMutationremoveArgs = {
	org: Scalars['String']
	userId: Scalars['String']
}

export type Orgs = {
	__typename?: 'Orgs'
	count: Scalars['Int']
	cursor: Cursor
	list: Array<Org>
	one?: Maybe<Org>
}

export type PlatformConfigs = {
	__typename?: 'PlatformConfigs'
	linux: Scalars['String']
	macos: Scalars['String']
	windows: Scalars['String']
}

export type ProviderRepo = {
	__typename?: 'ProviderRepo'
	configured: Scalars['Boolean']
	createdAt: Scalars['DateTime']
	defaultBranch: Scalars['String']
	id: Scalars['ID']
	name: Scalars['String']
	org: Org
	provider: RepoProvider
	source: Scalars['String']
	sourceId: Scalars['String']
}

export type ProviderRepoFilter = {
	configured?: InputMaybe<Scalars['Boolean']>
	id?: InputMaybe<Array<InputMaybe<Scalars['ID']>>>
	name?: InputMaybe<Array<InputMaybe<Scalars['String']>>>
	org?: InputMaybe<Array<InputMaybe<Scalars['String']>>>
	provider?: InputMaybe<Array<InputMaybe<Scalars['ID']>>>
}

export type ProviderRepoOrder = {
	createdAt?: InputMaybe<SortOrder>
}

export type ProviderRepos = {
	__typename?: 'ProviderRepos'
	count: Scalars['Int']
	cursor: Cursor
	list: Array<ProviderRepo>
	one?: Maybe<ProviderRepo>
}

export type Query = {
	__typename?: 'Query'
	agent: Agents
	agentToken: AgentTokens
	build: Builds
	job: BuildJobs
	me?: Maybe<User>
	org: Orgs
	providerRepo: ProviderRepos
	repo: Repos
	step: BuildSteps
}

export type QueryagentArgs = {
	order?: InputMaybe<AgentOrder>
	skip?: InputMaybe<Scalars['Int']>
	take?: InputMaybe<Scalars['Int']>
	where?: InputMaybe<AgentFilter>
}

export type QueryagentTokenArgs = {
	order?: InputMaybe<AgentTokenOrder>
	skip?: InputMaybe<Scalars['Int']>
	take?: InputMaybe<Scalars['Int']>
	where?: InputMaybe<AgentTokenFilter>
}

export type QuerybuildArgs = {
	order?: InputMaybe<BuildOrder>
	skip?: InputMaybe<Scalars['Int']>
	take?: InputMaybe<Scalars['Int']>
	where?: InputMaybe<BuildFilter>
}

export type QueryjobArgs = {
	order?: InputMaybe<BuildJobOrder>
	skip?: InputMaybe<Scalars['Int']>
	take?: InputMaybe<Scalars['Int']>
	where?: InputMaybe<BuildJobFilter>
}

export type QueryorgArgs = {
	order?: InputMaybe<OrgOrder>
	skip?: InputMaybe<Scalars['Int']>
	take?: InputMaybe<Scalars['Int']>
	where?: InputMaybe<OrgFilter>
}

export type QueryproviderRepoArgs = {
	order?: InputMaybe<ProviderRepoOrder>
	skip?: InputMaybe<Scalars['Int']>
	take?: InputMaybe<Scalars['Int']>
	where?: InputMaybe<ProviderRepoFilter>
}

export type QueryrepoArgs = {
	order?: InputMaybe<RepoOrder>
	skip?: InputMaybe<Scalars['Int']>
	take?: InputMaybe<Scalars['Int']>
	where?: InputMaybe<RepoFilter>
}

export type QuerystepArgs = {
	order?: InputMaybe<BuildStepOrder>
	skip?: InputMaybe<Scalars['Int']>
	take?: InputMaybe<Scalars['Int']>
	where?: InputMaybe<BuildStepFilter>
}

export type Repo = {
	__typename?: 'Repo'
	builds: Array<Build>
	config?: Maybe<BuildConfig>
	configured: Scalars['Boolean']
	createdAt: Scalars['DateTime']
	defaultBranch: Scalars['String']
	id: Scalars['ID']
	lastActivity: Scalars['DateTime']
	org: Org
	path: Scalars['String']
	providerSource: Scalars['String']
	providerType: RepoProviderType
	public: Scalars['Boolean']
	slug: Scalars['String']
}

export type RepobuildsArgs = {
	order?: InputMaybe<BuildOrder>
	skip?: InputMaybe<Scalars['Int']>
	take?: InputMaybe<Scalars['Int']>
	where?: InputMaybe<BuildFilter>
}

export type RepoFilter = {
	dependsOn?: InputMaybe<StringFilter>
	id?: InputMaybe<StringFilter>
	org?: InputMaybe<Array<InputMaybe<Scalars['String']>>>
	path?: InputMaybe<StringFilter>
	provider?: InputMaybe<Array<InputMaybe<Scalars['ID']>>>
	providerSource?: InputMaybe<StringFilter>
	providerType?: InputMaybe<Array<InputMaybe<RepoProviderType>>>
	slug?: InputMaybe<StringFilter>
}

export type RepoImportMutation = {
	__typename?: 'RepoImportMutation'
	custom: Repo
	provider: Repo
}

export type RepoImportMutationcustomArgs = {
	defaultBranch: Scalars['String']
	name: Scalars['String']
	org: Scalars['String']
	source: Scalars['String']
}

export type RepoImportMutationproviderArgs = {
	provider: RepoProviderType
	source: Scalars['String']
}

export type RepoMutation = {
	__typename?: 'RepoMutation'
	import: RepoImportMutation
}

export type RepoOrder = {
	createdAt?: InputMaybe<SortOrder>
	lastActivity?: InputMaybe<SortOrder>
}

export type RepoProvider = {
	__typename?: 'RepoProvider'
	avatarUrl?: Maybe<Scalars['String']>
	createdAt: Scalars['DateTime']
	displayName: Scalars['String']
	id: Scalars['ID']
	key: Scalars['String']
	link: Scalars['String']
	org: Org
	repos: RepoProvidersRepos
	type: RepoProviderType
}

export enum RepoProviderType {
	Bitbucket = 'Bitbucket',
	Custom = 'Custom',
	GitHub = 'GitHub',
}

export type RepoProvidersRepos = {
	__typename?: 'RepoProvidersRepos'
	availableCount: Scalars['Int']
	availableRepos: Array<ProviderRepo>
	configuredCount: Scalars['Int']
	configuredRepos: Array<Repo>
}

export type RepoProvidersReposavailableReposArgs = {
	order?: InputMaybe<ProviderRepoOrder>
	skip?: InputMaybe<Scalars['Int']>
	take?: InputMaybe<Scalars['Int']>
	where?: InputMaybe<ProviderRepoFilter>
}

export type RepoProvidersReposconfiguredReposArgs = {
	order?: InputMaybe<RepoOrder>
	skip?: InputMaybe<Scalars['Int']>
	take?: InputMaybe<Scalars['Int']>
	where?: InputMaybe<RepoFilter>
}

export type Repos = {
	__typename?: 'Repos'
	count: Scalars['Int']
	cursor: Cursor
	list: Array<Repo>
	one?: Maybe<Repo>
}

export type RunConfigs = {
	linux: Scalars['String']
	macos: Scalars['String']
	source: Scalars['String']
	windows: Scalars['String']
}

export enum RunState {
	ConfigParsing = 'ConfigParsing',
	ConfigQueued = 'ConfigQueued',
	Done = 'Done',
	Error = 'Error',
	Pending = 'Pending',
	Running = 'Running',
}

export enum SortOrder {
	ASC = 'ASC',
	DESC = 'DESC',
}

export type StepAgentMutation = {
	__typename?: 'StepAgentMutation'
	complete: BuildStep
	start: BuildStep
}

export type StepAgentMutationcompleteArgs = {
	date: Scalars['DateTime']
	id: Scalars['String']
	success: Scalars['Boolean']
}

export type StepAgentMutationstartArgs = {
	date: Scalars['DateTime']
	id: Scalars['String']
}

export enum StepState {
	DependencyFailed = 'DependencyFailed',
	Done = 'Done',
	Error = 'Error',
	Pending = 'Pending',
	Running = 'Running',
	Waiting = 'Waiting',
}

export type StringFilter = {
	and?: InputMaybe<Array<StringFilter>>
	eq?: InputMaybe<Scalars['String']>
	gt?: InputMaybe<Scalars['String']>
	gte?: InputMaybe<Scalars['String']>
	lt?: InputMaybe<Scalars['String']>
	lte?: InputMaybe<Scalars['String']>
	not?: InputMaybe<StringFilter>
	null?: InputMaybe<Scalars['Boolean']>
	or?: InputMaybe<Array<StringFilter>>
}

export type TagFilter = {
	and?: InputMaybe<Array<TagFilter>>
	in?: InputMaybe<Array<Scalars['String']>>
	not?: InputMaybe<TagFilter>
	or?: InputMaybe<Array<TagFilter>>
}

export type User = {
	__typename?: 'User'
	avatarUrl?: Maybe<Scalars['String']>
	createdAt: Scalars['DateTime']
	displayName: Scalars['String']
	email: Scalars['String']
	id: Scalars['ID']
	invitations: OrgInvitations
	org: Org
	orgs: Array<Org>
}

export type UserinvitationsArgs = {
	order?: InputMaybe<OrgInvitationOrder>
	skip?: InputMaybe<Scalars['Int']>
	take?: InputMaybe<Scalars['Int']>
	where?: InputMaybe<OrgInvitationFilter>
}

export type UserFilter = {
	githubId?: InputMaybe<Array<InputMaybe<Scalars['String']>>>
	id?: InputMaybe<Array<InputMaybe<Scalars['ID']>>>
}

export type UserInvitationMutation = {
	__typename?: 'UserInvitationMutation'
	accept: UserInvitationUpdate
	decline: UserInvitationUpdate
}

export type UserInvitationMutationacceptArgs = {
	id: Scalars['String']
}

export type UserInvitationMutationdeclineArgs = {
	id: Scalars['String']
}

export type UserInvitationUpdate = {
	__typename?: 'UserInvitationUpdate'
	invitation: OrgInvitation
	user: User
}

export type UserOrder = {
	createdAt?: InputMaybe<SortOrder>
}

export type UserOrgMutation = {
	__typename?: 'UserOrgMutation'
	create: User
}

export type UserOrgMutationcreateArgs = {
	name: Scalars['String']
	slug: Scalars['String']
}

export type Users = {
	__typename?: 'Users'
	count: Scalars['Int']
	cursor: Cursor
	list: Array<User>
	one?: Maybe<User>
}

export type AcquireBuildMutationVariables = Exact<{ [key: string]: never }>

export type AcquireBuildMutation = {
	__typename?: 'Mutation'
	agent: {
		__typename?: 'AgentMutation'
		build: {
			__typename?: 'BuildAgentMutation'
			acquire?: {
				__typename?: 'Build'
				id: string
				sha: string
				branch: string
				number: number
				path: string
				user: { __typename?: 'BuildUser'; id: string; displayName: string }
				repo: {
					__typename?: 'Repo'
					id: string
					slug: string
					defaultBranch: string
					providerType: RepoProviderType
					providerSource: string
					org: { __typename?: 'Org'; id: string; slug: string }
				}
				dependencyOf?: {
					__typename?: 'Build'
					id: string
					sha: string
					branch: string
					repo: {
						__typename?: 'Repo'
						id: string
						defaultBranch: string
						providerType: RepoProviderType
						providerSource: string
					}
				} | null
			} | null
		}
	}
}

export type ConfigureBuildMutationVariables = Exact<{
	sha: Scalars['String']
	build: Scalars['ID']
	config: RunConfigs
	dependencies: Array<Scalars['String']> | Scalars['String']
}>

export type ConfigureBuildMutation = {
	__typename?: 'Mutation'
	agent: {
		__typename?: 'AgentMutation'
		build: {
			__typename?: 'BuildAgentMutation'
			configure?: { __typename?: 'Build'; id: string } | null
		}
	}
}

export type ConfigureBuildErrorMutationVariables = Exact<{
	build: Scalars['ID']
	error: Scalars['String']
	notFound?: InputMaybe<Scalars['Boolean']>
	sha?: InputMaybe<Scalars['String']>
}>

export type ConfigureBuildErrorMutation = {
	__typename?: 'Mutation'
	agent: {
		__typename?: 'AgentMutation'
		build: {
			__typename?: 'BuildAgentMutation'
			error?: { __typename?: 'Build'; id: string } | null
		}
	}
}

export type AgentStepFragment = {
	__typename?: 'BuildStep'
	id: string
	step: number
	command: Array<string>
	path: string
	name: string
	dependencies: Array<{ __typename?: 'BuildStep'; id: string }>
	env: Array<{
		__typename?: 'BuildStepEnv'
		name: string
		value: string
		secret: boolean
	}>
}

export type AgentJobFragment = {
	__typename?: 'BuildJob'
	id: string
	number: number
	path: string
	repo: {
		__typename?: 'Repo'
		id: string
		slug: string
		providerType: RepoProviderType
		providerSource: string
	}
	build: { __typename?: 'Build'; id: string; sha: string; branch: string }
	docker?: {
		__typename?: 'DockerOptions'
		image?: string | null
		file?: string | null
		context?: string | null
	} | null
	steps: Array<{
		__typename?: 'BuildStep'
		id: string
		step: number
		command: Array<string>
		path: string
		name: string
		dependencies: Array<{ __typename?: 'BuildStep'; id: string }>
		env: Array<{
			__typename?: 'BuildStepEnv'
			name: string
			value: string
			secret: boolean
		}>
	}>
}

export type AcquireJobMutationVariables = Exact<{ [key: string]: never }>

export type AcquireJobMutation = {
	__typename?: 'Mutation'
	agent: {
		__typename?: 'AgentMutation'
		job: {
			__typename?: 'JobAgentMutation'
			acquire?: {
				__typename?: 'BuildJob'
				id: string
				number: number
				path: string
				repo: {
					__typename?: 'Repo'
					id: string
					slug: string
					providerType: RepoProviderType
					providerSource: string
				}
				build: { __typename?: 'Build'; id: string; sha: string; branch: string }
				docker?: {
					__typename?: 'DockerOptions'
					image?: string | null
					file?: string | null
					context?: string | null
				} | null
				steps: Array<{
					__typename?: 'BuildStep'
					id: string
					step: number
					command: Array<string>
					path: string
					name: string
					dependencies: Array<{ __typename?: 'BuildStep'; id: string }>
					env: Array<{
						__typename?: 'BuildStepEnv'
						name: string
						value: string
						secret: boolean
					}>
				}>
			} | null
		}
	}
}

export type RegisterMutationVariables = Exact<{
	token: Scalars['String']
	name: Scalars['String']
	platform: AgentPlatform
	tags: Array<Scalars['String']> | Scalars['String']
}>

export type RegisterMutation = {
	__typename?: 'Mutation'
	agent: {
		__typename?: 'AgentMutation'
		register: {
			__typename?: 'AgentRegistration'
			token: string
			agent: {
				__typename?: 'Agent'
				id: string
				name: string
				tags: Array<string>
				org: { __typename?: 'Org'; slug: string }
			}
		}
	}
}

export type StartStepMutationVariables = Exact<{
	id: Scalars['String']
	date: Scalars['DateTime']
}>

export type StartStepMutation = {
	__typename?: 'Mutation'
	agent: {
		__typename?: 'AgentMutation'
		step: {
			__typename?: 'StepAgentMutation'
			start: { __typename?: 'BuildStep'; id: string }
		}
	}
}

export type CompleteStepMutationVariables = Exact<{
	id: Scalars['String']
	date: Scalars['DateTime']
	success: Scalars['Boolean']
}>

export type CompleteStepMutation = {
	__typename?: 'Mutation'
	agent: {
		__typename?: 'AgentMutation'
		step: {
			__typename?: 'StepAgentMutation'
			complete: { __typename?: 'BuildStep'; id: string }
		}
	}
}

export const AgentStepFragmentDoc = {
	kind: 'Document',
	definitions: [
		{
			kind: 'FragmentDefinition',
			name: { kind: 'Name', value: 'AgentStep' },
			typeCondition: {
				kind: 'NamedType',
				name: { kind: 'Name', value: 'BuildStep' },
			},
			selectionSet: {
				kind: 'SelectionSet',
				selections: [
					{ kind: 'Field', name: { kind: 'Name', value: 'id' } },
					{ kind: 'Field', name: { kind: 'Name', value: 'step' } },
					{ kind: 'Field', name: { kind: 'Name', value: 'command' } },
					{ kind: 'Field', name: { kind: 'Name', value: 'path' } },
					{ kind: 'Field', name: { kind: 'Name', value: 'name' } },
					{
						kind: 'Field',
						name: { kind: 'Name', value: 'dependencies' },
						selectionSet: {
							kind: 'SelectionSet',
							selections: [
								{ kind: 'Field', name: { kind: 'Name', value: 'id' } },
							],
						},
					},
					{
						kind: 'Field',
						name: { kind: 'Name', value: 'env' },
						selectionSet: {
							kind: 'SelectionSet',
							selections: [
								{ kind: 'Field', name: { kind: 'Name', value: 'name' } },
								{ kind: 'Field', name: { kind: 'Name', value: 'value' } },
								{ kind: 'Field', name: { kind: 'Name', value: 'secret' } },
							],
						},
					},
				],
			},
		},
	],
} as unknown as DocumentNode<AgentStepFragment, unknown>
export const AgentJobFragmentDoc = {
	kind: 'Document',
	definitions: [
		{
			kind: 'FragmentDefinition',
			name: { kind: 'Name', value: 'AgentJob' },
			typeCondition: {
				kind: 'NamedType',
				name: { kind: 'Name', value: 'BuildJob' },
			},
			selectionSet: {
				kind: 'SelectionSet',
				selections: [
					{ kind: 'Field', name: { kind: 'Name', value: 'id' } },
					{ kind: 'Field', name: { kind: 'Name', value: 'number' } },
					{ kind: 'Field', name: { kind: 'Name', value: 'path' } },
					{
						kind: 'Field',
						name: { kind: 'Name', value: 'repo' },
						selectionSet: {
							kind: 'SelectionSet',
							selections: [
								{ kind: 'Field', name: { kind: 'Name', value: 'id' } },
								{ kind: 'Field', name: { kind: 'Name', value: 'slug' } },
								{
									kind: 'Field',
									name: { kind: 'Name', value: 'providerType' },
								},
								{
									kind: 'Field',
									name: { kind: 'Name', value: 'providerSource' },
								},
							],
						},
					},
					{
						kind: 'Field',
						name: { kind: 'Name', value: 'build' },
						selectionSet: {
							kind: 'SelectionSet',
							selections: [
								{ kind: 'Field', name: { kind: 'Name', value: 'id' } },
								{ kind: 'Field', name: { kind: 'Name', value: 'sha' } },
								{ kind: 'Field', name: { kind: 'Name', value: 'branch' } },
							],
						},
					},
					{
						kind: 'Field',
						name: { kind: 'Name', value: 'docker' },
						selectionSet: {
							kind: 'SelectionSet',
							selections: [
								{ kind: 'Field', name: { kind: 'Name', value: 'image' } },
								{ kind: 'Field', name: { kind: 'Name', value: 'file' } },
								{ kind: 'Field', name: { kind: 'Name', value: 'context' } },
							],
						},
					},
					{
						kind: 'Field',
						name: { kind: 'Name', value: 'steps' },
						selectionSet: {
							kind: 'SelectionSet',
							selections: [
								{
									kind: 'FragmentSpread',
									name: { kind: 'Name', value: 'AgentStep' },
								},
							],
						},
					},
				],
			},
		},
		...AgentStepFragmentDoc.definitions,
	],
} as unknown as DocumentNode<AgentJobFragment, unknown>
export const AcquireBuildDocument = {
	kind: 'Document',
	definitions: [
		{
			kind: 'OperationDefinition',
			operation: 'mutation',
			name: { kind: 'Name', value: 'AcquireBuild' },
			selectionSet: {
				kind: 'SelectionSet',
				selections: [
					{
						kind: 'Field',
						name: { kind: 'Name', value: 'agent' },
						selectionSet: {
							kind: 'SelectionSet',
							selections: [
								{
									kind: 'Field',
									name: { kind: 'Name', value: 'build' },
									selectionSet: {
										kind: 'SelectionSet',
										selections: [
											{
												kind: 'Field',
												name: { kind: 'Name', value: 'acquire' },
												selectionSet: {
													kind: 'SelectionSet',
													selections: [
														{
															kind: 'Field',
															name: { kind: 'Name', value: 'id' },
														},
														{
															kind: 'Field',
															name: { kind: 'Name', value: 'sha' },
														},
														{
															kind: 'Field',
															name: { kind: 'Name', value: 'branch' },
														},
														{
															kind: 'Field',
															name: { kind: 'Name', value: 'number' },
														},
														{
															kind: 'Field',
															name: { kind: 'Name', value: 'path' },
														},
														{
															kind: 'Field',
															name: { kind: 'Name', value: 'user' },
															selectionSet: {
																kind: 'SelectionSet',
																selections: [
																	{
																		kind: 'Field',
																		name: { kind: 'Name', value: 'id' },
																	},
																	{
																		kind: 'Field',
																		name: {
																			kind: 'Name',
																			value: 'displayName',
																		},
																	},
																],
															},
														},
														{
															kind: 'Field',
															name: { kind: 'Name', value: 'repo' },
															selectionSet: {
																kind: 'SelectionSet',
																selections: [
																	{
																		kind: 'Field',
																		name: { kind: 'Name', value: 'id' },
																	},
																	{
																		kind: 'Field',
																		name: { kind: 'Name', value: 'slug' },
																	},
																	{
																		kind: 'Field',
																		name: {
																			kind: 'Name',
																			value: 'defaultBranch',
																		},
																	},
																	{
																		kind: 'Field',
																		name: {
																			kind: 'Name',
																			value: 'providerType',
																		},
																	},
																	{
																		kind: 'Field',
																		name: {
																			kind: 'Name',
																			value: 'providerSource',
																		},
																	},
																	{
																		kind: 'Field',
																		name: { kind: 'Name', value: 'org' },
																		selectionSet: {
																			kind: 'SelectionSet',
																			selections: [
																				{
																					kind: 'Field',
																					name: { kind: 'Name', value: 'id' },
																				},
																				{
																					kind: 'Field',
																					name: { kind: 'Name', value: 'slug' },
																				},
																			],
																		},
																	},
																],
															},
														},
														{
															kind: 'Field',
															name: { kind: 'Name', value: 'dependencyOf' },
															selectionSet: {
																kind: 'SelectionSet',
																selections: [
																	{
																		kind: 'Field',
																		name: { kind: 'Name', value: 'id' },
																	},
																	{
																		kind: 'Field',
																		name: { kind: 'Name', value: 'sha' },
																	},
																	{
																		kind: 'Field',
																		name: { kind: 'Name', value: 'branch' },
																	},
																	{
																		kind: 'Field',
																		name: { kind: 'Name', value: 'repo' },
																		selectionSet: {
																			kind: 'SelectionSet',
																			selections: [
																				{
																					kind: 'Field',
																					name: { kind: 'Name', value: 'id' },
																				},
																				{
																					kind: 'Field',
																					name: {
																						kind: 'Name',
																						value: 'defaultBranch',
																					},
																				},
																				{
																					kind: 'Field',
																					name: {
																						kind: 'Name',
																						value: 'providerType',
																					},
																				},
																				{
																					kind: 'Field',
																					name: {
																						kind: 'Name',
																						value: 'providerSource',
																					},
																				},
																			],
																		},
																	},
																],
															},
														},
													],
												},
											},
										],
									},
								},
							],
						},
					},
				],
			},
		},
	],
} as unknown as DocumentNode<
	AcquireBuildMutation,
	AcquireBuildMutationVariables
>
export const ConfigureBuildDocument = {
	kind: 'Document',
	definitions: [
		{
			kind: 'OperationDefinition',
			operation: 'mutation',
			name: { kind: 'Name', value: 'ConfigureBuild' },
			variableDefinitions: [
				{
					kind: 'VariableDefinition',
					variable: { kind: 'Variable', name: { kind: 'Name', value: 'sha' } },
					type: {
						kind: 'NonNullType',
						type: {
							kind: 'NamedType',
							name: { kind: 'Name', value: 'String' },
						},
					},
				},
				{
					kind: 'VariableDefinition',
					variable: {
						kind: 'Variable',
						name: { kind: 'Name', value: 'build' },
					},
					type: {
						kind: 'NonNullType',
						type: { kind: 'NamedType', name: { kind: 'Name', value: 'ID' } },
					},
				},
				{
					kind: 'VariableDefinition',
					variable: {
						kind: 'Variable',
						name: { kind: 'Name', value: 'config' },
					},
					type: {
						kind: 'NonNullType',
						type: {
							kind: 'NamedType',
							name: { kind: 'Name', value: 'RunConfigs' },
						},
					},
				},
				{
					kind: 'VariableDefinition',
					variable: {
						kind: 'Variable',
						name: { kind: 'Name', value: 'dependencies' },
					},
					type: {
						kind: 'NonNullType',
						type: {
							kind: 'ListType',
							type: {
								kind: 'NonNullType',
								type: {
									kind: 'NamedType',
									name: { kind: 'Name', value: 'String' },
								},
							},
						},
					},
				},
			],
			selectionSet: {
				kind: 'SelectionSet',
				selections: [
					{
						kind: 'Field',
						name: { kind: 'Name', value: 'agent' },
						selectionSet: {
							kind: 'SelectionSet',
							selections: [
								{
									kind: 'Field',
									name: { kind: 'Name', value: 'build' },
									selectionSet: {
										kind: 'SelectionSet',
										selections: [
											{
												kind: 'Field',
												name: { kind: 'Name', value: 'configure' },
												arguments: [
													{
														kind: 'Argument',
														name: { kind: 'Name', value: 'sha' },
														value: {
															kind: 'Variable',
															name: { kind: 'Name', value: 'sha' },
														},
													},
													{
														kind: 'Argument',
														name: { kind: 'Name', value: 'build' },
														value: {
															kind: 'Variable',
															name: { kind: 'Name', value: 'build' },
														},
													},
													{
														kind: 'Argument',
														name: { kind: 'Name', value: 'config' },
														value: {
															kind: 'Variable',
															name: { kind: 'Name', value: 'config' },
														},
													},
													{
														kind: 'Argument',
														name: { kind: 'Name', value: 'dependencies' },
														value: {
															kind: 'Variable',
															name: { kind: 'Name', value: 'dependencies' },
														},
													},
												],
												selectionSet: {
													kind: 'SelectionSet',
													selections: [
														{
															kind: 'Field',
															name: { kind: 'Name', value: 'id' },
														},
													],
												},
											},
										],
									},
								},
							],
						},
					},
				],
			},
		},
	],
} as unknown as DocumentNode<
	ConfigureBuildMutation,
	ConfigureBuildMutationVariables
>
export const ConfigureBuildErrorDocument = {
	kind: 'Document',
	definitions: [
		{
			kind: 'OperationDefinition',
			operation: 'mutation',
			name: { kind: 'Name', value: 'ConfigureBuildError' },
			variableDefinitions: [
				{
					kind: 'VariableDefinition',
					variable: {
						kind: 'Variable',
						name: { kind: 'Name', value: 'build' },
					},
					type: {
						kind: 'NonNullType',
						type: { kind: 'NamedType', name: { kind: 'Name', value: 'ID' } },
					},
				},
				{
					kind: 'VariableDefinition',
					variable: {
						kind: 'Variable',
						name: { kind: 'Name', value: 'error' },
					},
					type: {
						kind: 'NonNullType',
						type: {
							kind: 'NamedType',
							name: { kind: 'Name', value: 'String' },
						},
					},
				},
				{
					kind: 'VariableDefinition',
					variable: {
						kind: 'Variable',
						name: { kind: 'Name', value: 'notFound' },
					},
					type: { kind: 'NamedType', name: { kind: 'Name', value: 'Boolean' } },
				},
				{
					kind: 'VariableDefinition',
					variable: { kind: 'Variable', name: { kind: 'Name', value: 'sha' } },
					type: { kind: 'NamedType', name: { kind: 'Name', value: 'String' } },
				},
			],
			selectionSet: {
				kind: 'SelectionSet',
				selections: [
					{
						kind: 'Field',
						name: { kind: 'Name', value: 'agent' },
						selectionSet: {
							kind: 'SelectionSet',
							selections: [
								{
									kind: 'Field',
									name: { kind: 'Name', value: 'build' },
									selectionSet: {
										kind: 'SelectionSet',
										selections: [
											{
												kind: 'Field',
												name: { kind: 'Name', value: 'error' },
												arguments: [
													{
														kind: 'Argument',
														name: { kind: 'Name', value: 'build' },
														value: {
															kind: 'Variable',
															name: { kind: 'Name', value: 'build' },
														},
													},
													{
														kind: 'Argument',
														name: { kind: 'Name', value: 'error' },
														value: {
															kind: 'Variable',
															name: { kind: 'Name', value: 'error' },
														},
													},
													{
														kind: 'Argument',
														name: { kind: 'Name', value: 'notFound' },
														value: {
															kind: 'Variable',
															name: { kind: 'Name', value: 'notFound' },
														},
													},
													{
														kind: 'Argument',
														name: { kind: 'Name', value: 'sha' },
														value: {
															kind: 'Variable',
															name: { kind: 'Name', value: 'sha' },
														},
													},
												],
												selectionSet: {
													kind: 'SelectionSet',
													selections: [
														{
															kind: 'Field',
															name: { kind: 'Name', value: 'id' },
														},
													],
												},
											},
										],
									},
								},
							],
						},
					},
				],
			},
		},
	],
} as unknown as DocumentNode<
	ConfigureBuildErrorMutation,
	ConfigureBuildErrorMutationVariables
>
export const AcquireJobDocument = {
	kind: 'Document',
	definitions: [
		{
			kind: 'OperationDefinition',
			operation: 'mutation',
			name: { kind: 'Name', value: 'AcquireJob' },
			selectionSet: {
				kind: 'SelectionSet',
				selections: [
					{
						kind: 'Field',
						name: { kind: 'Name', value: 'agent' },
						selectionSet: {
							kind: 'SelectionSet',
							selections: [
								{
									kind: 'Field',
									name: { kind: 'Name', value: 'job' },
									selectionSet: {
										kind: 'SelectionSet',
										selections: [
											{
												kind: 'Field',
												name: { kind: 'Name', value: 'acquire' },
												selectionSet: {
													kind: 'SelectionSet',
													selections: [
														{
															kind: 'FragmentSpread',
															name: { kind: 'Name', value: 'AgentJob' },
														},
													],
												},
											},
										],
									},
								},
							],
						},
					},
				],
			},
		},
		...AgentJobFragmentDoc.definitions,
	],
} as unknown as DocumentNode<AcquireJobMutation, AcquireJobMutationVariables>
export const RegisterDocument = {
	kind: 'Document',
	definitions: [
		{
			kind: 'OperationDefinition',
			operation: 'mutation',
			name: { kind: 'Name', value: 'Register' },
			variableDefinitions: [
				{
					kind: 'VariableDefinition',
					variable: {
						kind: 'Variable',
						name: { kind: 'Name', value: 'token' },
					},
					type: {
						kind: 'NonNullType',
						type: {
							kind: 'NamedType',
							name: { kind: 'Name', value: 'String' },
						},
					},
				},
				{
					kind: 'VariableDefinition',
					variable: { kind: 'Variable', name: { kind: 'Name', value: 'name' } },
					type: {
						kind: 'NonNullType',
						type: {
							kind: 'NamedType',
							name: { kind: 'Name', value: 'String' },
						},
					},
				},
				{
					kind: 'VariableDefinition',
					variable: {
						kind: 'Variable',
						name: { kind: 'Name', value: 'platform' },
					},
					type: {
						kind: 'NonNullType',
						type: {
							kind: 'NamedType',
							name: { kind: 'Name', value: 'AgentPlatform' },
						},
					},
				},
				{
					kind: 'VariableDefinition',
					variable: { kind: 'Variable', name: { kind: 'Name', value: 'tags' } },
					type: {
						kind: 'NonNullType',
						type: {
							kind: 'ListType',
							type: {
								kind: 'NonNullType',
								type: {
									kind: 'NamedType',
									name: { kind: 'Name', value: 'String' },
								},
							},
						},
					},
				},
			],
			selectionSet: {
				kind: 'SelectionSet',
				selections: [
					{
						kind: 'Field',
						name: { kind: 'Name', value: 'agent' },
						selectionSet: {
							kind: 'SelectionSet',
							selections: [
								{
									kind: 'Field',
									name: { kind: 'Name', value: 'register' },
									arguments: [
										{
											kind: 'Argument',
											name: { kind: 'Name', value: 'token' },
											value: {
												kind: 'Variable',
												name: { kind: 'Name', value: 'token' },
											},
										},
										{
											kind: 'Argument',
											name: { kind: 'Name', value: 'name' },
											value: {
												kind: 'Variable',
												name: { kind: 'Name', value: 'name' },
											},
										},
										{
											kind: 'Argument',
											name: { kind: 'Name', value: 'platform' },
											value: {
												kind: 'Variable',
												name: { kind: 'Name', value: 'platform' },
											},
										},
										{
											kind: 'Argument',
											name: { kind: 'Name', value: 'tags' },
											value: {
												kind: 'Variable',
												name: { kind: 'Name', value: 'tags' },
											},
										},
									],
									selectionSet: {
										kind: 'SelectionSet',
										selections: [
											{ kind: 'Field', name: { kind: 'Name', value: 'token' } },
											{
												kind: 'Field',
												name: { kind: 'Name', value: 'agent' },
												selectionSet: {
													kind: 'SelectionSet',
													selections: [
														{
															kind: 'Field',
															name: { kind: 'Name', value: 'id' },
														},
														{
															kind: 'Field',
															name: { kind: 'Name', value: 'name' },
														},
														{
															kind: 'Field',
															name: { kind: 'Name', value: 'tags' },
														},
														{
															kind: 'Field',
															name: { kind: 'Name', value: 'org' },
															selectionSet: {
																kind: 'SelectionSet',
																selections: [
																	{
																		kind: 'Field',
																		name: { kind: 'Name', value: 'slug' },
																	},
																],
															},
														},
													],
												},
											},
										],
									},
								},
							],
						},
					},
				],
			},
		},
	],
} as unknown as DocumentNode<RegisterMutation, RegisterMutationVariables>
export const StartStepDocument = {
	kind: 'Document',
	definitions: [
		{
			kind: 'OperationDefinition',
			operation: 'mutation',
			name: { kind: 'Name', value: 'StartStep' },
			variableDefinitions: [
				{
					kind: 'VariableDefinition',
					variable: { kind: 'Variable', name: { kind: 'Name', value: 'id' } },
					type: {
						kind: 'NonNullType',
						type: {
							kind: 'NamedType',
							name: { kind: 'Name', value: 'String' },
						},
					},
				},
				{
					kind: 'VariableDefinition',
					variable: { kind: 'Variable', name: { kind: 'Name', value: 'date' } },
					type: {
						kind: 'NonNullType',
						type: {
							kind: 'NamedType',
							name: { kind: 'Name', value: 'DateTime' },
						},
					},
				},
			],
			selectionSet: {
				kind: 'SelectionSet',
				selections: [
					{
						kind: 'Field',
						name: { kind: 'Name', value: 'agent' },
						selectionSet: {
							kind: 'SelectionSet',
							selections: [
								{
									kind: 'Field',
									name: { kind: 'Name', value: 'step' },
									selectionSet: {
										kind: 'SelectionSet',
										selections: [
											{
												kind: 'Field',
												name: { kind: 'Name', value: 'start' },
												arguments: [
													{
														kind: 'Argument',
														name: { kind: 'Name', value: 'id' },
														value: {
															kind: 'Variable',
															name: { kind: 'Name', value: 'id' },
														},
													},
													{
														kind: 'Argument',
														name: { kind: 'Name', value: 'date' },
														value: {
															kind: 'Variable',
															name: { kind: 'Name', value: 'date' },
														},
													},
												],
												selectionSet: {
													kind: 'SelectionSet',
													selections: [
														{
															kind: 'Field',
															name: { kind: 'Name', value: 'id' },
														},
													],
												},
											},
										],
									},
								},
							],
						},
					},
				],
			},
		},
	],
} as unknown as DocumentNode<StartStepMutation, StartStepMutationVariables>
export const CompleteStepDocument = {
	kind: 'Document',
	definitions: [
		{
			kind: 'OperationDefinition',
			operation: 'mutation',
			name: { kind: 'Name', value: 'CompleteStep' },
			variableDefinitions: [
				{
					kind: 'VariableDefinition',
					variable: { kind: 'Variable', name: { kind: 'Name', value: 'id' } },
					type: {
						kind: 'NonNullType',
						type: {
							kind: 'NamedType',
							name: { kind: 'Name', value: 'String' },
						},
					},
				},
				{
					kind: 'VariableDefinition',
					variable: { kind: 'Variable', name: { kind: 'Name', value: 'date' } },
					type: {
						kind: 'NonNullType',
						type: {
							kind: 'NamedType',
							name: { kind: 'Name', value: 'DateTime' },
						},
					},
				},
				{
					kind: 'VariableDefinition',
					variable: {
						kind: 'Variable',
						name: { kind: 'Name', value: 'success' },
					},
					type: {
						kind: 'NonNullType',
						type: {
							kind: 'NamedType',
							name: { kind: 'Name', value: 'Boolean' },
						},
					},
				},
			],
			selectionSet: {
				kind: 'SelectionSet',
				selections: [
					{
						kind: 'Field',
						name: { kind: 'Name', value: 'agent' },
						selectionSet: {
							kind: 'SelectionSet',
							selections: [
								{
									kind: 'Field',
									name: { kind: 'Name', value: 'step' },
									selectionSet: {
										kind: 'SelectionSet',
										selections: [
											{
												kind: 'Field',
												name: { kind: 'Name', value: 'complete' },
												arguments: [
													{
														kind: 'Argument',
														name: { kind: 'Name', value: 'id' },
														value: {
															kind: 'Variable',
															name: { kind: 'Name', value: 'id' },
														},
													},
													{
														kind: 'Argument',
														name: { kind: 'Name', value: 'date' },
														value: {
															kind: 'Variable',
															name: { kind: 'Name', value: 'date' },
														},
													},
													{
														kind: 'Argument',
														name: { kind: 'Name', value: 'success' },
														value: {
															kind: 'Variable',
															name: { kind: 'Name', value: 'success' },
														},
													},
												],
												selectionSet: {
													kind: 'SelectionSet',
													selections: [
														{
															kind: 'Field',
															name: { kind: 'Name', value: 'id' },
														},
													],
												},
											},
										],
									},
								},
							],
						},
					},
				],
			},
		},
	],
} as unknown as DocumentNode<
	CompleteStepMutation,
	CompleteStepMutationVariables
>
