type Maybe<T> = T | null;
/** All built-in and custom scalars, mapped to their actual values */
type Scalars = {
    ID: {
        input: string;
        output: string;
    };
    String: {
        input: string;
        output: string;
    };
    Boolean: {
        input: boolean;
        output: boolean;
    };
    Int: {
        input: number;
        output: number;
    };
    Float: {
        input: number;
        output: number;
    };
    /** A date-time string at UTC, such as 2007-12-03T10:15:30Z, compliant with the `date-time` format outlined in section 5.6 of the RFC 3339 profile of the ISO 8601 standard for representation of dates and times using the Gregorian calendar.This scalar is serialized to a string in ISO 8601 format and parsed from a string in ISO 8601 format. */
    DateTimeISO: {
        input: any;
        output: any;
    };
};
type AccuracyRankType = {
    __typename?: 'AccuracyRankType';
    accuracyScore: Scalars['Float']['output'];
    attester: Scalars['String']['output'];
    rank?: Maybe<Scalars['Int']['output']>;
    totalForecasters: Scalars['Int']['output'];
};
type AggregateAttestation = {
    __typename?: 'AggregateAttestation';
    _avg?: Maybe<AttestationAvgAggregate>;
    _count?: Maybe<AttestationCountAggregate>;
    _max?: Maybe<AttestationMaxAggregate>;
    _min?: Maybe<AttestationMinAggregate>;
    _sum?: Maybe<AttestationSumAggregate>;
};
type AggregateCategory = {
    __typename?: 'AggregateCategory';
    _avg?: Maybe<CategoryAvgAggregate>;
    _count?: Maybe<CategoryCountAggregate>;
    _max?: Maybe<CategoryMaxAggregate>;
    _min?: Maybe<CategoryMinAggregate>;
    _sum?: Maybe<CategorySumAggregate>;
};
type AggregateCondition = {
    __typename?: 'AggregateCondition';
    _avg?: Maybe<ConditionAvgAggregate>;
    _count?: Maybe<ConditionCountAggregate>;
    _max?: Maybe<ConditionMaxAggregate>;
    _min?: Maybe<ConditionMinAggregate>;
    _sum?: Maybe<ConditionSumAggregate>;
};
type AggregateConditionGroup = {
    __typename?: 'AggregateConditionGroup';
    _avg?: Maybe<ConditionGroupAvgAggregate>;
    _count?: Maybe<ConditionGroupCountAggregate>;
    _max?: Maybe<ConditionGroupMaxAggregate>;
    _min?: Maybe<ConditionGroupMinAggregate>;
    _sum?: Maybe<ConditionGroupSumAggregate>;
};
type AggregateUser = {
    __typename?: 'AggregateUser';
    _avg?: Maybe<UserAvgAggregate>;
    _count?: Maybe<UserCountAggregate>;
    _max?: Maybe<UserMaxAggregate>;
    _min?: Maybe<UserMinAggregate>;
    _sum?: Maybe<UserSumAggregate>;
};
type AggregatedProfitEntryType = {
    __typename?: 'AggregatedProfitEntryType';
    owner: Scalars['String']['output'];
    totalPnL: Scalars['Float']['output'];
};
type Attestation = {
    __typename?: 'Attestation';
    attestation_score?: Maybe<AttestationScore>;
    attester: Scalars['String']['output'];
    blockNumber: Scalars['Int']['output'];
    comment?: Maybe<Scalars['String']['output']>;
    condition?: Maybe<Condition>;
    conditionId?: Maybe<Scalars['String']['output']>;
    createdAt: Scalars['DateTimeISO']['output'];
    data: Scalars['String']['output'];
    decodedDataJson: Scalars['String']['output'];
    id: Scalars['Int']['output'];
    prediction: Scalars['String']['output'];
    recipient: Scalars['String']['output'];
    resolver?: Maybe<Scalars['String']['output']>;
    schemaId: Scalars['String']['output'];
    time: Scalars['Int']['output'];
    transactionHash: Scalars['String']['output'];
    uid: Scalars['String']['output'];
};
type AttestationAvgAggregate = {
    __typename?: 'AttestationAvgAggregate';
    blockNumber?: Maybe<Scalars['Float']['output']>;
    id?: Maybe<Scalars['Float']['output']>;
    time?: Maybe<Scalars['Float']['output']>;
};
type AttestationCountAggregate = {
    __typename?: 'AttestationCountAggregate';
    _all: Scalars['Int']['output'];
    attester: Scalars['Int']['output'];
    blockNumber: Scalars['Int']['output'];
    comment: Scalars['Int']['output'];
    conditionId: Scalars['Int']['output'];
    createdAt: Scalars['Int']['output'];
    data: Scalars['Int']['output'];
    decodedDataJson: Scalars['Int']['output'];
    id: Scalars['Int']['output'];
    prediction: Scalars['Int']['output'];
    recipient: Scalars['Int']['output'];
    resolver: Scalars['Int']['output'];
    schemaId: Scalars['Int']['output'];
    time: Scalars['Int']['output'];
    transactionHash: Scalars['Int']['output'];
    uid: Scalars['Int']['output'];
};
type AttestationGroupBy = {
    __typename?: 'AttestationGroupBy';
    _avg?: Maybe<AttestationAvgAggregate>;
    _count?: Maybe<AttestationCountAggregate>;
    _max?: Maybe<AttestationMaxAggregate>;
    _min?: Maybe<AttestationMinAggregate>;
    _sum?: Maybe<AttestationSumAggregate>;
    attester: Scalars['String']['output'];
    blockNumber: Scalars['Int']['output'];
    comment?: Maybe<Scalars['String']['output']>;
    conditionId?: Maybe<Scalars['String']['output']>;
    createdAt: Scalars['DateTimeISO']['output'];
    data: Scalars['String']['output'];
    decodedDataJson: Scalars['String']['output'];
    id: Scalars['Int']['output'];
    prediction: Scalars['String']['output'];
    recipient: Scalars['String']['output'];
    resolver?: Maybe<Scalars['String']['output']>;
    schemaId: Scalars['String']['output'];
    time: Scalars['Int']['output'];
    transactionHash: Scalars['String']['output'];
    uid: Scalars['String']['output'];
};
type AttestationMaxAggregate = {
    __typename?: 'AttestationMaxAggregate';
    attester?: Maybe<Scalars['String']['output']>;
    blockNumber?: Maybe<Scalars['Int']['output']>;
    comment?: Maybe<Scalars['String']['output']>;
    conditionId?: Maybe<Scalars['String']['output']>;
    createdAt?: Maybe<Scalars['DateTimeISO']['output']>;
    data?: Maybe<Scalars['String']['output']>;
    decodedDataJson?: Maybe<Scalars['String']['output']>;
    id?: Maybe<Scalars['Int']['output']>;
    prediction?: Maybe<Scalars['String']['output']>;
    recipient?: Maybe<Scalars['String']['output']>;
    resolver?: Maybe<Scalars['String']['output']>;
    schemaId?: Maybe<Scalars['String']['output']>;
    time?: Maybe<Scalars['Int']['output']>;
    transactionHash?: Maybe<Scalars['String']['output']>;
    uid?: Maybe<Scalars['String']['output']>;
};
type AttestationMinAggregate = {
    __typename?: 'AttestationMinAggregate';
    attester?: Maybe<Scalars['String']['output']>;
    blockNumber?: Maybe<Scalars['Int']['output']>;
    comment?: Maybe<Scalars['String']['output']>;
    conditionId?: Maybe<Scalars['String']['output']>;
    createdAt?: Maybe<Scalars['DateTimeISO']['output']>;
    data?: Maybe<Scalars['String']['output']>;
    decodedDataJson?: Maybe<Scalars['String']['output']>;
    id?: Maybe<Scalars['Int']['output']>;
    prediction?: Maybe<Scalars['String']['output']>;
    recipient?: Maybe<Scalars['String']['output']>;
    resolver?: Maybe<Scalars['String']['output']>;
    schemaId?: Maybe<Scalars['String']['output']>;
    time?: Maybe<Scalars['Int']['output']>;
    transactionHash?: Maybe<Scalars['String']['output']>;
    uid?: Maybe<Scalars['String']['output']>;
};
type AttestationScore = {
    __typename?: 'AttestationScore';
    attestation: Attestation;
    attestationId: Scalars['Int']['output'];
    attester: Scalars['String']['output'];
    createdAt: Scalars['DateTimeISO']['output'];
    errorSquared?: Maybe<Scalars['Float']['output']>;
    id: Scalars['Int']['output'];
    madeAt: Scalars['Int']['output'];
    marketAddress?: Maybe<Scalars['String']['output']>;
    marketId?: Maybe<Scalars['String']['output']>;
    outcome?: Maybe<Scalars['Int']['output']>;
    probabilityD18?: Maybe<Scalars['String']['output']>;
    probabilityFloat?: Maybe<Scalars['Float']['output']>;
    questionId?: Maybe<Scalars['String']['output']>;
    resolver?: Maybe<Scalars['String']['output']>;
    scoredAt?: Maybe<Scalars['DateTimeISO']['output']>;
    used: Scalars['Boolean']['output'];
};
type AttestationSumAggregate = {
    __typename?: 'AttestationSumAggregate';
    blockNumber?: Maybe<Scalars['Int']['output']>;
    id?: Maybe<Scalars['Int']['output']>;
    time?: Maybe<Scalars['Int']['output']>;
};
type Category = {
    __typename?: 'Category';
    _count?: Maybe<CategoryCount>;
    conditionGroups: Array<ConditionGroup>;
    conditions: Array<Condition>;
    createdAt: Scalars['DateTimeISO']['output'];
    id: Scalars['Int']['output'];
    name: Scalars['String']['output'];
    slug: Scalars['String']['output'];
};
type CategoryAvgAggregate = {
    __typename?: 'CategoryAvgAggregate';
    id?: Maybe<Scalars['Float']['output']>;
};
type CategoryCount = {
    __typename?: 'CategoryCount';
    condition: Scalars['Int']['output'];
    condition_group: Scalars['Int']['output'];
};
type CategoryCountAggregate = {
    __typename?: 'CategoryCountAggregate';
    _all: Scalars['Int']['output'];
    createdAt: Scalars['Int']['output'];
    id: Scalars['Int']['output'];
    name: Scalars['Int']['output'];
    slug: Scalars['Int']['output'];
};
type CategoryGroupBy = {
    __typename?: 'CategoryGroupBy';
    _avg?: Maybe<CategoryAvgAggregate>;
    _count?: Maybe<CategoryCountAggregate>;
    _max?: Maybe<CategoryMaxAggregate>;
    _min?: Maybe<CategoryMinAggregate>;
    _sum?: Maybe<CategorySumAggregate>;
    createdAt: Scalars['DateTimeISO']['output'];
    id: Scalars['Int']['output'];
    name: Scalars['String']['output'];
    slug: Scalars['String']['output'];
};
type CategoryMaxAggregate = {
    __typename?: 'CategoryMaxAggregate';
    createdAt?: Maybe<Scalars['DateTimeISO']['output']>;
    id?: Maybe<Scalars['Int']['output']>;
    name?: Maybe<Scalars['String']['output']>;
    slug?: Maybe<Scalars['String']['output']>;
};
type CategoryMinAggregate = {
    __typename?: 'CategoryMinAggregate';
    createdAt?: Maybe<Scalars['DateTimeISO']['output']>;
    id?: Maybe<Scalars['Int']['output']>;
    name?: Maybe<Scalars['String']['output']>;
    slug?: Maybe<Scalars['String']['output']>;
};
type CategorySumAggregate = {
    __typename?: 'CategorySumAggregate';
    id?: Maybe<Scalars['Int']['output']>;
};
type Condition = {
    __typename?: 'Condition';
    _count?: Maybe<ConditionCount>;
    assertionId?: Maybe<Scalars['String']['output']>;
    assertionTimestamp?: Maybe<Scalars['Int']['output']>;
    attestations: Array<Attestation>;
    category?: Maybe<Category>;
    categoryId?: Maybe<Scalars['Int']['output']>;
    chainId: Scalars['Int']['output'];
    claimStatement: Scalars['String']['output'];
    conditionGroup?: Maybe<ConditionGroup>;
    conditionGroupId?: Maybe<Scalars['Int']['output']>;
    createdAt: Scalars['DateTimeISO']['output'];
    description: Scalars['String']['output'];
    displayOrder?: Maybe<Scalars['Int']['output']>;
    endTime: Scalars['Int']['output'];
    id: Scalars['String']['output'];
    openInterest: Scalars['String']['output'];
    predictions: Array<Prediction>;
    public: Scalars['Boolean']['output'];
    question: Scalars['String']['output'];
    resolvedToYes: Scalars['Boolean']['output'];
    /** Canonical resolver address for this condition (latest observed wins) */
    resolver?: Maybe<Scalars['String']['output']>;
    settled: Scalars['Boolean']['output'];
    settledAt?: Maybe<Scalars['Int']['output']>;
    shortName?: Maybe<Scalars['String']['output']>;
    similarMarkets: Array<Scalars['String']['output']>;
};
type ConditionAvgAggregate = {
    __typename?: 'ConditionAvgAggregate';
    assertionTimestamp?: Maybe<Scalars['Float']['output']>;
    categoryId?: Maybe<Scalars['Float']['output']>;
    chainId?: Maybe<Scalars['Float']['output']>;
    conditionGroupId?: Maybe<Scalars['Float']['output']>;
    displayOrder?: Maybe<Scalars['Float']['output']>;
    endTime?: Maybe<Scalars['Float']['output']>;
    settledAt?: Maybe<Scalars['Float']['output']>;
};
type ConditionCount = {
    __typename?: 'ConditionCount';
    attestations: Scalars['Int']['output'];
    predictions: Scalars['Int']['output'];
};
type ConditionCountAggregate = {
    __typename?: 'ConditionCountAggregate';
    _all: Scalars['Int']['output'];
    assertionId: Scalars['Int']['output'];
    assertionTimestamp: Scalars['Int']['output'];
    categoryId: Scalars['Int']['output'];
    chainId: Scalars['Int']['output'];
    claimStatement: Scalars['Int']['output'];
    conditionGroupId: Scalars['Int']['output'];
    createdAt: Scalars['Int']['output'];
    description: Scalars['Int']['output'];
    displayOrder: Scalars['Int']['output'];
    endTime: Scalars['Int']['output'];
    id: Scalars['Int']['output'];
    openInterest: Scalars['Int']['output'];
    public: Scalars['Int']['output'];
    question: Scalars['Int']['output'];
    resolvedToYes: Scalars['Int']['output'];
    resolver: Scalars['Int']['output'];
    settled: Scalars['Int']['output'];
    settledAt: Scalars['Int']['output'];
    shortName: Scalars['Int']['output'];
    similarMarkets: Scalars['Int']['output'];
};
type ConditionGroup = {
    __typename?: 'ConditionGroup';
    _count?: Maybe<ConditionGroupCount>;
    category?: Maybe<Category>;
    categoryId?: Maybe<Scalars['Int']['output']>;
    conditions: Array<Condition>;
    createdAt: Scalars['DateTimeISO']['output'];
    id: Scalars['Int']['output'];
    name: Scalars['String']['output'];
};
type ConditionGroupAvgAggregate = {
    __typename?: 'ConditionGroupAvgAggregate';
    categoryId?: Maybe<Scalars['Float']['output']>;
    id?: Maybe<Scalars['Float']['output']>;
};
type ConditionGroupBy = {
    __typename?: 'ConditionGroupBy';
    _avg?: Maybe<ConditionAvgAggregate>;
    _count?: Maybe<ConditionCountAggregate>;
    _max?: Maybe<ConditionMaxAggregate>;
    _min?: Maybe<ConditionMinAggregate>;
    _sum?: Maybe<ConditionSumAggregate>;
    assertionId?: Maybe<Scalars['String']['output']>;
    assertionTimestamp?: Maybe<Scalars['Int']['output']>;
    categoryId?: Maybe<Scalars['Int']['output']>;
    chainId: Scalars['Int']['output'];
    claimStatement: Scalars['String']['output'];
    conditionGroupId?: Maybe<Scalars['Int']['output']>;
    createdAt: Scalars['DateTimeISO']['output'];
    description: Scalars['String']['output'];
    displayOrder?: Maybe<Scalars['Int']['output']>;
    endTime: Scalars['Int']['output'];
    id: Scalars['String']['output'];
    openInterest: Scalars['String']['output'];
    public: Scalars['Boolean']['output'];
    question: Scalars['String']['output'];
    resolvedToYes: Scalars['Boolean']['output'];
    resolver?: Maybe<Scalars['String']['output']>;
    settled: Scalars['Boolean']['output'];
    settledAt?: Maybe<Scalars['Int']['output']>;
    shortName?: Maybe<Scalars['String']['output']>;
    similarMarkets?: Maybe<Array<Scalars['String']['output']>>;
};
type ConditionGroupCount = {
    __typename?: 'ConditionGroupCount';
    condition: Scalars['Int']['output'];
};
type ConditionGroupCountAggregate = {
    __typename?: 'ConditionGroupCountAggregate';
    _all: Scalars['Int']['output'];
    categoryId: Scalars['Int']['output'];
    createdAt: Scalars['Int']['output'];
    id: Scalars['Int']['output'];
    name: Scalars['Int']['output'];
};
type ConditionGroupGroupBy = {
    __typename?: 'ConditionGroupGroupBy';
    _avg?: Maybe<ConditionGroupAvgAggregate>;
    _count?: Maybe<ConditionGroupCountAggregate>;
    _max?: Maybe<ConditionGroupMaxAggregate>;
    _min?: Maybe<ConditionGroupMinAggregate>;
    _sum?: Maybe<ConditionGroupSumAggregate>;
    categoryId?: Maybe<Scalars['Int']['output']>;
    createdAt: Scalars['DateTimeISO']['output'];
    id: Scalars['Int']['output'];
    name: Scalars['String']['output'];
};
type ConditionGroupMaxAggregate = {
    __typename?: 'ConditionGroupMaxAggregate';
    categoryId?: Maybe<Scalars['Int']['output']>;
    createdAt?: Maybe<Scalars['DateTimeISO']['output']>;
    id?: Maybe<Scalars['Int']['output']>;
    name?: Maybe<Scalars['String']['output']>;
};
type ConditionGroupMinAggregate = {
    __typename?: 'ConditionGroupMinAggregate';
    categoryId?: Maybe<Scalars['Int']['output']>;
    createdAt?: Maybe<Scalars['DateTimeISO']['output']>;
    id?: Maybe<Scalars['Int']['output']>;
    name?: Maybe<Scalars['String']['output']>;
};
type ConditionGroupSumAggregate = {
    __typename?: 'ConditionGroupSumAggregate';
    categoryId?: Maybe<Scalars['Int']['output']>;
    id?: Maybe<Scalars['Int']['output']>;
};
type ConditionMaxAggregate = {
    __typename?: 'ConditionMaxAggregate';
    assertionId?: Maybe<Scalars['String']['output']>;
    assertionTimestamp?: Maybe<Scalars['Int']['output']>;
    categoryId?: Maybe<Scalars['Int']['output']>;
    chainId?: Maybe<Scalars['Int']['output']>;
    claimStatement?: Maybe<Scalars['String']['output']>;
    conditionGroupId?: Maybe<Scalars['Int']['output']>;
    createdAt?: Maybe<Scalars['DateTimeISO']['output']>;
    description?: Maybe<Scalars['String']['output']>;
    displayOrder?: Maybe<Scalars['Int']['output']>;
    endTime?: Maybe<Scalars['Int']['output']>;
    id?: Maybe<Scalars['String']['output']>;
    openInterest?: Maybe<Scalars['String']['output']>;
    public?: Maybe<Scalars['Boolean']['output']>;
    question?: Maybe<Scalars['String']['output']>;
    resolvedToYes?: Maybe<Scalars['Boolean']['output']>;
    resolver?: Maybe<Scalars['String']['output']>;
    settled?: Maybe<Scalars['Boolean']['output']>;
    settledAt?: Maybe<Scalars['Int']['output']>;
    shortName?: Maybe<Scalars['String']['output']>;
};
type ConditionMinAggregate = {
    __typename?: 'ConditionMinAggregate';
    assertionId?: Maybe<Scalars['String']['output']>;
    assertionTimestamp?: Maybe<Scalars['Int']['output']>;
    categoryId?: Maybe<Scalars['Int']['output']>;
    chainId?: Maybe<Scalars['Int']['output']>;
    claimStatement?: Maybe<Scalars['String']['output']>;
    conditionGroupId?: Maybe<Scalars['Int']['output']>;
    createdAt?: Maybe<Scalars['DateTimeISO']['output']>;
    description?: Maybe<Scalars['String']['output']>;
    displayOrder?: Maybe<Scalars['Int']['output']>;
    endTime?: Maybe<Scalars['Int']['output']>;
    id?: Maybe<Scalars['String']['output']>;
    openInterest?: Maybe<Scalars['String']['output']>;
    public?: Maybe<Scalars['Boolean']['output']>;
    question?: Maybe<Scalars['String']['output']>;
    resolvedToYes?: Maybe<Scalars['Boolean']['output']>;
    resolver?: Maybe<Scalars['String']['output']>;
    settled?: Maybe<Scalars['Boolean']['output']>;
    settledAt?: Maybe<Scalars['Int']['output']>;
    shortName?: Maybe<Scalars['String']['output']>;
};
type ConditionSumAggregate = {
    __typename?: 'ConditionSumAggregate';
    assertionTimestamp?: Maybe<Scalars['Int']['output']>;
    categoryId?: Maybe<Scalars['Int']['output']>;
    chainId?: Maybe<Scalars['Int']['output']>;
    conditionGroupId?: Maybe<Scalars['Int']['output']>;
    displayOrder?: Maybe<Scalars['Int']['output']>;
    endTime?: Maybe<Scalars['Int']['output']>;
    settledAt?: Maybe<Scalars['Int']['output']>;
};
type ConditionSummary = {
    __typename?: 'ConditionSummary';
    endTime?: Maybe<Scalars['Int']['output']>;
    id: Scalars['String']['output'];
    question?: Maybe<Scalars['String']['output']>;
    resolvedToYes: Scalars['Boolean']['output'];
    resolver?: Maybe<Scalars['String']['output']>;
    settled: Scalars['Boolean']['output'];
    shortName?: Maybe<Scalars['String']['output']>;
};
type ForecasterScoreType = {
    __typename?: 'ForecasterScoreType';
    accuracyScore: Scalars['Float']['output'];
    attester: Scalars['String']['output'];
    numScored: Scalars['Int']['output'];
    numTimeWeighted: Scalars['Int']['output'];
    sumErrorSquared: Scalars['Float']['output'];
    sumTimeWeightedError: Scalars['Float']['output'];
};
type LimitOrder = {
    __typename?: 'LimitOrder';
    _count?: Maybe<LimitOrderCount>;
    cancelledAt?: Maybe<Scalars['Int']['output']>;
    cancelledTxHash?: Maybe<Scalars['String']['output']>;
    chainId: Scalars['Int']['output'];
    counterparty?: Maybe<Scalars['String']['output']>;
    counterpartyCollateral: Scalars['String']['output'];
    createdAt: Scalars['DateTimeISO']['output'];
    filledAt?: Maybe<Scalars['Int']['output']>;
    filledTxHash?: Maybe<Scalars['String']['output']>;
    id: Scalars['Int']['output'];
    marketAddress: Scalars['String']['output'];
    orderId: Scalars['String']['output'];
    placedAt: Scalars['Int']['output'];
    placedTxHash: Scalars['String']['output'];
    predictions: Array<Prediction>;
    predictor: Scalars['String']['output'];
    predictorCollateral: Scalars['String']['output'];
    refCode?: Maybe<Scalars['String']['output']>;
    resolver: Scalars['String']['output'];
    status: LimitOrderStatus;
};
type LimitOrderCount = {
    __typename?: 'LimitOrderCount';
    predictions: Scalars['Int']['output'];
};
type LimitOrderStatus = 'cancelled' | 'filled' | 'pending';
type PnLType = {
    __typename?: 'PnLType';
    collateralAddress?: Maybe<Scalars['String']['output']>;
    collateralDecimals?: Maybe<Scalars['Int']['output']>;
    collateralSymbol?: Maybe<Scalars['String']['output']>;
    marketId: Scalars['Int']['output'];
    openPositionsPnL: Scalars['String']['output'];
    owner: Scalars['String']['output'];
    positionCount: Scalars['Int']['output'];
    positions: Array<Scalars['Int']['output']>;
    totalDeposits: Scalars['String']['output'];
    totalPnL: Scalars['String']['output'];
    totalWithdrawals: Scalars['String']['output'];
};
/** Position model to store on-chain prediction positions */
type Position = {
    __typename?: 'Position';
    _count?: Maybe<PositionCount>;
    chainId: Scalars['Int']['output'];
    counterparty: Scalars['String']['output'];
    counterpartyCollateral?: Maybe<Scalars['String']['output']>;
    counterpartyNftTokenId: Scalars['String']['output'];
    createdAt: Scalars['DateTimeISO']['output'];
    endsAt?: Maybe<Scalars['Int']['output']>;
    id: Scalars['Int']['output'];
    marketAddress: Scalars['String']['output'];
    mintedAt: Scalars['Int']['output'];
    predictions: Array<Prediction>;
    predictor: Scalars['String']['output'];
    predictorCollateral?: Maybe<Scalars['String']['output']>;
    predictorNftTokenId: Scalars['String']['output'];
    /** True when the predictor's submitted outcomes were correct (previously makerWon) */
    predictorWon?: Maybe<Scalars['Boolean']['output']>;
    refCode?: Maybe<Scalars['String']['output']>;
    settledAt?: Maybe<Scalars['Int']['output']>;
    status: PositionStatus;
    totalCollateral: Scalars['String']['output'];
};
type PositionCount = {
    __typename?: 'PositionCount';
    predictions: Scalars['Int']['output'];
};
type PositionStatus = 'active' | 'consolidated' | 'settled';
type PositionType = {
    __typename?: 'PositionType';
    chainId: Scalars['Int']['output'];
    counterparty: Scalars['String']['output'];
    counterpartyCollateral?: Maybe<Scalars['String']['output']>;
    counterpartyNftTokenId: Scalars['String']['output'];
    endsAt?: Maybe<Scalars['Int']['output']>;
    id: Scalars['Int']['output'];
    marketAddress: Scalars['String']['output'];
    mintedAt: Scalars['Int']['output'];
    predictions: Array<PredictionType>;
    predictor: Scalars['String']['output'];
    predictorCollateral?: Maybe<Scalars['String']['output']>;
    predictorNftTokenId: Scalars['String']['output'];
    predictorWon?: Maybe<Scalars['Boolean']['output']>;
    refCode?: Maybe<Scalars['String']['output']>;
    settledAt?: Maybe<Scalars['Int']['output']>;
    status: Scalars['String']['output'];
    totalCollateral: Scalars['String']['output'];
};
type Prediction = {
    __typename?: 'Prediction';
    chainId?: Maybe<Scalars['Int']['output']>;
    condition: Condition;
    conditionId: Scalars['String']['output'];
    createdAt: Scalars['DateTimeISO']['output'];
    id: Scalars['Int']['output'];
    limitOrder?: Maybe<LimitOrder>;
    limitOrderId?: Maybe<Scalars['Int']['output']>;
    outcomeYes: Scalars['Boolean']['output'];
    position?: Maybe<Position>;
    positionId?: Maybe<Scalars['Int']['output']>;
};
type PredictionType = {
    __typename?: 'PredictionType';
    chainId?: Maybe<Scalars['Int']['output']>;
    condition?: Maybe<ConditionSummary>;
    conditionId: Scalars['String']['output'];
    outcomeYes: Scalars['Boolean']['output'];
};
type ProfitRankType = {
    __typename?: 'ProfitRankType';
    owner: Scalars['String']['output'];
    rank?: Maybe<Scalars['Int']['output']>;
    totalParticipants: Scalars['Int']['output'];
    totalPnL: Scalars['Float']['output'];
};
type Query = {
    __typename?: 'Query';
    accuracyRankByAddress: AccuracyRankType;
    aggregateAttestation: AggregateAttestation;
    aggregateCategory: AggregateCategory;
    aggregateCondition: AggregateCondition;
    aggregateConditionGroup: AggregateConditionGroup;
    aggregateUser: AggregateUser;
    allTimeProfitLeaderboard: Array<AggregatedProfitEntryType>;
    attestation?: Maybe<Attestation>;
    attestations: Array<Attestation>;
    categories: Array<Category>;
    category?: Maybe<Category>;
    condition?: Maybe<Condition>;
    conditionGroup?: Maybe<ConditionGroup>;
    conditionGroups: Array<ConditionGroup>;
    conditions: Array<Condition>;
    findFirstAttestation?: Maybe<Attestation>;
    findFirstAttestationOrThrow?: Maybe<Attestation>;
    findFirstCategory?: Maybe<Category>;
    findFirstCategoryOrThrow?: Maybe<Category>;
    findFirstCondition?: Maybe<Condition>;
    findFirstConditionGroup?: Maybe<ConditionGroup>;
    findFirstConditionGroupOrThrow?: Maybe<ConditionGroup>;
    findFirstConditionOrThrow?: Maybe<Condition>;
    findFirstUser?: Maybe<User>;
    findFirstUserOrThrow?: Maybe<User>;
    forecasterScore?: Maybe<ForecasterScoreType>;
    getAttestation?: Maybe<Attestation>;
    getCategory?: Maybe<Category>;
    getCondition?: Maybe<Condition>;
    getConditionGroup?: Maybe<ConditionGroup>;
    getLeaderboard: Array<PnLType>;
    getUser?: Maybe<User>;
    groupByAttestation: Array<AttestationGroupBy>;
    groupByCategory: Array<CategoryGroupBy>;
    groupByCondition: Array<ConditionGroupBy>;
    groupByConditionGroup: Array<ConditionGroupGroupBy>;
    groupByUser: Array<UserGroupBy>;
    positions: Array<PositionType>;
    positionsByConditionId: Array<PositionType>;
    positionsCount: Scalars['Int']['output'];
    profitRankByAddress: ProfitRankType;
    topForecasters: Array<ForecasterScoreType>;
    user?: Maybe<User>;
    users: Array<User>;
};
/**
 * Application-level user record, keyed by wallet address,
 * used for referrals and other per-wallet metadata.
 */
type User = {
    __typename?: 'User';
    _count?: Maybe<UserCount>;
    /** Canonical Ethereum wallet address for this user. */
    address: Scalars['String']['output'];
    createdAt: Scalars['DateTimeISO']['output'];
    id: Scalars['Int']['output'];
    /**
     * Maximum number of referrals this user's code allows. Default is 0,
     * so codes are not usable until explicitly configured.
     */
    maxReferrals: Scalars['Int']['output'];
    /** keccak256(utf8(trimmed_lowercase_code)) stored as 0x-prefixed hex. */
    refCodeHash?: Maybe<Scalars['String']['output']>;
    referrals: Array<User>;
    referredBy?: Maybe<User>;
    referredById?: Maybe<Scalars['Int']['output']>;
    updatedAt: Scalars['DateTimeISO']['output'];
};
type UserAvgAggregate = {
    __typename?: 'UserAvgAggregate';
    id?: Maybe<Scalars['Float']['output']>;
    maxReferrals?: Maybe<Scalars['Float']['output']>;
    referredById?: Maybe<Scalars['Float']['output']>;
};
type UserCount = {
    __typename?: 'UserCount';
    referrals: Scalars['Int']['output'];
};
type UserCountAggregate = {
    __typename?: 'UserCountAggregate';
    _all: Scalars['Int']['output'];
    address: Scalars['Int']['output'];
    createdAt: Scalars['Int']['output'];
    id: Scalars['Int']['output'];
    maxReferrals: Scalars['Int']['output'];
    refCodeHash: Scalars['Int']['output'];
    referredById: Scalars['Int']['output'];
    updatedAt: Scalars['Int']['output'];
};
type UserGroupBy = {
    __typename?: 'UserGroupBy';
    _avg?: Maybe<UserAvgAggregate>;
    _count?: Maybe<UserCountAggregate>;
    _max?: Maybe<UserMaxAggregate>;
    _min?: Maybe<UserMinAggregate>;
    _sum?: Maybe<UserSumAggregate>;
    address: Scalars['String']['output'];
    createdAt: Scalars['DateTimeISO']['output'];
    id: Scalars['Int']['output'];
    maxReferrals: Scalars['Int']['output'];
    refCodeHash?: Maybe<Scalars['String']['output']>;
    referredById?: Maybe<Scalars['Int']['output']>;
    updatedAt: Scalars['DateTimeISO']['output'];
};
type UserMaxAggregate = {
    __typename?: 'UserMaxAggregate';
    address?: Maybe<Scalars['String']['output']>;
    createdAt?: Maybe<Scalars['DateTimeISO']['output']>;
    id?: Maybe<Scalars['Int']['output']>;
    maxReferrals?: Maybe<Scalars['Int']['output']>;
    refCodeHash?: Maybe<Scalars['String']['output']>;
    referredById?: Maybe<Scalars['Int']['output']>;
    updatedAt?: Maybe<Scalars['DateTimeISO']['output']>;
};
type UserMinAggregate = {
    __typename?: 'UserMinAggregate';
    address?: Maybe<Scalars['String']['output']>;
    createdAt?: Maybe<Scalars['DateTimeISO']['output']>;
    id?: Maybe<Scalars['Int']['output']>;
    maxReferrals?: Maybe<Scalars['Int']['output']>;
    refCodeHash?: Maybe<Scalars['String']['output']>;
    referredById?: Maybe<Scalars['Int']['output']>;
    updatedAt?: Maybe<Scalars['DateTimeISO']['output']>;
};
type UserSumAggregate = {
    __typename?: 'UserSumAggregate';
    id?: Maybe<Scalars['Int']['output']>;
    maxReferrals?: Maybe<Scalars['Int']['output']>;
    referredById?: Maybe<Scalars['Int']['output']>;
};

declare enum ChartType {
    PRICE = "Price Chart",
    DEPTH = "Depth",
    ORDER_BOOK = "Order Book",
    VOLUME = "VOLUME",
    LIQUIDITY = "LIQUIDITY"
}
declare enum TimeWindow {
    D = "D",
    W = "W",
    M = "M"
}
declare enum TimeInterval {
    I5M = "I5M",
    I15M = "I15M",
    I30M = "I30M",
    I4H = "I4H",
    I1D = "I1D"
}
declare enum LineType {
    MarketPrice = "marketPrice",
    IndexPrice = "indexPrice",
    ResourcePrice = "resourcePrice",
    TrailingAvgPrice = "trailingAvgPrice"
}

export { type Category as CategoryType, ChartType, LineType, type Query, TimeInterval, TimeWindow };