export type Maybe<T> = T | null;
export type InputMaybe<T> = Maybe<T>;
export type Exact<T extends { [key: string]: unknown }> = { [K in keyof T]: T[K] };
export type MakeOptional<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]?: Maybe<T[SubKey]> };
export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]: Maybe<T[SubKey]> };
export type MakeEmpty<T extends { [key: string]: unknown }, K extends keyof T> = { [_ in K]?: never };
export type Incremental<T> = T | { [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never };
/** All built-in and custom scalars, mapped to their actual values */
export 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; }
  BigDecimal: { input: any; output: any; }
  BigInt: { input: any; output: any; }
  Bytes: { input: any; output: any; }
};

export type Position = {
  __typename?: 'Position';
  creationTime: Scalars['Int']['output'];
  id: Scalars['Bytes']['output'];
  lastTaxTime?: Maybe<Scalars['Int']['output']>;
  owner: Scalars['Bytes']['output'];
  share: Scalars['BigDecimal']['output'];
  status: PositionStatus;
  taxRate: Scalars['BigDecimal']['output'];
};

export enum PositionStatus {
  Active = 'Active',
  Closed = 'Closed'
}

export type Query = {
  __typename?: 'Query';
  positions?: Maybe<Array<Maybe<Position>>>;
  stats?: Maybe<Array<Maybe<Stats>>>;
};

export type Stats = {
  __typename?: 'Stats';
  activeSupply: Scalars['BigInt']['output'];
  id: Scalars['Bytes']['output'];
  outstandingSupply: Scalars['BigInt']['output'];
};

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


export type GetPositionsQuery = { __typename?: 'Query', positions?: Array<{ __typename?: 'Position', id: any, owner: any, share: any, creationTime: number, lastTaxTime?: number | null, taxRate: any, status: PositionStatus } | null> | null };