import { TypedDocumentNode as DocumentNode } from '@graphql-typed-document-node/core';
export declare type Maybe<T> = T | null;
export declare type InputMaybe<T> = Maybe<T>;
export declare type Exact<T extends {
    [key: string]: unknown;
}> = {
    [K in keyof T]: T[K];
};
export declare type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
    [SubKey in K]?: Maybe<T[SubKey]>;
};
export declare 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 declare 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 declare 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 declare type AgentjobsArgs = {
    order?: InputMaybe<BuildJobOrder>;
    skip?: InputMaybe<Scalars['Int']>;
    take?: InputMaybe<Scalars['Int']>;
    where?: InputMaybe<BuildJobFilter>;
};
export declare 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 declare type AgentMutation = {
    __typename?: 'AgentMutation';
    build: BuildAgentMutation;
    job: JobAgentMutation;
    register: AgentRegistration;
    step: StepAgentMutation;
};
export declare type AgentMutationregisterArgs = {
    name: Scalars['String'];
    platform: AgentPlatform;
    priority?: InputMaybe<Scalars['Int']>;
    tags?: InputMaybe<Array<Scalars['String']>>;
    token: Scalars['String'];
};
export declare type AgentOrder = {
    createdAt?: InputMaybe<SortOrder>;
    lastActivity?: InputMaybe<SortOrder>;
    priority?: InputMaybe<SortOrder>;
};
export declare enum AgentPlatform {
    Linux = "Linux",
    Windows = "Windows",
    macOS = "macOS"
}
export declare type AgentRegistration = {
    __typename?: 'AgentRegistration';
    agent: Agent;
    token: Scalars['String'];
};
export declare type AgentToken = {
    __typename?: 'AgentToken';
    createdAt: Scalars['DateTime'];
    default: Scalars['Boolean'];
    id: Scalars['ID'];
    name: Scalars['String'];
    org: Org;
    token: Scalars['String'];
};
export declare 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 declare type AgentTokenOrder = {
    createdAt?: InputMaybe<SortOrder>;
};
export declare type AgentTokens = {
    __typename?: 'AgentTokens';
    count: Scalars['Int'];
    cursor: Cursor;
    list: Array<AgentToken>;
    one?: Maybe<AgentToken>;
};
export declare type Agents = {
    __typename?: 'Agents';
    count: Scalars['Int'];
    cursor: Cursor;
    list: Array<Agent>;
    one?: Maybe<Agent>;
};
export declare 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 declare type AuthMutation = {
    __typename?: 'AuthMutation';
    signIn: User;
    signUp: User;
};
export declare type AuthMutationsignInArgs = {
    email: Scalars['String'];
    password: Scalars['String'];
    remember?: InputMaybe<Scalars['Boolean']>;
};
export declare type AuthMutationsignUpArgs = {
    email: Scalars['String'];
    password: Scalars['String'];
    remember?: InputMaybe<Scalars['Boolean']>;
};
export declare 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 declare type BuildAgentMutation = {
    __typename?: 'BuildAgentMutation';
    acquire?: Maybe<Build>;
    configure?: Maybe<Build>;
    error?: Maybe<Build>;
};
export declare type BuildAgentMutationconfigureArgs = {
    build: Scalars['ID'];
    config?: InputMaybe<RunConfigs>;
    dependencies: Array<Scalars['String']>;
    sha: Scalars['String'];
};
export declare type BuildAgentMutationerrorArgs = {
    build: Scalars['ID'];
    error: Scalars['String'];
    notFound?: InputMaybe<Scalars['Boolean']>;
    sha?: InputMaybe<Scalars['String']>;
};
export declare 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 declare type BuildErrors = {
    __typename?: 'BuildErrors';
    cancelled: Scalars['Boolean'];
    config?: Maybe<Scalars['String']>;
    configNotFound: Scalars['Boolean'];
};
export declare 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 declare 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 declare 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 declare type BuildJobOrder = {
    createdAt?: InputMaybe<SortOrder>;
};
export declare type BuildJobs = {
    __typename?: 'BuildJobs';
    count: Scalars['Int'];
    cursor: Cursor;
    list: Array<BuildJob>;
    one?: Maybe<BuildJob>;
};
export declare type BuildOrder = {
    createdAt?: InputMaybe<SortOrder>;
};
export declare 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 declare type BuildStepEnv = {
    __typename?: 'BuildStepEnv';
    name: Scalars['String'];
    secret: Scalars['Boolean'];
    value: Scalars['String'];
};
export declare 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 declare type BuildStepOrder = {
    createdAt?: InputMaybe<SortOrder>;
};
export declare type BuildSteps = {
    __typename?: 'BuildSteps';
    count: Scalars['Int'];
    cursor: Cursor;
    list: Array<BuildStep>;
    one?: Maybe<BuildStep>;
};
export declare 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 declare enum BuildUserProvider {
    Bitbucket = "Bitbucket",
    GitHub = "GitHub",
    Refloat = "Refloat"
}
export declare type Builds = {
    __typename?: 'Builds';
    count: Scalars['Int'];
    cursor: Cursor;
    list: Array<Build>;
    one?: Maybe<Build>;
};
export declare type CurrentUserMutation = {
    __typename?: 'CurrentUserMutation';
    invitation: UserInvitationMutation;
    org: UserOrgMutation;
    update: User;
};
export declare type CurrentUserMutationupdateArgs = {
    displayName?: InputMaybe<Scalars['String']>;
};
export declare type Cursor = {
    __typename?: 'Cursor';
    current?: Maybe<Scalars['String']>;
    next?: Maybe<Scalars['String']>;
};
export declare 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 declare type DockerOptions = {
    __typename?: 'DockerOptions';
    context?: Maybe<Scalars['String']>;
    file?: Maybe<Scalars['String']>;
    image?: Maybe<Scalars['String']>;
};
export declare 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 declare type JobAgentMutation = {
    __typename?: 'JobAgentMutation';
    acquire?: Maybe<BuildJob>;
};
export declare type Mutation = {
    __typename?: 'Mutation';
    agent: AgentMutation;
    auth: AuthMutation;
    me: CurrentUserMutation;
    org: OrgMutation;
    repo: RepoMutation;
    runBuild: Build;
};
export declare type MutationrunBuildArgs = {
    branch: Scalars['String'];
    message: Scalars['String'];
    org?: InputMaybe<Scalars['String']>;
    repo?: InputMaybe<Scalars['String']>;
    sha: Scalars['String'];
};
export declare 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 declare type OrginvitationsArgs = {
    order?: InputMaybe<OrgInvitationOrder>;
    skip?: InputMaybe<Scalars['Int']>;
    take?: InputMaybe<Scalars['Int']>;
    where?: InputMaybe<OrgInvitationFilter>;
};
export declare type OrgreposArgs = {
    order?: InputMaybe<RepoOrder>;
    skip?: InputMaybe<Scalars['Int']>;
    take?: InputMaybe<Scalars['Int']>;
    where?: InputMaybe<RepoFilter>;
};
export declare type OrgusersArgs = {
    order?: InputMaybe<UserOrder>;
    skip?: InputMaybe<Scalars['Int']>;
    take?: InputMaybe<Scalars['Int']>;
    where?: InputMaybe<UserFilter>;
};
export declare type OrgFilter = {
    id?: InputMaybe<Array<InputMaybe<Scalars['ID']>>>;
    slug?: InputMaybe<Array<InputMaybe<Scalars['String']>>>;
};
export declare type OrgInvitation = {
    __typename?: 'OrgInvitation';
    createdAt: Scalars['DateTime'];
    email: Scalars['String'];
    id: Scalars['ID'];
    org: Org;
    state: OrgInvitationState;
};
export declare type OrgInvitationFilter = {
    id?: InputMaybe<StringFilter>;
    mine?: InputMaybe<Scalars['Boolean']>;
    state?: InputMaybe<OrgInvitationStateFilter>;
};
export declare type OrgInvitationOrder = {
    createdAt?: InputMaybe<SortOrder>;
};
export declare enum OrgInvitationState {
    Accepted = "Accepted",
    Declined = "Declined",
    Pending = "Pending"
}
export declare type OrgInvitationStateFilter = {
    and?: InputMaybe<Array<OrgInvitationStateFilter>>;
    eq?: InputMaybe<OrgInvitationState>;
    not?: InputMaybe<OrgInvitationStateFilter>;
    or?: InputMaybe<Array<OrgInvitationStateFilter>>;
};
export declare type OrgInvitations = {
    __typename?: 'OrgInvitations';
    count: Scalars['Int'];
    cursor: Cursor;
    list: Array<OrgInvitation>;
    one?: Maybe<OrgInvitation>;
};
export declare type OrgMutation = {
    __typename?: 'OrgMutation';
    create: Org;
    users: OrgUsersMutation;
};
export declare type OrgMutationcreateArgs = {
    name: Scalars['String'];
    slug: Scalars['String'];
};
export declare type OrgOrder = {
    createdAt?: InputMaybe<SortOrder>;
};
export declare type OrgUsersMutation = {
    __typename?: 'OrgUsersMutation';
    invite: OrgInvitation;
    remove: Org;
};
export declare type OrgUsersMutationinviteArgs = {
    email: Scalars['String'];
    org: Scalars['String'];
};
export declare type OrgUsersMutationremoveArgs = {
    org: Scalars['String'];
    userId: Scalars['String'];
};
export declare type Orgs = {
    __typename?: 'Orgs';
    count: Scalars['Int'];
    cursor: Cursor;
    list: Array<Org>;
    one?: Maybe<Org>;
};
export declare type PlatformConfigs = {
    __typename?: 'PlatformConfigs';
    linux: Scalars['String'];
    macos: Scalars['String'];
    windows: Scalars['String'];
};
export declare 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 declare 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 declare type ProviderRepoOrder = {
    createdAt?: InputMaybe<SortOrder>;
};
export declare type ProviderRepos = {
    __typename?: 'ProviderRepos';
    count: Scalars['Int'];
    cursor: Cursor;
    list: Array<ProviderRepo>;
    one?: Maybe<ProviderRepo>;
};
export declare type Query = {
    __typename?: 'Query';
    agent: Agents;
    agentToken: AgentTokens;
    build: Builds;
    job: BuildJobs;
    me?: Maybe<User>;
    org: Orgs;
    providerRepo: ProviderRepos;
    repo: Repos;
    step: BuildSteps;
};
export declare type QueryagentArgs = {
    order?: InputMaybe<AgentOrder>;
    skip?: InputMaybe<Scalars['Int']>;
    take?: InputMaybe<Scalars['Int']>;
    where?: InputMaybe<AgentFilter>;
};
export declare type QueryagentTokenArgs = {
    order?: InputMaybe<AgentTokenOrder>;
    skip?: InputMaybe<Scalars['Int']>;
    take?: InputMaybe<Scalars['Int']>;
    where?: InputMaybe<AgentTokenFilter>;
};
export declare type QuerybuildArgs = {
    order?: InputMaybe<BuildOrder>;
    skip?: InputMaybe<Scalars['Int']>;
    take?: InputMaybe<Scalars['Int']>;
    where?: InputMaybe<BuildFilter>;
};
export declare type QueryjobArgs = {
    order?: InputMaybe<BuildJobOrder>;
    skip?: InputMaybe<Scalars['Int']>;
    take?: InputMaybe<Scalars['Int']>;
    where?: InputMaybe<BuildJobFilter>;
};
export declare type QueryorgArgs = {
    order?: InputMaybe<OrgOrder>;
    skip?: InputMaybe<Scalars['Int']>;
    take?: InputMaybe<Scalars['Int']>;
    where?: InputMaybe<OrgFilter>;
};
export declare type QueryproviderRepoArgs = {
    order?: InputMaybe<ProviderRepoOrder>;
    skip?: InputMaybe<Scalars['Int']>;
    take?: InputMaybe<Scalars['Int']>;
    where?: InputMaybe<ProviderRepoFilter>;
};
export declare type QueryrepoArgs = {
    order?: InputMaybe<RepoOrder>;
    skip?: InputMaybe<Scalars['Int']>;
    take?: InputMaybe<Scalars['Int']>;
    where?: InputMaybe<RepoFilter>;
};
export declare type QuerystepArgs = {
    order?: InputMaybe<BuildStepOrder>;
    skip?: InputMaybe<Scalars['Int']>;
    take?: InputMaybe<Scalars['Int']>;
    where?: InputMaybe<BuildStepFilter>;
};
export declare 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 declare type RepobuildsArgs = {
    order?: InputMaybe<BuildOrder>;
    skip?: InputMaybe<Scalars['Int']>;
    take?: InputMaybe<Scalars['Int']>;
    where?: InputMaybe<BuildFilter>;
};
export declare 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 declare type RepoImportMutation = {
    __typename?: 'RepoImportMutation';
    custom: Repo;
    provider: Repo;
};
export declare type RepoImportMutationcustomArgs = {
    defaultBranch: Scalars['String'];
    name: Scalars['String'];
    org: Scalars['String'];
    source: Scalars['String'];
};
export declare type RepoImportMutationproviderArgs = {
    provider: RepoProviderType;
    source: Scalars['String'];
};
export declare type RepoMutation = {
    __typename?: 'RepoMutation';
    import: RepoImportMutation;
};
export declare type RepoOrder = {
    createdAt?: InputMaybe<SortOrder>;
    lastActivity?: InputMaybe<SortOrder>;
};
export declare 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 declare enum RepoProviderType {
    Bitbucket = "Bitbucket",
    Custom = "Custom",
    GitHub = "GitHub"
}
export declare type RepoProvidersRepos = {
    __typename?: 'RepoProvidersRepos';
    availableCount: Scalars['Int'];
    availableRepos: Array<ProviderRepo>;
    configuredCount: Scalars['Int'];
    configuredRepos: Array<Repo>;
};
export declare type RepoProvidersReposavailableReposArgs = {
    order?: InputMaybe<ProviderRepoOrder>;
    skip?: InputMaybe<Scalars['Int']>;
    take?: InputMaybe<Scalars['Int']>;
    where?: InputMaybe<ProviderRepoFilter>;
};
export declare type RepoProvidersReposconfiguredReposArgs = {
    order?: InputMaybe<RepoOrder>;
    skip?: InputMaybe<Scalars['Int']>;
    take?: InputMaybe<Scalars['Int']>;
    where?: InputMaybe<RepoFilter>;
};
export declare type Repos = {
    __typename?: 'Repos';
    count: Scalars['Int'];
    cursor: Cursor;
    list: Array<Repo>;
    one?: Maybe<Repo>;
};
export declare type RunConfigs = {
    linux: Scalars['String'];
    macos: Scalars['String'];
    source: Scalars['String'];
    windows: Scalars['String'];
};
export declare enum RunState {
    ConfigParsing = "ConfigParsing",
    ConfigQueued = "ConfigQueued",
    Done = "Done",
    Error = "Error",
    Pending = "Pending",
    Running = "Running"
}
export declare enum SortOrder {
    ASC = "ASC",
    DESC = "DESC"
}
export declare type StepAgentMutation = {
    __typename?: 'StepAgentMutation';
    complete: BuildStep;
    start: BuildStep;
};
export declare type StepAgentMutationcompleteArgs = {
    date: Scalars['DateTime'];
    id: Scalars['String'];
    success: Scalars['Boolean'];
};
export declare type StepAgentMutationstartArgs = {
    date: Scalars['DateTime'];
    id: Scalars['String'];
};
export declare enum StepState {
    DependencyFailed = "DependencyFailed",
    Done = "Done",
    Error = "Error",
    Pending = "Pending",
    Running = "Running",
    Waiting = "Waiting"
}
export declare 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 declare type TagFilter = {
    and?: InputMaybe<Array<TagFilter>>;
    in?: InputMaybe<Array<Scalars['String']>>;
    not?: InputMaybe<TagFilter>;
    or?: InputMaybe<Array<TagFilter>>;
};
export declare 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 declare type UserinvitationsArgs = {
    order?: InputMaybe<OrgInvitationOrder>;
    skip?: InputMaybe<Scalars['Int']>;
    take?: InputMaybe<Scalars['Int']>;
    where?: InputMaybe<OrgInvitationFilter>;
};
export declare type UserFilter = {
    githubId?: InputMaybe<Array<InputMaybe<Scalars['String']>>>;
    id?: InputMaybe<Array<InputMaybe<Scalars['ID']>>>;
};
export declare type UserInvitationMutation = {
    __typename?: 'UserInvitationMutation';
    accept: UserInvitationUpdate;
    decline: UserInvitationUpdate;
};
export declare type UserInvitationMutationacceptArgs = {
    id: Scalars['String'];
};
export declare type UserInvitationMutationdeclineArgs = {
    id: Scalars['String'];
};
export declare type UserInvitationUpdate = {
    __typename?: 'UserInvitationUpdate';
    invitation: OrgInvitation;
    user: User;
};
export declare type UserOrder = {
    createdAt?: InputMaybe<SortOrder>;
};
export declare type UserOrgMutation = {
    __typename?: 'UserOrgMutation';
    create: User;
};
export declare type UserOrgMutationcreateArgs = {
    name: Scalars['String'];
    slug: Scalars['String'];
};
export declare type Users = {
    __typename?: 'Users';
    count: Scalars['Int'];
    cursor: Cursor;
    list: Array<User>;
    one?: Maybe<User>;
};
export declare type AcquireBuildMutationVariables = Exact<{
    [key: string]: never;
}>;
export declare 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 declare type ConfigureBuildMutationVariables = Exact<{
    sha: Scalars['String'];
    build: Scalars['ID'];
    config: RunConfigs;
    dependencies: Array<Scalars['String']> | Scalars['String'];
}>;
export declare type ConfigureBuildMutation = {
    __typename?: 'Mutation';
    agent: {
        __typename?: 'AgentMutation';
        build: {
            __typename?: 'BuildAgentMutation';
            configure?: {
                __typename?: 'Build';
                id: string;
            } | null;
        };
    };
};
export declare type ConfigureBuildErrorMutationVariables = Exact<{
    build: Scalars['ID'];
    error: Scalars['String'];
    notFound?: InputMaybe<Scalars['Boolean']>;
    sha?: InputMaybe<Scalars['String']>;
}>;
export declare type ConfigureBuildErrorMutation = {
    __typename?: 'Mutation';
    agent: {
        __typename?: 'AgentMutation';
        build: {
            __typename?: 'BuildAgentMutation';
            error?: {
                __typename?: 'Build';
                id: string;
            } | null;
        };
    };
};
export declare 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 declare 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 declare type AcquireJobMutationVariables = Exact<{
    [key: string]: never;
}>;
export declare 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 declare type RegisterMutationVariables = Exact<{
    token: Scalars['String'];
    name: Scalars['String'];
    platform: AgentPlatform;
    tags: Array<Scalars['String']> | Scalars['String'];
}>;
export declare 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 declare type StartStepMutationVariables = Exact<{
    id: Scalars['String'];
    date: Scalars['DateTime'];
}>;
export declare type StartStepMutation = {
    __typename?: 'Mutation';
    agent: {
        __typename?: 'AgentMutation';
        step: {
            __typename?: 'StepAgentMutation';
            start: {
                __typename?: 'BuildStep';
                id: string;
            };
        };
    };
};
export declare type CompleteStepMutationVariables = Exact<{
    id: Scalars['String'];
    date: Scalars['DateTime'];
    success: Scalars['Boolean'];
}>;
export declare type CompleteStepMutation = {
    __typename?: 'Mutation';
    agent: {
        __typename?: 'AgentMutation';
        step: {
            __typename?: 'StepAgentMutation';
            complete: {
                __typename?: 'BuildStep';
                id: string;
            };
        };
    };
};
export declare const AgentStepFragmentDoc: DocumentNode<AgentStepFragment, unknown>;
export declare const AgentJobFragmentDoc: DocumentNode<AgentJobFragment, unknown>;
export declare const AcquireBuildDocument: DocumentNode<AcquireBuildMutation, Exact<{
    [key: string]: never;
}>>;
export declare const ConfigureBuildDocument: DocumentNode<ConfigureBuildMutation, Exact<{
    sha: Scalars['String'];
    build: Scalars['ID'];
    config: RunConfigs;
    dependencies: Array<Scalars['String']> | Scalars['String'];
}>>;
export declare const ConfigureBuildErrorDocument: DocumentNode<ConfigureBuildErrorMutation, Exact<{
    build: Scalars['ID'];
    error: Scalars['String'];
    notFound?: InputMaybe<boolean> | undefined;
    sha?: InputMaybe<string> | undefined;
}>>;
export declare const AcquireJobDocument: DocumentNode<AcquireJobMutation, Exact<{
    [key: string]: never;
}>>;
export declare const RegisterDocument: DocumentNode<RegisterMutation, Exact<{
    token: Scalars['String'];
    name: Scalars['String'];
    platform: AgentPlatform;
    tags: Array<Scalars['String']> | Scalars['String'];
}>>;
export declare const StartStepDocument: DocumentNode<StartStepMutation, Exact<{
    id: Scalars['String'];
    date: Scalars['DateTime'];
}>>;
export declare const CompleteStepDocument: DocumentNode<CompleteStepMutation, Exact<{
    id: Scalars['String'];
    date: Scalars['DateTime'];
    success: Scalars['Boolean'];
}>>;
//# sourceMappingURL=schema.d.ts.map