import { FieldsSelection } from './runtime/_type-selection.js';

type Scalars = {
    MyCustomScalar: {
        x: string;
    };
    String: string;
    Int: number;
    Float: number;
    Boolean: boolean;
    ID: string;
};
type SomeEnum = "X" | "Y" | "Z";
type SomeEnum2 = "hello" | "world";
interface Query {
    /** Some description */
    repository: Repository;
    queryWithDefaultArgs: Scalars["String"] | null;
    optionalArgs: Repository;
    user: User | null;
    someScalarValue: Scalars["String"] | null;
    recursiveType: (RecursiveType | null)[] | null;
    throwsError: Scalars["String"];
    requiredFields: Scalars["String"];
    account: Account | null;
    coordinates: Point | null;
    unionThatImplementsInterface: GenericError | null;
    InterfaceNotImplemented: InterfaceNotImplemented | null;
    __typename: "Query";
}
interface RecursiveType {
    value: Scalars["String"] | null;
    recurse: RecursiveType | null;
    __typename: "RecursiveType";
}
interface Repository {
    createdAt: Scalars["String"];
    forks: ForkConnection | null;
    scalarButWithRequiredArgs: Scalars["String"];
    customScalar: Scalars["MyCustomScalar"] | null;
    __typename: "Repository";
}
interface ForkConnection {
    edges: (ForkEdge | null)[] | null;
    __typename: "ForkConnection";
}
interface ForkEdge {
    cursor: Scalars["String"] | null;
    node: Fork | null;
    __typename: "ForkEdge";
}
interface Fork {
    name: Scalars["String"] | null;
    number: Scalars["Int"] | null;
    __typename: "Fork";
}
interface User {
    /** Some description */
    name: Scalars["String"] | null;
    common: Scalars["Int"] | null;
    commonButDiffType: Scalars["Int"] | null;
    __typename: "User";
}
interface Subscription {
    user: User | null;
    __typename: "Subscription";
}
type Account = (User | Guest) & {
    __isUnion?: true;
};
interface Guest {
    anonymous: Scalars["Boolean"] | null;
    common: Scalars["Int"] | null;
    commonButDiffType: Scalars["String"] | null;
    __typename: "Guest";
}
interface House {
    owner: User | null;
    x: Scalars["String"] | null;
    y: Scalars["String"] | null;
    __typename: "House";
}
interface Bank {
    address: Scalars["String"] | null;
    x: Scalars["String"] | null;
    y: Scalars["String"] | null;
    __typename: "Bank";
}
type Point = (House | Bank) & {
    __isUnion?: true;
};
type ClientError = (ClientErrorNameAlreadyTaken | ClientErrorNameInvalid) & {
    __isUnion?: true;
};
interface ClientErrorNameAlreadyTaken {
    message: Scalars["String"];
    ownProp1: Scalars["String"] | null;
    __typename: "ClientErrorNameAlreadyTaken";
}
interface ClientErrorNameInvalid {
    message: Scalars["String"];
    ownProp2: Scalars["String"] | null;
    __typename: "ClientErrorNameInvalid";
}
interface ClientErrorWithoutInterface {
    ownProp3: Scalars["String"] | null;
    __typename: "ClientErrorWithoutInterface";
}
type GenericError = (ClientErrorNameAlreadyTaken | ClientErrorNameInvalid | ClientErrorWithoutInterface) & {
    __isUnion?: true;
};
interface InterfaceNotImplemented {
    id: Scalars["ID"];
    title: Scalars["String"] | null;
    url: Scalars["String"] | null;
    permalink: Scalars["String"] | null;
    entry_id: Scalars["ID"] | null;
    __typename: string;
}
interface InputWithRequiredFields {
    requiredField: Scalars["String"];
    optionalField?: Scalars["String"] | null;
}
interface QueryGenqlSelection {
    /** Some description */
    repository?: RepositoryGenqlSelection & {
        __args: {
            name: Scalars["String"];
            owner?: Scalars["String"] | null;
        };
    };
    queryWithDefaultArgs?: {
        __args: {
            input?: DefaultArgsInput | null;
            defaultValue?: Scalars["Int"] | null;
            requiredButDefault?: Scalars["Int"];
        };
    } | boolean | number;
    optionalArgs?: RepositoryGenqlSelection & {
        __args?: {
            name?: Scalars["String"] | null;
            owner?: Scalars["String"] | null;
        };
    };
    user?: UserGenqlSelection;
    someScalarValue?: {
        __args: {
            x?: Scalars["Float"] | null;
        };
    } | boolean | number;
    recursiveType?: RecursiveTypeGenqlSelection & {
        __args?: {
            requiredVal?: Scalars["String"][] | null;
        };
    };
    throwsError?: boolean | number;
    requiredFields?: {
        __args: {
            input: InputWithRequiredFields;
        };
    };
    account?: AccountGenqlSelection;
    coordinates?: PointGenqlSelection;
    unionThatImplementsInterface?: GenericErrorGenqlSelection & {
        __args?: {
            typename?: Scalars["String"] | null;
        };
    };
    InterfaceNotImplemented?: InterfaceNotImplementedGenqlSelection;
    __typename?: boolean | number;
}
interface DefaultArgsInput {
    string?: Scalars["String"];
}
interface RecursiveTypeGenqlSelection {
    value?: boolean | number;
    recurse?: RecursiveTypeGenqlSelection & {
        __args?: {
            arg?: Scalars["Int"] | null;
        };
    };
    __typename?: boolean | number;
}
interface RepositoryGenqlSelection {
    createdAt?: boolean | number;
    forks?: ForkConnectionGenqlSelection & {
        __args?: {
            filter?: Scalars["String"] | null;
        };
    };
    scalarButWithRequiredArgs?: {
        __args: {
            x: Scalars["Int"];
        };
    };
    customScalar?: boolean | number;
    __typename?: boolean | number;
}
interface ForkConnectionGenqlSelection {
    edges?: ForkEdgeGenqlSelection;
    __typename?: boolean | number;
}
interface ForkEdgeGenqlSelection {
    cursor?: boolean | number;
    node?: ForkGenqlSelection;
    __typename?: boolean | number;
}
interface ForkGenqlSelection {
    name?: boolean | number;
    number?: boolean | number;
    __typename?: boolean | number;
}
interface UserGenqlSelection {
    /** Some description */
    name?: boolean | number;
    common?: boolean | number;
    commonButDiffType?: boolean | number;
    __typename?: boolean | number;
}
interface SubscriptionGenqlSelection {
    user?: UserGenqlSelection;
    __typename?: boolean | number;
}
interface AccountGenqlSelection {
    on_User?: UserGenqlSelection;
    on_Guest?: GuestGenqlSelection;
    __typename?: boolean | number;
}
interface GuestGenqlSelection {
    anonymous?: boolean | number;
    common?: boolean | number;
    commonButDiffType?: boolean | number;
    __typename?: boolean | number;
}
interface HouseGenqlSelection {
    owner?: UserGenqlSelection;
    x?: boolean | number;
    y?: boolean | number;
    __typename?: boolean | number;
}
interface BankGenqlSelection {
    address?: boolean | number;
    x?: boolean | number;
    y?: boolean | number;
    __typename?: boolean | number;
}
interface PointGenqlSelection {
    x?: boolean | number;
    y?: boolean | number;
    on_House?: HouseGenqlSelection;
    on_Bank?: BankGenqlSelection;
    __typename?: boolean | number;
}
interface ClientErrorGenqlSelection {
    message?: boolean | number;
    on_ClientErrorNameAlreadyTaken?: ClientErrorNameAlreadyTakenGenqlSelection;
    on_ClientErrorNameInvalid?: ClientErrorNameInvalidGenqlSelection;
    __typename?: boolean | number;
}
interface ClientErrorNameAlreadyTakenGenqlSelection {
    message?: boolean | number;
    ownProp1?: boolean | number;
    __typename?: boolean | number;
}
interface ClientErrorNameInvalidGenqlSelection {
    message?: boolean | number;
    ownProp2?: boolean | number;
    __typename?: boolean | number;
}
interface ClientErrorWithoutInterfaceGenqlSelection {
    ownProp3?: boolean | number;
    __typename?: boolean | number;
}
interface GenericErrorGenqlSelection {
    on_ClientErrorNameAlreadyTaken?: ClientErrorNameAlreadyTakenGenqlSelection;
    on_ClientErrorNameInvalid?: ClientErrorNameInvalidGenqlSelection;
    on_ClientErrorWithoutInterface?: ClientErrorWithoutInterfaceGenqlSelection;
    on_ClientError?: ClientErrorGenqlSelection;
    __typename?: boolean | number;
}
interface InterfaceNotImplementedGenqlSelection {
    id?: boolean | number;
    title?: boolean | number;
    url?: boolean | number;
    permalink?: boolean | number;
    entry_id?: boolean | number;
    __typename?: boolean | number;
}
type FragmentsMap = {
    Query: {
        root: Query;
        selection: QueryGenqlSelection;
    };
    RecursiveType: {
        root: RecursiveType;
        selection: RecursiveTypeGenqlSelection;
    };
    Repository: {
        root: Repository;
        selection: RepositoryGenqlSelection;
    };
    ForkConnection: {
        root: ForkConnection;
        selection: ForkConnectionGenqlSelection;
    };
    ForkEdge: {
        root: ForkEdge;
        selection: ForkEdgeGenqlSelection;
    };
    Fork: {
        root: Fork;
        selection: ForkGenqlSelection;
    };
    User: {
        root: User;
        selection: UserGenqlSelection;
    };
    Subscription: {
        root: Subscription;
        selection: SubscriptionGenqlSelection;
    };
    Guest: {
        root: Guest;
        selection: GuestGenqlSelection;
    };
    House: {
        root: House;
        selection: HouseGenqlSelection;
    };
    Bank: {
        root: Bank;
        selection: BankGenqlSelection;
    };
    Point: {
        root: Point;
        selection: PointGenqlSelection;
    };
    ClientError: {
        root: ClientError;
        selection: ClientErrorGenqlSelection;
    };
    ClientErrorNameAlreadyTaken: {
        root: ClientErrorNameAlreadyTaken;
        selection: ClientErrorNameAlreadyTakenGenqlSelection;
    };
    ClientErrorNameInvalid: {
        root: ClientErrorNameInvalid;
        selection: ClientErrorNameInvalidGenqlSelection;
    };
    ClientErrorWithoutInterface: {
        root: ClientErrorWithoutInterface;
        selection: ClientErrorWithoutInterfaceGenqlSelection;
    };
    InterfaceNotImplemented: {
        root: InterfaceNotImplemented;
        selection: InterfaceNotImplementedGenqlSelection;
    };
};
type OmitDistributive<T, K extends PropertyKey> = T extends any ? T extends object ? Id<OmitRecursively<T, K>> : T : never;
type Id<T> = {} & {
    [P in keyof T]: T[P];
};
type OmitRecursively<T, K extends PropertyKey> = Omit<{
    [P in keyof T]: OmitDistributive<T[P], K>;
}, K>;
declare function fragmentOn<TypeName extends keyof FragmentsMap, Selection extends FragmentsMap[TypeName]["selection"]>(name: TypeName, fields: Selection): {
    readonly __fragmentOn: TypeName;
} & Selection;
declare namespace fragmentOn {
    type infer<T> = T extends {
        __fragmentOn: infer U extends keyof FragmentsMap;
    } ? OmitRecursively<FieldsSelection<FragmentsMap[U]["root"], Omit<T, "__fragmentOn">>, "__fragmentOn"> : never;
}
type RecursiveCollection<T, Key extends keyof T> = T & {
    [key in Key]: {
        items: RecursiveCollection<T, Key>;
    };
};
declare function fragmentOnRecursiveCollection<TypeName extends keyof FragmentsMap, Selection extends FragmentsMap[TypeName]["selection"], RecursiveKey extends keyof FragmentsMap[TypeName]["selection"]>(name: TypeName, fields: Selection, options: {
    recursiveKey: RecursiveKey;
    levels: number;
    getLevelArgs?: (level: number) => unknown;
}): RecursiveCollection<{
    readonly __fragmentOn: TypeName;
} & Selection, RecursiveKey>;
declare const isQuery: (obj?: {
    __typename?: any;
} | null) => obj is Query;
declare const isRecursiveType: (obj?: {
    __typename?: any;
} | null) => obj is RecursiveType;
declare const isRepository: (obj?: {
    __typename?: any;
} | null) => obj is Repository;
declare const isForkConnection: (obj?: {
    __typename?: any;
} | null) => obj is ForkConnection;
declare const isForkEdge: (obj?: {
    __typename?: any;
} | null) => obj is ForkEdge;
declare const isFork: (obj?: {
    __typename?: any;
} | null) => obj is Fork;
declare const isUser: (obj?: {
    __typename?: any;
} | null) => obj is User;
declare const isSubscription: (obj?: {
    __typename?: any;
} | null) => obj is Subscription;
declare const isAccount: (obj?: {
    __typename?: any;
} | null) => obj is Account;
declare const isGuest: (obj?: {
    __typename?: any;
} | null) => obj is Guest;
declare const isHouse: (obj?: {
    __typename?: any;
} | null) => obj is House;
declare const isBank: (obj?: {
    __typename?: any;
} | null) => obj is Bank;
declare const isPoint: (obj?: {
    __typename?: any;
} | null) => obj is Point;
declare const isClientError: (obj?: {
    __typename?: any;
} | null) => obj is ClientError;
declare const isClientErrorNameAlreadyTaken: (obj?: {
    __typename?: any;
} | null) => obj is ClientErrorNameAlreadyTaken;
declare const isClientErrorNameInvalid: (obj?: {
    __typename?: any;
} | null) => obj is ClientErrorNameInvalid;
declare const isClientErrorWithoutInterface: (obj?: {
    __typename?: any;
} | null) => obj is ClientErrorWithoutInterface;
declare const isGenericError: (obj?: {
    __typename?: any;
} | null) => obj is GenericError;
declare const isInterfaceNotImplemented: (obj?: {
    __typename?: any;
} | null) => obj is InterfaceNotImplemented;
declare const enumSomeEnum: {
    X: "X";
    Y: "Y";
    Z: "Z";
};
declare const enumSomeEnum2: {
    hello: "hello";
    world: "world";
};

export { type Account, type AccountGenqlSelection, type Bank, type BankGenqlSelection, type ClientError, type ClientErrorGenqlSelection, type ClientErrorNameAlreadyTaken, type ClientErrorNameAlreadyTakenGenqlSelection, type ClientErrorNameInvalid, type ClientErrorNameInvalidGenqlSelection, type ClientErrorWithoutInterface, type ClientErrorWithoutInterfaceGenqlSelection, type DefaultArgsInput, type Fork, type ForkConnection, type ForkConnectionGenqlSelection, type ForkEdge, type ForkEdgeGenqlSelection, type ForkGenqlSelection, type GenericError, type GenericErrorGenqlSelection, type Guest, type GuestGenqlSelection, type House, type HouseGenqlSelection, type InputWithRequiredFields, type InterfaceNotImplemented, type InterfaceNotImplementedGenqlSelection, type Point, type PointGenqlSelection, type Query, type QueryGenqlSelection, type RecursiveType, type RecursiveTypeGenqlSelection, type Repository, type RepositoryGenqlSelection, type Scalars, type SomeEnum, type SomeEnum2, type Subscription, type SubscriptionGenqlSelection, type User, type UserGenqlSelection, enumSomeEnum, enumSomeEnum2, fragmentOn, fragmentOnRecursiveCollection, isAccount, isBank, isClientError, isClientErrorNameAlreadyTaken, isClientErrorNameInvalid, isClientErrorWithoutInterface, isFork, isForkConnection, isForkEdge, isGenericError, isGuest, isHouse, isInterfaceNotImplemented, isPoint, isQuery, isRecursiveType, isRepository, isSubscription, isUser };