@saucelabs/visual/build/index.d.ts

JS client bindings for Sauce Labs Visual

import * as arktype_dist_types_scopes_type from 'arktype/dist/types/scopes/type';
import { Type } from 'arktype';
import { TypedDocumentNode } from '@graphql-typed-document-node/core';
import { ApolloClient, NormalizedCacheObject } from '@apollo/client/core/index.js';

type Maybe<T> = T | null;
type InputMaybe<T> = Maybe<T>;
type Exact<T extends {
    [key: string]: unknown;
}> = {
    [K in keyof T]: T[K];
};
type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
    [SubKey in K]?: Maybe<T[SubKey]>;
};
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 */
type Scalars = {
    ID: string;
    String: string;
    Boolean: boolean;
    Int: number;
    Float: number;
    /** A location in a connection that can be used for resuming pagination. */
    Cursor: any;
    /**
     * A point in time as described by the [ISO
     * 8601](https://en.wikipedia.org/wiki/ISO_8601) standard. May or may not include a timezone.
     */
    Datetime: Date | string | number;
    FullText: any;
    /** The `JSON` scalar type represents JSON values as specified by [ECMA-404](http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf). */
    JSON: any;
    /** A universally unique identifier as defined by [RFC 4122](https://tools.ietf.org/html/rfc4122). */
    UUID: string;
    Void: any;
    WebdriverElementID: string;
    WebdriverSessionBlob: string;
};
type AddCommentIn = {
    action?: InputMaybe<CommentAction>;
    comment: Scalars['String'];
    diffId: Scalars['UUID'];
};
type ApplicationSummary = {
    __typename?: 'ApplicationSummary';
    id: Scalars['String'];
    name: Scalars['String'];
    version: Scalars['String'];
};
type ApproveBuildIn = {
    id?: InputMaybe<Scalars['UUID']>;
    onlyNew?: InputMaybe<Scalars['Boolean']>;
    /** @deprecated Use `id`. This field will be removed in a future update. */
    uuid?: InputMaybe<Scalars['UUID']>;
};
/**
 * A `Baseline` is what a `Snapshot` is compared to.
 *
 * For details see https://docs.saucelabs.com/visual-testing/sauce-visual/index.html#baseline-matching
 */
type Baseline = Node & {
    __typename?: 'Baseline';
    appId: Maybe<Scalars['String']>;
    appName: Maybe<Scalars['String']>;
    appVersion: Maybe<Scalars['String']>;
    branch: Maybe<Scalars['String']>;
    browser: Browser;
    browserVersion: Maybe<Scalars['String']>;
    /** Reads and enables pagination through a set of `Baseline`. */
    childBaselines: BaselinesConnection;
    createdAt: Scalars['Datetime'];
    createdByOrgId: Scalars['UUID'];
    createdByUser: User;
    createdByUserId: Scalars['UUID'];
    device: Maybe<Scalars['String']>;
    devicePixelRatio: Maybe<Scalars['Float']>;
    /** Reads and enables pagination through a set of `Diff`. */
    diffs: DiffsConnection;
    domFormat: DomFormat;
    hasDom: Scalars['Boolean'];
    height: Maybe<Scalars['Int']>;
    id: Scalars['UUID'];
    ignoreRegions: Array<Maybe<Region>>;
    imageUrl: Scalars['String'];
    isLatest: Scalars['Boolean'];
    latest: Baseline;
    metadata: Maybe<Scalars['JSON']>;
    name: Scalars['String'];
    /** A globally unique identifier. Can be used in various places throughout the system to identify this single value. */
    nodeId: Scalars['ID'];
    operatingSystem: OperatingSystem;
    operatingSystemVersion: Maybe<Scalars['String']>;
    /** Reads a single `Baseline` that is related to this `Baseline`. */
    parent: Maybe<Baseline>;
    parentId: Maybe<Scalars['UUID']>;
    project: Maybe<Scalars['String']>;
    /** Reads a single `Snapshot` that is related to this `Baseline`. */
    snapshot: Maybe<Snapshot>;
    snapshotId: Maybe<Scalars['UUID']>;
    suiteName: Maybe<Scalars['String']>;
    testName: Maybe<Scalars['String']>;
    thumbnailUrl: Scalars['String'];
    uiIgnoreRegions: Array<Maybe<Region>>;
    uploadId: Scalars['String'];
    userAgent: Maybe<Scalars['String']>;
    viewportHeight: Maybe<Scalars['Int']>;
    viewportWidth: Maybe<Scalars['Int']>;
    width: Maybe<Scalars['Int']>;
};
/**
 * A `Baseline` is what a `Snapshot` is compared to.
 *
 * For details see https://docs.saucelabs.com/visual-testing/sauce-visual/index.html#baseline-matching
 */
type BaselineChildBaselinesArgs = {
    after: InputMaybe<Scalars['Cursor']>;
    before: InputMaybe<Scalars['Cursor']>;
    condition: InputMaybe<BaselineCondition>;
    filter: InputMaybe<BaselineFilter>;
    first: InputMaybe<Scalars['Int']>;
    last: InputMaybe<Scalars['Int']>;
    offset: InputMaybe<Scalars['Int']>;
    orderBy?: InputMaybe<Array<BaselinesOrderBy>>;
};
/**
 * A `Baseline` is what a `Snapshot` is compared to.
 *
 * For details see https://docs.saucelabs.com/visual-testing/sauce-visual/index.html#baseline-matching
 */
type BaselineDiffsArgs = {
    after: InputMaybe<Scalars['Cursor']>;
    before: InputMaybe<Scalars['Cursor']>;
    condition: InputMaybe<DiffCondition>;
    filter: InputMaybe<DiffFilter>;
    first: InputMaybe<Scalars['Int']>;
    last: InputMaybe<Scalars['Int']>;
    offset: InputMaybe<Scalars['Int']>;
    orderBy?: InputMaybe<Array<DiffsOrderBy>>;
};
/**
 * A condition to be used against `Baseline` object types. All fields are tested
 * for equality and combined with a logical ‘and.’
 */
type BaselineCondition = {
    /** Checks for equality with the object’s `branch` field. */
    branch?: InputMaybe<Scalars['String']>;
    /** Checks for equality with the object’s `createdAt` field. */
    createdAt?: InputMaybe<Scalars['Datetime']>;
    /** Checks for equality with the object’s `createdByOrgId` field. */
    createdByOrgId?: InputMaybe<Scalars['UUID']>;
    /** Checks for equality with the object’s `createdByUserId` field. */
    createdByUserId?: InputMaybe<Scalars['UUID']>;
    /** Checks for equality with the object’s `id` field. */
    id?: InputMaybe<Scalars['UUID']>;
    /** Checks for equality with the object’s `parentId` field. */
    parentId?: InputMaybe<Scalars['UUID']>;
    /** Checks for equality with the object’s `project` field. */
    project?: InputMaybe<Scalars['String']>;
    /** Checks for equality with the object’s `snapshotId` field. */
    snapshotId?: InputMaybe<Scalars['UUID']>;
};
/** A filter to be used against `Baseline` object types. All fields are combined with a logical ‘and.’ */
type BaselineFilter = {
    /** Filter by the object’s `branch` field. */
    branch?: InputMaybe<StringFilter>;
    /** Filter by the object’s `createdAt` field. */
    createdAt?: InputMaybe<DatetimeFilter>;
    /** Filter by the object’s `createdByOrgId` field. */
    createdByOrgId?: InputMaybe<UuidFilter>;
    /** Filter by the object’s `createdByUserId` field. */
    createdByUserId?: InputMaybe<UuidFilter>;
    /** Filter by the object’s `id` field. */
    id?: InputMaybe<UuidFilter>;
    /** Filter by the object’s `parentId` field. */
    parentId?: InputMaybe<UuidFilter>;
    /** Filter by the object’s `project` field. */
    project?: InputMaybe<StringFilter>;
    /** Filter by the object’s `snapshotId` field. */
    snapshotId?: InputMaybe<UuidFilter>;
};
/** One or more values from 'SnapshotIn' we should use as an override when finding a baseline. */
type BaselineOverrideIn = {
    browser?: InputMaybe<Browser>;
    browserVersion?: InputMaybe<Scalars['String']>;
    device?: InputMaybe<Scalars['String']>;
    name?: InputMaybe<Scalars['String']>;
    operatingSystem?: InputMaybe<OperatingSystem>;
    operatingSystemVersion?: InputMaybe<Scalars['String']>;
    suiteName?: InputMaybe<Scalars['String']>;
    testName?: InputMaybe<Scalars['String']>;
};
/** A connection to a list of `Baseline` values. */
type BaselinesConnection = {
    __typename?: 'BaselinesConnection';
    /** A list of edges which contains the `Baseline` and cursor to aid in pagination. */
    edges: Array<BaselinesEdge>;
    /** A list of `Baseline` objects. */
    nodes: Array<Baseline>;
    /** Information to aid in pagination. */
    pageInfo: PageInfo;
    /** The count of *all* `Baseline` you could get from the connection. */
    totalCount: Scalars['Int'];
};
/** A `Baseline` edge in the connection. */
type BaselinesEdge = {
    __typename?: 'BaselinesEdge';
    /** A cursor for use in pagination. */
    cursor: Maybe<Scalars['Cursor']>;
    /** The `Baseline` at the end of the edge. */
    node: Baseline;
};
/** Methods to use when ordering `Baseline`. */
declare enum BaselinesOrderBy {
    BranchAsc = "BRANCH_ASC",
    BranchDesc = "BRANCH_DESC",
    CreatedAtAsc = "CREATED_AT_ASC",
    CreatedAtDesc = "CREATED_AT_DESC",
    CreatedByOrgIdAsc = "CREATED_BY_ORG_ID_ASC",
    CreatedByOrgIdDesc = "CREATED_BY_ORG_ID_DESC",
    CreatedByUserIdAsc = "CREATED_BY_USER_ID_ASC",
    CreatedByUserIdDesc = "CREATED_BY_USER_ID_DESC",
    IdAsc = "ID_ASC",
    IdDesc = "ID_DESC",
    Natural = "NATURAL",
    ParentIdAsc = "PARENT_ID_ASC",
    ParentIdDesc = "PARENT_ID_DESC",
    PrimaryKeyAsc = "PRIMARY_KEY_ASC",
    PrimaryKeyDesc = "PRIMARY_KEY_DESC",
    ProjectAsc = "PROJECT_ASC",
    ProjectDesc = "PROJECT_DESC",
    SnapshotIdAsc = "SNAPSHOT_ID_ASC",
    SnapshotIdDesc = "SNAPSHOT_ID_DESC"
}
type Branch = Node & {
    __typename?: 'Branch';
    baselines: BaselinesConnection;
    /** Returns the differents values availables for attributes. */
    distinctAttributeValues: DistinctAttributeValues;
    id: Scalars['String'];
    lastUsed: Scalars['Datetime'];
    name: Maybe<Scalars['String']>;
    /** A globally unique identifier. Can be used in various places throughout the system to identify this single value. */
    nodeId: Scalars['ID'];
    /** Reads a single `Project` that is related to this `Branch`. */
    project: Maybe<Project>;
    projectId: Scalars['String'];
};
type BranchBaselinesArgs = {
    after: InputMaybe<Scalars['Cursor']>;
    before: InputMaybe<Scalars['Cursor']>;
    condition: InputMaybe<BaselineCondition>;
    filter: InputMaybe<BaselineFilter>;
    filters: InputMaybe<SnapshotFiltersIn>;
    first: InputMaybe<Scalars['Int']>;
    last: InputMaybe<Scalars['Int']>;
    offset: InputMaybe<Scalars['Int']>;
    orderBy?: InputMaybe<Array<BaselinesOrderBy>>;
};
/** A connection to a list of `Branch` values. */
type BranchesConnection = {
    __typename?: 'BranchesConnection';
    /** A list of edges which contains the `Branch` and cursor to aid in pagination. */
    edges: Array<BranchesEdge>;
    /** A list of `Branch` objects. */
    nodes: Array<Branch>;
    /** Information to aid in pagination. */
    pageInfo: PageInfo;
    /** The count of *all* `Branch` you could get from the connection. */
    totalCount: Scalars['Int'];
};
/** A `Branch` edge in the connection. */
type BranchesEdge = {
    __typename?: 'BranchesEdge';
    /** A cursor for use in pagination. */
    cursor: Maybe<Scalars['Cursor']>;
    /** The `Branch` at the end of the edge. */
    node: Branch;
};
/** Methods to use when ordering `Branch`. */
declare enum BranchesOrderBy {
    Natural = "NATURAL",
    PrimaryKeyAsc = "PRIMARY_KEY_ASC",
    PrimaryKeyDesc = "PRIMARY_KEY_DESC"
}
declare enum Browser {
    Chrome = "CHROME",
    Edge = "EDGE",
    Firefox = "FIREFOX",
    None = "NONE",
    PlaywrightWebkit = "PLAYWRIGHT_WEBKIT",
    Safari = "SAFARI"
}
/** The result of diffing a `Baseline` with a `Snapshot`. */
type Build = Node & {
    __typename?: 'Build';
    branch: Maybe<Scalars['String']>;
    commentCount: Maybe<Scalars['Int']>;
    createdAt: Scalars['Datetime'];
    createdByOrgId: Scalars['UUID'];
    createdByUser: User;
    createdByUserId: Scalars['UUID'];
    /**
     * User provided id for a build.
     *
     * Use `buildByCustomId` to look up a build by its `customId`.
     *
     * Properties:
     * - up to 64 bytes (try to stick to ASCII characters)
     * - in case of colissions, the latest build is returned
     * - collissions may hurt query performance
     *
     * Recommendations:
     * - generate the id from the CI pipeline link by applying a hashing function
     * - prefix/postfix the id with a team id to avoid collisions with other teams, e.g. `sha512(teamId + ':' + url)`
     */
    customId: Maybe<Scalars['String']>;
    defaultBranch: Maybe<Scalars['String']>;
    /** @deprecated Use diffCountExtended. This will be removed by 2024-02-11. */
    diffCount: Scalars['Int'];
    /**
     * Returns the number of diffs in a build that have a specific status.
     *
     * E.g. to get the number of "new" snapshots use `{ status: UNAPPROVED, withBaseline: false}`
     */
    diffCountExtended: Scalars['Int'];
    /** Reads and enables pagination through a set of `Diff`. */
    diffs: DiffsConnection;
    diffsPaginated: DiffsConnection;
    /** Returns the differents values availables for attributes. */
    distinctAttributeValues: DistinctAttributeValues;
    /**
     * If not null, it indicates that the build encountered an error.
     *
     * By convention, the following errors exist:
     * - `{"code": "TIMEOUT"}`: The build timed out, because `finishBuild` was not called.
     * - `{"code": "DIFF_TIMEOUT"}`: At least one diff could not be computed within the time limit.
     *
     * Other error types may exist and the frontend should display a generic error message
     * together with the JSON contents of `error`.
     */
    error: Maybe<Scalars['JSON']>;
    finishAfter: Maybe<Scalars['Datetime']>;
    /** Full-text search ranking when filtered by `fullText`. */
    fullTextRank: Maybe<Scalars['Float']>;
    id: Scalars['UUID'];
    keepAliveTimeout: Maybe<Scalars['Int']>;
    mode: BuildMode;
    name: Scalars['String'];
    /** A globally unique identifier. Can be used in various places throughout the system to identify this single value. */
    nodeId: Scalars['ID'];
    openSessions: Maybe<Scalars['Int']>;
    owningTeamId: Scalars['UUID'];
    project: Maybe<Scalars['String']>;
    /** Reads and enables pagination through a set of `Snapshot`. */
    snapshots: SnapshotsConnection;
    status: BuildStatus;
    url: Scalars['String'];
};
/** The result of diffing a `Baseline` with a `Snapshot`. */
type BuildDiffCountArgs = {
    status: DiffStatus;
};
/** The result of diffing a `Baseline` with a `Snapshot`. */
type BuildDiffCountExtendedArgs = {
    input: DiffCountIn;
};
/** The result of diffing a `Baseline` with a `Snapshot`. */
type BuildDiffsArgs = {
    after: InputMaybe<Scalars['Cursor']>;
    before: InputMaybe<Scalars['Cursor']>;
    condition: InputMaybe<DiffCondition>;
    filter: InputMaybe<DiffFilter>;
    first: InputMaybe<Scalars['Int']>;
    last: InputMaybe<Scalars['Int']>;
    offset: InputMaybe<Scalars['Int']>;
    orderBy?: InputMaybe<Array<DiffsOrderBy>>;
};
/** The result of diffing a `Baseline` with a `Snapshot`. */
type BuildDiffsPaginatedArgs = {
    after: InputMaybe<Scalars['Cursor']>;
    before: InputMaybe<Scalars['Cursor']>;
    condition: InputMaybe<DiffCondition>;
    filter: InputMaybe<DiffFilter>;
    filters: InputMaybe<DiffFiltersIn>;
    first: InputMaybe<Scalars['Int']>;
    last: InputMaybe<Scalars['Int']>;
    offset: InputMaybe<Scalars['Int']>;
    orderBy?: InputMaybe<Array<DiffsOrderBy>>;
};
/** The result of diffing a `Baseline` with a `Snapshot`. */
type BuildSnapshotsArgs = {
    after: InputMaybe<Scalars['Cursor']>;
    before: InputMaybe<Scalars['Cursor']>;
    condition: InputMaybe<SnapshotCondition>;
    filter: InputMaybe<SnapshotFilter>;
    first: InputMaybe<Scalars['Int']>;
    last: InputMaybe<Scalars['Int']>;
    offset: InputMaybe<Scalars['Int']>;
    orderBy?: InputMaybe<Array<SnapshotsOrderBy>>;
};
/** A condition to be used against `Build` object types. All fields are tested for equality and combined with a logical ‘and.’ */
type BuildCondition = {
    /** Checks for equality with the object’s `branch` field. */
    branch?: InputMaybe<Scalars['String']>;
    /** Checks for equality with the object’s `createdAt` field. */
    createdAt?: InputMaybe<Scalars['Datetime']>;
    /** Checks for equality with the object’s `createdByOrgId` field. */
    createdByOrgId?: InputMaybe<Scalars['UUID']>;
    /** Checks for equality with the object’s `createdByUserId` field. */
    createdByUserId?: InputMaybe<Scalars['UUID']>;
    /** Checks for equality with the object’s `fullText` field. */
    fullText?: InputMaybe<Scalars['FullText']>;
    /** Checks for equality with the object’s `id` field. */
    id?: InputMaybe<Scalars['UUID']>;
    /** Checks for equality with the object’s `owningTeamId` field. */
    owningTeamId?: InputMaybe<Scalars['UUID']>;
    /** Checks for equality with the object’s `project` field. */
    project?: InputMaybe<Scalars['String']>;
    /** Checks for equality with the object’s `status` field. */
    status?: InputMaybe<BuildStatus>;
};
/** A filter to be used against `Build` object types. All fields are combined with a logical ‘and.’ */
type BuildFilter = {
    /** Filter by the object’s `branch` field. */
    branch?: InputMaybe<StringFilter>;
    /** Filter by the object’s `createdAt` field. */
    createdAt?: InputMaybe<DatetimeFilter>;
    /** Filter by the object’s `createdByOrgId` field. */
    createdByOrgId?: InputMaybe<UuidFilter>;
    /** Filter by the object’s `createdByUserId` field. */
    createdByUserId?: InputMaybe<UuidFilter>;
    /** Filter by the object’s `fullText` field. */
    fullText?: InputMaybe<FullTextFilter>;
    /** Filter by the object’s `id` field. */
    id?: InputMaybe<UuidFilter>;
    /** Filter by the object’s `owningTeamId` field. */
    owningTeamId?: InputMaybe<UuidFilter>;
    /** Filter by the object’s `project` field. */
    project?: InputMaybe<StringFilter>;
    /** Filter by the object’s `status` field. */
    status?: InputMaybe<BuildStatusFilter>;
};
type BuildIn = {
    branch?: InputMaybe<Scalars['String']>;
    customId?: InputMaybe<Scalars['String']>;
    defaultBranch?: InputMaybe<Scalars['String']>;
    /**
     * A positive integer that is the time in seconds that the Build is allowed to be in the RUNNING state after the last snapshot was created or updated.
     * The number clipped to the interval [1;86400].
     */
    keepAliveTimeout?: InputMaybe<Scalars['Int']>;
    name?: InputMaybe<Scalars['String']>;
    project?: InputMaybe<Scalars['String']>;
};
declare enum BuildMode {
    Completed = "COMPLETED",
    Running = "RUNNING"
}
/**
 * Lifecycle status of a `Build`.
 *
 * 1. A new `Build` is always in `RUNNING` state.
 * 2. When the `finishBuild` mutation was called, its state is as follows:
 *    - `ERRORED` if build.error is not null or else
 *    - `EMPTY` if there are no Diffs in the Build or else
 *    - `RUNNING` if any Diff in the Build is QUEUED or else
 *    - `ERRORED` if any Diff in the Build is ERRORED or else
 *    - `UNAPPROVED` if any Diff in the Build is UNAPPROVED or else
 *    - `REJECTED` if any Diff in the Build is REJECTED or else
 *    - `APPROVED` if any Diff in the Build is APPROVED and
 *    - `EQUAL` in any other case
 *
 * When `finishBuild` is not called, the build will time out and end up in the `ERRORED` state.
 */
declare enum BuildStatus {
    Approved = "APPROVED",
    Empty = "EMPTY",
    Equal = "EQUAL",
    Errored = "ERRORED",
    Queued = "QUEUED",
    Rejected = "REJECTED",
    Running = "RUNNING",
    Unapproved = "UNAPPROVED"
}
/** A filter to be used against BuildStatus fields. All fields are combined with a logical ‘and.’ */
type BuildStatusFilter = {
    /** Greater than the specified value. */
    greaterThan?: InputMaybe<BuildStatus>;
    /** Greater than or equal to the specified value. */
    greaterThanOrEqualTo?: InputMaybe<BuildStatus>;
    /** Included in the specified list. */
    in?: InputMaybe<Array<BuildStatus>>;
    /** Is null (if `true` is specified) or is not null (if `false` is specified). */
    isNull?: InputMaybe<Scalars['Boolean']>;
    /** Less than the specified value. */
    lessThan?: InputMaybe<BuildStatus>;
    /** Less than or equal to the specified value. */
    lessThanOrEqualTo?: InputMaybe<BuildStatus>;
};
/** A connection to a list of `Build` values. */
type BuildsConnection = {
    __typename?: 'BuildsConnection';
    /** A list of edges which contains the `Build` and cursor to aid in pagination. */
    edges: Array<BuildsEdge>;
    /** A list of `Build` objects. */
    nodes: Array<Build>;
    /** Information to aid in pagination. */
    pageInfo: PageInfo;
    /** The count of *all* `Build` you could get from the connection. */
    totalCount: Scalars['Int'];
};
/** A `Build` edge in the connection. */
type BuildsEdge = {
    __typename?: 'BuildsEdge';
    /** A cursor for use in pagination. */
    cursor: Maybe<Scalars['Cursor']>;
    /** The `Build` at the end of the edge. */
    node: Build;
};
/** Methods to use when ordering `Build`. */
declare enum BuildsOrderBy {
    BranchAsc = "BRANCH_ASC",
    BranchDesc = "BRANCH_DESC",
    CreatedAtAsc = "CREATED_AT_ASC",
    CreatedAtDesc = "CREATED_AT_DESC",
    CreatedByOrgIdAsc = "CREATED_BY_ORG_ID_ASC",
    CreatedByOrgIdAscCustomIdAsc = "CREATED_BY_ORG_ID_ASC__CUSTOM_ID_ASC",
    CreatedByOrgIdDesc = "CREATED_BY_ORG_ID_DESC",
    CreatedByOrgIdDescCustomIdDesc = "CREATED_BY_ORG_ID_DESC__CUSTOM_ID_DESC",
    CreatedByUserIdAsc = "CREATED_BY_USER_ID_ASC",
    CreatedByUserIdDesc = "CREATED_BY_USER_ID_DESC",
    IdAsc = "ID_ASC",
    IdDesc = "ID_DESC",
    Natural = "NATURAL",
    OwningTeamIdAsc = "OWNING_TEAM_ID_ASC",
    OwningTeamIdDesc = "OWNING_TEAM_ID_DESC",
    PrimaryKeyAsc = "PRIMARY_KEY_ASC",
    PrimaryKeyDesc = "PRIMARY_KEY_DESC",
    ProjectAsc = "PROJECT_ASC",
    ProjectDesc = "PROJECT_DESC",
    StatusAsc = "STATUS_ASC",
    StatusDesc = "STATUS_DESC"
}
type Comment = Node & {
    __typename?: 'Comment';
    action: Maybe<CommentAction>;
    comment: Scalars['String'];
    createdAt: Scalars['Datetime'];
    createdByOrgId: Scalars['UUID'];
    createdByUser: User;
    createdByUserId: Scalars['UUID'];
    /** Reads a single `Diff` that is related to this `Comment`. */
    diff: Maybe<Diff>;
    diffId: Scalars['UUID'];
    id: Scalars['UUID'];
    /** A globally unique identifier. Can be used in various places throughout the system to identify this single value. */
    nodeId: Scalars['ID'];
    updatedAt: Maybe<Scalars['Datetime']>;
};
declare enum CommentAction {
    Approved = "APPROVED",
    Rejected = "REJECTED",
    Unapproved = "UNAPPROVED",
    Unrejected = "UNREJECTED"
}
/** A condition to be used against `Comment` object types. All fields are tested for equality and combined with a logical ‘and.’ */
type CommentCondition = {
    /** Checks for equality with the object’s `createdAt` field. */
    createdAt?: InputMaybe<Scalars['Datetime']>;
    /** Checks for equality with the object’s `diffId` field. */
    diffId?: InputMaybe<Scalars['UUID']>;
    /** Checks for equality with the object’s `id` field. */
    id?: InputMaybe<Scalars['UUID']>;
};
/** A filter to be used against `Comment` object types. All fields are combined with a logical ‘and.’ */
type CommentFilter = {
    /** Filter by the object’s `createdAt` field. */
    createdAt?: InputMaybe<DatetimeFilter>;
    /** Filter by the object’s `diffId` field. */
    diffId?: InputMaybe<UuidFilter>;
    /** Filter by the object’s `id` field. */
    id?: InputMaybe<UuidFilter>;
};
/** A connection to a list of `Comment` values. */
type CommentsConnection = {
    __typename?: 'CommentsConnection';
    /** A list of edges which contains the `Comment` and cursor to aid in pagination. */
    edges: Array<CommentsEdge>;
    /** A list of `Comment` objects. */
    nodes: Array<Comment>;
    /** Information to aid in pagination. */
    pageInfo: PageInfo;
    /** The count of *all* `Comment` you could get from the connection. */
    totalCount: Scalars['Int'];
};
/** A `Comment` edge in the connection. */
type CommentsEdge = {
    __typename?: 'CommentsEdge';
    /** A cursor for use in pagination. */
    cursor: Maybe<Scalars['Cursor']>;
    /** The `Comment` at the end of the edge. */
    node: Comment;
};
/** Methods to use when ordering `Comment`. */
declare enum CommentsOrderBy {
    CreatedAtAsc = "CREATED_AT_ASC",
    CreatedAtDesc = "CREATED_AT_DESC",
    DiffIdAsc = "DIFF_ID_ASC",
    DiffIdDesc = "DIFF_ID_DESC",
    IdAsc = "ID_ASC",
    IdDesc = "ID_DESC",
    Natural = "NATURAL",
    PrimaryKeyAsc = "PRIMARY_KEY_ASC",
    PrimaryKeyDesc = "PRIMARY_KEY_DESC"
}
type CreateDerivedBaselinesIn = {
    baselineIds: Array<Scalars['UUID']>;
    onlyApplyIfIsLatest?: InputMaybe<Scalars['Boolean']>;
    uiIgnoreRegions?: InputMaybe<Array<RegionIn>>;
};
type CreateSnapshotFromWebDriverIn = {
    /**
     * One or more overrides for locating the matching baseline. Can be used for cross browser / OS
     * visual testing.
     */
    baselineOverride?: InputMaybe<BaselineOverrideIn>;
    buildId?: InputMaybe<Scalars['UUID']>;
    /** @deprecated Use `buildId`. This field will be removed in a future update. */
    buildUuid?: InputMaybe<Scalars['UUID']>;
    captureDom?: InputMaybe<Scalars['Boolean']>;
    /** The selenium ID of an element we should clip the screen to. */
    clipElement?: InputMaybe<Scalars['WebdriverElementID']>;
    /** @deprecated(reason: "clipElement should be used instead.") */
    clipSelector?: InputMaybe<Scalars['String']>;
    diffingMethod?: InputMaybe<DiffingMethod>;
    diffingOptions?: InputMaybe<DiffingOptionsIn>;
    /** Enable full page screenshot using scroll-and-stitch strategy. */
    fullPageConfig?: InputMaybe<FullPageConfigIn>;
    /** Hide all scrollbars in the app. */
    hideScrollBars?: InputMaybe<Scalars['Boolean']>;
    ignoreElements?: InputMaybe<Array<ElementIn>>;
    ignoreRegions?: InputMaybe<Array<RegionIn>>;
    ignoreSelectors?: InputMaybe<Array<IgnoreSelectorIn>>;
    /** This will be mandatory in the future. */
    jobId?: InputMaybe<Scalars['String']>;
    name: Scalars['String'];
    sessionId: Scalars['ID'];
    /** Pass the `blob` field from the `webdriverSessionInfo` query here. */
    sessionMetadata: Scalars['WebdriverSessionBlob'];
    suiteName?: InputMaybe<Scalars['String']>;
    testName?: InputMaybe<Scalars['String']>;
};
/** A filter to be used against Datetime fields. All fields are combined with a logical ‘and.’ */
type DatetimeFilter = {
    /** Greater than the specified value. */
    greaterThan?: InputMaybe<Scalars['Datetime']>;
    /** Greater than or equal to the specified value. */
    greaterThanOrEqualTo?: InputMaybe<Scalars['Datetime']>;
    /** Included in the specified list. */
    in?: InputMaybe<Array<Scalars['Datetime']>>;
    /** Is null (if `true` is specified) or is not null (if `false` is specified). */
    isNull?: InputMaybe<Scalars['Boolean']>;
    /** Less than the specified value. */
    lessThan?: InputMaybe<Scalars['Datetime']>;
    /** Less than or equal to the specified value. */
    lessThanOrEqualTo?: InputMaybe<Scalars['Datetime']>;
};
type DeleteCommentIn = {
    id: Scalars['UUID'];
};
/**
 * The result of diffing a `Baseline` with a `Snapshot`.
 *
 * See the documentation for `Baseline` for details how a `Snapshot` is matched to `Baseline`.
 */
type Diff = Node & {
    __typename?: 'Diff';
    /** @deprecated Experimental. May be removed at any time. */
    altDomDiffUrl: Maybe<Scalars['String']>;
    /** Reads a single `Baseline` that is related to this `Diff`. */
    baseline: Maybe<Baseline>;
    baselineId: Maybe<Scalars['UUID']>;
    /** Reads a single `Build` that is related to this `Diff`. */
    build: Maybe<Build>;
    buildId: Scalars['UUID'];
    /** Reads and enables pagination through a set of `Comment`. */
    comments: CommentsConnection;
    createdAt: Scalars['Datetime'];
    diffBounds: Maybe<Rect>;
    diffClusters: Array<Maybe<Rect>>;
    diffingMethod: DiffingMethod;
    /** snapshot { uploadId } should be requested at the same moment */
    domDiffUrl: Maybe<Scalars['String']>;
    feedback: DiffFeedback;
    hasDom: Scalars['Boolean'];
    id: Scalars['UUID'];
    /** A globally unique identifier. Can be used in various places throughout the system to identify this single value. */
    nodeId: Scalars['ID'];
    options: Maybe<DiffingOption>;
    preview: Array<Rect>;
    /** Reads a single `Snapshot` that is related to this `Diff`. */
    snapshot: Maybe<Snapshot>;
    snapshotId: Scalars['UUID'];
    status: DiffStatus;
    statusIsEqual: Maybe<Scalars['Boolean']>;
    /**
     * Last time the diff was updated.
     *
     * By default `updatedAt = createdAt`.
     */
    updatedAt: Scalars['Datetime'];
    /** User id of user that last updated the diff. If no user updated the status yet, it is set to `created_by`. */
    updatedBy: Scalars['UUID'];
    updatedByUser: User;
};
/**
 * The result of diffing a `Baseline` with a `Snapshot`.
 *
 * See the documentation for `Baseline` for details how a `Snapshot` is matched to `Baseline`.
 */
type DiffCommentsArgs = {
    after: InputMaybe<Scalars['Cursor']>;
    before: InputMaybe<Scalars['Cursor']>;
    condition: InputMaybe<CommentCondition>;
    filter: InputMaybe<CommentFilter>;
    first: InputMaybe<Scalars['Int']>;
    last: InputMaybe<Scalars['Int']>;
    offset: InputMaybe<Scalars['Int']>;
    orderBy?: InputMaybe<Array<CommentsOrderBy>>;
};
/**
 * The result of diffing a `Baseline` with a `Snapshot`.
 *
 * See the documentation for `Baseline` for details how a `Snapshot` is matched to `Baseline`.
 */
type DiffPreviewArgs = {
    input: DiffPreviewIn;
};
/** A condition to be used against `Diff` object types. All fields are tested for equality and combined with a logical ‘and.’ */
type DiffCondition = {
    /** Checks for equality with the object’s `baselineId` field. */
    baselineId?: InputMaybe<Scalars['UUID']>;
    /** Checks for equality with the object’s `buildId` field. */
    buildId?: InputMaybe<Scalars['UUID']>;
    /** Checks for equality with the object’s `createdAt` field. */
    createdAt?: InputMaybe<Scalars['Datetime']>;
    /** Checks for equality with the object’s `id` field. */
    id?: InputMaybe<Scalars['UUID']>;
    /** Checks for equality with the object’s `snapshotId` field. */
    snapshotId?: InputMaybe<Scalars['UUID']>;
    /** Checks for equality with the object’s `status` field. */
    status?: InputMaybe<DiffStatus>;
};
type DiffCountIn = {
    status: DiffStatus;
    /** Set to true to only count diffs that have a baseline. */
    withBaseline?: InputMaybe<Scalars['Boolean']>;
};
type DiffFeedback = {
    __typename?: 'DiffFeedback';
    hasIrrelevantChanges: Scalars['Boolean'];
    isBroken: Scalars['Boolean'];
};
/** A connection to a list of `DiffFeedback` values. */
type DiffFeedbacksConnection = {
    __typename?: 'DiffFeedbacksConnection';
    /** A list of edges which contains the `DiffFeedback` and cursor to aid in pagination. */
    edges: Array<DiffFeedbacksEdge>;
    /** A list of `DiffFeedback` objects. */
    nodes: Array<DiffFeedback>;
    /** Information to aid in pagination. */
    pageInfo: PageInfo;
    /** The count of *all* `DiffFeedback` you could get from the connection. */
    totalCount: Scalars['Int'];
};
/** A `DiffFeedback` edge in the connection. */
type DiffFeedbacksEdge = {
    __typename?: 'DiffFeedbacksEdge';
    /** A cursor for use in pagination. */
    cursor: Maybe<Scalars['Cursor']>;
    /** The `DiffFeedback` at the end of the edge. */
    node: DiffFeedback;
};
/** Methods to use when ordering `DiffFeedback`. */
declare enum DiffFeedbacksOrderBy {
    Natural = "NATURAL"
}
/** A filter to be used against `Diff` object types. All fields are combined with a logical ‘and.’ */
type DiffFilter = {
    /** Filter by the object’s `baselineId` field. */
    baselineId?: InputMaybe<UuidFilter>;
    /** Filter by the object’s `buildId` field. */
    buildId?: InputMaybe<UuidFilter>;
    /** Filter by the object’s `createdAt` field. */
    createdAt?: InputMaybe<DatetimeFilter>;
    /** Filter by the object’s `id` field. */
    id?: InputMaybe<UuidFilter>;
    /** Filter by the object’s `snapshotId` field. */
    snapshotId?: InputMaybe<UuidFilter>;
    /** Filter by the object’s `status` field. */
    status?: InputMaybe<DiffStatusFilter>;
};
/** Extension of SnapshotFiltersIn. Should contain the same values here in addition to status filters. */
type DiffFiltersIn = {
    browser?: InputMaybe<Array<Browser>>;
    device?: InputMaybe<Array<Scalars['String']>>;
    groupBy?: InputMaybe<Array<GroupByOption>>;
    operatingSystem?: InputMaybe<Array<OperatingSystemFilterIn>>;
    search?: InputMaybe<Scalars['String']>;
    status?: InputMaybe<Array<DiffStatus>>;
};
type DiffPreviewIn = {
    ignoreRegions: Array<RegionIn>;
};
/**
 * Lifecycle status of a `Diff`.
 *
 * 1. When a `Diff` is created from a `Snapshot` it will be `QUEUED`.
 * 2. After the difference between snapshot and baseline was computed, the state is either
 *     `EQUAL` (`Baseline` and snapshot are equal) or
 *     `UNAPPROVED` (differences between `Baseline` and `Snapshot` were detected or no `Baseline` exists).
 * 3. A user can update the status of an existing `Diff` to either
 *     `APPROVED` (a new `Baseline` is then created from the `Snapshot`)
 *     `REJECTED` (no new `Baseline` is created)
 *     `UNAPPROVED` (if it was approved before, the previous `Baseline` is restored)
 */
declare enum DiffStatus {
    Approved = "APPROVED",
    Equal = "EQUAL",
    Errored = "ERRORED",
    Queued = "QUEUED",
    Rejected = "REJECTED",
    Unapproved = "UNAPPROVED"
}
/** A filter to be used against DiffStatus fields. All fields are combined with a logical ‘and.’ */
type DiffStatusFilter = {
    /** Greater than the specified value. */
    greaterThan?: InputMaybe<DiffStatus>;
    /** Greater than or equal to the specified value. */
    greaterThanOrEqualTo?: InputMaybe<DiffStatus>;
    /** Included in the specified list. */
    in?: InputMaybe<Array<DiffStatus>>;
    /** Is null (if `true` is specified) or is not null (if `false` is specified). */
    isNull?: InputMaybe<Scalars['Boolean']>;
    /** Less than the specified value. */
    lessThan?: InputMaybe<DiffStatus>;
    /** Less than or equal to the specified value. */
    lessThanOrEqualTo?: InputMaybe<DiffStatus>;
};
/**
 * Method to use for diffing.
 *
 * SIMPLE is the default.
 *
 * Note: EXPERIMENTAL is deprecated. Use BALANCED instead.
 */
declare enum DiffingMethod {
    Balanced = "BALANCED",
    Experimental = "EXPERIMENTAL",
    Simple = "SIMPLE"
}
type DiffingOption = {
    __typename?: 'DiffingOption';
    content: Maybe<Scalars['Boolean']>;
    dimensions: Maybe<Scalars['Boolean']>;
    position: Maybe<Scalars['Boolean']>;
    structure: Maybe<Scalars['Boolean']>;
    style: Maybe<Scalars['Boolean']>;
    visual: Maybe<Scalars['Boolean']>;
};
type DiffingOptionsIn = {
    content?: InputMaybe<Scalars['Boolean']>;
    dimensions?: InputMaybe<Scalars['Boolean']>;
    position?: InputMaybe<Scalars['Boolean']>;
    structure?: InputMaybe<Scalars['Boolean']>;
    style?: InputMaybe<Scalars['Boolean']>;
    visual?: InputMaybe<Scalars['Boolean']>;
};
/** A connection to a list of `Diff` values. */
type DiffsConnection = {
    __typename?: 'DiffsConnection';
    /** A list of edges which contains the `Diff` and cursor to aid in pagination. */
    edges: Array<DiffsEdge>;
    /** A list of `Diff` objects. */
    nodes: Array<Diff>;
    /** Information to aid in pagination. */
    pageInfo: PageInfo;
    /** The count of *all* `Diff` you could get from the connection. */
    totalCount: Scalars['Int'];
};
/** A `Diff` edge in the connection. */
type DiffsEdge = {
    __typename?: 'DiffsEdge';
    /** A cursor for use in pagination. */
    cursor: Maybe<Scalars['Cursor']>;
    /** The `Diff` at the end of the edge. */
    node: Diff;
};
/** Methods to use when ordering `Diff`. */
declare enum DiffsOrderBy {
    BaselineIdAsc = "BASELINE_ID_ASC",
    BaselineIdDesc = "BASELINE_ID_DESC",
    BuildIdAsc = "BUILD_ID_ASC",
    BuildIdDesc = "BUILD_ID_DESC",
    CreatedAtAsc = "CREATED_AT_ASC",
    CreatedAtDesc = "CREATED_AT_DESC",
    IdAsc = "ID_ASC",
    IdDesc = "ID_DESC",
    Natural = "NATURAL",
    PrimaryKeyAsc = "PRIMARY_KEY_ASC",
    PrimaryKeyDesc = "PRIMARY_KEY_DESC",
    SnapshotIdAsc = "SNAPSHOT_ID_ASC",
    SnapshotIdDesc = "SNAPSHOT_ID_DESC",
    StatusAsc = "STATUS_ASC",
    StatusDesc = "STATUS_DESC",
    StatusIsEqualAsc = "STATUS_IS_EQUAL_ASC",
    StatusIsEqualDesc = "STATUS_IS_EQUAL_DESC"
}
type DistinctAttributeValues = {
    __typename?: 'DistinctAttributeValues';
    browser: Array<Maybe<Browser>>;
    device: Array<Maybe<Scalars['String']>>;
    operatingSystem: Array<OperatingSystemAttribute>;
    suiteName: Array<Maybe<Scalars['String']>>;
    testName: Array<Maybe<Scalars['String']>>;
};
declare enum DomFormat {
    AndroidAppium = "ANDROID_APPIUM",
    Browser = "BROWSER",
    IosAppium = "IOS_APPIUM",
    None = "NONE"
}
type ElementIn = {
    diffingOptions?: InputMaybe<DiffingOptionsIn>;
    /** The server-assigned ID of an element from webdriver. */
    id: Scalars['WebdriverElementID'];
    name?: InputMaybe<Scalars['String']>;
};
type FinishBuildIn = {
    customId?: InputMaybe<Scalars['String']>;
    /** Delay the finishing the build for at least the specified number of seconds. */
    delay?: InputMaybe<Scalars['Int']>;
    /** @deprecated Use `uuid`. This field will be removed in a future update. */
    id?: InputMaybe<Scalars['ID']>;
    uuid?: InputMaybe<Scalars['UUID']>;
};
type ForceFinishBuildIn = {
    customId?: InputMaybe<Scalars['String']>;
    uuid?: InputMaybe<Scalars['UUID']>;
};
type FullPageConfigIn = {
    /**
     * Delay in ms after scrolling and before taking screenshots.
     * A slight delay can be helpful if the page is using lazy loading when scrolling
     */
    delayAfterScrollMs?: InputMaybe<Scalars['Int']>;
    /** Disable CSS animations and the input caret in the app. */
    disableCSSAnimation?: InputMaybe<Scalars['Boolean']>;
    /** @deprecated Use hideElementsAfterFirstScroll instead where available. */
    hideAfterFirstScroll?: InputMaybe<Array<InputMaybe<Scalars['String']>>>;
    /** Hide elements on the page after first scroll using their server-assigned ID from webdriver. */
    hideElementsAfterFirstScroll?: InputMaybe<Array<Scalars['WebdriverElementID']>>;
    /** @deprecated(reason: "use hideScrollBars in CreateSnapshotFromWebDriverIn instead.") */
    hideScrollBars?: InputMaybe<Scalars['Boolean']>;
    /** Selector of an element that we should crop the screenshot to. Available only on native apps. */
    nativeClipSelector?: InputMaybe<SelectorIn>;
    /** @experimental Element used for scrolling (available only in native apps) */
    scrollElement?: InputMaybe<Scalars['WebdriverElementID']>;
    /**
     * Limit the number of screenshots taken for scrolling and stitching.
     * Default and max value is 10
     */
    scrollLimit?: InputMaybe<Scalars['Int']>;
    /** Change scroll behaviour before and after taking full page screenshot. Available only on native apps. */
    scrollOption?: InputMaybe<ScrollOption>;
};
/** A filter to be used against FullText fields. All fields are combined with a logical ‘and.’ */
type FullTextFilter = {
    /** Performs a full text search on the field. */
    matches?: InputMaybe<Scalars['String']>;
};
declare enum GroupByOption {
    Browser = "Browser",
    Device = "Device",
    OperatingSystemOperatingSystemVersion = "OperatingSystem_OperatingSystemVersion",
    SuiteName = "SuiteName",
    TestName = "TestName"
}
type IgnoreSelectorIn = {
    diffingOptions?: InputMaybe<DiffingOptionsIn>;
    name?: InputMaybe<Scalars['String']>;
    selector: SelectorIn;
};
/** All input for the `mergeBaselines` mutation. */
type MergeBaselinesInput = {
    /**
     * An arbitrary string value with no semantic meaning. Will be included in the
     * payload verbatim. May be used to track mutations by the client.
     */
    clientMutationId?: InputMaybe<Scalars['String']>;
    projectName: Scalars['String'];
    sourceBranch: Scalars['String'];
    targetBranch: Scalars['String'];
};
/** The output of our `mergeBaselines` mutation. */
type MergeBaselinesPayload = {
    __typename?: 'MergeBaselinesPayload';
    baselines: Maybe<Array<Baseline>>;
    /**
     * The exact same `clientMutationId` that was provided in the mutation input,
     * unchanged and unused. May be used by a client to track mutations.
     */
    clientMutationId: Maybe<Scalars['String']>;
    /** Our root query field type. Allows us to run any query from our mutation payload. */
    query: Maybe<Query>;
};
/** The root mutation type which contains root level fields which mutate data. */
type Mutation = {
    __typename?: 'Mutation';
    addComment: Comment;
    /** @deprecated Use setDiffStatus */
    approveBuild: Build;
    createBuild: Build;
    /**
     * Copy a set of baselines specified by `baselineIds` and save it as the latest baseline, but
     * replace uiIgnoreRegions with the provided value.
     */
    createDerivedBaselines: Array<Baseline>;
    createSnapshot: Snapshot;
    createSnapshotFromWebDriver: Snapshot;
    createSnapshotUpload: SnapshotUpload;
    deleteComment: Maybe<Scalars['Void']>;
    finishBuild: Build;
    forceFinishBuild: Maybe<Build>;
    mergeBaselines: MergeBaselinesPayload;
    setDiffFeedback: Diff;
    setDiffStatus: Array<Diff>;
    updateComment: Comment;
    /** @deprecated Use setDiffStatus */
    updateDiff: Diff;
};
/** The root mutation type which contains root level fields which mutate data. */
type MutationAddCommentArgs = {
    input: AddCommentIn;
};
/** The root mutation type which contains root level fields which mutate data. */
type MutationApproveBuildArgs = {
    input: ApproveBuildIn;
};
/** The root mutation type which contains root level fields which mutate data. */
type MutationCreateBuildArgs = {
    input: BuildIn;
};
/** The root mutation type which contains root level fields which mutate data. */
type MutationCreateDerivedBaselinesArgs = {
    input: CreateDerivedBaselinesIn;
};
/** The root mutation type which contains root level fields which mutate data. */
type MutationCreateSnapshotArgs = {
    input: SnapshotIn;
};
/** The root mutation type which contains root level fields which mutate data. */
type MutationCreateSnapshotFromWebDriverArgs = {
    input: CreateSnapshotFromWebDriverIn;
};
/** The root mutation type which contains root level fields which mutate data. */
type MutationCreateSnapshotUploadArgs = {
    input: SnapshotUploadIn;
};
/** The root mutation type which contains root level fields which mutate data. */
type MutationDeleteCommentArgs = {
    input: DeleteCommentIn;
};
/** The root mutation type which contains root level fields which mutate data. */
type MutationFinishBuildArgs = {
    input: FinishBuildIn;
};
/** The root mutation type which contains root level fields which mutate data. */
type MutationForceFinishBuildArgs = {
    input: ForceFinishBuildIn;
};
/** The root mutation type which contains root level fields which mutate data. */
type MutationMergeBaselinesArgs = {
    input: MergeBaselinesInput;
};
/** The root mutation type which contains root level fields which mutate data. */
type MutationSetDiffFeedbackArgs = {
    input: SetDiffFeedbackIn;
};
/** The root mutation type which contains root level fields which mutate data. */
type MutationSetDiffStatusArgs = {
    input: SetDiffStatusIn;
};
/** The root mutation type which contains root level fields which mutate data. */
type MutationUpdateCommentArgs = {
    input: UpdateCommentIn;
};
/** The root mutation type which contains root level fields which mutate data. */
type MutationUpdateDiffArgs = {
    input: UpdateDiffIn;
};
/** An object with a globally unique `ID`. */
type Node = {
    /** A globally unique identifier. Can be used in various places throughout the system to identify this single value. */
    nodeId: Scalars['ID'];
};
declare enum OperatingSystem {
    Android = "ANDROID",
    Ios = "IOS",
    Linux = "LINUX",
    Macos = "MACOS",
    Unknown = "UNKNOWN",
    Windows = "WINDOWS"
}
type OperatingSystemAttribute = {
    __typename?: 'OperatingSystemAttribute';
    name: Maybe<OperatingSystem>;
    version: Maybe<Scalars['String']>;
};
type OperatingSystemFilterIn = {
    name: OperatingSystem;
    version: Scalars['String'];
};
type Org = {
    __typename?: 'Org';
    id: Maybe<Scalars['UUID']>;
    /** Reads and enables pagination through a set of `OrgStat`. */
    orgStats: OrgStatsConnection;
    statsGroupedByDay: OrgStatsGroupedByDayConnection;
};
type OrgOrgStatsArgs = {
    after: InputMaybe<Scalars['Cursor']>;
    before: InputMaybe<Scalars['Cursor']>;
    condition: InputMaybe<OrgStatCondition>;
    filter: InputMaybe<OrgStatFilter>;
    first: InputMaybe<Scalars['Int']>;
    last: InputMaybe<Scalars['Int']>;
    offset: InputMaybe<Scalars['Int']>;
    orderBy?: InputMaybe<Array<OrgStatsOrderBy>>;
};
type OrgStatsGroupedByDayArgs = {
    after: InputMaybe<Scalars['Cursor']>;
    before: InputMaybe<Scalars['Cursor']>;
    first: InputMaybe<Scalars['Int']>;
    last: InputMaybe<Scalars['Int']>;
    offset: InputMaybe<Scalars['Int']>;
};
type OrgStat = Node & {
    __typename?: 'OrgStat';
    hour: Scalars['Datetime'];
    /** A globally unique identifier. Can be used in various places throughout the system to identify this single value. */
    nodeId: Scalars['ID'];
    /** Reads a single `Org` that is related to this `OrgStat`. */
    org: Maybe<Org>;
    orgId: Scalars['UUID'];
    snapshotsUsed: Scalars['Int'];
};
/** A condition to be used against `OrgStat` object types. All fields are tested for equality and combined with a logical ‘and.’ */
type OrgStatCondition = {
    /** Checks for equality with the object’s `orgId` field. */
    orgId?: InputMaybe<Scalars['UUID']>;
};
/** A filter to be used against `OrgStat` object types. All fields are combined with a logical ‘and.’ */
type OrgStatFilter = {
    /** Filter by the object’s `orgId` field. */
    orgId?: InputMaybe<UuidFilter>;
};
/** A connection to a list of `OrgStat` values. */
type OrgStatsConnection = {
    __typename?: 'OrgStatsConnection';
    /** A list of edges which contains the `OrgStat` and cursor to aid in pagination. */
    edges: Array<OrgStatsEdge>;
    /** A list of `OrgStat` objects. */
    nodes: Array<OrgStat>;
    /** Information to aid in pagination. */
    pageInfo: PageInfo;
    /** The count of *all* `OrgStat` you could get from the connection. */
    totalCount: Scalars['Int'];
};
/** A `OrgStat` edge in the connection. */
type OrgStatsEdge = {
    __typename?: 'OrgStatsEdge';
    /** A cursor for use in pagination. */
    cursor: Maybe<Scalars['Cursor']>;
    /** The `OrgStat` at the end of the edge. */
    node: OrgStat;
};
/** A connection to a list of `OrgStatsGroupedByDayRecord` values. */
type OrgStatsGroupedByDayConnection = {
    __typename?: 'OrgStatsGroupedByDayConnection';
    /** A list of edges which contains the `OrgStatsGroupedByDayRecord` and cursor to aid in pagination. */
    edges: Array<OrgStatsGroupedByDayEdge>;
    /** A list of `OrgStatsGroupedByDayRecord` objects. */
    nodes: Array<OrgStatsGroupedByDayRecord>;
    /** The count of *all* `OrgStatsGroupedByDayRecord` you could get from the connection. */
    totalCount: Scalars['Int'];
};
/** A `OrgStatsGroupedByDayRecord` edge in the connection. */
type OrgStatsGroupedByDayEdge = {
    __typename?: 'OrgStatsGroupedByDayEdge';
    /** A cursor for use in pagination. */
    cursor: Maybe<Scalars['Cursor']>;
    /** The `OrgStatsGroupedByDayRecord` at the end of the edge. */
    node: OrgStatsGroupedByDayRecord;
};
/** The return type of our `statsGroupedByDay` query. */
type OrgStatsGroupedByDayRecord = {
    __typename?: 'OrgStatsGroupedByDayRecord';
    day: Maybe<Scalars['Datetime']>;
    snapshotsUsed: Maybe<Scalars['Int']>;
};
/** Methods to use when ordering `OrgStat`. */
declare enum OrgStatsOrderBy {
    Natural = "NATURAL",
    OrgIdAsc = "ORG_ID_ASC",
    OrgIdAscHourAsc = "ORG_ID_ASC__HOUR_ASC",
    OrgIdDesc = "ORG_ID_DESC",
    OrgIdDescHourDesc = "ORG_ID_DESC__HOUR_DESC",
    PrimaryKeyAsc = "PRIMARY_KEY_ASC",
    PrimaryKeyDesc = "PRIMARY_KEY_DESC"
}
/** Information about pagination in a connection. */
type PageInfo = {
    __typename?: 'PageInfo';
    /** When paginating forwards, the cursor to continue. */
    endCursor: Maybe<Scalars['Cursor']>;
    /** When paginating forwards, are there more items? */
    hasNextPage: Scalars['Boolean'];
    /** When paginating backwards, are there more items? */
    hasPreviousPage: Scalars['Boolean'];
    /** When paginating backwards, the cursor to continue. */
    startCursor: Maybe<Scalars['Cursor']>;
};
type Project = Node & {
    __typename?: 'Project';
    /**
     * Reads and enables pagination through a set of `Branch`.
     * @deprecated Experimental API, could change at any time. Use with caution.
     */
    branches: BranchesConnection;
    id: Scalars['String'];
    lastUsed: Scalars['Datetime'];
    name: Maybe<Scalars['String']>;
    /** A globally unique identifier. Can be used in various places throughout the system to identify this single value. */
    nodeId: Scalars['ID'];
};
type ProjectBranchesArgs = {
    after: InputMaybe<Scalars['Cursor']>;
    before: InputMaybe<Scalars['Cursor']>;
    first: InputMaybe<Scalars['Int']>;
    last: InputMaybe<Scalars['Int']>;
    offset: InputMaybe<Scalars['Int']>;
    orderBy?: InputMaybe<Array<BranchesOrderBy>>;
};
/** A connection to a list of `Project` values. */
type ProjectsConnection = {
    __typename?: 'ProjectsConnection';
    /** A list of edges which contains the `Project` and cursor to aid in pagination. */
    edges: Array<ProjectsEdge>;
    /** A list of `Project` objects. */
    nodes: Array<Project>;
    /** Information to aid in pagination. */
    pageInfo: PageInfo;
    /** The count of *all* `Project` you could get from the connection. */
    totalCount: Sca