function makeArrowStyles(direction: string, color: string, size: number): any {
  let arrowStyles;

  if (direction === 'topLeft') {
    arrowStyles = {
      borderLeft: `${size}px solid transparent`,
      borderRight: `${size}px solid transparent`,
      borderBottom: `${size}px solid ${color}`,
      borderTop: 0,
      top: `-${size}px`,
      left: `${size}px`,
    };
  }

  if (direction === 'topCenter') {
    arrowStyles = {
      borderLeft: `${size}px solid transparent`,
      borderRight: `${size}px solid transparent`,
      borderBottom: `${size}px solid ${color}`,
      borderTop: 0,
      top: `-${size}px`,
      left: `calc(50% - ${size}px)`,
    };
  }

  if (direction === 'topRight') {
    arrowStyles = {
      borderLeft: `${size}px solid transparent`,
      borderRight: `${size}px solid transparent`,
      borderBottom: `${size}px solid ${color}`,
      borderTop: 0,
      top: `-${size}px`,
      right: `${size}px`,
    };
  }

  if (direction === 'rightTop') {
    arrowStyles = {
      borderLeft: `${size}px solid ${color}`,
      borderRight: 0,
      borderBottom: `${size}px solid transparent`,
      borderTop: `${size}px solid transparent`,
      right: `-${size}px`,
      top: `${size}px`,
    };
  }

  if (direction === 'rightCenter') {
    arrowStyles = {
      borderLeft: `${size}px solid ${color}`,
      borderRight: 0,
      borderBottom: `${size}px solid transparent`,
      borderTop: `${size}px solid transparent`,
      right: `-${size}px`,
      top: `calc(50% - ${size}px)`,
    };
  }

  if (direction === 'rightBottom') {
    arrowStyles = {
      borderLeft: `${size}px solid ${color}`,
      borderRight: 0,
      borderBottom: `${size}px solid transparent`,
      borderTop: `${size}px solid transparent`,
      right: `-${size}px`,
      bottom: `${size}px`,
    };
  }

  if (direction === 'bottomRight') {
    arrowStyles = {
      borderLeft: `${size}px solid transparent`,
      borderRight: `${size}px solid transparent`,
      borderBottom: 0,
      borderTop: `${size}px solid ${color}`,
      right: `${size}px`,
      bottom: `-${size}px`,
    };
  }

  if (direction === 'bottomCenter') {
    arrowStyles = {
      borderLeft: `${size}px solid transparent`,
      borderRight: `${size}px solid transparent`,
      borderBottom: 0,
      borderTop: `${size}px solid ${color}`,
      right: `calc(50% - ${size}px)`,
      bottom: `-${size}px`,
    };
  }

  if (direction === 'bottomLeft') {
    arrowStyles = {
      borderLeft: `${size}px solid transparent`,
      borderRight: `${size}px solid transparent`,
      borderBottom: 0,
      borderTop: `${size}px solid ${color}`,
      left: `${size}px`,
      bottom: `-${size}px`,
    };
  }

  if (direction === 'leftBottom') {
    arrowStyles = {
      borderLeft: 0,
      borderRight: `${size}px solid ${color}`,
      borderBottom: `${size}px solid transparent`,
      borderTop: `${size}px solid transparent`,
      left: `-${size}px`,
      bottom: `${size}px`,
    };
  }

  if (direction === 'leftCenter') {
    arrowStyles = {
      borderLeft: 0,
      borderRight: `${size}px solid ${color}`,
      borderBottom: `${size}px solid transparent`,
      borderTop: `${size}px solid transparent`,
      left: `-${size}px`,
      bottom: `calc(50% - ${size}px)`,
    };
  }

  if (direction === 'leftTop') {
    arrowStyles = {
      borderLeft: 0,
      borderRight: `${size}px solid ${color}`,
      borderBottom: `${size}px solid transparent`,
      borderTop: `${size}px solid transparent`,
      left: `-${size}px`,
      top: `${size}px`,
    };
  }

  return arrowStyles;
}


function setTranslation(direction = 'topCenter', size: number) {
  let x = '0px';
  let y = '0px';

  if (direction === 'topLeft') {
    x = -(size * 2) + 'px';
    y = (size + BUFFER) + 'px';
  }

  if (direction === 'topCenter') {
    x = '-50%';
    y = (size + BUFFER) + 'px';
  }

  if (direction === 'topRight') {
    x = 'calc(-100% + ' + (size * 2) + 'px)';
    y = (size + BUFFER) + 'px';
  }

  if (direction === 'rightTop') {
    x = 'calc(-100% + ' + (-size - BUFFER) + 'px)';
    y = -(size * 2) + 'px';
  }

  if (direction === 'rightCenter') {
    x = 'calc(-100% + ' + (-size - BUFFER) + 'px)';
    y = '-50%';
  }

  if (direction === 'rightBottom') {
    x = 'calc(-100% + ' + (-size - BUFFER) + 'px)';
    y = 'calc(-100% + ' + (size * 2) + 'px)';
  }

  if (direction === 'bottomRight') {
    x = 'calc(-100% + ' + (size * 2) + 'px)';
    y = 'calc(-100% + ' + (-size - BUFFER) + 'px)';
  }

  if (direction === 'bottomCenter') {
    x = '-50%';
    y = 'calc(-100% + ' + (-size - BUFFER) + 'px)';
  }

  if (direction === 'bottomLeft') {
    x = -(size * 2) + 'px';
    y = 'calc(-100% + ' + (-size - BUFFER) + 'px)';
  }

  if (direction === 'leftBottom') {
    x = (size + BUFFER) + 'px';
    y = 'calc(-100% + ' + (size * 2) + 'px)';
  }

  if (direction === 'leftCenter') {
    x = (size + BUFFER) + 'px';
    y = '-50%';
  }

  if (direction === 'leftTop') {
    x = (size + BUFFER) + 'px';
    y = -(size * 2) + 'px';
  }

  return `translate(${x}, ${y})`;
}


(direction: string, color: string, size: number): React.CSSProperties => {
  return {
    ...base,
    ...makeArrowStyles(direction, color, size),
  };
}


() => window.addEventListener('click', this.checkClick)


export class ToolTip extends React.PureComponent<IToolTipProps, IToolTipState> {
  container: HTMLDivElement = null;

  state = {
    isVisible: this.props.isVisible,
  };

  componentDidMount() {
    if (this.props.onDeactivate) {
      setTimeout(() => window.addEventListener('click', this.checkClick), 60);
    }
  }

  componentWillUpdate(nextProps: IToolTipProps) {
    if (this.props.isVisible !== nextProps.isVisible) {
      this.setState({
        isVisible: nextProps.isVisible,
      });
    }
  }

  componentWillUnmount() {
    window.removeEventListener('click', this.checkClick);
  }

  @autobind
  saveContainerRef(el: HTMLDivElement) {
    this.container = el;
  }

  @autobind
  checkClick(e: any) {
    e.preventDefault();
    if (!this.container || this.container.contains(e.target as any)) {
      return;
    }
    this.setState({
      isVisible: false,
    });
    if (this.props.onDeactivate) {
      this.props.onDeactivate();
    }
  }

  render() {
    const {
      arrowPosition,
      backgroundColor,
      hasDropShadow,
      children,
      position,
      size,
      zIndex,
      width,
    } = this.props;

    const {
      isVisible,
    } = this.state;

    return (
      <div
        ref={this.saveContainerRef}
        {...css(
          STYLES.base,
          { position: 'absolute', backgroundColor },
          width && { width },
          position && {
            left: position.left,
            top: position.top,
            transform: setTranslation(arrowPosition, size),
          },
          !isVisible && { display: 'none' },
          zIndex ? { zIndex } : { zIndex: TOOLTIP_Z_INDEX },
          hasDropShadow && { filter: 'drop-shadow(0px 0px 25px rgba(0, 0, 0, 0.117647))' },
        )}
      >
        {children}
        <div {...css(makeArrow(this.props.arrowPosition, this.props.backgroundColor, this.props.size))} />
      </div>
    );
  }
}


export interface IToolTipProps extends React.Props<any> {
  arrowPosition?: ArrowPosition;
  backgroundColor: string;
  hasDropShadow?: boolean;
  isVisible: boolean;
  size: number;
  position?: {
    top: number,
    left: number,
  };
  zIndex?: number;
  onDeactivate?(): any;
  width?: number;
}


export interface IToolTipState {
  isVisible: boolean;
}


export type ArrowPosition = 'topLeft' | 'topCenter' | 'topRight' | 'rightTop' |
  'rightCenter' | 'rightBottom' | 'bottomRight' | 'bottomCenter' |
  'bottomLeft' | 'leftBottom' | 'leftCenter' | 'leftTop';


componentDidMount() {
    if (this.props.onDeactivate) {
      setTimeout(() => window.addEventListener('click', this.checkClick), 60);
    }
  }


componentWillUpdate(nextProps: IToolTipProps) {
    if (this.props.isVisible !== nextProps.isVisible) {
      this.setState({
        isVisible: nextProps.isVisible,
      });
    }
  }


componentWillUnmount() {
    window.removeEventListener('click', this.checkClick);
  }


@autobind
  saveContainerRef(el: HTMLDivElement) {
    this.container = el;
  }


@autobind
  checkClick(e: any) {
    e.preventDefault();
    if (!this.container || this.container.contains(e.target as any)) {
      return;
    }
    this.setState({
      isVisible: false,
    });
    if (this.props.onDeactivate) {
      this.props.onDeactivate();
    }
  }


render() {
    const {
      arrowPosition,
      backgroundColor,
      hasDropShadow,
      children,
      position,
      size,
      zIndex,
      width,
    } = this.props;

    const {
      isVisible,
    } = this.state;

    return (
      <div
        ref={this.saveContainerRef}
        {...css(
          STYLES.base,
          { position: 'absolute', backgroundColor },
          width && { width },
          position && {
            left: position.left,
            top: position.top,
            transform: setTranslation(arrowPosition, size),
          },
          !isVisible && { display: 'none' },
          zIndex ? { zIndex } : { zIndex: TOOLTIP_Z_INDEX },
          hasDropShadow && { filter: 'drop-shadow(0px 0px 25px rgba(0, 0, 0, 0.117647))' },
        )}
      >
        {children}
        <div {...css(makeArrow(this.props.arrowPosition, this.props.backgroundColor, this.props.size))} />
      </div>
    );
  }


@Controller('categorias')
export class CategoriaController {
  constructor(
      private readonly categoriaService: CategoriaService,
  ) {}

  @Get()
  @HttpCode(200)
  async get() {
    return await this.categoriaService.get();
  }

  @Post()
  @HttpCode(200)
  async insert(@Body() categoria:Categoria) {
      return await this.categoriaService.save(new Categoria(categoria));
  }

  @Put()
  @HttpCode(200)
  async update(@Body() categoria:Categoria) {
    return await this.categoriaService.save(new Categoria(categoria));
  }

  @Delete(':id')
  @HttpCode(200)
  async delete(@Param('id') id:number) {
    return await this.categoriaService.delete(id);
  }
}


@Get()
  @HttpCode(200)
  async get() {
    return await this.categoriaService.get();
  }


@Post()
  @HttpCode(200)
  async insert(@Body() categoria:Categoria) {
      return await this.categoriaService.save(new Categoria(categoria));
  }


@Put()
  @HttpCode(200)
  async update(@Body() categoria:Categoria) {
    return await this.categoriaService.save(new Categoria(categoria));
  }


@Delete(':id')
  @HttpCode(200)
  async delete(@Param('id') id:number) {
    return await this.categoriaService.delete(id);
  }


async (packet: IlpPrepare, next: MiddlewareCallback<IlpPrepare, IlpReply>) => {
            const { amount } = packet

            // TODO: Do we need a BigNumber-based token bucket?
            if (!incomingBucket.take(Number(amount))) {
              throw new InsufficientLiquidityError('exceeded money bandwidth, throttling.')
            }

            return next(packet)
          }


export default class ThroughputMiddleware implements Middleware {

  async applyToPipelines (pipelines: Pipelines, account: Account) {
    if (account.info.throughput) {
      const {
        refillPeriod = DEFAULT_REFILL_PERIOD,
        incomingAmount = false,
        outgoingAmount = false
      } = account.info.throughput || {}

      if (incomingAmount) {
        // TODO: When we add the ability to update middleware, our state will get
        //   reset every update, which may not be desired.
        const incomingBucket = new TokenBucket({ refillPeriod, refillCount: Number(incomingAmount) })
        log.trace('created incoming amount limit token bucket for account. accountId=%s refillPeriod=%s incomingAmount=%s',
          account.id, refillPeriod, incomingAmount)

        pipelines.incomingData.insertLast({
          name: 'throughput',
          method: async (packet: IlpPrepare, next: MiddlewareCallback<IlpPrepare, IlpReply>) => {
            const { amount } = packet

            // TODO: Do we need a BigNumber-based token bucket?
            if (!incomingBucket.take(Number(amount))) {
              throw new InsufficientLiquidityError('exceeded money bandwidth, throttling.')
            }

            return next(packet)
          }
        })
      }

      if (outgoingAmount) {
        // TODO: When we add the ability to update middleware, our state will get
        //   reset every update, which may not be desired.
        const incomingBucket = new TokenBucket({ refillPeriod, refillCount: Number(outgoingAmount) })
        log.trace('created outgoing amount limit token bucket for account. accountId=%s refillPeriod=%s outgoingAmount=%s',
          account.id, refillPeriod, outgoingAmount)

        pipelines.outgoingData.insertLast({
          name: 'throughput',
          method: async (packet: IlpPrepare, next: MiddlewareCallback<IlpPrepare, IlpReply>) => {
            const { amount } = packet

            // TODO: Do we need a BigNumber-based token bucket?
            if (!incomingBucket.take(Number(amount))) {
              throw new InsufficientLiquidityError('exceeded money bandwidth, throttling.')
            }

            return next(packet)
          }
        })
      }
    }
  }
}


async applyToPipelines (pipelines: Pipelines, account: Account) {
    if (account.info.throughput) {
      const {
        refillPeriod = DEFAULT_REFILL_PERIOD,
        incomingAmount = false,
        outgoingAmount = false
      } = account.info.throughput || {}

      if (incomingAmount) {
        // TODO: When we add the ability to update middleware, our state will get
        //   reset every update, which may not be desired.
        const incomingBucket = new TokenBucket({ refillPeriod, refillCount: Number(incomingAmount) })
        log.trace('created incoming amount limit token bucket for account. accountId=%s refillPeriod=%s incomingAmount=%s',
          account.id, refillPeriod, incomingAmount)

        pipelines.incomingData.insertLast({
          name: 'throughput',
          method: async (packet: IlpPrepare, next: MiddlewareCallback<IlpPrepare, IlpReply>) => {
            const { amount } = packet

            // TODO: Do we need a BigNumber-based token bucket?
            if (!incomingBucket.take(Number(amount))) {
              throw new InsufficientLiquidityError('exceeded money bandwidth, throttling.')
            }

            return next(packet)
          }
        })
      }

      if (outgoingAmount) {
        // TODO: When we add the ability to update middleware, our state will get
        //   reset every update, which may not be desired.
        const incomingBucket = new TokenBucket({ refillPeriod, refillCount: Number(outgoingAmount) })
        log.trace('created outgoing amount limit token bucket for account. accountId=%s refillPeriod=%s outgoingAmount=%s',
          account.id, refillPeriod, outgoingAmount)

        pipelines.outgoingData.insertLast({
          name: 'throughput',
          method: async (packet: IlpPrepare, next: MiddlewareCallback<IlpPrepare, IlpReply>) => {
            const { amount } = packet

            // TODO: Do we need a BigNumber-based token bucket?
            if (!incomingBucket.take(Number(amount))) {
              throw new InsufficientLiquidityError('exceeded money bandwidth, throttling.')
            }

            return next(packet)
          }
        })
      }
    }
  }


() => localeCN


export default class Calendar extends React.Component<CalendarProps, any> {
  static defaultProps = {
    prefixCls: 'am-calendar',
    timePickerPrefixCls: 'am-picker',
    timePickerPickerPrefixCls: 'am-picker-col'
  };

  static contextTypes = {
    antLocale: PropTypes.object
  };

  render() {
    // tslint:disable-next-line:no-this-assignment
    const { props, context } = this;
    const locale = getComponentLocale(props, context, 'Calendar', () => localeCN
    );
    const Header = RMCalendar.DefaultHeader;

    return (
      <RMCalendar
        locale={locale}
        // tslint:disable-next-line:jsx-no-multiline-js
        renderHeader={headerProps => (
          <Header {...headerProps} closeIcon={<Icon type="cross" />}


render() {
    // tslint:disable-next-line:no-this-assignment
    const { props, context } = this;
    const locale = getComponentLocale(props, context, 'Calendar', () => localeCN
    );
    const Header = RMCalendar.DefaultHeader;

    return (
      <RMCalendar
        locale={locale}
        // tslint:disable-next-line:jsx-no-multiline-js
        renderHeader={headerProps => (
          <Header {...headerProps} closeIcon={<Icon type="cross" />}


@Component({
  selector: 'verseghy-toast',
  templateUrl: './toast.component.html',
  styleUrls: ['./toast.component.scss'],
  animations: [
    trigger('toast', [
      transition(':enter', [
        style({
          opacity: 0,
          transform: 'translate3d(0, calc(100% + 10px), 0)',
        }),
        animate(
          '200ms ease-out',
          style({
            opacity: 1,
            transform: 'translate3d(0, 0, 0)',
          })
        ),
      ]),
      transition(':leave', [
        style({
          opacity: 1,
          transform: 'translate3d(0, 0, 0)',
        }),
        animate(
          '200ms ease-in',
          style({
            opacity: 0,
            transform: 'translate3d(0, calc(100% + 10px), 0)',
          })
        ),
      ]),
    ]),
  ],
  changeDetection: ChangeDetectionStrategy.OnPush,
})
export class ToastComponent {
  toast$ = this.toastService.toast$

  constructor(private toastService: ToastService) {}
}


({
  attributes,
  children,
  element,
}: ElementProps) => {
  switch (element.type) {
    case ElementType['heading_one']:
      return <RichTextH1 {...attributes}>{children}</RichTextH1>;
    case ElementType['heading_two']:
      return <RichTextH2 {...attributes}>{children}</RichTextH2>;
    case ElementType['heading_three']:
      return <RichTextH3 {...attributes}>{children}</RichTextH3>;
    case ElementType['list_item']:
      return <RichTextLi {...attributes}>{children}</RichTextLi>;
    case ElementType['ol_list']:
      return <RichTextOl {...attributes}>{children}</RichTextOl>;
    case ElementType['ul_list']:
      return <RichTextUl {...attributes}>{children}</RichTextUl>;
    default:
      return <RichTextP {...attributes}>{children}</RichTextP>;
  }
}


export interface ElementProps {
  attributes: { [key: string]: string | number | boolean };
  children: React.ReactNode;
  element: CustomElement;
}


export enum ElementType {
  'heading_one' = 'heading_one',
  'heading_two' = 'heading_two',
  'heading_three' = 'heading_three',
  'ol_list' = 'ol_list',
  'ul_list' = 'ul_list',
  'list_item' = 'list_item',
  'paragraph' = 'paragraph',
}


export type CustomText = {
  bold?: boolean;
  italic?: boolean;
  underline?: boolean;
} & Text;


export type CustomDescendant = CustomElement | CustomText;


export type CustomElement = { type: ElementType; children: CustomDescendant[] } & SlateElement;


(props) => props.theme.spacing[3]


({ theme }) => theme.mediaQueries.lg


() => {
  const [requestedApproval, setRequestedApproval] = useState(false)
  const TranslateString = useI18n()
  const allowance = useLotteryAllowance()
  const { onApprove } = useLotteryApprove()
  const lotteryHasDrawn = useGetLotteryHasDrawn()
  const cakeBalance = useTokenBalance(getCakeAddress())

  const tickets = useTickets()
  const ticketsLength = tickets.length
  const [onPresentMyTickets] = useModal(<MyTicketsModal myTicketNumbers={tickets} from="buy" />)
  const [onPresentApprove] = useModal(<PurchaseWarningModal />)
  const [onPresentBuy] = useModal(<BuyTicketModal max={cakeBalance} tokenName="CAKE" />)

  const handleApprove = useCallback(async () => {
    try {
      setRequestedApproval(true)
      const txHash = await onApprove()
      // user rejected tx or didn't go thru
      if (!txHash) {
        setRequestedApproval(false)
      }
      onPresentApprove()
    } catch (e) {
      console.error(e)
    }
  }, [onApprove, onPresentApprove])

  const renderLotteryTicketButtons = () => {
    if (!allowance.toNumber()) {
      return (
        <>
          <Button fullWidth disabled>
            {TranslateString(432, 'View your tickets')}
          </Button>
          <Button fullWidth disabled={requestedApproval} onClick={handleApprove}>
            {TranslateString(999, 'Approve ANO')}
          </Button>
        </>


async () => {
    try {
      setRequestedApproval(true)
      const txHash = await onApprove()
      // user rejected tx or didn't go thru
      if (!txHash) {
        setRequestedApproval(false)
      }
      onPresentApprove()
    } catch (e) {
      console.error(e)
    }
  }


() => {
    if (!allowance.toNumber()) {
      return (
        <>
          <Button fullWidth disabled>
            {TranslateString(432, 'View your tickets')}
          </Button>
          <Button fullWidth disabled={requestedApproval} onClick={handleApprove}>
            {TranslateString(999, 'Approve ANO')}
          </Button>
        </>


TranslateString(432, 'View your tickets')


TranslateString(999, 'Approve ANO')


TranslateString(430, 'Buy ticket')


lotteryHasDrawn ? (
        <Button disabled


TranslateString(999, 'On sale soon')


() => {
        if (this.props.textCase === 'upper') return css.upperCase;
        return css[`font-size-${this.props.size === '30' ? '13' : '14'}`];
    }


() => (
        <div className={ css.tooltipWrapper }>
            <Tooltip
                trigger


() => this.props.column.info


() => this.props.selectAll && this.props.isFirstColumn && (
        <Checkbox
            size


(props: HeaderCellContentProps) => (
        <div onMouseDown={ props.onResizeStart }


(props: HeaderCellContentProps, dropdownProps?: IDropdownToggler) => (
        <FlexCell
            { ...this.props.column }


(props: HeaderCellContentProps) => (
        <ColumnHeaderDropdown
            isOpen={ this.state.isDropdownOpen }


export class DataTableHeaderCell<TItem, TId> extends React.Component<DataTableHeaderCellProps<TItem, TId> & DataTableHeaderCellMods, DataTableHeaderCellState> {
    state: DataTableHeaderCellState = {
        isDropdownOpen: null,
    };

    getTextStyle = () => {
        if (this.props.textCase === 'upper') return css.upperCase;
        return css[`font-size-${this.props.size === '30' ? '13' : '14'}`];
    }

    getColumnCaption = () => (
        <div className={ css.tooltipWrapper }>
            <Tooltip
                trigger="hover"
                placement="bottom-start"
                renderContent={ (!this.state.isDropdownOpen && this.props.column.info) ? () => this.props.column.info : null }


interface DataTableHeaderCellState {
    isDropdownOpen: boolean;
}


cx(css


export enum Bundle_OrderBy {
  Id = 'id',
  EthPrice = 'ethPrice'
}


export enum Burn_OrderBy {
  Id = 'id',
  Transaction = 'transaction',
  Timestamp = 'timestamp',
  Pair = 'pair',
  Liquidity = 'liquidity',
  Sender = 'sender',
  Amount0 = 'amount0',
  Amount1 = 'amount1',
  To = 'to',
  LogIndex = 'logIndex',
  AmountUsd = 'amountUSD',
  Complete = 'complete',
  FeeTo = 'feeTo',
  FeeLiquidity = 'feeLiquidity'
}


export enum DayData_OrderBy {
  Id = 'id',
  Date = 'date',
  Factory = 'factory',
  VolumeEth = 'volumeETH',
  VolumeUsd = 'volumeUSD',
  UntrackedVolume = 'untrackedVolume',
  LiquidityEth = 'liquidityETH',
  LiquidityUsd = 'liquidityUSD',
  TxCount = 'txCount'
}


export enum Factory_OrderBy {
  Id = 'id',
  PairCount = 'pairCount',
  VolumeUsd = 'volumeUSD',
  VolumeEth = 'volumeETH',
  UntrackedVolumeUsd = 'untrackedVolumeUSD',
  LiquidityUsd = 'liquidityUSD',
  LiquidityEth = 'liquidityETH',
  TxCount = 'txCount',
  TokenCount = 'tokenCount',
  UserCount = 'userCount',
  Pairs = 'pairs',
  Tokens = 'tokens',
  HourData = 'hourData',
  DayData = 'dayData'
}


export enum HourData_OrderBy {
  Id = 'id',
  Date = 'date',
  Factory = 'factory',
  VolumeEth = 'volumeETH',
  VolumeUsd = 'volumeUSD',
  UntrackedVolume = 'untrackedVolume',
  LiquidityEth = 'liquidityETH',
  LiquidityUsd = 'liquidityUSD',
  TxCount = 'txCount'
}


export enum LiquidityPositionSnapshot_OrderBy {
  Id = 'id',
  LiquidityPosition = 'liquidityPosition',
  Timestamp = 'timestamp',
  Block = 'block',
  User = 'user',
  Pair = 'pair',
  Token0PriceUsd = 'token0PriceUSD',
  Token1PriceUsd = 'token1PriceUSD',
  Reserve0 = 'reserve0',
  Reserve1 = 'reserve1',
  ReserveUsd = 'reserveUSD',
  LiquidityTokenTotalSupply = 'liquidityTokenTotalSupply',
  LiquidityTokenBalance = 'liquidityTokenBalance'
}


export enum LiquidityPosition_OrderBy {
  Id = 'id',
  User = 'user',
  Pair = 'pair',
  LiquidityTokenBalance = 'liquidityTokenBalance',
  Snapshots = 'snapshots',
  Block = 'block',
  Timestamp = 'timestamp'
}


export enum Mint_OrderBy {
  Id = 'id',
  Transaction = 'transaction',
  Timestamp = 'timestamp',
  Pair = 'pair',
  To = 'to',
  Liquidity = 'liquidity',
  Sender = 'sender',
  Amount0 = 'amount0',
  Amount1 = 'amount1',
  LogIndex = 'logIndex',
  AmountUsd = 'amountUSD',
  FeeTo = 'feeTo',
  FeeLiquidity = 'feeLiquidity'
}


export enum OrderDirection {
  Asc = 'asc',
  Desc = 'desc'
}


export enum PairDayData_OrderBy {
  Id = 'id',
  Date = 'date',
  Pair = 'pair',
  Token0 = 'token0',
  Token1 = 'token1',
  Reserve0 = 'reserve0',
  Reserve1 = 'reserve1',
  TotalSupply = 'totalSupply',
  ReserveUsd = 'reserveUSD',
  VolumeToken0 = 'volumeToken0',
  VolumeToken1 = 'volumeToken1',
  VolumeUsd = 'volumeUSD',
  TxCount = 'txCount'
}


export enum PairHourData_OrderBy {
  Id = 'id',
  Date = 'date',
  Pair = 'pair',
  Reserve0 = 'reserve0',
  Reserve1 = 'reserve1',
  ReserveUsd = 'reserveUSD',
  VolumeToken0 = 'volumeToken0',
  VolumeToken1 = 'volumeToken1',
  VolumeUsd = 'volumeUSD',
  TxCount = 'txCount'
}


export enum Pair_OrderBy {
  Id = 'id',
  Factory = 'factory',
  Name = 'name',
  Token0 = 'token0',
  Token1 = 'token1',
  Reserve0 = 'reserve0',
  Reserve1 = 'reserve1',
  TotalSupply = 'totalSupply',
  ReserveEth = 'reserveETH',
  ReserveUsd = 'reserveUSD',
  TrackedReserveEth = 'trackedReserveETH',
  Token0Price = 'token0Price',
  Token1Price = 'token1Price',
  VolumeToken0 = 'volumeToken0',
  VolumeToken1 = 'volumeToken1',
  VolumeUsd = 'volumeUSD',
  UntrackedVolumeUsd = 'untrackedVolumeUSD',
  TxCount = 'txCount',
  LiquidityProviderCount = 'liquidityProviderCount',
  LiquidityPositions = 'liquidityPositions',
  LiquidityPositionSnapshots = 'liquidityPositionSnapshots',
  DayData = 'dayData',
  HourData = 'hourData',
  Mints = 'mints',
  Burns = 'burns',
  Swaps = 'swaps',
  Timestamp = 'timestamp',
  Block = 'block'
}


export enum Swap_OrderBy {
  Id = 'id',
  Transaction = 'transaction',
  Timestamp = 'timestamp',
  Pair = 'pair',
  Sender = 'sender',
  Amount0In = 'amount0In',
  Amount1In = 'amount1In',
  Amount0Out = 'amount0Out',
  Amount1Out = 'amount1Out',
  To = 'to',
  LogIndex = 'logIndex',
  AmountUsd = 'amountUSD'
}


export enum TokenDayData_OrderBy {
  Id = 'id',
  Date = 'date',
  Token = 'token',
  Volume = 'volume',
  VolumeEth = 'volumeETH',
  VolumeUsd = 'volumeUSD',
  TxCount = 'txCount',
  Liquidity = 'liquidity',
  LiquidityEth = 'liquidityETH',
  LiquidityUsd = 'liquidityUSD',
  PriceUsd = 'priceUSD'
}


export enum TokenHourData_OrderBy {
  Id = 'id',
  Date = 'date',
  Token = 'token',
  Volume = 'volume',
  VolumeEth = 'volumeETH',
  VolumeUsd = 'volumeUSD',
  TxCount = 'txCount',
  Liquidity = 'liquidity',
  LiquidityEth = 'liquidityETH',
  LiquidityUsd = 'liquidityUSD',
  PriceUsd = 'priceUSD'
}


export enum Token_OrderBy {
  Id = 'id',
  Factory = 'factory',
  Symbol = 'symbol',
  Name = 'name',
  Decimals = 'decimals',
  TotalSupply = 'totalSupply',
  Volume = 'volume',
  VolumeUsd = 'volumeUSD',
  UntrackedVolumeUsd = 'untrackedVolumeUSD',
  TxCount = 'txCount',
  Liquidity = 'liquidity',
  DerivedEth = 'derivedETH',
  HourData = 'hourData',
  DayData = 'dayData',
  BasePairs = 'basePairs',
  QuotePairs = 'quotePairs',
  BasePairsDayData = 'basePairsDayData',
  QuotePairsDayData = 'quotePairsDayData'
}


export enum Transaction_OrderBy {
  Id = 'id',
  BlockNumber = 'blockNumber',
  Timestamp = 'timestamp',
  Mints = 'mints',
  Burns = 'burns',
  Swaps = 'swaps'
}


export enum User_OrderBy {
  Id = 'id',
  LiquidityPositions = 'liquidityPositions'
}


export enum _SubgraphErrorPolicy_ {
  /** Data will be returned even if the subgraph has indexing errors */
  Allow = 'allow',
  /** If the subgraph has indexing errors, data will be omitted. The default. */
  Deny = 'deny'
}


/** All built-in and custom scalars, mapped to their actual values */
export type Scalars = {
  ID: string;
  String: string;
  Boolean: boolean;
  Int: number;
  Float: number;
  BigDecimal: any;
  BigInt: any;
  Bytes: any;
};


export type Block_Height = {
  hash?: Maybe<Scalars['Bytes']>;
  number?: Maybe<Scalars['Int']>;
  number_gte?: Maybe<Scalars['Int']>;
};


export type Bundle = {
  __typename?: 'Bundle';
  id: Scalars['ID'];
  ethPrice: Scalars['BigDecimal'];
};


export type Bundle_Filter = {
  id?: Maybe<Scalars['ID']>;
  id_not?: Maybe<Scalars['ID']>;
  id_gt?: Maybe<Scalars['ID']>;
  id_lt?: Maybe<Scalars['ID']>;
  id_gte?: Maybe<Scalars['ID']>;
  id_lte?: Maybe<Scalars['ID']>;
  id_in?: Maybe<Array<Scalars['ID']>>;
  id_not_in?: Maybe<Array<Scalars['ID']>>;
  ethPrice?: Maybe<Scalars['BigDecimal']>;
  ethPrice_not?: Maybe<Scalars['BigDecimal']>;
  ethPrice_gt?: Maybe<Scalars['BigDecimal']>;
  ethPrice_lt?: Maybe<Scalars['BigDecimal']>;
  ethPrice_gte?: Maybe<Scalars['BigDecimal']>;
  ethPrice_lte?: Maybe<Scalars['BigDecimal']>;
  ethPrice_in?: Maybe<Array<Scalars['BigDecimal']>>;
  ethPrice_not_in?: Maybe<Array<Scalars['BigDecimal']>>;
};


export type Burn = {
  __typename?: 'Burn';
  id: Scalars['ID'];
  transaction: Transaction;
  timestamp: Scalars['BigInt'];
  pair: Pair;
  liquidity: Scalars['BigDecimal'];
  sender?: Maybe<Scalars['Bytes']>;
  amount0?: Maybe<Scalars['BigDecimal']>;
  amount1?: Maybe<Scalars['BigDecimal']>;
  to?: Maybe<Scalars['Bytes']>;
  logIndex?: Maybe<Scalars['BigInt']>;
  amountUSD?: Maybe<Scalars['BigDecimal']>;
  complete: Scalars['Boolean'];
  feeTo?: Maybe<Scalars['Bytes']>;
  feeLiquidity?: Maybe<Scalars['BigDecimal']>;
};


export type Burn_Filter = {
  id?: Maybe<Scalars['ID']>;
  id_not?: Maybe<Scalars['ID']>;
  id_gt?: Maybe<Scalars['ID']>;
  id_lt?: Maybe<Scalars['ID']>;
  id_gte?: Maybe<Scalars['ID']>;
  id_lte?: Maybe<Scalars['ID']>;
  id_in?: Maybe<Array<Scalars['ID']>>;
  id_not_in?: Maybe<Array<Scalars['ID']>>;
  transaction?: Maybe<Scalars['String']>;
  transaction_not?: Maybe<Scalars['String']>;
  transaction_gt?: Maybe<Scalars['String']>;
  transaction_lt?: Maybe<Scalars['String']>;
  transaction_gte?: Maybe<Scalars['String']>;
  transaction_lte?: Maybe<Scalars['String']>;
  transaction_in?: Maybe<Array<Scalars['String']>>;
  transaction_not_in?: Maybe<Array<Scalars['String']>>;
  transaction_contains?: Maybe<Scalars['String']>;
  transaction_not_contains?: Maybe<Scalars['String']>;
  transaction_starts_with?: Maybe<Scalars['String']>;
  transaction_not_starts_with?: Maybe<Scalars['String']>;
  transaction_ends_with?: Maybe<Scalars['String']>;
  transaction_not_ends_with?: Maybe<Scalars['String']>;
  timestamp?: Maybe<Scalars['BigInt']>;
  timestamp_not?: Maybe<Scalars['BigInt']>;
  timestamp_gt?: Maybe<Scalars['BigInt']>;
  timestamp_lt?: Maybe<Scalars['BigInt']>;
  timestamp_gte?: Maybe<Scalars['BigInt']>;
  timestamp_lte?: Maybe<Scalars['BigInt']>;
  timestamp_in?: Maybe<Array<Scalars['BigInt']>>;
  timestamp_not_in?: Maybe<Array<Scalars['BigInt']>>;
  pair?: Maybe<Scalars['String']>;
  pair_not?: Maybe<Scalars['String']>;
  pair_gt?: Maybe<Scalars['String']>;
  pair_lt?: Maybe<Scalars['String']>;
  pair_gte?: Maybe<Scalars['String']>;
  pair_lte?: Maybe<Scalars['String']>;
  pair_in?: Maybe<Array<Scalars['String']>>;
  pair_not_in?: Maybe<Array<Scalars['String']>>;
  pair_contains?: Maybe<Scalars['String']>;
  pair_not_contains?: Maybe<Scalars['String']>;
  pair_starts_with?: Maybe<Scalars['String']>;
  pair_not_starts_with?: Maybe<Scalars['String']>;
  pair_ends_with?: Maybe<Scalars['String']>;
  pair_not_ends_with?: Maybe<Scalars['String']>;
  liquidity?: Maybe<Scalars['BigDecimal']>;
  liquidity_not?: Maybe<Scalars['BigDecimal']>;
  liquidity_gt?: Maybe<Scalars['BigDecimal']>;
  liquidity_lt?: Maybe<Scalars['BigDecimal']>;
  liquidity_gte?: Maybe<Scalars['BigDecimal']>;
  liquidity_lte?: Maybe<Scalars['BigDecimal']>;
  liquidity_in?: Maybe<Array<Scalars['BigDecimal']>>;
  liquidity_not_in?: Maybe<Array<Scalars['BigDecimal']>>;
  sender?: Maybe<Scalars['Bytes']>;
  sender_not?: Maybe<Scalars['Bytes']>;
  sender_in?: Maybe<Array<Scalars['Bytes']>>;
  sender_not_in?: Maybe<Array<Scalars['Bytes']>>;
  sender_contains?: Maybe<Scalars['Bytes']>;
  sender_not_contains?: Maybe<Scalars['Bytes']>;
  amount0?: Maybe<Scalars['BigDecimal']>;
  amount0_not?: Maybe<Scalars['BigDecimal']>;
  amount0_gt?: Maybe<Scalars['BigDecimal']>;
  amount0_lt?: Maybe<Scalars['BigDecimal']>;
  amount0_gte?: Maybe<Scalars['BigDecimal']>;
  amount0_lte?: Maybe<Scalars['BigDecimal']>;
  amount0_in?: Maybe<Array<Scalars['BigDecimal']>>;
  amount0_not_in?: Maybe<Array<Scalars['BigDecimal']>>;
  amount1?: Maybe<Scalars['BigDecimal']>;
  amount1_not?: Maybe<Scalars['BigDecimal']>;
  amount1_gt?: Maybe<Scalars['BigDecimal']>;
  amount1_lt?: Maybe<Scalars['BigDecimal']>;
  amount1_gte?: Maybe<Scalars['BigDecimal']>;
  amount1_lte?: Maybe<Scalars['BigDecimal']>;
  amount1_in?: Maybe<Array<Scalars['BigDecimal']>>;
  amount1_not_in?: Maybe<Array<Scalars['BigDecimal']>>;
  to?: Maybe<Scalars['Bytes']>;
  to_not?: Maybe<Scalars['Bytes']>;
  to_in?: Maybe<Array<Scalars['Bytes']>>;
  to_not_in?: Maybe<Array<Scalars['Bytes']>>;
  to_contains?: Maybe<Scalars['Bytes']>;
  to_not_contains?: Maybe<Scalars['Bytes']>;
  logIndex?: Maybe<Scalars['BigInt']>;
  logIndex_not?: Maybe<Scalars['BigInt']>;
  logIndex_gt?: Maybe<Scalars['BigInt']>;
  logIndex_lt?: Maybe<Scalars['BigInt']>;
  logIndex_gte?: Maybe<Scalars['BigInt']>;
  logIndex_lte?: Maybe<Scalars['BigInt']>;
  logIndex_in?: Maybe<Array<Scalars['BigInt']>>;
  logIndex_not_in?: Maybe<Array<Scalars['BigInt']>>;
  amountUSD?: Maybe<Scalars['BigDecimal']>;
  amountUSD_not?: Maybe<Scalars['BigDecimal']>;
  amountUSD_gt?: Maybe<Scalars['BigDecimal']>;
  amountUSD_lt?: Maybe<Scalars['BigDecimal']>;
  amountUSD_gte?: Maybe<Scalars['BigDecimal']>;
  amountUSD_lte?: Maybe<Scalars['BigDecimal']>;
  amountUSD_in?: Maybe<Array<Scalars['BigDecimal']>>;
  amountUSD_not_in?: Maybe<Array<Scalars['BigDecimal']>>;
  complete?: Maybe<Scalars['Boolean']>;
  complete_not?: Maybe<Scalars['Boolean']>;
  complete_in?: Maybe<Array<Scalars['Boolean']>>;
  complete_not_in?: Maybe<Array<Scalars['Boolean']>>;
  feeTo?: Maybe<Scalars['Bytes']>;
  feeTo_not?: Maybe<Scalars['Bytes']>;
  feeTo_in?: Maybe<Array<Scalars['Bytes']>>;
  feeTo_not_in?: Maybe<Array<Scalars['Bytes']>>;
  feeTo_contains?: Maybe<Scalars['Bytes']>;
  feeTo_not_contains?: Maybe<Scalars['Bytes']>;
  feeLiquidity?: Maybe<Scalars['BigDecimal']>;
  feeLiquidity_not?: Maybe<Scalars['BigDecimal']>;
  feeLiquidity_gt?: Maybe<Scalars['BigDecimal']>;
  feeLiquidity_lt?: Maybe<Scalars['BigDecimal']>;
  feeLiquidity_gte?: Maybe<Scalars['BigDecimal']>;
  feeLiquidity_lte?: Maybe<Scalars['BigDecimal']>;
  feeLiquidity_in?: Maybe<Array<Scalars['BigDecimal']>>;
  feeLiquidity_not_in?: Maybe<Array<Scalars['BigDecimal']>>;
};


export type DayData = {
  __typename?: 'DayData';
  id: Scalars['ID'];
  date: Scalars['Int'];
  factory: Factory;
  volumeETH: Scalars['BigDecimal'];
  volumeUSD: Scalars['BigDecimal'];
  untrackedVolume: Scalars['BigDecimal'];
  liquidityETH: Scalars['BigDecimal'];
  liquidityUSD: Scalars['BigDecimal'];
  txCount: Scalars['BigInt'];
};


export type DayData_Filter = {
  id?: Maybe<Scalars['ID']>;
  id_not?: Maybe<Scalars['ID']>;
  id_gt?: Maybe<Scalars['ID']>;
  id_lt?: Maybe<Scalars['ID']>;
  id_gte?: Maybe<Scalars['ID']>;
  id_lte?: Maybe<Scalars['ID']>;
  id_in?: Maybe<Array<Scalars['ID']>>;
  id_not_in?: Maybe<Array<Scalars['ID']>>;
  date?: Maybe<Scalars['Int']>;
  date_not?: Maybe<Scalars['Int']>;
  date_gt?: Maybe<Scalars['Int']>;
  date_lt?: Maybe<Scalars['Int']>;
  date_gte?: Maybe<Scalars['Int']>;
  date_lte?: Maybe<Scalars['Int']>;
  date_in?: Maybe<Array<Scalars['Int']>>;
  date_not_in?: Maybe<Array<Scalars['Int']>>;
  factory?: Maybe<Scalars['String']>;
  factory_not?: Maybe<Scalars['String']>;
  factory_gt?: Maybe<Scalars['String']>;
  factory_lt?: Maybe<Scalars['String']>;
  factory_gte?: Maybe<Scalars['String']>;
  factory_lte?: Maybe<Scalars['String']>;
  factory_in?: Maybe<Array<Scalars['String']>>;
  factory_not_in?: Maybe<Array<Scalars['String']>>;
  factory_contains?: Maybe<Scalars['String']>;
  factory_not_contains?: Maybe<Scalars['String']>;
  factory_starts_with?: Maybe<Scalars['String']>;
  factory_not_starts_with?: Maybe<Scalars['String']>;
  factory_ends_with?: Maybe<Scalars['String']>;
  factory_not_ends_with?: Maybe<Scalars['String']>;
  volumeETH?: Maybe<Scalars['BigDecimal']>;
  volumeETH_not?: Maybe<Scalars['BigDecimal']>;
  volumeETH_gt?: Maybe<Scalars['BigDecimal']>;
  volumeETH_lt?: Maybe<Scalars['BigDecimal']>;
  volumeETH_gte?: Maybe<Scalars['BigDecimal']>;
  volumeETH_lte?: Maybe<Scalars['BigDecimal']>;
  volumeETH_in?: Maybe<Array<Scalars['BigDecimal']>>;
  volumeETH_not_in?: Maybe<Array<Scalars['BigDecimal']>>;
  volumeUSD?: Maybe<Scalars['BigDecimal']>;
  volumeUSD_not?: Maybe<Scalars['BigDecimal']>;
  volumeUSD_gt?: Maybe<Scalars['BigDecimal']>;
  volumeUSD_lt?: Maybe<Scalars['BigDecimal']>;
  volumeUSD_gte?: Maybe<Scalars['BigDecimal']>;
  volumeUSD_lte?: Maybe<Scalars['BigDecimal']>;
  volumeUSD_in?: Maybe<Array<Scalars['BigDecimal']>>;
  volumeUSD_not_in?: Maybe<Array<Scalars['BigDecimal']>>;
  untrackedVolume?: Maybe<Scalars['BigDecimal']>;
  untrackedVolume_not?: Maybe<Scalars['BigDecimal']>;
  untrackedVolume_gt?: Maybe<Scalars['BigDecimal']>;
  untrackedVolume_lt?: Maybe<Scalars['BigDecimal']>;
  untrackedVolume_gte?: Maybe<Scalars['BigDecimal']>;
  untrackedVolume_lte?: Maybe<Scalars['BigDecimal']>;
  untrackedVolume_in?: Maybe<Array<Scalars['BigDecimal']>>;
  untrackedVolume_not_in?: Maybe<Array<Scalars['BigDecimal']>>;
  liquidityETH?: Maybe<Scalars['BigDecimal']>;
  liquidityETH_not?: Maybe<Scalars['BigDecimal']>;
  liquidityETH_gt?: Maybe<Scalars['BigDecimal']>;
  liquidityETH_lt?: Maybe<Scalars['BigDecimal']>;
  liquidityETH_gte?: Maybe<Scalars['BigDecimal']>;
  liquidityETH_lte?: Maybe<Scalars['BigDecimal']>;
  liquidityETH_in?: Maybe<Array<Scalars['BigDecimal']>>;
  liquidityETH_not_in?: Maybe<Array<Scalars['BigDecimal']>>;
  liquidityUSD?: Maybe<Scalars['BigDecimal']>;
  liquidityUSD_not?: Maybe<Scalars['BigDecimal']>;
  liquidityUSD_gt?: Maybe<Scalars['BigDecimal']>;
  liquidityUSD_lt?: Maybe<Scalars['BigDecimal']>;
  liquidityUSD_gte?: Maybe<Scalars['BigDecimal']>;
  liquidityUSD_lte?: Maybe<Scalars['BigDecimal']>;
  liquidityUSD_in?: Maybe<Array<Scalars['BigDecimal']>>;
  liquidityUSD_not_in?: Maybe<Array<Scalars['BigDecimal']>>;
  txCount?: Maybe<Scalars['BigInt']>;
  txCount_not?: Maybe<Scalars['BigInt']>;
  txCount_gt?: Maybe<Scalars['BigInt']>;
  txCount_lt?: Maybe<Scalars['BigInt']>;
  txCount_gte?: Maybe<Scalars['BigInt']>;
  txCount_lte?: Maybe<Scalars['BigInt']>;
  txCount_in?: Maybe<Array<Scalars['BigInt']>>;
  txCount_not_in?: Maybe<Array<Scalars['BigInt']>>;
};


export type Factory = {
  __typename?: 'Factory';
  id: Scalars['ID'];
  pairCount: Scalars['BigInt'];
  volumeUSD: Scalars['BigDecimal'];
  volumeETH: Scalars['BigDecimal'];
  untrackedVolumeUSD: Scalars['BigDecimal'];
  liquidityUSD: Scalars['BigDecimal'];
  liquidityETH: Scalars['BigDecimal'];
  txCount: Scalars['BigInt'];
  tokenCount: Scalars['BigInt'];
  userCount: Scalars['BigInt'];
  pairs: Array<Pair>;
  tokens: Array<Token>;
  hourData: Array<HourData>;
  dayData: Array<DayData>;
};


export type FactoryPairsArgs = {
  skip?: Maybe<Scalars['Int']>;
  first?: Maybe<Scalars['Int']>;
  orderBy?: Maybe<Pair_OrderBy>;
  orderDirection?: Maybe<OrderDirection>;
  where?: Maybe<Pair_Filter>;
};


export type FactoryTokensArgs = {
  skip?: Maybe<Scalars['Int']>;
  first?: Maybe<Scalars['Int']>;
  orderBy?: Maybe<Token_OrderBy>;
  orderDirection?: Maybe<OrderDirection>;
  where?: Maybe<Token_Filter>;
};


export type FactoryHourDataArgs = {
  skip?: Maybe<Scalars['Int']>;
  first?: Maybe<Scalars['Int']>;
  orderBy?: Maybe<HourData_OrderBy>;
  orderDirection?: Maybe<OrderDirection>;
  where?: Maybe<HourData_Filter>;
};


export type FactoryDayDataArgs = {
  skip?: Maybe<Scalars['Int']>;
  first?: Maybe<Scalars['Int']>;
  orderBy?: Maybe<DayData_OrderBy>;
  orderDirection?: Maybe<OrderDirection>;
  where?: Maybe<DayData_Filter>;
};


export type Factory_Filter = {
  id?: Maybe<Scalars['ID']>;
  id_not?: Maybe<Scalars['ID']>;
  id_gt?: Maybe<Scalars['ID']>;
  id_lt?: Maybe<Scalars['ID']>;
  id_gte?: Maybe<Scalars['ID']>;
  id_lte?: Maybe<Scalars['ID']>;
  id_in?: Maybe<Array<Scalars['ID']>>;
  id_not_in?: Maybe<Array<Scalars['ID']>>;
  pairCount?: Maybe<Scalars['BigInt']>;
  pairCount_not?: Maybe<Scalars['BigInt']>;
  pairCount_gt?: Maybe<Scalars['BigInt']>;
  pairCount_lt?: Maybe<Scalars['BigInt']>;
  pairCount_gte?: Maybe<Scalars['BigInt']>;
  pairCount_lte?: Maybe<Scalars['BigInt']>;
  pairCount_in?: Maybe<Array<Scalars['BigInt']>>;
  pairCount_not_in?: Maybe<Array<Scalars['BigInt']>>;
  volumeUSD?: Maybe<Scalars['BigDecimal']>;
  volumeUSD_not?: Maybe<Scalars['BigDecimal']>;
  volumeUSD_gt?: Maybe<Scalars['BigDecimal']>;
  volumeUSD_lt?: Maybe<Scalars['BigDecimal']>;
  volumeUSD_gte?: Maybe<Scalars['BigDecimal']>;
  volumeUSD_lte?: Maybe<Scalars['BigDecimal']>;
  volumeUSD_in?: Maybe<Array<Scalars['BigDecimal']>>;
  volumeUSD_not_in?: Maybe<Array<Scalars['BigDecimal']>>;
  volumeETH?: Maybe<Scalars['BigDecimal']>;
  volumeETH_not?: Maybe<Scalars['BigDecimal']>;
  volumeETH_gt?: Maybe<Scalars['BigDecimal']>;
  volumeETH_lt?: Maybe<Scalars['BigDecimal']>;
  volumeETH_gte?: Maybe<Scalars['BigDecimal']>;
  volumeETH_lte?: Maybe<Scalars['BigDecimal']>;
  volumeETH_in?: Maybe<Array<Scalars['BigDecimal']>>;
  volumeETH_not_in?: Maybe<Array<Scalars['BigDecimal']>>;
  untrackedVolumeUSD?: Maybe<Scalars['BigDecimal']>;
  untrackedVolumeUSD_not?: Maybe<Scalars['BigDecimal']>;
  untrackedVolumeUSD_gt?: Maybe<Scalars['BigDecimal']>;
  untrackedVolumeUSD_lt?: Maybe<Scalars['BigDecimal']>;
  untrackedVolumeUSD_gte?: Maybe<Scalars['BigDecimal']>;
  untrackedVolumeUSD_lte?: Maybe<Scalars['BigDecimal']>;
  untrackedVolumeUSD_in?: Maybe<Array<Scalars['BigDecimal']>>;
  untrackedVolumeUSD_not_in?: Maybe<Array<Scalars['BigDecimal']>>;
  liquidityUSD?: Maybe<Scalars['BigDecimal']>;
  liquidityUSD_not?: Maybe<Scalars['BigDecimal']>;
  liquidityUSD_gt?: Maybe<Scalars['BigDecimal']>;
  liquidityUSD_lt?: Maybe<Scalars['BigDecimal']>;
  liquidityUSD_gte?: Maybe<Scalars['BigDecimal']>;
  liquidityUSD_lte?: Maybe<Scalars['BigDecimal']>;
  liquidityUSD_in?: Maybe<Array<Scalars['BigDecimal']>>;
  liquidityUSD_not_in?: Maybe<Array<Scalars['BigDecimal']>>;
  liquidityETH?: Maybe<Scalars['BigDecimal']>;
  liquidityETH_not?: Maybe<Scalars['BigDecimal']>;
  liquidityETH_gt?: Maybe<Scalars['BigDecimal']>;
  liquidityETH_lt?: Maybe<Scalars['BigDecimal']>;
  liquidityETH_gte?: Maybe<Scalars['BigDecimal']>;
  liquidityETH_lte?: Maybe<Scalars['BigDecimal']>;
  liquidityETH_in?: Maybe<Array<Scalars['BigDecimal']>>;
  liquidityETH_not_in?: Maybe<Array<Scalars['BigDecimal']>>;
  txCount?: Maybe<Scalars['BigInt']>;
  txCount_not?: Maybe<Scalars['BigInt']>;
  txCount_gt?: Maybe<Scalars['BigInt']>;
  txCount_lt?: Maybe<Scalars['BigInt']>;
  txCount_gte?: Maybe<Scalars['BigInt']>;
  txCount_lte?: Maybe<Scalars['BigInt']>;
  txCount_in?: Maybe<Array<Scalars['BigInt']>>;
  txCount_not_in?: Maybe<Array<Scalars['BigInt']>>;
  tokenCount?: Maybe<Scalars['BigInt']>;
  tokenCount_not?: Maybe<Scalars['BigInt']>;
  tokenCount_gt?: Maybe<Scalars['BigInt']>;
  tokenCount_lt?: Maybe<Scalars['BigInt']>;
  tokenCount_gte?: Maybe<Scalars['BigInt']>;
  tokenCount_lte?: Maybe<Scalars['BigInt']>;
  tokenCount_in?: Maybe<Array<Scalars['BigInt']>>;
  tokenCount_not_in?: Maybe<Array<Scalars['BigInt']>>;
  userCount?: Maybe<Scalars['BigInt']>;
  userCount_not?: Maybe<Scalars['BigInt']>;
  userCount_gt?: Maybe<Scalars['BigInt']>;
  userCount_lt?: Maybe<Scalars['BigInt']>;
  userCount_gte?: Maybe<Scalars['BigInt']>;
  userCount_lte?: Maybe<Scalars['BigInt']>;
  userCount_in?: Maybe<Array<Scalars['BigInt']>>;
  userCount_not_in?: Maybe<Array<Scalars['BigInt']>>;
};


export type HourData = {
  __typename?: 'HourData';
  id: Scalars['ID'];
  date: Scalars['Int'];
  factory: Factory;
  volumeETH: Scalars['BigDecimal'];
  volumeUSD: Scalars['BigDecimal'];
  untrackedVolume: Scalars['BigDecimal'];
  liquidityETH: Scalars['BigDecimal'];
  liquidityUSD: Scalars['BigDecimal'];
  txCount: Scalars['BigInt'];
};


export type HourData_Filter = {
  id?: Maybe<Scalars['ID']>;
  id_not?: Maybe<Scalars['ID']>;
  id_gt?: Maybe<Scalars['ID']>;
  id_lt?: Maybe<Scalars['ID']>;
  id_gte?: Maybe<Scalars['ID']>;
  id_lte?: Maybe<Scalars['ID']>;
  id_in?: Maybe<Array<Scalars['ID']>>;
  id_not_in?: Maybe<Array<Scalars['ID']>>;
  date?: Maybe<Scalars['Int']>;
  date_not?: Maybe<Scalars['Int']>;
  date_gt?: Maybe<Scalars['Int']>;
  date_lt?: Maybe<Scalars['Int']>;
  date_gte?: Maybe<Scalars['Int']>;
  date_lte?: Maybe<Scalars['Int']>;
  date_in?: Maybe<Array<Scalars['Int']>>;
  date_not_in?: Maybe<Array<Scalars['Int']>>;
  factory?: Maybe<Scalars['String']>;
  factory_not?: Maybe<Scalars['String']>;
  factory_gt?: Maybe<Scalars['String']>;
  factory_lt?: Maybe<Scalars['String']>;
  factory_gte?: Maybe<Scalars['String']>;
  factory_lte?: Maybe<Scalars['String']>;
  factory_in?: Maybe<Array<Scalars['String']>>;
  factory_not_in?: Maybe<Array<Scalars['String']>>;
  factory_contains?: Maybe<Scalars['String']>;
  factory_not_contains?: Maybe<Scalars['String']>;
  factory_starts_with?: Maybe<Scalars['String']>;
  factory_not_starts_with?: Maybe<Scalars['String']>;
  factory_ends_with?: Maybe<Scalars['String']>;
  factory_not_ends_with?: Maybe<Scalars['String']>;
  volumeETH?: Maybe<Scalars['BigDecimal']>;
  volumeETH_not?: Maybe<Scalars['BigDecimal']>;
  volumeETH_gt?: Maybe<Scalars['BigDecimal']>;
  volumeETH_lt?: Maybe<Scalars['BigDecimal']>;
  volumeETH_gte?: Maybe<Scalars['BigDecimal']>;
  volumeETH_lte?: Maybe<Scalars['BigDecimal']>;
  volumeETH_in?: Maybe<Array<Scalars['BigDecimal']>>;
  volumeETH_not_in?: Maybe<Array<Scalars['BigDecimal']>>;
  volumeUSD?: Maybe<Scalars['BigDecimal']>;
  volumeUSD_not?: Maybe<Scalars['BigDecimal']>;
  volumeUSD_gt?: Maybe<Scalars['BigDecimal']>;
  volumeUSD_lt?: Maybe<Scalars['BigDecimal']>;
  volumeUSD_gte?: Maybe<Scalars['BigDecimal']>;
  volumeUSD_lte?: Maybe<Scalars['BigDecimal']>;
  volumeUSD_in?: Maybe<Array<Scalars['BigDecimal']>>;
  volumeUSD_not_in?: Maybe<Array<Scalars['BigDecimal']>>;
  untrackedVolume?: Maybe<Scalars['BigDecimal']>;
  untrackedVolume_not?: Maybe<Scalars['BigDecimal']>;
  untrackedVolume_gt?: Maybe<Scalars['BigDecimal']>;
  untrackedVolume_lt?: Maybe<Scalars['BigDecimal']>;
  untrackedVolume_gte?: Maybe<Scalars['BigDecimal']>;
  untrackedVolume_lte?: Maybe<Scalars['BigDecimal']>;
  untrackedVolume_in?: Maybe<Array<Scalars['BigDecimal']>>;
  untrackedVolume_not_in?: Maybe<Array<Scalars['BigDecimal']>>;
  liquidityETH?: Maybe<Scalars['BigDecimal']>;
  liquidityETH_not?: Maybe<Scalars['BigDecimal']>;
  liquidityETH_gt?: Maybe<Scalars['BigDecimal']>;
  liquidityETH_lt?: Maybe<Scalars['BigDecimal']>;
  liquidityETH_gte?: Maybe<Scalars['BigDecimal']>;
  liquidityETH_lte?: Maybe<Scalars['BigDecimal']>;
  liquidityETH_in?: Maybe<Array<Scalars['BigDecimal']>>;
  liquidityETH_not_in?: Maybe<Array<Scalars['BigDecimal']>>;
  liquidityUSD?: Maybe<Scalars['BigDecimal']>;
  liquidityUSD_not?: Maybe<Scalars['BigDecimal']>;
  liquidityUSD_gt?: Maybe<Scalars['BigDecimal']>;
  liquidityUSD_lt?: Maybe<Scalars['BigDecimal']>;
  liquidityUSD_gte?: Maybe<Scalars['BigDecimal']>;
  liquidityUSD_lte?: Maybe<Scalars['BigDecimal']>;
  liquidityUSD_in?: Maybe<Array<Scalars['BigDecimal']>>;
  liquidityUSD_not_in?: Maybe<Array<Scalars['BigDecimal']>>;
  txCount?: Maybe<Scalars['BigInt']>;
  txCount_not?: Maybe<Scalars['BigInt']>;
  txCount_gt?: Maybe<Scalars['BigInt']>;
  txCount_lt?: Maybe<Scalars['BigInt']>;
  txCount_gte?: Maybe<Scalars['BigInt']>;
  txCount_lte?: Maybe<Scalars['BigInt']>;
  txCount_in?: Maybe<Array<Scalars['BigInt']>>;
  txCount_not_in?: Maybe<Array<Scalars['BigInt']>>;
};


export type LiquidityPosition = {
  __typename?: 'LiquidityPosition';
  id: Scalars['ID'];
  user: User;
  pair: Pair;
  liquidityTokenBalance: Scalars['BigDecimal'];
  snapshots: Array<Maybe<LiquidityPositionSnapshot>>;
  block: Scalars['Int'];
  timestamp: Scalars['Int'];
};


export type LiquidityPositionSnapshotsArgs = {
  skip?: Maybe<Scalars['Int']>;
  first?: Maybe<Scalars['Int']>;
  orderBy?: Maybe<LiquidityPositionSnapshot_OrderBy>;
  orderDirection?: Maybe<OrderDirection>;
  where?: Maybe<LiquidityPositionSnapshot_Filter>;
};


export type LiquidityPositionSnapshot = {
  __typename?: 'LiquidityPositionSnapshot';
  id: Scalars['ID'];
  liquidityPosition: LiquidityPosition;
  timestamp: Scalars['Int'];
  block: Scalars['Int'];
  user: User;
  pair: Pair;
  token0PriceUSD: Scalars['BigDecimal'];
  token1PriceUSD: Scalars['BigDecimal'];
  reserve0: Scalars['BigDecimal'];
  reserve1: Scalars['BigDecimal'];
  reserveUSD: Scalars['BigDecimal'];
  liquidityTokenTotalSupply: Scalars['BigDecimal'];
  liquidityTokenBalance: Scalars['BigDecimal'];
};


export type LiquidityPosition_Filter = {
  id?: Maybe<Scalars['ID']>;
  id_not?: Maybe<Scalars['ID']>;
  id_gt?: Maybe<Scalars['ID']>;
  id_lt?: Maybe<Scalars['ID']>;
  id_gte?: Maybe<Scalars['ID']>;
  id_lte?: Maybe<Scalars['ID']>;
  id_in?: Maybe<Array<Scalars['ID']>>;
  id_not_in?: Maybe<Array<Scalars['ID']>>;
  user?: Maybe<Scalars['String']>;
  user_not?: Maybe<Scalars['String']>;
  user_gt?: Maybe<Scalars['String']>;
  user_lt?: Maybe<Scalars['String']>;
  user_gte?: Maybe<Scalars['String']>;
  user_lte?: Maybe<Scalars['String']>;
  user_in?: Maybe<Array<Scalars['String']>>;
  user_not_in?: Maybe<Array<Scalars['String']>>;
  user_contains?: Maybe<Scalars['String']>;
  user_not_contains?: Maybe<Scalars['String']>;
  user_starts_with?: Maybe<Scalars['String']>;
  user_not_starts_with?: Maybe<Scalars['String']>;
  user_ends_with?: Maybe<Scalars['String']>;
  user_not_ends_with?: Maybe<Scalars['String']>;
  pair?: Maybe<Scalars['String']>;
  pair_not?: Maybe<Scalars['String']>;
  pair_gt?: Maybe<Scalars['String']>;
  pair_lt?: Maybe<Scalars['String']>;
  pair_gte?: Maybe<Scalars['String']>;
  pair_lte?: Maybe<Scalars['String']>;
  pair_in?: Maybe<Array<Scalars['String']>>;
  pair_not_in?: Maybe<Array<Scalars['String']>>;
  pair_contains?: Maybe<Scalars['String']>;
  pair_not_contains?: Maybe<Scalars['String']>;
  pair_starts_with?: Maybe<Scalars['String']>;
  pair_not_starts_with?: Maybe<Scalars['String']>;
  pair_ends_with?: Maybe<Scalars['String']>;
  pair_not_ends_with?: Maybe<Scalars['String']>;
  liquidityTokenBalance?: Maybe<Scalars['BigDecimal']>;
  liquidityTokenBalance_not?: Maybe<Scalars['BigDecimal']>;
  liquidityTokenBalance_gt?: Maybe<Scalars['BigDecimal']>;
  liquidityTokenBalance_lt?: Maybe<Scalars['BigDecimal']>;
  liquidityTokenBalance_gte?: Maybe<Scalars['BigDecimal']>;
  liquidityTokenBalance_lte?: Maybe<Scalars['BigDecimal']>;
  liquidityTokenBalance_in?: Maybe<Array<Scalars['BigDecimal']>>;
  liquidityTokenBalance_not_in?: Maybe<Array<Scalars['BigDecimal']>>;
  block?: Maybe<Scalars['Int']>;
  block_not?: Maybe<Scalars['Int']>;
  block_gt?: Maybe<Scalars['Int']>;
  block_lt?: Maybe<Scalars['Int']>;
  block_gte?: Maybe<Scalars['Int']>;
  block_lte?: Maybe<Scalars['Int']>;
  block_in?: Maybe<Array<Scalars['Int']>>;
  block_not_in?: Maybe<Array<Scalars['Int']>>;
  timestamp?: Maybe<Scalars['Int']>;
  timestamp_not?: Maybe<Scalars['Int']>;
  timestamp_gt?: Maybe<Scalars['Int']>;
  timestamp_lt?: Maybe<Scalars['Int']>;
  timestamp_gte?: Maybe<Scalars['Int']>;
  timestamp_lte?: Maybe<Scalars['Int']>;
  timestamp_in?: Maybe<Array<Scalars['Int']>>;
  timestamp_not_in?: Maybe<Array<Scalars['Int']>>;
};


export type Mint = {
  __typename?: 'Mint';
  id: Scalars['ID'];
  transaction: Transaction;
  timestamp: Scalars['BigInt'];
  pair: Pair;
  to: Scalars['Bytes'];
  liquidity: Scalars['BigDecimal'];
  sender?: Maybe<Scalars['Bytes']>;
  amount0?: Maybe<Scalars['BigDecimal']>;
  amount1?: Maybe<Scalars['BigDecimal']>;
  logIndex?: Maybe<Scalars['BigInt']>;
  amountUSD?: Maybe<Scalars['BigDecimal']>;
  feeTo?: Maybe<Scalars['Bytes']>;
  feeLiquidity?: Maybe<Scalars['BigDecimal']>;
};


export type Mint_Filter = {
  id?: Maybe<Scalars['ID']>;
  id_not?: Maybe<Scalars['ID']>;
  id_gt?: Maybe<Scalars['ID']>;
  id_lt?: Maybe<Scalars['ID']>;
  id_gte?: Maybe<Scalars['ID']>;
  id_lte?: Maybe<Scalars['ID']>;
  id_in?: Maybe<Array<Scalars['ID']>>;
  id_not_in?: Maybe<Array<Scalars['ID']>>;
  transaction?: Maybe<Scalars['String']>;
  transaction_not?: Maybe<Scalars['String']>;
  transaction_gt?: Maybe<Scalars['String']>;
  transaction_lt?: Maybe<Scalars['String']>;
  transaction_gte?: Maybe<Scalars['String']>;
  transaction_lte?: Maybe<Scalars['String']>;
  transaction_in?: Maybe<Array<Scalars['String']>>;
  transaction_not_in?: Maybe<Array<Scalars['String']>>;
  transaction_contains?: Maybe<Scalars['String']>;
  transaction_not_contains?: Maybe<Scalars['String']>;
  transaction_starts_with?: Maybe<Scalars['String']>;
  transaction_not_starts_with?: Maybe<Scalars['String']>;
  transaction_ends_with?: Maybe<Scalars['String']>;
  transaction_not_ends_with?: Maybe<Scalars['String']>;
  timestamp?: Maybe<Scalars['BigInt']>;
  timestamp_not?: Maybe<Scalars['BigInt']>;
  timestamp_gt?: Maybe<Scalars['BigInt']>;
  timestamp_lt?: Maybe<Scalars['BigInt']>;
  timestamp_gte?: Maybe<Scalars['BigInt']>;
  timestamp_lte?: Maybe<Scalars['BigInt']>;
  timestamp_in?: Maybe<Array<Scalars['BigInt']>>;
  timestamp_not_in?: Maybe<Array<Scalars['BigInt']>>;
  pair?: Maybe<Scalars['String']>;
  pair_not?: Maybe<Scalars['String']>;
  pair_gt?: Maybe<Scalars['String']>;
  pair_lt?: Maybe<Scalars['String']>;
  pair_gte?: Maybe<Scalars['String']>;
  pair_lte?: Maybe<Scalars['String']>;
  pair_in?: Maybe<Array<Scalars['String']>>;
  pair_not_in?: Maybe<Array<Scalars['String']>>;
  pair_contains?: Maybe<Scalars['String']>;
  pair_not_contains?: Maybe<Scalars['String']>;
  pair_starts_with?: Maybe<Scalars['String']>;
  pair_not_starts_with?: Maybe<Scalars['String']>;
  pair_ends_with?: Maybe<Scalars['String']>;
  pair_not_ends_with?: Maybe<Scalars['String']>;
  to?: Maybe<Scalars['Bytes']>;
  to_not?: Maybe<Scalars['Bytes']>;
  to_in?: Maybe<Array<Scalars['Bytes']>>;
  to_not_in?: Maybe<Array<Scalars['Bytes']>>;
  to_contains?: Maybe<Scalars['Bytes']>;
  to_not_contains?: Maybe<Scalars['Bytes']>;
  liquidity?: Maybe<Scalars['BigDecimal']>;
  liquidity_not?: Maybe<Scalars['BigDecimal']>;
  liquidity_gt?: Maybe<Scalars['BigDecimal']>;
  liquidity_lt?: Maybe<Scalars['BigDecimal']>;
  liquidity_gte?: Maybe<Scalars['BigDecimal']>;
  liquidity_lte?: Maybe<Scalars['BigDecimal']>;
  liquidity_in?: Maybe<Array<Scalars['BigDecimal']>>;
  liquidity_not_in?: Maybe<Array<Scalars['BigDecimal']>>;
  sender?: Maybe<Scalars['Bytes']>;
  sender_not?: Maybe<Scalars['Bytes']>;
  sender_in?: Maybe<Array<Scalars['Bytes']>>;
  sender_not_in?: Maybe<Array<Scalars['Bytes']>>;
  sender_contains?: Maybe<Scalars['Bytes']>;
  sender_not_contains?: Maybe<Scalars['Bytes']>;
  amount0?: Maybe<Scalars['BigDecimal']>;
  amount0_not?: Maybe<Scalars['BigDecimal']>;
  amount0_gt?: Maybe<Scalars['BigDecimal']>;
  amount0_lt?: Maybe<Scalars['BigDecimal']>;
  amount0_gte?: Maybe<Scalars['BigDecimal']>;
  amount0_lte?: Maybe<Scalars['BigDecimal']>;
  amount0_in?: Maybe<Array<Scalars['BigDecimal']>>;
  amount0_not_in?: Maybe<Array<Scalars['BigDecimal']>>;
  amount1?: Maybe<Scalars['BigDecimal']>;
  amount1_not?: Maybe<Scalars['BigDecimal']>;
  amount1_gt?: Maybe<Scalars['BigDecimal']>;
  amount1_lt?: Maybe<Scalars['BigDecimal']>;
  amount1_gte?: Maybe<Scalars['BigDecimal']>;
  amount1_lte?: Maybe<Scalars['BigDecimal']>;
  amount1_in?: Maybe<Array<Scalars['BigDecimal']>>;
  amount1_not_in?: Maybe<Array<Scalars['BigDecimal']>>;
  logIndex?: Maybe<Scalars['BigInt']>;
  logIndex_not?: Maybe<Scalars['BigInt']>;
  logIndex_gt?: Maybe<Scalars['BigInt']>;
  logIndex_lt?: Maybe<Scalars['BigInt']>;
  logIndex_gte?: Maybe<Scalars['BigInt']>;
  logIndex_lte?: Maybe<Scalars['BigInt']>;
  logIndex_in?: Maybe<Array<Scalars['BigInt']>>;
  logIndex_not_in?: Maybe<Array<Scalars['BigInt']>>;
  amountUSD?: Maybe<Scalars['BigDecimal']>;
  amountUSD_not?: Maybe<Scalars['BigDecimal']>;
  amountUSD_gt?: Maybe<Scalars['BigDecimal']>;
  amountUSD_lt?: Maybe<Scalars['BigDecimal']>;
  amountUSD_gte?: Maybe<Scalars['BigDecimal']>;
  amountUSD_lte?: Maybe<Scalars['BigDecimal']>;
  amountUSD_in?: Maybe<Array<Scalars['BigDecimal']>>;
  amountUSD_not_in?: Maybe<Array<Scalars['BigDecimal']>>;
  feeTo?: Maybe<Scalars['Bytes']>;
  feeTo_not?: Maybe<Scalars['Bytes']>;
  feeTo_in?: Maybe<Array<Scalars['Bytes']>>;
  feeTo_not_in?: Maybe<Array<Scalars['Bytes']>>;
  feeTo_contains?: Maybe<Scalars['Bytes']>;
  feeTo_not_contains?: Maybe<Scalars['Bytes']>;
  feeLiquidity?: Maybe<Scalars['BigDecimal']>;
  feeLiquidity_not?: Maybe<Scalars['BigDecimal']>;
  feeLiquidity_gt?: Maybe<Scalars['BigDecimal']>;
  feeLiquidity_lt?: Maybe<Scalars['BigDecimal']>;
  feeLiquidity_gte?: Maybe<Scalars['BigDecimal']>;
  feeLiquidity_lte?: Maybe<Scalars['BigDecimal']>;
  feeLiquidity_in?: Maybe<Array<Scalars['BigDecimal']>>;
  feeLiquidity_not_in?: Maybe<Array<Scalars['BigDecimal']>>;
};


export type Pair = {
  __typename?: 'Pair';
  id: Scalars['ID'];
  factory: Factory;
  name: Scalars['String'];
  token0: Token;
  token1: Token;
  reserve0: Scalars['BigDecimal'];
  reserve1: Scalars['BigDecimal'];
  totalSupply: Scalars['BigDecimal'];
  reserveETH: Scalars['BigDecimal'];
  reserveUSD: Scalars['BigDecimal'];
  trackedReserveETH: Scalars['BigDecimal'];
  token0Price: Scalars['BigDecimal'];
  token1Price: Scalars['BigDecimal'];
  volumeToken0: Scalars['BigDecimal'];
  volumeToken1: Scalars['BigDecimal'];
  volumeUSD: Scalars['BigDecimal'];
  untrackedVolumeUSD: Scalars['BigDecimal'];
  txCount: Scalars['BigInt'];
  liquidityProviderCount: Scalars['BigInt'];
  liquidityPositions: Array<LiquidityPosition>;
  liquidityPositionSnapshots: Array<LiquidityPositionSnapshot>;
  dayData: Array<PairDayData>;
  hourData: Array<PairHourData>;
  mints: Array<Mint>;
  burns: Array<Burn>;
  swaps: Array<Swap>;
  timestamp: Scalars['BigInt'];
  block: Scalars['BigInt'];
};


export type PairLiquidityPositionsArgs = {
  skip?: Maybe<Scalars['Int']>;
  first?: Maybe<Scalars['Int']>;
  orderBy?: Maybe<LiquidityPosition_OrderBy>;
  orderDirection?: Maybe<OrderDirection>;
  where?: Maybe<LiquidityPosition_Filter>;
};


export type PairLiquidityPositionSnapshotsArgs = {
  skip?: Maybe<Scalars['Int']>;
  first?: Maybe<Scalars['Int']>;
  orderBy?: Maybe<LiquidityPositionSnapshot_OrderBy>;
  orderDirection?: Maybe<OrderDirection>;
  where?: Maybe<LiquidityPositionSnapshot_Filter>;
};


export type PairDayDataArgs = {
  skip?: Maybe<Scalars['Int']>;
  first?: Maybe<Scalars['Int']>;
  orderBy?: Maybe<PairDayData_OrderBy>;
  orderDirection?: Maybe<OrderDirection>;
  where?: Maybe<PairDayData_Filter>;
};


export type PairHourDataArgs = {
  skip?: Maybe<Scalars['Int']>;
  first?: Maybe<Scalars['Int']>;
  orderBy?: Maybe<PairHourData_OrderBy>;
  orderDirection?: Maybe<OrderDirection>;
  where?: Maybe<PairHourData_Filter>;
};


export type PairMintsArgs = {
  skip?: Maybe<Scalars['Int']>;
  first?: Maybe<Scalars['Int']>;
  orderBy?: Maybe<Mint_OrderBy>;
  orderDirection?: Maybe<OrderDirection>;
  where?: Maybe<Mint_Filter>;
};


export type PairBurnsArgs = {
  skip?: Maybe<Scalars['Int']>;
  first?: Maybe<Scalars['Int']>;
  orderBy?: Maybe<Burn_OrderBy>;
  orderDirection?: Maybe<OrderDirection>;
  where?: Maybe<Burn_Filter>;
};


export type PairSwapsArgs = {
  skip?: Maybe<Scalars['Int']>;
  first?: Maybe<Scalars['Int']>;
  orderBy?: Maybe<Swap_OrderBy>;
  orderDirection?: Maybe<OrderDirection>;
  where?: Maybe<Swap_Filter>;
};


export type PairDayData = {
  __typename?: 'PairDayData';
  id: Scalars['ID'];
  date: Scalars['Int'];
  pair: Pair;
  token0: Token;
  token1: Token;
  reserve0: Scalars['BigDecimal'];
  reserve1: Scalars['BigDecimal'];
  totalSupply: Scalars['BigDecimal'];
  reserveUSD: Scalars['BigDecimal'];
  volumeToken0: Scalars['BigDecimal'];
  volumeToken1: Scalars['BigDecimal'];
  volumeUSD: Scalars['BigDecimal'];
  txCount: Scalars['BigInt'];
};


export type PairHourData = {
  __typename?: 'PairHourData';
  id: Scalars['ID'];
  date: Scalars['Int'];
  pair: Pair;
  reserve0: Scalars['BigDecimal'];
  reserve1: Scalars['BigDecimal'];
  reserveUSD: Scalars['BigDecimal'];
  volumeToken0: Scalars['BigDecimal'];
  volumeToken1: Scalars['BigDecimal'];
  volumeUSD: Scalars['BigDecimal'];
  txCount: Scalars['BigInt'];
};


export type PairHourData_Filter = {
  id?: Maybe<Scalars['ID']>;
  id_not?: Maybe<Scalars['ID']>;
  id_gt?: Maybe<Scalars['ID']>;
  id_lt?: Maybe<Scalars['ID']>;
  id_gte?: Maybe<Scalars['ID']>;
  id_lte?: Maybe<Scalars['ID']>;
  id_in?: Maybe<Array<Scalars['ID']>>;
  id_not_in?: Maybe<Array<Scalars['ID']>>;
  date?: Maybe<Scalars['Int']>;
  date_not?: Maybe<Scalars['Int']>;
  date_gt?: Maybe<Scalars['Int']>;
  date_lt?: Maybe<Scalars['Int']>;
  date_gte?: Maybe<Scalars['Int']>;
  date_lte?: Maybe<Scalars['Int']>;
  date_in?: Maybe<Array<Scalars['Int']>>;
  date_not_in?: Maybe<Array<Scalars['Int']>>;
  pair?: Maybe<Scalars['String']>;
  pair_not?: Maybe<Scalars['String']>;
  pair_gt?: Maybe<Scalars['String']>;
  pair_lt?: Maybe<Scalars['String']>;
  pair_gte?: Maybe<Scalars['String']>;
  pair_lte?: Maybe<Scalars['String']>;
  pair_in?: Maybe<Array<Scalars['String']>>;
  pair_not_in?: Maybe<Array<Scalars['String']>>;
  pair_contains?: Maybe<Scalars['String']>;
  pair_not_contains?: Maybe<Scalars['String']>;
  pair_starts_with?: Maybe<Scalars['String']>;
  pair_not_starts_with?: Maybe<Scalars['String']>;
  pair_ends_with?: Maybe<Scalars['String']>;
  pair_not_ends_with?: Maybe<Scalars['String']>;
  reserve0?: Maybe<Scalars['BigDecimal']>;
  reserve0_not?: Maybe<Scalars['BigDecimal']>;
  reserve0_gt?: Maybe<Scalars['BigDecimal']>;
  reserve0_lt?: Maybe<Scalars['BigDecimal']>;
  reserve0_gte?: Maybe<Scalars['BigDecimal']>;
  reserve0_lte?: Maybe<Scalars['BigDecimal']>;
  reserve0_in?: Maybe<Array<Scalars['BigDecimal']>>;
  reserve0_not_in?: Maybe<Array<Scalars['BigDecimal']>>;
  reserve1?: Maybe<Scalars['BigDecimal']>;
  reserve1_not?: Maybe<Scalars['BigDecimal']>;
  reserve1_gt?: Maybe<Scalars['BigDecimal']>;
  reserve1_lt?: Maybe<Scalars['BigDecimal']>;
  reserve1_gte?: Maybe<Scalars['BigDecimal']>;
  reserve1_lte?: Maybe<Scalars['BigDecimal']>;
  reserve1_in?: Maybe<Array<Scalars['BigDecimal']>>;
  reserve1_not_in?: Maybe<Array<Scalars['BigDecimal']>>;
  reserveUSD?: Maybe<Scalars['BigDecimal']>;
  reserveUSD_not?: Maybe<Scalars['BigDecimal']>;
  reserveUSD_gt?: Maybe<Scalars['BigDecimal']>;
  reserveUSD_lt?: Maybe<Scalars['BigDecimal']>;
  reserveUSD_gte?: Maybe<Scalars['BigDecimal']>;
  reserveUSD_lte?: Maybe<Scalars['BigDecimal']>;
  reserveUSD_in?: Maybe<Array<Scalars['BigDecimal']>>;
  reserveUSD_not_in?: Maybe<Array<Scalars['BigDecimal']>>;
  volumeToken0?: Maybe<Scalars['BigDecimal']>;
  volumeToken0_not?: Maybe<Scalars['BigDecimal']>;
  volumeToken0_gt?: Maybe<Scalars['BigDecimal']>;
  volumeToken0_lt?: Maybe<Scalars['BigDecimal']>;
  volumeToken0_gte?: Maybe<Scalars['BigDecimal']>;
  volumeToken0_lte?: Maybe<Scalars['BigDecimal']>;
  volumeToken0_in?: Maybe<Array<Scalars['BigDecimal']>>;
  volumeToken0_not_in?: Maybe<Array<Scalars['BigDecimal']>>;
  volumeToken1?: Maybe<Scalars['BigDecimal']>;
  volumeToken1_not?: Maybe<Scalars['BigDecimal']>;
  volumeToken1_gt?: Maybe<Scalars['BigDecimal']>;
  volumeToken1_lt?: Maybe<Scalars['BigDecimal']>;
  volumeToken1_gte?: Maybe<Scalars['BigDecimal']>;
  volumeToken1_lte?: Maybe<Scalars['BigDecimal']>;
  volumeToken1_in?: Maybe<Array<Scalars['BigDecimal']>>;
  volumeToken1_not_in?: Maybe<Array<Scalars['BigDecimal']>>;
  volumeUSD?: Maybe<Scalars['BigDecimal']>;
  volumeUSD_not?: Maybe<Scalars['BigDecimal']>;
  volumeUSD_gt?: Maybe<Scalars['BigDecimal']>;
  volumeUSD_lt?: Maybe<Scalars['BigDecimal']>;
  volumeUSD_gte?: Maybe<Scalars['BigDecimal']>;
  volumeUSD_lte?: Maybe<Scalars['BigDecimal']>;
  volumeUSD_in?: Maybe<Array<Scalars['BigDecimal']>>;
  volumeUSD_not_in?: Maybe<Array<Scalars['BigDecimal']>>;
  txCount?: Maybe<Scalars['BigInt']>;
  txCount_not?: Maybe<Scalars['BigInt']>;
  txCount_gt?: Maybe<Scalars['BigInt']>;
  txCount_lt?: Maybe<Scalars['BigInt']>;
  txCount_gte?: Maybe<Scalars['BigInt']>;
  txCount_lte?: Maybe<Scalars['BigInt']>;
  txCount_in?: Maybe<Array<Scalars['BigInt']>>;
  txCount_not_in?: Maybe<Array<Scalars['BigInt']>>;
};


export type Query = {
  __typename?: 'Query';
  user?: Maybe<User>;
  users: Array<User>;
  bundle?: Maybe<Bundle>;
  bundles: Array<Bundle>;
  factory?: Maybe<Factory>;
  factories: Array<Factory>;
  hourData?: Maybe<HourData>;
  hourDatas: Array<HourData>;
  dayData?: Maybe<DayData>;
  dayDatas: Array<DayData>;
  token?: Maybe<Token>;
  tokens: Array<Token>;
  tokenHourData?: Maybe<TokenHourData>;
  tokenHourDatas: Array<TokenHourData>;
  tokenDayData?: Maybe<TokenDayData>;
  tokenDayDatas: Array<TokenDayData>;
  pair?: Maybe<Pair>;
  pairs: Array<Pair>;
  pairHourData?: Maybe<PairHourData>;
  pairHourDatas: Array<PairHourData>;
  pairDayData?: Maybe<PairDayData>;
  pairDayDatas: Array<PairDayData>;
  liquidityPosition?: Maybe<LiquidityPosition>;
  liquidityPositions: Array<LiquidityPosition>;
  liquidityPositionSnapshot?: Maybe<LiquidityPositionSnapshot>;
  liquidityPositionSnapshots: Array<LiquidityPositionSnapshot>;
  transaction?: Maybe<Transaction>;
  transactions: Array<Transaction>;
  mint?: Maybe<Mint>;
  mints: Array<Mint>;
  burn?: Maybe<Burn>;
  burns: Array<Burn>;
  swap?: Maybe<Swap>;
  swaps: Array<Swap>;
  tokenSearch: Array<Token>;
  pairSearch: Array<Pair>;
  userSearch: Array<User>;
  /** Access to subgraph metadata */
  _meta?: Maybe<_Meta_>;
};


export type QueryUserArgs = {
  id: Scalars['ID'];
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type QueryUsersArgs = {
  skip?: Maybe<Scalars['Int']>;
  first?: Maybe<Scalars['Int']>;
  orderBy?: Maybe<User_OrderBy>;
  orderDirection?: Maybe<OrderDirection>;
  where?: Maybe<User_Filter>;
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type QueryBundleArgs = {
  id: Scalars['ID'];
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type QueryBundlesArgs = {
  skip?: Maybe<Scalars['Int']>;
  first?: Maybe<Scalars['Int']>;
  orderBy?: Maybe<Bundle_OrderBy>;
  orderDirection?: Maybe<OrderDirection>;
  where?: Maybe<Bundle_Filter>;
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type QueryFactoryArgs = {
  id: Scalars['ID'];
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type QueryFactoriesArgs = {
  skip?: Maybe<Scalars['Int']>;
  first?: Maybe<Scalars['Int']>;
  orderBy?: Maybe<Factory_OrderBy>;
  orderDirection?: Maybe<OrderDirection>;
  where?: Maybe<Factory_Filter>;
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type QueryHourDataArgs = {
  id: Scalars['ID'];
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type QueryHourDatasArgs = {
  skip?: Maybe<Scalars['Int']>;
  first?: Maybe<Scalars['Int']>;
  orderBy?: Maybe<HourData_OrderBy>;
  orderDirection?: Maybe<OrderDirection>;
  where?: Maybe<HourData_Filter>;
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type QueryDayDataArgs = {
  id: Scalars['ID'];
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type QueryDayDatasArgs = {
  skip?: Maybe<Scalars['Int']>;
  first?: Maybe<Scalars['Int']>;
  orderBy?: Maybe<DayData_OrderBy>;
  orderDirection?: Maybe<OrderDirection>;
  where?: Maybe<DayData_Filter>;
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type QueryTokenArgs = {
  id: Scalars['ID'];
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type QueryTokensArgs = {
  skip?: Maybe<Scalars['Int']>;
  first?: Maybe<Scalars['Int']>;
  orderBy?: Maybe<Token_OrderBy>;
  orderDirection?: Maybe<OrderDirection>;
  where?: Maybe<Token_Filter>;
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type QueryTokenHourDataArgs = {
  id: Scalars['ID'];
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type QueryTokenHourDatasArgs = {
  skip?: Maybe<Scalars['Int']>;
  first?: Maybe<Scalars['Int']>;
  orderBy?: Maybe<TokenHourData_OrderBy>;
  orderDirection?: Maybe<OrderDirection>;
  where?: Maybe<TokenHourData_Filter>;
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type QueryTokenDayDataArgs = {
  id: Scalars['ID'];
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type QueryTokenDayDatasArgs = {
  skip?: Maybe<Scalars['Int']>;
  first?: Maybe<Scalars['Int']>;
  orderBy?: Maybe<TokenDayData_OrderBy>;
  orderDirection?: Maybe<OrderDirection>;
  where?: Maybe<TokenDayData_Filter>;
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type QueryPairArgs = {
  id: Scalars['ID'];
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type QueryPairsArgs = {
  skip?: Maybe<Scalars['Int']>;
  first?: Maybe<Scalars['Int']>;
  orderBy?: Maybe<Pair_OrderBy>;
  orderDirection?: Maybe<OrderDirection>;
  where?: Maybe<Pair_Filter>;
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type QueryPairHourDataArgs = {
  id: Scalars['ID'];
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type QueryPairHourDatasArgs = {
  skip?: Maybe<Scalars['Int']>;
  first?: Maybe<Scalars['Int']>;
  orderBy?: Maybe<PairHourData_OrderBy>;
  orderDirection?: Maybe<OrderDirection>;
  where?: Maybe<PairHourData_Filter>;
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type QueryPairDayDataArgs = {
  id: Scalars['ID'];
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type QueryPairDayDatasArgs = {
  skip?: Maybe<Scalars['Int']>;
  first?: Maybe<Scalars['Int']>;
  orderBy?: Maybe<PairDayData_OrderBy>;
  orderDirection?: Maybe<OrderDirection>;
  where?: Maybe<PairDayData_Filter>;
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type QueryLiquidityPositionArgs = {
  id: Scalars['ID'];
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type QueryLiquidityPositionsArgs = {
  skip?: Maybe<Scalars['Int']>;
  first?: Maybe<Scalars['Int']>;
  orderBy?: Maybe<LiquidityPosition_OrderBy>;
  orderDirection?: Maybe<OrderDirection>;
  where?: Maybe<LiquidityPosition_Filter>;
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type QueryLiquidityPositionSnapshotArgs = {
  id: Scalars['ID'];
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type QueryLiquidityPositionSnapshotsArgs = {
  skip?: Maybe<Scalars['Int']>;
  first?: Maybe<Scalars['Int']>;
  orderBy?: Maybe<LiquidityPositionSnapshot_OrderBy>;
  orderDirection?: Maybe<OrderDirection>;
  where?: Maybe<LiquidityPositionSnapshot_Filter>;
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type QueryTransactionArgs = {
  id: Scalars['ID'];
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type QueryTransactionsArgs = {
  skip?: Maybe<Scalars['Int']>;
  first?: Maybe<Scalars['Int']>;
  orderBy?: Maybe<Transaction_OrderBy>;
  orderDirection?: Maybe<OrderDirection>;
  where?: Maybe<Transaction_Filter>;
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type QueryMintArgs = {
  id: Scalars['ID'];
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type QueryMintsArgs = {
  skip?: Maybe<Scalars['Int']>;
  first?: Maybe<Scalars['Int']>;
  orderBy?: Maybe<Mint_OrderBy>;
  orderDirection?: Maybe<OrderDirection>;
  where?: Maybe<Mint_Filter>;
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type QueryBurnArgs = {
  id: Scalars['ID'];
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type QueryBurnsArgs = {
  skip?: Maybe<Scalars['Int']>;
  first?: Maybe<Scalars['Int']>;
  orderBy?: Maybe<Burn_OrderBy>;
  orderDirection?: Maybe<OrderDirection>;
  where?: Maybe<Burn_Filter>;
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type QuerySwapArgs = {
  id: Scalars['ID'];
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type QuerySwapsArgs = {
  skip?: Maybe<Scalars['Int']>;
  first?: Maybe<Scalars['Int']>;
  orderBy?: Maybe<Swap_OrderBy>;
  orderDirection?: Maybe<OrderDirection>;
  where?: Maybe<Swap_Filter>;
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type QueryTokenSearchArgs = {
  text: Scalars['String'];
  first?: Maybe<Scalars['Int']>;
  skip?: Maybe<Scalars['Int']>;
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type QueryPairSearchArgs = {
  text: Scalars['String'];
  first?: Maybe<Scalars['Int']>;
  skip?: Maybe<Scalars['Int']>;
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type QueryUserSearchArgs = {
  text: Scalars['String'];
  first?: Maybe<Scalars['Int']>;
  skip?: Maybe<Scalars['Int']>;
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type Query_MetaArgs = {
  block?: Maybe<Block_Height>;
};


export type Subscription = {
  __typename?: 'Subscription';
  user?: Maybe<User>;
  users: Array<User>;
  bundle?: Maybe<Bundle>;
  bundles: Array<Bundle>;
  factory?: Maybe<Factory>;
  factories: Array<Factory>;
  hourData?: Maybe<HourData>;
  hourDatas: Array<HourData>;
  dayData?: Maybe<DayData>;
  dayDatas: Array<DayData>;
  token?: Maybe<Token>;
  tokens: Array<Token>;
  tokenHourData?: Maybe<TokenHourData>;
  tokenHourDatas: Array<TokenHourData>;
  tokenDayData?: Maybe<TokenDayData>;
  tokenDayDatas: Array<TokenDayData>;
  pair?: Maybe<Pair>;
  pairs: Array<Pair>;
  pairHourData?: Maybe<PairHourData>;
  pairHourDatas: Array<PairHourData>;
  pairDayData?: Maybe<PairDayData>;
  pairDayDatas: Array<PairDayData>;
  liquidityPosition?: Maybe<LiquidityPosition>;
  liquidityPositions: Array<LiquidityPosition>;
  liquidityPositionSnapshot?: Maybe<LiquidityPositionSnapshot>;
  liquidityPositionSnapshots: Array<LiquidityPositionSnapshot>;
  transaction?: Maybe<Transaction>;
  transactions: Array<Transaction>;
  mint?: Maybe<Mint>;
  mints: Array<Mint>;
  burn?: Maybe<Burn>;
  burns: Array<Burn>;
  swap?: Maybe<Swap>;
  swaps: Array<Swap>;
  /** Access to subgraph metadata */
  _meta?: Maybe<_Meta_>;
};


export type SubscriptionUserArgs = {
  id: Scalars['ID'];
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type SubscriptionUsersArgs = {
  skip?: Maybe<Scalars['Int']>;
  first?: Maybe<Scalars['Int']>;
  orderBy?: Maybe<User_OrderBy>;
  orderDirection?: Maybe<OrderDirection>;
  where?: Maybe<User_Filter>;
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type SubscriptionBundleArgs = {
  id: Scalars['ID'];
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type SubscriptionBundlesArgs = {
  skip?: Maybe<Scalars['Int']>;
  first?: Maybe<Scalars['Int']>;
  orderBy?: Maybe<Bundle_OrderBy>;
  orderDirection?: Maybe<OrderDirection>;
  where?: Maybe<Bundle_Filter>;
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type SubscriptionFactoryArgs = {
  id: Scalars['ID'];
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type SubscriptionFactoriesArgs = {
  skip?: Maybe<Scalars['Int']>;
  first?: Maybe<Scalars['Int']>;
  orderBy?: Maybe<Factory_OrderBy>;
  orderDirection?: Maybe<OrderDirection>;
  where?: Maybe<Factory_Filter>;
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type SubscriptionHourDataArgs = {
  id: Scalars['ID'];
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type SubscriptionHourDatasArgs = {
  skip?: Maybe<Scalars['Int']>;
  first?: Maybe<Scalars['Int']>;
  orderBy?: Maybe<HourData_OrderBy>;
  orderDirection?: Maybe<OrderDirection>;
  where?: Maybe<HourData_Filter>;
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type SubscriptionDayDataArgs = {
  id: Scalars['ID'];
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type SubscriptionDayDatasArgs = {
  skip?: Maybe<Scalars['Int']>;
  first?: Maybe<Scalars['Int']>;
  orderBy?: Maybe<DayData_OrderBy>;
  orderDirection?: Maybe<OrderDirection>;
  where?: Maybe<DayData_Filter>;
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type SubscriptionTokenArgs = {
  id: Scalars['ID'];
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type SubscriptionTokensArgs = {
  skip?: Maybe<Scalars['Int']>;
  first?: Maybe<Scalars['Int']>;
  orderBy?: Maybe<Token_OrderBy>;
  orderDirection?: Maybe<OrderDirection>;
  where?: Maybe<Token_Filter>;
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type SubscriptionTokenHourDataArgs = {
  id: Scalars['ID'];
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type SubscriptionTokenHourDatasArgs = {
  skip?: Maybe<Scalars['Int']>;
  first?: Maybe<Scalars['Int']>;
  orderBy?: Maybe<TokenHourData_OrderBy>;
  orderDirection?: Maybe<OrderDirection>;
  where?: Maybe<TokenHourData_Filter>;
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type SubscriptionTokenDayDataArgs = {
  id: Scalars['ID'];
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type SubscriptionTokenDayDatasArgs = {
  skip?: Maybe<Scalars['Int']>;
  first?: Maybe<Scalars['Int']>;
  orderBy?: Maybe<TokenDayData_OrderBy>;
  orderDirection?: Maybe<OrderDirection>;
  where?: Maybe<TokenDayData_Filter>;
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type SubscriptionPairArgs = {
  id: Scalars['ID'];
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type SubscriptionPairsArgs = {
  skip?: Maybe<Scalars['Int']>;
  first?: Maybe<Scalars['Int']>;
  orderBy?: Maybe<Pair_OrderBy>;
  orderDirection?: Maybe<OrderDirection>;
  where?: Maybe<Pair_Filter>;
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type SubscriptionPairHourDataArgs = {
  id: Scalars['ID'];
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type SubscriptionPairHourDatasArgs = {
  skip?: Maybe<Scalars['Int']>;
  first?: Maybe<Scalars['Int']>;
  orderBy?: Maybe<PairHourData_OrderBy>;
  orderDirection?: Maybe<OrderDirection>;
  where?: Maybe<PairHourData_Filter>;
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type SubscriptionPairDayDataArgs = {
  id: Scalars['ID'];
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type SubscriptionPairDayDatasArgs = {
  skip?: Maybe<Scalars['Int']>;
  first?: Maybe<Scalars['Int']>;
  orderBy?: Maybe<PairDayData_OrderBy>;
  orderDirection?: Maybe<OrderDirection>;
  where?: Maybe<PairDayData_Filter>;
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type SubscriptionLiquidityPositionArgs = {
  id: Scalars['ID'];
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type SubscriptionLiquidityPositionsArgs = {
  skip?: Maybe<Scalars['Int']>;
  first?: Maybe<Scalars['Int']>;
  orderBy?: Maybe<LiquidityPosition_OrderBy>;
  orderDirection?: Maybe<OrderDirection>;
  where?: Maybe<LiquidityPosition_Filter>;
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type SubscriptionLiquidityPositionSnapshotArgs = {
  id: Scalars['ID'];
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type SubscriptionLiquidityPositionSnapshotsArgs = {
  skip?: Maybe<Scalars['Int']>;
  first?: Maybe<Scalars['Int']>;
  orderBy?: Maybe<LiquidityPositionSnapshot_OrderBy>;
  orderDirection?: Maybe<OrderDirection>;
  where?: Maybe<LiquidityPositionSnapshot_Filter>;
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type SubscriptionTransactionArgs = {
  id: Scalars['ID'];
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type SubscriptionTransactionsArgs = {
  skip?: Maybe<Scalars['Int']>;
  first?: Maybe<Scalars['Int']>;
  orderBy?: Maybe<Transaction_OrderBy>;
  orderDirection?: Maybe<OrderDirection>;
  where?: Maybe<Transaction_Filter>;
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type SubscriptionMintArgs = {
  id: Scalars['ID'];
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type SubscriptionMintsArgs = {
  skip?: Maybe<Scalars['Int']>;
  first?: Maybe<Scalars['Int']>;
  orderBy?: Maybe<Mint_OrderBy>;
  orderDirection?: Maybe<OrderDirection>;
  where?: Maybe<Mint_Filter>;
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type SubscriptionBurnArgs = {
  id: Scalars['ID'];
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type SubscriptionBurnsArgs = {
  skip?: Maybe<Scalars['Int']>;
  first?: Maybe<Scalars['Int']>;
  orderBy?: Maybe<Burn_OrderBy>;
  orderDirection?: Maybe<OrderDirection>;
  where?: Maybe<Burn_Filter>;
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type SubscriptionSwapArgs = {
  id: Scalars['ID'];
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type SubscriptionSwapsArgs = {
  skip?: Maybe<Scalars['Int']>;
  first?: Maybe<Scalars['Int']>;
  orderBy?: Maybe<Swap_OrderBy>;
  orderDirection?: Maybe<OrderDirection>;
  where?: Maybe<Swap_Filter>;
  block?: Maybe<Block_Height>;
  subgraphError?: _SubgraphErrorPolicy_;
};


export type Subscription_MetaArgs = {
  block?: Maybe<Block_Height>;
};


export type Swap = {
  __typename?: 'Swap';
  id: Scalars['ID'];
  transaction: Transaction;
  timestamp: Scalars['BigInt'];
  pair: Pair;
  sender: Scalars['Bytes'];
  amount0In: Scalars['BigDecimal'];
  amount1In: Scalars['BigDecimal'];
  amount0Out: Scalars['BigDecimal'];
  amount1Out: Scalars['BigDecimal'];
  to: Scalars['Bytes'];
  logIndex?: Maybe<Scalars['BigInt']>;
  amountUSD: Scalars['BigDecimal'];
};


export type Swap_Filter = {
  id?: Maybe<Scalars['ID']>;
  id_not?: Maybe<Scalars['ID']>;
  id_gt?: Maybe<Scalars['ID']>;
  id_lt?: Maybe<Scalars['ID']>;
  id_gte?: Maybe<Scalars['ID']>;
  id_lte?: Maybe<Scalars['ID']>;
  id_in?: Maybe<Array<Scalars['ID']>>;
  id_not_in?: Maybe<Array<Scalars['ID']>>;
  transaction?: Maybe<Scalars['String']>;
  transaction_not?: Maybe<Scalars['String']>;
  transaction_gt?: Maybe<Scalars['String']>;
  transaction_lt?: Maybe<Scalars['String']>;
  transaction_gte?: Maybe<Scalars['String']>;
  transaction_lte?: Maybe<Scalars['String']>;
  transaction_in?: Maybe<Array<Scalars['String']>>;
  transaction_not_in?: Maybe<Array<Scalars['String']>>;
  transaction_contains?: Maybe<Scalars['String']>;
  transaction_not_contains?: Maybe<Scalars['String']>;
  transaction_starts_with?: Maybe<Scalars['String']>;
  transaction_not_starts_with?: Maybe<Scalars['String']>;
  transaction_ends_with?: Maybe<Scalars['String']>;
  transaction_not_ends_with?: Maybe<Scalars['String']>;
  timestamp?: Maybe<Scalars['BigInt']>;
  timestamp_not?: Maybe<Scalars['BigInt']>;
  timestamp_gt?: Maybe<Scalars['BigInt']>;
  timestamp_lt?: Maybe<Scalars['BigInt']>;
  timestamp_gte?: Maybe<Scalars['BigInt']>;
  timestamp_lte?: Maybe<Scalars['BigInt']>;
  timestamp_in?: Maybe<Array<Scalars['BigInt']>>;
  timestamp_not_in?: Maybe<Array<Scalars['BigInt']>>;
  pair?: Maybe<Scalars['String']>;
  pair_not?: Maybe<Scalars['String']>;
  pair_gt?: Maybe<Scalars['String']>;
  pair_lt?: Maybe<Scalars['String']>;
  pair_gte?: Maybe<Scalars['String']>;
  pair_lte?: Maybe<Scalars['String']>;
  pair_in?: Maybe<Array<Scalars['String']>>;
  pair_not_in?: Maybe<Array<Scalars['String']>>;
  pair_contains?: Maybe<Scalars['String']>;
  pair_not_contains?: Maybe<Scalars['String']>;
  pair_starts_with?: Maybe<Scalars['String']>;
  pair_not_starts_with?: Maybe<Scalars['String']>;
  pair_ends_with?: Maybe<Scalars['String']>;
  pair_not_ends_with?: Maybe<Scalars['String']>;
  sender?: Maybe<Scalars['Bytes']>;
  sender_not?: Maybe<Scalars['Bytes']>;
  sender_in?: Maybe<Array<Scalars['Bytes']>>;
  sender_not_in?: Maybe<Array<Scalars['Bytes']>>;
  sender_contains?: Maybe<Scalars['Bytes']>;
  sender_not_contains?: Maybe<Scalars['Bytes']>;
  amount0In?: Maybe<Scalars['BigDecimal']>;
  amount0In_not?: Maybe<Scalars['BigDecimal']>;
  amount0In_gt?: Maybe<Scalars['BigDecimal']>;
  amount0In_lt?: Maybe<Scalars['BigDecimal']>;
  amount0In_gte?: Maybe<Scalars['BigDecimal']>;
  amount0In_lte?: Maybe<Scalars['BigDecimal']>;
  amount0In_in?: Maybe<Array<Scalars['BigDecimal']>>;
  amount0In_not_in?: Maybe<Array<Scalars['BigDecimal']>>;
  amount1In?: Maybe<Scalars['BigDecimal']>;
  amount1In_not?: Maybe<Scalars['BigDecimal']>;
  amount1In_gt?: Maybe<Scalars['BigDecimal']>;
  amount1In_lt?: Maybe<Scalars['BigDecimal']>;
  amount1In_gte?: Maybe<Scalars['BigDecimal']>;
  amount1In_lte?: Maybe<Scalars['BigDecimal']>;
  amount1In_in?: Maybe<Array<Scalars['BigDecimal']>>;
  amount1In_not_in?: Maybe<Array<Scalars['BigDecimal']>>;
  amount0Out?: Maybe<Scalars['BigDecimal']>;
  amount0Out_not?: Maybe<Scalars['BigDecimal']>;
  amount0Out_gt?: Maybe<Scalars['BigDecimal']>;
  amount0Out_lt?: Maybe<Scalars['BigDecimal']>;
  amount0Out_gte?: Maybe<Scalars['BigDecimal']>;
  amount0Out_lte?: Maybe<Scalars['BigDecimal']>;
  amount0Out_in?: Maybe<Array<Scalars['BigDecimal']>>;
  amount0Out_not_in?: Maybe<Array<Scalars['BigDecimal']>>;
  amount1Out?: Maybe<Scalars['BigDecimal']>;
  amount1Out_not?: Maybe<Scalars['BigDecimal']>;
  amount1Out_gt?: Maybe<Scalars['BigDecimal']>;
  amount1Out_lt?: Maybe<Scalars['BigDecimal']>;
  amount1Out_gte?: Maybe<Scalars['BigDecimal']>;
  amount1Out_lte?: Maybe<Scalars['BigDecimal']>;
  amount1Out_in?: Maybe<Array<Scalars['BigDecimal']>>;
  amount1Out_not_in?: Maybe<Array<Scalars['BigDecimal']>>;
  to?: Maybe<Scalars['Bytes']>;
  to_not?: Maybe<Scalars['Bytes']>;
  to_in?: Maybe<Array<Scalars['Bytes']>>;
  to_not_in?: Maybe<Array<Scalars['Bytes']>>;
  to_contains?: Maybe<Scalars['Bytes']>;
  to_not_contains?: Maybe<Scalars['Bytes']>;
  logIndex?: Maybe<Scalars['BigInt']>;
  logIndex_not?: Maybe<Scalars['BigInt']>;
  logIndex_gt?: Maybe<Scalars['BigInt']>;
  logIndex_lt?: Maybe<Scalars['BigInt']>;
  logIndex_gte?: Maybe<Scalars['BigInt']>;
  logIndex_lte?: Maybe<Scalars['BigInt']>;
  logIndex_in?: Maybe<Array<Scalars['BigInt']>>;
  logIndex_not_in?: Maybe<Array<Scalars['BigInt']>>;
  amountUSD?: Maybe<Scalars['BigDecimal']>;
  amountUSD_not?: Maybe<Scalars['BigDecimal']>;
  amountUSD_gt?: Maybe<Scalars['BigDecimal']>;
  amountUSD_lt?: Maybe<Scalars['BigDecimal']>;
  amountUSD_gte?: Maybe<Scalars['BigDecimal']>;
  amountUSD_lte?: Maybe<Scalars['BigDecimal']>;
  amountUSD_in?: Maybe<Array<Scalars['BigDecimal']>>;
  amountUSD_not_in?: Maybe<Array<Scalars['BigDecimal']>>;
};


export type Token = {
  __typename?: 'Token';
  id: Scalars['ID'];
  factory: Factory;
  symbol: Scalars['String'];
  name: Scalars['String'];
  decimals: Scalars['BigInt'];
  totalSupply: Scalars['BigInt'];
  volume: Scalars['BigDecimal'];
  volumeUSD: Scalars['BigDecimal'];
  untrackedVolumeUSD: Scalars['BigDecimal'];
  txCount: Scalars['BigInt'];
  liquidity: Scalars['BigDecimal'];
  derivedETH: Scalars['BigDecimal'];
  hourData: Array<TokenHourData>;
  dayData: Array<TokenDayData>;
  basePairs: Array<Pair>;
  quotePairs: Array<Pair>;
  basePairsDayData: Array<PairDayData>;
  quotePairsDayData: Array<PairDayData>;
};


export type TokenHourDataArgs = {
  skip?: Maybe<Scalars['Int']>;
  first?: Maybe<Scalars['Int']>;
  orderBy?: Maybe<TokenHourData_OrderBy>;
  orderDirection?: Maybe<OrderDirection>;
  where?: Maybe<TokenHourData_Filter>;
};


export type TokenDayDataArgs = {
  skip?: Maybe<Scalars['Int']>;
  first?: Maybe<Scalars['Int']>;
  orderBy?: Maybe<TokenDayData_OrderBy>;
  orderDirection?: Maybe<OrderDirection>;
  where?: Maybe<TokenDayData_Filter>;
};


export type TokenBasePairsArgs = {
  skip?: Maybe<Scalars['Int']>;
  first?: Maybe<Scalars['Int']>;
  orderBy?: Maybe<Pair_OrderBy>;
  orderDirection?: Maybe<OrderDirection>;
  where?: Maybe<Pair_Filter>;
};


export type TokenQuotePairsArgs = {
  skip?: Maybe<Scalars['Int']>;
  first?: Maybe<Scalars['Int']>;
  orderBy?: Maybe<Pair_OrderBy>;
  orderDirection?: Maybe<OrderDirection>;
  where?: Maybe<Pair_Filter>;
};


export type TokenBasePairsDayDataArgs = {
  skip?: Maybe<Scalars['Int']>;
  first?: Maybe<Scalars['Int']>;
  orderBy?: Maybe<PairDayData_OrderBy>;
  orderDirection?: Maybe<OrderDirection>;
  where?: Maybe<PairDayData_Filter>;
};


export type TokenQuotePairsDayDataArgs = {
  skip?: Maybe<Scalars['Int']>;
  first?: Maybe<Scalars['Int']>;
  orderBy?: Maybe<PairDayData_OrderBy>;
  orderDirection?: Maybe<OrderDirection>;
  where?: Maybe<PairDayData_Filter>;
};


export type TokenDayData = {
  __typename?: 'TokenDayData';
  id: Scalars['ID'];
  date: Scalars['Int'];
  token: Token;
  volume: Scalars['BigDecimal'];
  volumeETH: Scalars['BigDecimal'];
  volumeUSD: Scalars['BigDecimal'];
  txCount: Scalars['BigInt'];
  liquidity: Scalars['BigDecimal'];
  liquidityETH: Scalars['BigDecimal'];
  liquidityUSD: Scalars['BigDecimal'];
  priceUSD: Scalars['BigDecimal'];
};


export type TokenDayData_Filter = {
  id?: Maybe<Scalars['ID']>;
  id_not?: Maybe<Scalars['ID']>;
  id_gt?: Maybe<Scalars['ID']>;
  id_lt?: Maybe<Scalars['ID']>;
  id_gte?: Maybe<Scalars['ID']>;
  id_lte?: Maybe<Scalars['ID']>;
  id_in?: Maybe<Array<Scalars['ID']>>;
  id_not_in?: Maybe<Array<Scalars['ID']>>;
  date?: Maybe<Scalars['Int']>;
  date_not?: Maybe<Scalars['Int']>;
  date_gt?: Maybe<Scalars['Int']>;
  date_lt?: Maybe<Scalars['Int']>;
  date_gte?: Maybe<Scalars['Int']>;
  date_lte?: Maybe<Scalars['Int']>;
  date_in?: Maybe<Array<Scalars['Int']>>;
  date_not_in?: Maybe<Array<Scalars['Int']>>;
  token?: Maybe<Scalars['String']>;
  token_not?: Maybe<Scalars['String']>;
  token_gt?: Maybe<Scalars['String']>;
  token_lt?: Maybe<Scalars['String']>;
  token_gte?: Maybe<Scalars['String']>;
  token_lte?: Maybe<Scalars['String']>;
  token_in?: Maybe<Array<Scalars['String']>>;
  token_not_in?: Maybe<Array<Scalars['String']>>;
  token_contains?: Maybe<Scalars['String']>;
  token_not_contains?: Maybe<Scalars['String']>;
  token_starts_with?: Maybe<Scalars['String']>;
  token_not_starts_with?: Maybe<Scalars['String']>;
  token_ends_with?: Maybe<Scalars['String']>;
  token_not_ends_with?: Maybe<Scalars['String']>;
  volume?: Maybe<Scalars['BigDecimal']>;
  volume_not?: Maybe<Scalars['BigDecimal']>;
  volume_gt?: Maybe<Scalars['BigDecimal']>;
  volume_lt?: Maybe<Scalars['BigDecimal']>;
  volume_gte?: Maybe<Scalars['BigDecimal']>;
  volume_lte?: Maybe<Scalars['BigDecimal']>;
  volume_in?: Maybe<Array<Scalars['BigDecimal']>>;
  volume_not_in?: Maybe<Array<Scalars['BigDecimal']>>;
  volumeETH?: Maybe<Scalars['BigDecimal']>;
  volumeETH_not?: Maybe<Scalars['BigDecimal']>;
  volumeETH_gt?: Maybe<Scalars['BigDecimal']>;
  volumeETH_lt?: Maybe<Scalars['BigDecimal']>;
  volumeETH_gte?: Maybe<Scalars['BigDecimal']>;
  volumeETH_lte?: Maybe<Scalars['BigDecimal']>;
  volumeETH_in?: Maybe<Array<Scalars['BigDecimal']>>;
  volumeETH_not_in?: Maybe<Array<Scalars['BigDecimal']>>;
  volumeUSD?: Maybe<Scalars['BigDecimal']>;
  volumeUSD_not?: Maybe<Scalars['BigDecimal']>;
  volumeUSD_gt?: Maybe<Scalars['BigDecimal']>;
  volumeUSD_lt?: Maybe<Scalars['BigDecimal']>;
  volumeUSD_gte?: Maybe<Scalars['BigDecimal']>;
  volumeUSD_lte?: Maybe<Scalars['BigDecimal']>;
  volumeUSD_in?: Maybe<Array<Scalars['BigDecimal']>>;
  volumeUSD_not_in?: Maybe<Array<Scalars['BigDecimal']>>;
  txCount?: Maybe<Scalars['BigInt']>;
  txCount_not?: Maybe<Scalars['BigInt']>;
  txCount_gt?: Maybe<Scalars['BigInt']>;
  txCount_lt?: Maybe<Scalars['BigInt']>;
  txCount_gte?: Maybe<Scalars['BigInt']>;
  txCount_lte?: Maybe<Scalars['BigInt']>;
  txCount_in?: Maybe<Array<Scalars['BigInt']>>;
  txCount_not_in?: Maybe<Array<Scalars['BigInt']>>;
  liquidity?: Maybe<Scalars['BigDecimal']>;
  liquidity_not?: Maybe<Scalars['BigDecimal']>;
  liquidity_gt?: Maybe<Scalars['BigDecimal']>;
  liquidity_lt?: Maybe<Scalars['BigDecimal']>;
  liquidity_gte?: Maybe<Scalars['BigDecimal']>;
  liquidity_lte?: Maybe<Scalars['BigDecimal']>;
  liquidity_in?: Maybe<Array<Scalars['BigDecimal']>>;
  liquidity_not_in?: Maybe<Array<Scalars['BigDecimal']>>;
  liquidityETH?: Maybe<Scalars['BigDecimal']>;
  liquidityETH_not?: Maybe<Scalars['BigDecimal']>;
  liquidityETH_gt?: Maybe<Scalars['BigDecimal']>;
  liquidityETH_lt?: Maybe<Scalars['BigDecimal']>;
  liquidityETH_gte?: Maybe<Scalars['BigDecimal']>;
  liquidityETH_lte?: Maybe<Scalars['BigDecimal']>;
  liquidityETH_in?: Maybe<Array<Scalars['BigDecimal']>>;
  liquidityETH_not_in?: Maybe<Array<Scalars['BigDecimal']>>;
  liquidityUSD?: Maybe<Scalars['BigDecimal']>;
  liquidityUSD_not?: Maybe<Scalars['BigDecimal']>;
  liquidityUSD_gt?: Maybe<Scalars['BigDecimal']>;
  liquidityUSD_lt?: Maybe<Scalars['BigDecimal']>;
  liquidityUSD_gte?: Maybe<Scalars['BigDecimal']>;
  liquidityUSD_lte?: Maybe<Scalars['BigDecimal']>;
  liquidityUSD_in?: Maybe<Array<Scalars['BigDecimal']>>;
  liquidityUSD_not_in?: Maybe<Array<Scalars['BigDecimal']>>;
  priceUSD?: Maybe<Scalars['BigDecimal']>;
  priceUSD_not?: Maybe<Scalars['BigDecimal']>;
  priceUSD_gt?: Maybe<Scalars['BigDecimal']>;
  priceUSD_lt?: Maybe<Scalars['BigDecimal']>;
  priceUSD_gte?: Maybe<Scalars['BigDecimal']>;
  priceUSD_lte?: Maybe<Scalars['BigDecimal']>;
  priceUSD_in?: Maybe<Array<Scalars['BigDecimal']>>;
  priceUSD_not_in?: Maybe<Array<Scalars['BigDecimal']>>;
};


export type TokenHourData = {
  __typename?: 'TokenHourData';
  id: Scalars['ID'];
  date: Scalars['Int'];
  token: Token;
  volume: Scalars['BigDecimal'];
  volumeETH: Scalars['BigDecimal'];
  volumeUSD: Scalars['BigDecimal'];
  txCount: Scalars['BigInt'];
  liquidity: Scalars['BigDecimal'];
  liquidityETH: Scalars['BigDecimal'];
  liquidityUSD: Scalars['BigDecimal'];
  priceUSD: Scalars['BigDecimal'];
};